KevinMidboe/linguist
1
0
Fork 0
mirror of https://github.com/KevinMidboe/linguist.git synced 2025-10-29 17:50:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add Chapel parallel programming language.

Browse Source 
Includes several example programs from source distribution.
This commit is contained in:
Thomas Van Doren
2014-07-02 14:51:15 -07:00
parent e274196441
commit a6ccce7b76
7 changed files with 3097 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
lib/linguist/languages.yml
View File

@@ -347,6 +347,14 @@ Ceylon:
extensions: extensions:
- .ceylon - .ceylon
Chapel:
type: programming
color: "#8dc63f"
aliases:
- chpl
extensions:
- .chpl
ChucK: ChucK:
lexer: Java lexer: Java
extensions: extensions:

803
lib/linguist/samples.json
View File

@@ -83,6 +83,9 @@
"Ceylon": [ "Ceylon": [
".ceylon" ".ceylon"
], ],
"Chapel": [
".chpl"
],
"Cirru": [ "Cirru": [
".cirru" ".cirru"
], ],
@@ -792,8 +795,8 @@
"exception.zep.php" "exception.zep.php"
] ]
}, },
"tokens_total": 650233, "tokens_total": 659840,
"languages_total": 870, "languages_total": 875,
"tokens": { "tokens": {
"ABAP": { "ABAP": {
"*/**": 1, "*/**": 1,
@@ -16278,6 +16281,798 @@
"<=>": 1, "<=>": 1,
"other.name": 1 "other.name": 1
}, },
"Chapel": {
"//": 150,
"use": 5,
"BlockDist": 2,
"CyclicDist": 1,
"BlockCycDist": 1,
"ReplicatedDist": 2,
";": 516,
"DimensionalDist2D": 2,
"ReplicatedDim": 2,
"BlockCycDim": 1,
"config": 10,
"const": 59,
"n": 16,
"Space": 12,
"{": 122,
"}": 120,
"BlockSpace": 2,
"dmapped": 8,
"Block": 4,
"(": 626,
"boundingBox": 2,
")": 626,
"var": 72,
"BA": 3,
"[": 920,
"]": 920,
"int": 21,
"forall": 43,
"ba": 4,
"in": 76,
"do": 62,
"here.id": 7,
"writeln": 53,
"MyLocaleView": 5,
"#numLocales": 1,
"MyLocales": 5,
"locale": 1,
"reshape": 2,
"Locales": 6,
"BlockSpace2": 2,
"targetLocales": 1,
"BA2": 3,
"CyclicSpace": 2,
"Cyclic": 1,
"startIdx": 2,
"Space.low": 5,
"CA": 3,
"ca": 2,
"BlkCycSpace": 2,
"BlockCyclic": 1,
"blocksize": 1,
"BCA": 3,
"bca": 2,
"ReplicatedSpace": 2,
"RA": 11,
"ra": 4,
"RA.numElements": 1,
"A": 13,
"i": 250,
"j": 25,
"i*100": 1,
"+": 334,
"on": 7,
"here": 3,
"LocaleSpace.high": 3,
"nl1": 2,
"nl2": 2,
"if": 98,
"numLocales": 5,
"then": 80,
"else": 16,
"numLocales/2": 1,
"#nl1": 2,
"#nl2": 1,
"#nl1*nl2": 1,
"DimReplicatedBlockcyclicSpace": 2,
"new": 7,
"BlockCyclicDim": 1,
"lowIdx": 1,
"blockSize": 1,
"DRBA": 3,
"for": 36,
"locId1": 2,
"drba": 2,
"Helper": 2,
"print": 5,
"to": 9,
"the": 10,
"console": 1,
"Time": 2,
"get": 3,
"timing": 6,
"routines": 1,
"benchmarking": 1,
"block": 1,
"-": 345,
"distributed": 1,
"arrays": 6,
"luleshInit": 1,
"initialization": 1,
"code": 1,
"data": 1,
"set": 4,
"param": 25,
"useBlockDist": 5,
"CHPL_COMM": 1,
"use3DRepresentation": 4,
"false": 4,
"useSparseMaterials": 3,
"true": 5,
"printWarnings": 3,
"&&": 9,
"luleshInit.filename": 1,
"halt": 5,
"initialEnergy": 2,
"e": 84,
"initial": 1,
"energy": 5,
"value": 1,
"showProgress": 3,
"time": 9,
"and": 4,
"dt": 14,
"values": 1,
"each": 1,
"step": 1,
"debug": 8,
"various": 1,
"info": 1,
"doTiming": 4,
"main": 3,
"timestep": 1,
"loop": 2,
"printCoords": 2,
"final": 1,
"computed": 1,
"coordinates": 2,
"XI_M": 2,
"XI_M_SYMM": 4,
"XI_M_FREE": 3,
"XI_P": 2,
"c": 7,
"XI_P_SYMM": 3,
"XI_P_FREE": 3,
"ETA_M": 2,
"ETA_M_SYMM": 4,
"ETA_M_FREE": 3,
"ETA_P": 2,
"c0": 1,
"ETA_P_SYMM": 3,
"ETA_P_FREE": 3,
"ZETA_M": 2,
"ZETA_M_SYMM": 4,
"ZETA_M_FREE": 3,
"ZETA_P": 2,
"xc00": 1,
"ZETA_P_SYMM": 3,
"ZETA_P_FREE": 3,
"numElems": 2,
"numNodes": 1,
"initProblemSize": 1,
"ElemSpace": 4,
"#elemsPerEdge": 3,
"#numElems": 1,
"NodeSpace": 4,
"#nodesPerEdge": 3,
"#numNodes": 1,
"Elems": 45,
"Nodes": 16,
"x": 111,
"y": 107,
"z": 107,
"real": 60,
"nodesPerElem": 6,
"elemToNode": 7,
"nodesPerElem*index": 1,
"lxim": 3,
"lxip": 3,
"letam": 3,
"letap": 3,
"lzetam": 3,
"lzetap": 3,
"index": 4,
"XSym": 4,
"YSym": 4,
"ZSym": 4,
"sparse": 3,
"subdomain": 3,
"u_cut": 5,
"hgcoef": 1,
"qstop": 2,
"monoq_max_slope": 7,
"monoq_limiter_mult": 7,
"e_cut": 3,
"p_cut": 6,
"ss4o3": 1,
"/3.0": 2,
"q_cut": 2,
"v_cut": 2,
"qlc_monoq": 2,
"qqc_monoq": 2,
"qqc": 1,
"qqc2": 1,
"*": 260,
"qqc**2": 1,
"eosvmax": 14,
"eosvmin": 9,
"pmin": 7,
"emin": 7,
"dvovmax": 1,
"refdens": 3,
"deltatimemultlb": 1,
"deltatimemultub": 1,
"dtmax": 1,
"stoptime": 3,
"maxcycles": 3,
"max": 2,
"dtfixed": 2,
"MatElems": 9,
"MatElemsType": 2,
"enumerateMatElems": 2,
"proc": 44,
"type": 1,
"return": 15,
"Elems.type": 1,
"iter": 3,
"yield": 3,
"elemBC": 16,
"p": 10,
"pressure": 1,
"q": 13,
"ql": 3,
"linear": 1,
"term": 2,
"qq": 3,
"quadratic": 1,
"v": 9,
"//relative": 1,
"volume": 21,
"vnew": 9,
"volo": 5,
"reference": 1,
"delv": 3,
"m_vnew": 1,
"m_v": 1,
"vdov": 4,
"derivative": 1,
"over": 2,
"arealg": 2,
"elem": 3,
"characteristic": 2,
"length": 2,
"ss": 2,
"elemMass": 4,
"mass": 12,
"xd": 8,
"yd": 8,
"zd": 8,
"velocities": 2,
"xdd": 3,
"ydd": 3,
"zdd": 3,
"acceleration": 1,
"fx": 8,
"fy": 8,
"fz": 8,
"atomic": 2,
"forces": 1,
"nodalMass": 3,
"current": 1,
"deltatime": 3,
"variable": 1,
"increment": 1,
"dtcourant": 1,
"e20": 2,
"courant": 1,
"constraint": 2,
"dthydro": 1,
"change": 2,
"cycle": 5,
"iteration": 1,
"count": 1,
"simulation": 1,
"initLulesh": 2,
"st": 4,
"getCurrentTime": 4,
"while": 4,
"<": 42,
"iterTime": 2,
"TimeIncrement": 2,
"LagrangeLeapFrog": 1,
"deprint": 3,
"format": 9,
"et": 3,
"/cycle": 1,
"outfile": 1,
"open": 1,
"iomode.cw": 1,
"writer": 1,
"outfile.writer": 1,
"fmtstr": 4,
"writer.writeln": 1,
"writer.close": 1,
"outfile.close": 1,
"initCoordinates": 1,
"initElemToNodeMapping": 1,
"initGreekVars": 1,
"initXSyms": 1,
"initYSyms": 1,
"initZSyms": 1,
"//calculated": 1,
"fly": 1,
"using": 1,
"elemToNodes": 3,
"initMasses": 2,
"octantCorner": 2,
"initBoundaryConditions": 2,
"massAccum": 3,
"eli": 18,
"x_local": 11,
"y_local": 11,
"z_local": 11,
"*real": 40,
"localizeNeighborNodes": 6,
"CalcElemVolume": 3,
"neighbor": 2,
".add": 1,
".read": 1,
"/": 26,
"surfaceNode": 8,
"mask": 16,
"<<": 2,
"&": 18,
"f": 4,
"|": 14,
"xf0": 4,
"xcc": 4,
"check": 3,
"loc": 4,
"maxloc": 1,
"reduce": 2,
"zip": 1,
"freeSurface": 3,
"initFreeSurface": 1,
"b": 4,
"inline": 5,
"ref": 19,
"noi": 4,
"TripleProduct": 4,
"x1": 1,
"y1": 1,
"z1": 1,
"x2": 1,
"y2": 1,
"z2": 1,
"x3": 1,
"y3": 1,
"z3": 1,
"x1*": 1,
"y2*z3": 1,
"z2*y3": 1,
"x2*": 1,
"z1*y3": 1,
"y1*z3": 1,
"x3*": 1,
"y1*z2": 1,
"z1*y2": 1,
"dx61": 2,
"dy61": 2,
"dz61": 2,
"dx70": 2,
"dy70": 2,
"dz70": 2,
"dx63": 2,
"dy63": 2,
"dz63": 2,
"dx20": 2,
"dy20": 2,
"dz20": 2,
"dx50": 2,
"dy50": 2,
"dz50": 2,
"dx64": 2,
"dy64": 2,
"dz64": 2,
"dx31": 2,
"dy31": 2,
"dz31": 2,
"dx72": 2,
"dy72": 2,
"dz72": 2,
"dx43": 2,
"dy43": 2,
"dz43": 2,
"dx57": 2,
"dy57": 2,
"dz57": 2,
"dx14": 2,
"dy14": 2,
"dz14": 2,
"dx25": 2,
"dy25": 2,
"dz25": 2,
"InitStressTermsForElems": 1,
"sigxx": 2,
"sigyy": 2,
"sigzz": 2,
"D": 9,
"CalcElemShapeFunctionDerivatives": 2,
"b_x": 18,
"b_y": 18,
"b_z": 18,
"fjxxi": 5,
".125": 9,
"fjxet": 6,
"fjxze": 5,
"fjyxi": 5,
"fjyet": 6,
"fjyze": 5,
"fjzxi": 5,
"fjzet": 6,
"fjzze": 5,
"cjxxi": 5,
"cjxet": 6,
"cjxze": 5,
"cjyxi": 5,
"cjyet": 6,
"cjyze": 5,
"cjzxi": 5,
"cjzet": 6,
"cjzze": 5,
"CalcElemNodeNormals": 1,
"pfx": 15,
"pfy": 15,
"pfz": 15,
"ElemFaceNormal": 7,
"n1": 23,
"n2": 23,
"n3": 23,
"n4": 23,
"bisectX0": 3,
"bisectY0": 3,
"bisectZ0": 3,
"bisectX1": 3,
"bisectY1": 3,
"bisectZ1": 3,
"areaX": 5,
"areaY": 5,
"areaZ": 5,
"rx": 6,
"ry": 6,
"rz": 6,
"//results": 1,
"SumElemStressesToNodeForces": 1,
"stress_xx": 2,
"stress_yy": 2,
"stress_zz": 2,
"CalcElemVolumeDerivative": 1,
"VoluDer": 9,
"n0": 13,
"n5": 13,
"ox": 1,
"oy": 1,
"oz": 1,
"ox/12.0": 1,
"oy/12.0": 1,
"oz/12.0": 1,
"dvdx": 10,
"dvdy": 10,
"dvdz": 10,
"CalcElemFBHourglassForce": 1,
"hourgam": 7,
"coefficient": 4,
"hgfx": 2,
"hgfy": 2,
"hgfz": 2,
"hx": 3,
"hy": 3,
"hz": 3,
"shx": 3,
"shy": 3,
"shz": 3,
"CalcElemCharacteristicLength": 2,
"AreaFace": 7,
"p0": 7,
"p1": 7,
"p2": 7,
"p3": 7,
"gx": 5,
"gy": 5,
"gz": 5,
"area": 2,
"charLength": 2,
"sqrt": 10,
"CalcElemVelocityGradient": 2,
"xvel": 25,
"yvel": 25,
"zvel": 25,
"detJ": 5,
"d": 12,
"inv_detJ": 10,
"dyddx": 2,
"dxddy": 2,
"dzddx": 2,
"dxddz": 2,
"dzddy": 2,
"dyddz": 2,
"CalcPressureForElems": 4,
"p_new": 17,
"bvc": 15,
"pbvc": 14,
"e_old": 7,
"compression": 10,
"vnewc": 22,
"c1s": 3,
"abs": 8,
"//impossible": 1,
"targetdt": 1,
"//don": 1,
"t": 3,
"have": 2,
"negative": 2,
"determ": 1,
"can": 2,
"we": 1,
"be": 2,
"able": 1,
"write": 1,
"these": 1,
"as": 1,
"follows": 1,
"CalcVelocityForNodes": 1,
"local": 8,
"xdtmp": 4,
"ydtmp": 4,
"zdtmp": 4,
"CalcPositionForNodes": 1,
"ijk": 7,
"CalcLagrangeElements": 1,
"dxx": 6,
"dyy": 6,
"dzz": 6,
"CalcKinematicsForElems": 2,
"k": 20,
"vdovthird": 4,
"<=>": 7,
"0": 5,
"all": 1,
"elements": 3,
"8": 4,
"6": 1,
"nodal": 2,
"from": 2,
"global": 3,
"copy": 2,
"into": 3,
"xd_local": 4,
"yd_local": 4,
"zd_local": 4,
"dt2": 4,
"5": 1,
"wish": 1,
"this": 2,
"was": 1,
"too": 1,
"calculations": 1,
"relativeVolume": 3,
"1": 2,
"put": 1,
"velocity": 3,
"gradient": 3,
"quantities": 1,
"their": 1,
"2": 1,
"3": 1,
"sungeun": 1,
"Temporary": 1,
"array": 4,
"reused": 1,
"throughout": 1,
"delv_xi": 12,
"delv_eta": 12,
"delv_zeta": 12,
"position": 1,
"delx_xi": 7,
"delx_eta": 7,
"delx_zeta": 7,
"CalcQForElems": 1,
"MONOTONIC": 1,
"Q": 1,
"option": 1,
"Calculate": 1,
"gradients": 2,
"CalcMonotonicQGradientsForElems": 2,
"Transfer": 2,
"veloctiy": 1,
"first": 1,
"order": 1,
"problem": 1,
"commElements": 1,
"CommElements": 1,
"monoQ": 1,
"*/": 1,
"CalcMonotonicQForElems": 2,
"ApplyMaterialPropertiesForElems": 1,
"matelm": 2,
"vc": 6,
"exit": 1,
"EvalEOSForElems": 2,
"UpdateVolumesForElems": 1,
"tmpV": 4,
"ptiny": 9,
"xl": 26,
"yl": 26,
"zl": 26,
"xvl": 26,
"yvl": 26,
"zvl": 26,
"vol": 5,
"norm": 20,
"ax": 7,
"ay": 7,
"az": 7,
"dxv": 4,
"dyv": 4,
"dzv": 4,
"dxj": 1,
"dyj": 1,
"dzj": 1,
"dxi": 1,
"dyi": 1,
"dzi": 1,
"dxk": 1,
"dyk": 1,
"dzk": 1,
"dyi*dzj": 1,
"dzi*dyj": 1,
"dzi*dxj": 1,
"dxi*dzj": 1,
"dxi*dyj": 1,
"dyi*dxj": 1,
"ax*ax": 3,
"ay*ay": 3,
"az*az": 3,
"ax*dxv": 3,
"ay*dyv": 3,
"az*dzv": 3,
"dyj*dzk": 1,
"dzj*dyk": 1,
"dzj*dxk": 1,
"dxj*dzk": 1,
"dxj*dyk": 1,
"dyj*dxk": 1,
"dyk*dzi": 1,
"dzk*dyi": 1,
"dzk*dxi": 1,
"dxk*dzi": 1,
"dxk*dyi": 1,
"dyk*dxi": 1,
"//got": 1,
"rid": 1,
"of": 3,
"call": 1,
"through": 1,
"bcMask": 7,
"delvm": 27,
"delvp": 27,
"select": 6,
"when": 18,
"phixi": 10,
"phieta": 10,
"phizeta": 10,
"qlin": 4,
"qquad": 4,
"delvxxi": 4,
"delvxeta": 4,
"delvxzeta": 4,
"rho": 3,
"delvxxi**2": 1,
"phixi**2": 1,
"delvxeta**2": 1,
"phieta**2": 1,
"delvxzeta**2": 1,
"phizeta**2": 1,
"rho0": 8,
"delvc": 11,
"p_old": 8,
"q_old": 7,
"compHalfStep": 8,
"qq_old": 7,
"ql_old": 7,
"work": 5,
"e_new": 25,
"q_new": 11,
"vchalf": 2,
"CalcEnergyForElems": 2,
"CalcSoundSpeedForElems": 2,
"sixth": 2,
"pHalfStep": 5,
"vhalf": 1,
"ssc": 18,
"vhalf**2": 1,
"q_tilde": 4,
"**2": 6,
"enewc": 2,
"pnewc": 2,
"ssTmp": 4,
"elemToNodesTuple": 1,
"title": 2,
"string": 1,
"pi": 1,
"solarMass": 7,
"pi**2": 1,
"daysPerYear": 13,
"record": 1,
"body": 6,
"pos": 5,
"does": 1,
"not": 1,
"after": 1,
"it": 1,
"is": 1,
"up": 1,
"bodies": 8,
"numbodies": 5,
"bodies.numElements": 1,
"initSun": 2,
"writef": 2,
"advance": 2,
"b.v": 2,
"b.mass": 1,
".v": 1,
"updateVelocities": 2,
"b1": 2,
"b2": 2,
"dpos": 4,
"b1.pos": 2,
"b2.pos": 2,
"mag": 3,
"sumOfSquares": 4,
"**3": 1,
"b1.v": 2,
"b2.mass": 2,
"b2.v": 1,
"b1.mass": 3,
"b.pos": 1,
"Random": 1,
"random": 1,
"number": 1,
"generation": 1,
"Timer": 2,
"class": 1,
"timer": 2,
"sort": 1,
"**15": 1,
"size": 1,
"sorted": 1,
"thresh": 6,
"recursive": 1,
"depth": 1,
"serialize": 1,
"verbose": 7,
"out": 1,
"many": 1,
"bool": 1,
"disable": 1,
"numbers": 1,
"fillRandom": 1,
"timer.start": 1,
"pqsort": 4,
"timer.stop": 1,
"timer.elapsed": 1,
"arr": 32,
"low": 12,
"arr.domain.low": 1,
"high": 14,
"arr.domain.high": 1,
"where": 2,
"arr.rank": 2,
"bubbleSort": 2,
"pivotVal": 9,
"findPivot": 2,
"pivotLoc": 3,
"partition": 2,
"serial": 1,
"cobegin": 1,
"mid": 7,
"ilo": 9,
"ihi": 6,
"low..high": 2
},
"Cirru": { "Cirru": {
"print": 38, "print": 38,
"array": 14, "array": 14,
@@ -70803,6 +71598,7 @@
"COBOL": 90, "COBOL": 90,
"CSS": 43867, "CSS": 43867,
"Ceylon": 50, "Ceylon": 50,
"Chapel": 9607,
"Cirru": 244, "Cirru": 244,
"Clojure": 510, "Clojure": 510,
"CoffeeScript": 2951, "CoffeeScript": 2951,
@@ -71003,6 +71799,7 @@
"COBOL": 4, "COBOL": 4,
"CSS": 2, "CSS": 2,
"Ceylon": 1, "Ceylon": 1,
"Chapel": 5,
"Cirru": 9, "Cirru": 9,
"Clojure": 7, "Clojure": 7,
"CoffeeScript": 9, "CoffeeScript": 9,
@@ -71179,5 +71976,5 @@
"fish": 3, "fish": 3,
"wisp": 1 "wisp": 1
}, },
"md5": "b82e97a2c9c123d8e370eeffe64a1a1d" "md5": "4c7029e118ceca989e36b7f3c025a771"
} }

304
samples/Chapel/distributions.chpl Normal file
View File

@@ -0,0 +1,304 @@
//
// Distributions Primer
//
// This primer demonstrates uses of some of Chapel's standard
// distributions. To use these distributions in a Chapel program,
// the respective module must be used:
//
use BlockDist, CyclicDist, BlockCycDist, ReplicatedDist;
use DimensionalDist2D, ReplicatedDim, BlockCycDim;
//
// For each distribution, we'll create a distributed domain and array
// and then initialize it just to give a brief flavor of how the
// distribution maps across locales. Running this example on 6
// locales does a nice job of illustrating the distribution
// characteristics.
//
// All of these distributions support options to map to a different
// virtual locale grid than the one used by default (a
// multidimensional factoring of the built-in Locales array), as well
// as to control the amount of parallelism used in data parallel
// loops. See the Standard Distributions chapter of the language spec
// for more details.
//
//
// Make the program size configurable from the command line.
//
config const n = 8;
//
// Declare a 2-dimensional domain Space that we will later use to
// initialize the distributed domains.
//
const Space = {1..n, 1..n};
//
// The Block distribution distributes a bounding box from
// n-dimensional space across the target locale array viewed as an
// n-dimensional virtual locale grid. The bounding box is blocked
// into roughly equal portions across the locales. Note that domains
// declared over a Block distribution can also store indices outside
// of the bounding box; the bounding box is merely used to compute
// the blocking of space.
//
// In this example, we declare a 2-dimensional Block-distributed
// domain BlockSpace and a Block-distributed array BA declared over
// the domain.
//
const BlockSpace = Space dmapped Block(boundingBox=Space);
var BA: [BlockSpace] int;
//
// To illustrate how the index set is distributed across locales,
// we'll use a forall loop to initialize each array element to the
// locale ID that stores that index/element/iteration.
//
forall ba in BA do
ba = here.id;
//
// Output the Block-distributed array to visually see how the elements
// are partitioned across the locales.
//
writeln("Block Array Index Map");
writeln(BA);
writeln();
//
// Most of Chapel's standard distributions support an optional
// targetLocales argument that permits you to pass in your own
// array of locales to be targeted. In general, the targetLocales
// argument should match the rank of the distribution. So for
// example, to map a Block to a [numLocales x 1] view of the
// locale set, one could do something like this:
//
// We start by creating our own array of the locale values. Here
// we use the standard array reshape function for convenience,
// but more generally, this array could be accessed/assigned like any
// other.
//
var MyLocaleView = {0..#numLocales, 1..1};
var MyLocales: [MyLocaleView] locale = reshape(Locales, MyLocaleView);
//
// Then we'll declare a distributed domain/array that targets
// this view of the locales:
//
const BlockSpace2 = Space dmapped Block(boundingBox=Space,
targetLocales=MyLocales);
var BA2: [BlockSpace2] int;
//
// Then we'll do a similar computation as before to verify where
// everything ended up:
//
forall ba in BA2 do
ba = here.id;
writeln("Block Array Index Map");
writeln(BA2);
writeln();
//
// Next, we'll perform a similar computation for the Cyclic distribution.
// Cyclic distributions start at a designated n-dimensional index and
// distribute the n-dimensional space across an n-dimensional array
// of locales in a round-robin fashion (in each dimension). As with
// the Block distribution, domains may be declared using the
// distribution who have lower indices that the starting index; that
// value should just be considered a parameterization of how the
// distribution is defined.
//
const CyclicSpace = Space dmapped Cyclic(startIdx=Space.low);
var CA: [CyclicSpace] int;
forall ca in CA do
ca = here.id;
writeln("Cyclic Array Index Map");
writeln(CA);
writeln();
//
// Next, we'll declare a Block-Cyclic distribution. These
// distributions also deal out indices in a round-robin fashion,
// but rather than dealing out singleton indices, they deal out blocks
// of indices. Thus, the BlockCyclic distribution is parameterized
// by a starting index (as with Cyclic) and a block size (per
// dimension) specifying how large the chunks to be dealt out are.
//
const BlkCycSpace = Space dmapped BlockCyclic(startIdx=Space.low,
blocksize=(2, 3));
var BCA: [BlkCycSpace] int;
forall bca in BCA do
bca = here.id;
writeln("Block-Cyclic Array Index Map");
writeln(BCA);
writeln();
//
// The ReplicatedDist distribution is different: each of the
// original domain's indices - and the corresponding array elements -
// is replicated onto each locale. (Note: consistency among these
// array replicands is NOT maintained automatically.)
//
// This replication is observable in some cases but not others,
// as shown below. Note: this behavior may change in the future.
//
const ReplicatedSpace = Space dmapped ReplicatedDist();
var RA: [ReplicatedSpace] int;
// The replication is observable - this visits each replicand.
forall ra in RA do
ra = here.id;
writeln("Replicated Array Index Map, ", RA.numElements, " elements total");
writeln(RA);
writeln();
//
// The replication is observable when the replicated array is
// on the left-hand side. If the right-hand side is not replicated,
// it is copied into each replicand.
// We illustrate this using a non-distributed array.
//
var A: [Space] int = [(i,j) in Space] i*100 + j;
RA = A;
writeln("Replicated Array after being array-assigned into");
writeln(RA);
writeln();
//
// Analogously, each replicand will be visited and
// other participated expressions will be computed on each locale
// (a) when the replicated array is assigned a scalar:
// RA = 5;
// (b) when it appears first in a zippered forall loop:
// forall (ra, a) in zip(RA, A) do ...;
// (c) when it appears in a for loop:
// for ra in RA do ...;
//
// Zippering (RA,A) or (A,RA) in a 'for' loop will generate
// an error due to their different number of elements.
// Let RA store the Index Map again, for the examples below.
forall ra in RA do
ra = here.id;
//
// Only the local replicand is accessed - replication is NOT observable
// and consistency is NOT maintained - when:
// (a) the replicated array is indexed - an individual element is read...
//
on Locales(0) do
writeln("on ", here, ": ", RA(Space.low));
on Locales(LocaleSpace.high) do
writeln("on ", here, ": ", RA(Space.low));
writeln();
// ...or an individual element is written;
on Locales(LocaleSpace.high) do
RA(Space.low) = 7777;
writeln("Replicated Array after being indexed into");
writeln(RA);
writeln();
//
// (b) the replicated array is on the right-hand side of an assignment...
//
on Locales(LocaleSpace.high) do
A = RA + 4;
writeln("Non-Replicated Array after assignment from Replicated Array + 4");
writeln(A);
writeln();
//
// (c) ...or, generally, the replicated array or domain participates
// in a zippered forall loop, but not in the first position.
// The loop could look like:
//
// forall (a, (i,j), ra) in (A, ReplicatedSpace, RA) do ...;
//
//
// The DimensionalDist2D distribution lets us build a 2D distribution
// as a composition of specifiers for individual dimensions.
// Under such a "dimensional" distribution each dimension is handled
// independently of the other.
//
// The dimension specifiers are similar to the corresponding multi-dimensional
// distributions in constructor arguments and index-to-locale mapping rules.
// However, instead of an array of locales, a specifier constructor
// accepts just the number of locales that the indices in the corresponding
// dimension will be distributed across.
//
// The DimensionalDist2D constructor requires:
// * an [0..nl1-1, 0..nl2-1] array of locales, where
// nl1 and nl2 are the number of locales in each dimension, and
// * two dimension specifiers, created for nl1 and nl2 locale counts, resp.
//
// Presently, the following dimension specifiers are available
// (shown here with their constructor arguments):
//
// * ReplicatedDim(numLocales)
// * BlockDim(numLocales, boundingBoxLow, boundingBoxHigh)
// * BlockCyclicDim(lowIdx, blockSize, numLocales)
//
//
// The following example creates a dimensional distribution that
// replicates over 2 locales (when available) in the first dimemsion
// and distributes using block-cyclic distribution in the second dimension.
// The example computes nl1 and nl2 and reshapes MyLocales correspondingly.
//
var (nl1, nl2) = if numLocales == 1 then (1, 1) else (2, numLocales/2);
MyLocaleView = {0..#nl1, 0..#nl2};
MyLocales = reshape(Locales[0..#nl1*nl2], MyLocaleView);
const DimReplicatedBlockcyclicSpace = Space
dmapped DimensionalDist2D(MyLocales,
new ReplicatedDim(numLocales = nl1),
new BlockCyclicDim(numLocales = nl2,
lowIdx = 1, blockSize = 2));
var DRBA: [DimReplicatedBlockcyclicSpace] int;
// The ReplicatedDim specifier always accesses the local replicand.
// (This differs from how the ReplicatedDist distribution works.)
//
// This example visits each replicand. The behavior is the same
// regardless of the second index into MyLocales below.
for locId1 in 0..#nl1 do on MyLocales[locId1, 0] {
forall drba in DRBA do
drba = here.id;
writeln("Dimensional2D(Replicated,BlockCyclic) Array Index Map",
" from ", here);
// Technicality: 'writeln(DRBA)' would read DRBA always on Locale 0.
// Since we want to see what DRBA contains on the current locale,
// we use 'Helper' that is mapped using the default distribution.
// 'Helper = DRBA' captures the view of DRBA on the current locale,
// which we then print out.
const Helper: [Space] int = DRBA;
writeln(Helper);
writeln();
}

1
samples/Chapel/hello.chpl Normal file
View File

@@ -0,0 +1 @@
writeln("Hello, world!"); // print 'Hello, world!' to the console

1692
samples/Chapel/lulesh.chpl Normal file
View File

File diff suppressed because it is too large Load Diff

147
samples/Chapel/nbody.chpl Normal file
View File

@@ -0,0 +1,147 @@
/* The Computer Language Benchmarks Game
http://benchmarksgame.alioth.debian.org/
contributed by Albert Sidelnik
modified by Brad Chamberlain
*/
//
// The number of timesteps to simulate; may be set via the command-line
//
config const n = 10000;
//
// Constants representing pi, the solar mass, and the number of days per year
//
const pi = 3.141592653589793,
solarMass = 4 * pi**2,
daysPerYear = 365.24;
//
// a record representing one of the bodies in the solar system
//
record body {
var pos: 3*real;
var v: 3*real;
var mass: real; // does not change after it is set up
}
//
// the array of bodies that we'll be simulating
//
var bodies = [/* sun */
new body(mass = solarMass),
/* jupiter */
new body(pos = ( 4.84143144246472090e+00,
-1.16032004402742839e+00,
-1.03622044471123109e-01),
v = ( 1.66007664274403694e-03 * daysPerYear,
7.69901118419740425e-03 * daysPerYear,
-6.90460016972063023e-05 * daysPerYear),
mass = 9.54791938424326609e-04 * solarMass),
/* saturn */
new body(pos = ( 8.34336671824457987e+00,
4.12479856412430479e+00,
-4.03523417114321381e-01),
v = (-2.76742510726862411e-03 * daysPerYear,
4.99852801234917238e-03 * daysPerYear,
2.30417297573763929e-05 * daysPerYear),
mass = 2.85885980666130812e-04 * solarMass),
/* uranus */
new body(pos = ( 1.28943695621391310e+01,
-1.51111514016986312e+01,
-2.23307578892655734e-01),
v = ( 2.96460137564761618e-03 * daysPerYear,
2.37847173959480950e-03 * daysPerYear,
-2.96589568540237556e-05 * daysPerYear),
mass = 4.36624404335156298e-05 * solarMass),
/* neptune */
new body(pos = ( 1.53796971148509165e+01,
-2.59193146099879641e+01,
1.79258772950371181e-01),
v = ( 2.68067772490389322e-03 * daysPerYear,
1.62824170038242295e-03 * daysPerYear,
-9.51592254519715870e-05 * daysPerYear),
mass = 5.15138902046611451e-05 * solarMass)
];
//
// the number of bodies to be simulated
//
const numbodies = bodies.numElements;
//
// The computation involves initializing the sun's velocity,
// writing the initial energy, advancing the system through 'n'
// timesteps, and writing the final energy.
//
proc main() {
initSun();
writef("%.9r\n", energy());
for 1..n do
advance(0.01);
writef("%.9r\n", energy());
}
//
// compute the sun's initial velocity
//
proc initSun() {
const p = + reduce (for b in bodies do (b.v * b.mass));
bodies[1].v = -p / solarMass;
}
//
// advance the positions and velocities of all the bodies
//
proc advance(dt) {
for i in 1..numbodies {
for j in i+1..numbodies {
updateVelocities(bodies[i], bodies[j]);
inline proc updateVelocities(ref b1, ref b2) {
const dpos = b1.pos - b2.pos,
mag = dt / sqrt(sumOfSquares(dpos))**3;
b1.v -= dpos * b2.mass * mag;
b2.v += dpos * b1.mass * mag;
}
}
}
for b in bodies do
b.pos += dt * b.v;
}
//
// compute the energy of the bodies
//
proc energy() {
var e = 0.0;
for i in 1..numbodies {
const b1 = bodies[i];
e += 0.5 * b1.mass * sumOfSquares(b1.v);
for j in i+1..numbodies {
const b2 = bodies[j];
e -= (b1.mass * b2.mass) / sqrt(sumOfSquares(b1.pos - b2.pos));
}
}
return e;
}
//
// a helper routine to compute the sum of squares of a 3-tuple's components
//
inline proc sumOfSquares(x)
return x(1)**2 + x(2)**2 + x(3)**2;

145
samples/Chapel/quicksort.chpl Normal file
View File

@@ -0,0 +1,145 @@
//
// An example of a parallel quick sort implementation that uses
// "cobegin" to make each recursive call in parallel and "serial" to
// limit the number of threads.
//
use Random, Time; // for random number generation and the Timer class
var timer: Timer; // to time the sort
config var n: int = 2**15; // the size of the array to be sorted
config var thresh: int = 1; // the recursive depth to serialize
config var verbose: int = 0; // print out this many elements in array
config var timing: bool = true; // set timing to false to disable timer
var A: [1..n] real; // array of real numbers
//
// initialize array with random numbers
//
fillRandom(A);
//
// print out front of array if verbose flag is set
//
if verbose > 0 then
writeln("A[1..", verbose, "] = ", A[1..verbose]);
//
// start timer, call parallel quick sort routine, stop timer
//
if timing then timer.start();
pqsort(A, thresh);
if timing then timer.stop();
//
// report sort time
//
if timing then writeln("sorted in ", timer.elapsed(), " seconds");
//
// print out front of array if verbose flag is set
// values should now be in sorted order
//
if verbose > 0 then
writeln("A[1..", verbose, "] = ", A[1..verbose]);
//
// verify that array is sorted or halt
//
for i in 2..n do
if A(i) < A(i-1) then
halt("A(", i-1, ") == ", A(i-1), " > A(", i, ") == ", A(i));
writeln("verification success");
//
// pqsort -- parallel quick sort
//
// arr: generic 1D array of values (real, int, ...)
// thresh: number of recursive calls to make before serializing
// low: lower bound of array to start sort at, defaults to whole array
// high: upper bound of array to stop sort at, defaults to whole array
//
proc pqsort(arr: [],
thresh: int,
low: int = arr.domain.low,
high: int = arr.domain.high) where arr.rank == 1 {
//
// base case: arr[low..high] is small enough to bubble sort
//
if high - low < 8 {
bubbleSort(arr, low, high);
return;
}
//
// determine pivot and partition arr[low..high]
//
const pivotVal = findPivot();
const pivotLoc = partition(pivotVal);
//
// make recursive calls to parallel quick sort each unsorted half of
// the array; if thresh is 0 or less, start executing conquer tasks
// serially
//
serial thresh <= 0 do cobegin {
pqsort(arr, thresh-1, low, pivotLoc-1);
pqsort(arr, thresh-1, pivotLoc+1, high);
}
//
// findPivot -- helper routine to find pivot value using simple
// median-of-3 method, returns pivot value
//
proc findPivot() {
const mid = low + (high-low+1) / 2;
if arr(mid) < arr(low) then arr(mid) <=> arr(low);
if arr(high) < arr(low) then arr(high) <=> arr(low);
if arr(high) < arr(mid) then arr(high) <=> arr(mid);
const pivotVal = arr(mid);
arr(mid) = arr(high-1);
arr(high-1) = pivotVal;
return pivotVal;
}
//
// partition -- helper routine to partition array such that all
// values less than pivot are to its left and all
// values greater than pivot are to its right, returns
// pivot location
//
proc partition(pivotVal) {
var ilo = low, ihi = high-1;
while (ilo < ihi) {
do { ilo += 1; } while arr(ilo) < pivotVal;
do { ihi -= 1; } while pivotVal < arr(ihi);
if (ilo < ihi) {
arr(ilo) <=> arr(ihi);
}
}
arr(high-1) = arr(ilo);
arr(ilo) = pivotVal;
return ilo;
}
}
//
// bubbleSort -- bubble sort for base case of quick sort
//
// arr: generic 1D array of values (real, int, ...)
// low: lower bound of array to start sort at
// high: upper bound of array to stop sort at
//
proc bubbleSort(arr: [], low: int, high: int) where arr.rank == 1 {
for i in low..high do
for j in low..high-1 do
if arr(j) > arr(j+1) then
arr(j) <=> arr(j+1);
}