.. default-domain:: chpl .. _primers-learnChapelInYMinutes: learnChapelInYMinutes.chpl ========================== `View learnChapelInYMinutes.chpl on GitHub `_ Learn Chapel in Y Minutes This primer will go over basic syntax and concepts in Chapel. Comments are C-family style .. code-block:: chapel // one line comment multi-line comment .. primers-yminutes-printing: Basic printing -------------- .. code-block:: chapel write( "Hello, " ); writeln( "World!" ); ``write`` and ``writeln`` can take a list of things to print. Each thing is printed right next to the others, so include your spacing! .. code-block:: chapel writeln( "There are ", 3, " commas (\",\") in this line of code" ); Different output channels: .. code-block:: chapel stdout.writeln( "This goes to standard output, just like plain writeln() does"); stderr.writeln( "This goes to standard error" ); .. primers-yminutes-vars: Variables --------- Variables don't have to be explicitly typed as long as the compiler can figure out the type that it will hold. 10 is an ``int``, so ``myVar`` is implicitly an ``int`` .. code-block:: chapel var myVar = 10; myVar = -10; var mySecondVar = myVar; ``var anError;`` would be a compile-time error. We can (and should) explicitly type things. .. code-block:: chapel var myThirdVar: real; var myFourthVar: real = -1.234; myThirdVar = myFourthVar; .. primers-yminutes-types: Types ----- There are a number of basic types. .. code-block:: chapel var myInt: int = -1000; // Signed ints var myUint: uint = 1234; // Unsigned ints var myReal: real = 9.876; // Floating point numbers var myImag: imag = 5.0i; // Imaginary numbers var myCplx: complex = 10 + 9i; // Complex numbers myCplx = myInt + myImag ; // Another way to form complex numbers var myBool: bool = false; // Booleans var myStr: string = "Some string..."; // Strings Some types can have sizes. .. code-block:: chapel var my8Int: int(8) = 10; // 8 bit (one byte) sized int; var my64Real: real(64) = 1.516; // 64 bit (8 bytes) sized real Typecasting. .. code-block:: chapel var intFromReal = myReal : int; var intFromReal2: int = myReal : int; Type aliasing. .. code-block:: chapel type chroma = int; // Type of a single hue type RGBColor = 3*chroma; // Type representing a full color var black: RGBColor = ( 0,0,0 ); var white: RGBColor = ( 255, 255, 255 ); .. primers-yminutes-consts-params: Constants and Parameters ------------------------ A ``const`` is a constant, and cannot be changed after set in runtime. .. code-block:: chapel const almostPi: real = 22.0/7.0; A ``param`` is a constant whose value must be known statically at compile-time. Their value also cannot be changed. .. code-block:: chapel param compileTimeConst: int = 16; The ``config`` modifier allows values to be set at the command line. Set with ``--VarName=Value`` or ``--VarName Value`` at runtime. .. code-block:: chapel config var varCmdLineArg: int = -123; config const constCmdLineArg: int = 777; ``config param`` can be set/changed at compile-time. Set with ``--set paramCmdLineArg=value`` at compile-time. .. code-block:: chapel config param paramCmdLineArg: bool = false; writeln( varCmdLineArg, ", ", constCmdLineArg, ", ", paramCmdLineArg ); .. primers-yminutes-refs: References ---------- ``ref`` operates much like a reference in C++. Here, ``refToActual`` refers to ``actual``. .. code-block:: chapel var actual = 10; ref refToActual = actual; writeln( actual, " == ", refToActual ); // prints the same value actual = -123; // modify actual (which refToActual refers to) writeln( actual, " == ", refToActual ); // prints the same value refToActual = 99999999; // modify what refToActual refers to (which is actual) writeln( actual, " == ", refToActual ); // prints the same value .. primers-yminutes-ops: Operators --------- Math operators: .. code-block:: chapel var a: int, thisInt = 1234, thatInt = 5678; a = thisInt + thatInt; // Addition a = thisInt * thatInt; // Multiplication a = thisInt - thatInt; // Subtraction a = thisInt / thatInt; // Division a = thisInt ** thatInt; // Exponentiation a = thisInt % thatInt; // Remainder (modulo) Logical operators: .. code-block:: chapel var b: bool, thisBool = false, thatBool = true; b = thisBool && thatBool; // Logical and b = thisBool || thatBool; // Logical or b = !thisBool; // Logical negation Relational operators: .. code-block:: chapel b = thisInt > thatInt; // Greater-than b = thisInt >= thatInt; // Greater-than-or-equal-to b = thisInt < a && a <= thatInt; // Less-than, and, less-than-or-equal-to b = thisInt != thatInt; // Not-equal-to b = thisInt == thatInt; // Equal-to Bitwise operators: .. code-block:: chapel a = thisInt << 10; // Left-bit-shift by 10 bits; a = thatInt >> 5; // Right-bit-shift by 5 bits; a = ~thisInt; // Bitwise-negation a = thisInt ^ thatInt; // Bitwise exclusive-or Compound assignment operators: .. code-block:: chapel a += thisInt; // Addition-equals ( a = a + thisInt;) a *= thatInt; // Times-equals ( a = a * thatInt; ) b &&= thatBool; // Logical-and-equals ( b = b && thatBool; ) a <<= 3; // Left-bit-shift-equals ( a = a << 10; ) Unlike other C family languages, there are no pre/post-increment/decrement operators, such as: ``++j``, ``--j``, ``j++``, ``j--`` Swap operator: .. code-block:: chapel var old_this = thisInt; var old_that = thatInt; thisInt <=> thatInt; // Swap the values of thisInt and thatInt writeln( (old_this == thatInt) && (old_that == thisInt) ); Operator overloads can also be defined, as we'll see with procedures. .. primers-yminutes-tuples: Tuples ------ Tuples can be of the same type or different types. .. code-block:: chapel var sameTup: 2*int = (10,-1); var sameTup2 = (11, -6); var diffTup: (int,real,complex) = (5, 1.928, myCplx); var diffTupe2 = ( 7, 5.64, 6.0+1.5i ); They are accessed using array bracket notation but are 1-indexed. .. code-block:: chapel writeln( "(", sameTup[1], ",", sameTup[2], ")" ); writeln( diffTup ); Tuples can also be written into. .. code-block:: chapel diffTup[1] = -1; Tuple values can be expanded into their own variables. .. code-block:: chapel var (tupInt, tupReal, tupCplx) = diffTup; writeln( diffTup == (tupInt, tupReal, tupCplx) ); They are also useful for writing a list of variables, as is common in debugging. .. code-block:: chapel writeln( (a,b,thisInt,thatInt,thisBool,thatBool) ); .. primers-yminutes-control-flow: Control Flow ------------ ``if`` - ``then`` - ``else`` works just like any other C-family language. .. code-block:: chapel if 10 < 100 then writeln( "All is well" ); if -1 < 1 then writeln( "Continuing to believe reality" ); else writeln( "Send mathematician, something's wrong" ); if ( 10 > 100 ) { writeln( "Universe broken. Please reboot universe." ); } if ( a % 2 == 0 ) { writeln( a, " is even." ); } else { writeln( a, " is odd." ); } if ( a % 3 == 0 ) { writeln( a, " is even divisible by 3." ); } else if ( a % 3 == 1 ){ writeln( a, " is divided by 3 with a remainder of 1." ); } else { writeln( b, " is divided by 3 with a remainder of 2." ); } Ternary: ``if`` - ``then`` - ``else`` in a statement. .. code-block:: chapel var maximum = if ( thisInt < thatInt ) then thatInt else thisInt; ``select`` statements are much like switch statements in other languages. However, ``select`` statements don't cascade like in C or Java. .. code-block:: chapel var inputOption = "anOption"; select( inputOption ){ when "anOption" do writeln( "Chose 'anOption'" ); when "otherOption" { writeln( "Chose 'otherOption'" ); writeln( "Which has a body" ); } otherwise { writeln( "Any other Input" ); writeln( "the otherwise case doesn't need a do if the body is one line" ); } } ``while`` and ``do``-``while`` loops are basically the same as well. .. code-block:: chapel var j: int = 1; var jSum: int = 0; while( j <= 1000 ){ jSum += j; j += 1; } writeln( jSum ); do { jSum += j; j += 1; } while ( j <= 10000 ); writeln( jSum ); ``for`` loops are much like those in python in that they iterate over a range. Ranges themselves are types, and can be stuffed into variables. .. code-block:: chapel for i in 1..10 do write( i , ", ") ; writeln( ); var iSum: int = 0; for i in 1..1000 { iSum += i; } writeln( iSum ); for x in 1..10 { for y in 1..10 { write( (x,y), "\t" ); } writeln( ); } .. primers-yminutes-range-domain: Ranges and Domains ------------------ For-loops and arrays both use ranges and domains to define an index set that can be iterated over. Ranges are single dimensional integer indices, while domains can be multi-dimensional and represent indices of different types. They are first-class citizen types, and can be assigned into variables. .. code-block:: chapel var range1to10: range = 1..10; // 1, 2, 3, ..., 10 var range2to11 = 2..11; // 2, 3, 4, ..., 11 var rangeThisToThat: range = thisInt..thatInt; // using variables var rangeEmpty: range = 100..-100 ; // this is valid but contains no indices Ranges can be unbounded. .. code-block:: chapel var range1toInf: range(boundedType=BoundedRangeType.boundedLow) = 1.. ; // 1, 2, 3, 4, 5, ... var rangeNegInfTo1 = ..1; // ..., -4, -3, -2, -1, 0, 1 Ranges can be strided (and reversed) using the ``by`` operator. .. code-block:: chapel var range2to10by2: range(stridable=true) = 2..10 by 2; // 2, 4, 6, 8, 10 var reverse2to10by2 = 10..2 by -2; // 10, 8, 6, 4, 2 Note: ``range(boundedType= ... )`` and ``range(stridable= ... )`` are only necessary if we explicitly type the variable. The end point of a range can be determined using the count (``#``) operator. .. code-block:: chapel var rangeCount: range = -5..#12; // range from -5 to 6 Operators can be mixed. .. code-block:: chapel var rangeCountBy: range(stridable=true) = -5..#12 by 2; // -5, -3, -1, 1, 3, 5 writeln( rangeCountBy ); Properties of the range can be queried. In this example, printing the first index, last index, number of indices, stride, and if 2 is include in the range. .. code-block:: chapel writeln( ( rangeCountBy.first, rangeCountBy.last, rangeCountBy.length, rangeCountBy.stride, rangeCountBy.member( 2 ) ) ); for i in rangeCountBy { write( i, if i == rangeCountBy.last then "\n" else ", " ); } Rectangular domains are defined using the same range syntax, but they are required to be bounded (unlike ranges). .. code-block:: chapel var domain1to10: domain(1) = {1..10}; // 1D domain from 1..10; var twoDimensions: domain(2) = {-2..2,0..2}; // 2D domain over product of ranges var thirdDim: range = 1..16; var threeDims: domain(3) = {thirdDim, 1..10, 5..10}; // using a range variable Indices can be iterated over as tuples. .. code-block:: chapel for idx in twoDimensions do write( idx , ", "); writeln( ); These tuples can also be deconstructed. .. code-block:: chapel for (x,y) in twoDimensions { write( "(", x, ", ", y, ")", ", " ); } writeln( ); Associative domains act like sets. .. code-block:: chapel var stringSet: domain(string); // empty set of strings stringSet += "a"; stringSet += "b"; stringSet += "c"; stringSet += "a"; // Redundant add "a" stringSet -= "c"; // Remove "c" writeln( stringSet ); Both ranges and domains can be sliced to produce a range or domain with the intersection of indices. .. code-block:: chapel var rangeA = 1.. ; // range from 1 to infinity var rangeB = ..5; // range from negative infinity to 5 var rangeC = rangeA[rangeB]; // resulting range is 1..5 writeln( (rangeA, rangeB, rangeC ) ); var domainA = {1..10, 5..20}; var domainB = {-5..5, 1..10}; var domainC = domainA[domainB]; writeln( (domainA, domainB, domainC) ); .. primers-yminutes-array: Arrays ------ Arrays are similar to those of other languages. Their sizes are defined using domains that represent their indices. .. code-block:: chapel var intArray: [1..10] int; var intArray2: [{1..10}] int; // equivalent They are accessed using bracket notation. .. code-block:: chapel for i in 1..10 do intArray[i] = -i; writeln( intArray ); We cannot access ``intArray[0]`` because it exists outside of the index set, ``{1..10}``, we defined it to have. ``intArray[11]`` is illegal for the same reason. .. code-block:: chapel var realDomain: domain(2) = {1..5,1..7}; var realArray: [realDomain] real; var realArray2: [1..5,1..7] real; // equivalent var realArray3: [{1..5,1..7}] real; // equivalent for i in 1..5 { for j in realDomain.dim(2) { // Only use the 2nd dimension of the domain realArray[i,j] = -1.61803 * i + 0.5 * j; // Access using index list var idx: 2*int = (i,j); // Note: 'index' is a keyword realArray[idx] = - realArray[(i,j)]; // Index using tuples } } Arrays have domains as members, and can be iterated over as normal. .. code-block:: chapel for idx in realArray.domain { // Again, idx is a 2*int tuple realArray[idx] = 1 / realArray[idx[1],idx[2]]; // Access by tuple and list } writeln( realArray ); The values of an array can also be iterated directly. .. code-block:: chapel var rSum: real = 0; for value in realArray { rSum += value; // Read a value value = rSum; // Write a value } writeln( rSum, "\n", realArray ); Associative arrays (dictionaries) can be created using associative domains. .. code-block:: chapel var dictDomain: domain(string) = { "one", "two" }; var dict: [dictDomain] int = [ "one" => 1, "two" => 2 ]; dict["three"] = 3; for key in dictDomain do writeln( dict[key] ); Arrays can be assigned to each other in a few different ways. These arrays will be used in the example. .. code-block:: chapel var thisArray : [{0..5}] int = [0,1,2,3,4,5]; var thatArray : [{0..5}] int; First, simply assign one to the other. This copies ``thisArray`` into ``thatArray``, instead of just creating a reference. Therefore, modifying ``thisArray`` does not also modify ``thatArray``. .. code-block:: chapel thatArray = thisArray; thatArray[1] = -1; writeln( (thisArray, thatArray) ); Assign a slice from one array to a slice (of the same size) in the other. .. code-block:: chapel thatArray[{4..5}] = thisArray[{1..2}]; writeln( (thisArray, thatArray) ); Operations can also be promoted to work on arrays. .. code-block:: chapel var thisPlusThat = thisArray + thatArray; writeln( thisPlusThat ); Moving on, arrays and loops can also be expressions, where the loop body's expression is the result of each iteration. .. code-block:: chapel var arrayFromLoop = for i in 1..10 do i; writeln( arrayFromLoop ); An expression can result in nothing, such as when filtering with an if-expression. .. code-block:: chapel var evensOrFives = for i in 1..10 do if (i % 2 == 0 || i % 5 == 0) then i; writeln( arrayFromLoop ); Array expressions can also be written with a bracket notation. Note: this syntax uses the ``forall`` parallel concept discussed later. .. code-block:: chapel var evensOrFivesAgain = [ i in 1..10 ] if (i % 2 == 0 || i % 5 == 0) then i; They can also be written over the values of the array. .. code-block:: chapel arrayFromLoop = [ value in arrayFromLoop ] value + 1; Note: This notation can get somewhat tricky. For example, this code would break, for reasons to be explained when discussing zipped iterators. .. code-block:: chapel evensOrFives = [ i in 1..10 ] if (i % 2 == 0 || i % 5 == 0) then i; .. primers-yminutes-proc: Procedures ---------- Chapel procedures have similar syntax functions in other languages. .. code-block:: chapel proc fibonacci( n : int ) : int { if ( n <= 1 ) then return n; return fibonacci( n-1 ) + fibonacci( n-2 ); } Input parameters can be untyped to create a generic procedure. .. code-block:: chapel proc doublePrint( thing ): void { write( thing, " ", thing, "\n"); } The return type can be inferred, as long as the compiler can figure it out. .. code-block:: chapel proc addThree( n ) { return n + 3; } doublePrint( addThree( fibonacci( 20 ) ) ); It is also possible to take an 'unlimited' number of parameters. .. code-block:: chapel proc maxOf( x ...?k ) { // x refers to a tuple of one type, with k elements var maximum = x[1]; for i in 2..k do maximum = if (maximum < x[i]) then x[i] else maximum; return maximum; } writeln( maxOf( 1, -10, 189, -9071982, 5, 17, 20001, 42 ) ); Procedures can have default parameter values, and the parameters can be named in the call, even out of order. .. code-block:: chapel proc defaultsProc( x: int, y: real = 1.2634 ): (int,real) { return (x,y); } writeln( defaultsProc( 10 ) ); writeln( defaultsProc( x=11 ) ); writeln( defaultsProc( x=12, y=5.432 ) ); writeln( defaultsProc( y=9.876, x=13 ) ); The ``?`` operator is called the query operator, and is used to take undetermined values like tuple or array sizes and generic types. For example, taking arrays as parameters. The query operator is used to determine the domain of ``A``. This is important for defining the return type, though it's not required. .. code-block:: chapel proc invertArray( A: [?D] int ): [D] int{ for a in A do a = -a; return A; } writeln( invertArray( intArray ) ); We can query the type of arguments to generic procedures. Here we define a procedure that takes two arguments of the same type, yet we don't define what that type is. .. code-block:: chapel proc genericProc( arg1 : ?valueType, arg2 : valueType ): void { select( valueType ){ when int do writeln( arg1, " and ", arg2, " are ints" ); when real do writeln( arg1, " and ", arg2, " are reals" ); otherwise writeln( arg1, " and ", arg2, " are somethings!" ); } } genericProc( 1, 2 ); genericProc( 1.2, 2.3 ); genericProc( 1.0+2.0i, 3.0+4.0i ); We can also enforce a form of polymorphism with the ``where`` clause This allows the compiler to decide which function to use. Note: That means that all information needs to be known at compile-time. The param modifier on the arg is used to enforce this constraint. .. code-block:: chapel proc whereProc( param N : int ): void where ( N > 0 ) { writeln( "N is greater than 0" ); } proc whereProc( param N : int ): void where ( N < 0 ) { writeln( "N is less than 0" ); } whereProc( 10 ); whereProc( -1 ); ``whereProc( 0 )`` would result in a compiler error because there are no functions that satisfy the ``where`` clause's condition. We could have defined a ``whereProc`` without a ``where`` clause that would then have served as a catch all for all the other cases (of which there is only one). .. primers-yminutes-intent: Intents ------- Intent modifiers on the arguments convey how those arguments are passed to the procedure. * in: copy arg in, but not out * out: copy arg out, but not in * inout: copy arg in, copy arg out * ref: pass arg by reference .. code-block:: chapel proc intentsProc( in inarg, out outarg, inout inoutarg, ref refarg ){ writeln( "Inside Before: ", (inarg, outarg, inoutarg, refarg) ); inarg = inarg + 100; outarg = outarg + 100; inoutarg = inoutarg + 100; refarg = refarg + 100; writeln( "Inside After: ", (inarg, outarg, inoutarg, refarg) ); } var inVar: int = 1; var outVar: int = 2; var inoutVar: int = 3; var refVar: int = 4; writeln( "Outside Before: ", (inVar, outVar, inoutVar, refVar) ); intentsProc( inVar, outVar, inoutVar, refVar ); writeln( "Outside After: ", (inVar, outVar, inoutVar, refVar) ); Similarly, we can define intents on the return type. ``refElement`` returns a reference to an element of array. This makes more practical sense for class methods where references to elements in a data-structure are returned via a method or iterator. .. code-block:: chapel proc refElement( array : [?D] ?T, idx ) ref : T { return array[ idx ]; } var myChangingArray : [1..5] int = [1,2,3,4,5]; writeln( myChangingArray ); ref refToElem = refElement( myChangingArray, 5 ); // store reference to element in ref variable writeln( refToElem ); refToElem = -2; // modify reference which modifies actual value in array writeln( refToElem ); writeln( myChangingArray ); .. primers-yminutes-op-defs: Operator Definitions -------------------- Operator definitions are through procedures as well. We can define the unary operators: ``+ - ! ~`` and the binary operators: ``+ - * / % ** == <= >= < > << >> & | ˆ by`` ``+= -= *= /= %= **= &= |= ˆ= <<= >>= <=>`` Boolean exclusive or operator. .. code-block:: chapel proc ^( left : bool, right : bool ): bool { return (left || right) && !( left && right ); } writeln( true ^ true ); writeln( false ^ true ); writeln( true ^ false ); writeln( false ^ false ); Define a ``*`` operator on any two types that returns a tuple of those types. .. code-block:: chapel proc *( left : ?ltype, right : ?rtype): ( ltype, rtype ){ return (left, right ); } writeln( 1 * "a" ); // Uses our ``*`` operator. writeln( 1 * 2 ); // Uses the default ``*`` operator. Note: You could break everything if you get careless with your overloads. This here will break everything. Don't do it. .. code-block:: chapel proc +( left: int, right: int ): int { return left - right; } .. primers-yminutes-iterators: Iterators --------- Iterators are sisters to the procedure, and almost everything about procedures also applies to iterators. However, instead of returning a single value, iterators yield many values to a loop. This is useful when a complicated set or order of iterations is needed, as it allows the code defining the iterations to be separate from the loop body. .. code-block:: chapel iter oddsThenEvens( N: int ): int { for i in 1..N by 2 do yield i; // yield values instead of returning. for i in 2..N by 2 do yield i; } for i in oddsThenEvens( 10 ) do write( i, ", " ); writeln( ); Iterators can also yield conditionally, the result of which can be nothing .. code-block:: chapel iter absolutelyNothing( N ): int { for i in 1..N { if ( N < i ) { // Always false yield i; // Yield statement never happens } } } for i in absolutelyNothing( 10 ) { writeln( "Woa there! absolutelyNothing yielded ", i ); } We can zipper together two or more iterators (who have the same number of iterations) using ``zip()`` to create a single zipped iterator, where each iteration of the zipped iterator yields a tuple of one value yielded from each iterator. .. code-block:: chapel for (positive, negative) in zip( 1..5, -5..-1) do writeln( (positive, negative) ); Zipper iteration is quite important in the assignment of arrays, slices of arrays, and array/loop expressions. .. code-block:: chapel var fromThatArray : [1..#5] int = [1,2,3,4,5]; var toThisArray : [100..#5] int; Some zipper operations implement other operations. The first statement and the loop are equivalent. .. code-block:: chapel toThisArray = fromThatArray; for (i,j) in zip( toThisArray.domain, fromThatArray.domain) { toThisArray[ i ] = fromThatArray[ j ]; } These two chunks are also equivalent. .. code-block:: chapel toThisArray = [ j in -100..#5 ] j; writeln( toThisArray ); for (i, j) in zip( toThisArray.domain, -100..#5 ){ toThisArray[i] = j; } writeln( toThisArray ); This is very important in understanding why this statement exhibits a runtime error. .. code-block:: chapel var iterArray : [1..10] int = [ i in 1..10 ] if ( i % 2 == 1 ) then j; Even though the domain of the array and the loop-expression are the same size, the body of the expression can be thought of as an iterator. Because iterators can yield nothing, that iterator yields a different number of things than the domain of the array or loop, which is not allowed. .. primers-yminutes-classes: Classes ------- Classes are similar to those in C++ and Java, allocated on the heap. .. code-block:: chapel class MyClass { Member variables .. code-block:: chapel var memberInt : int; var memberBool : bool = true; proc MyClass( val : real ){ this.memberInt = ceil( val ): int; } Explicitly defined constructor. (There are default constructors.) .. code-block:: chapel proc ~MyClass( ){ writeln( "MyClass Destructor called ", (this.memberInt, this.memberBool) ); } Class methods. .. code-block:: chapel proc setMemberInt( val: int ){ this.memberInt = val; } proc setMemberBool( val: bool ){ this.memberBool = val; } proc getMemberInt( ): int{ return this.memberInt; } proc getMemberBool( ): bool { return this.memberBool; } } // end MyClass Default constructor, using default values. .. code-block:: chapel var myObject = new MyClass( 10 ); myObject = new MyClass( memberInt = 10 ); // Equivalent writeln( myObject.getMemberInt( ) ); Same, but using our values. .. code-block:: chapel var myDiffObject = new MyClass( -1, true ); myDiffObject = new MyClass( memberInt = -1, memberBool = true ); // Equivalent writeln( myDiffObject ); Using the written constructor. .. code-block:: chapel var myOtherObject = new MyClass( 1.95 ); myOtherObject = new MyClass( val = 1.95 ); // Equivalent writeln( myOtherObject.getMemberInt( ) ); We can define an operator on our class as well, but the definition has to be outside the class definition. .. code-block:: chapel proc +( A : MyClass, B : MyClass) : MyClass { return new MyClass( memberInt = A.getMemberInt( ) + B.getMemberInt( ), memberBool = A.getMemberBool( ) || B.getMemberBool( ) ); } var plusObject = myObject + myDiffObject; writeln( plusObject ); Destruction. .. code-block:: chapel delete myObject; delete myDiffObject; delete myOtherObject; delete plusObject; Classes can inherit from one or more parent classes .. code-block:: chapel class MyChildClass : MyClass { var memberComplex: complex; } Here's an example of generic classes. .. code-block:: chapel class GenericClass { type classType; var classDomain: domain(1); var classArray: [classDomain] classType; Explicit constructor. .. code-block:: chapel proc GenericClass( type classType, elements : int ){ this.classDomain = {1..#elements}; } Copy constructor. Note: We still have to put the type as an argument, but we can default to the type of the other object using the query (``?``) operator. Further, we can take advantage of this to allow our copy constructor to copy classes of different types and cast on the fly. .. code-block:: chapel proc GenericClass( other : GenericClass(?otherType), type classType = otherType ) { this.classDomain = other.classDomain; // Copy and cast for idx in this.classDomain do this[ idx ] = other[ idx ] : classType; } Define bracket notation on a GenericClass object so it can behave like a normal array i.e. ``objVar[ i ]`` or ``objVar( i )`` .. code-block:: chapel proc this( i : int ) ref : classType { return this.classArray[ i ]; } Define an implicit iterator for the class to yield values from the array to a loop i.e. ``for i in objVar do ...`` .. code-block:: chapel iter these( ) ref : classType { for i in this.classDomain do yield this[i]; } } // end GenericClass We can assign to the member array of the object using the bracket notation that we defined. .. code-block:: chapel var realList = new GenericClass( real, 10 ); for i in realList.classDomain do realList[i] = i + 1.0; We can iterate over the values in our list with the iterator we defined. .. code-block:: chapel for value in realList do write( value, ", " ); writeln( ); Make a copy of realList using the copy constructor. .. code-block:: chapel var copyList = new GenericClass( realList ); for value in copyList do write( value, ", " ); writeln( ); Make a copy of realList and change the type, also using the copy constructor. .. code-block:: chapel var copyNewTypeList = new GenericClass( realList, int ); for value in copyNewTypeList do write( value, ", " ); writeln( ); .. primers-yminutes-modules: Modules ------- Modules are Chapel's way of managing name spaces. The files containing these modules do not need to be named after the modules (as in Java), but files implicitly name modules. For example, this file implicitly names the ``learnChapelInYMinutes`` module .. code-block:: chapel module OurModule { We can use modules inside of other modules. Time is one of the standard modules. .. code-block:: chapel use Time; We'll use this procedure in the parallelism section. .. code-block:: chapel proc countdown( seconds: int ){ for i in 1..seconds by -1 { writeln( i ); sleep( 1 ); } } It is possible to create arbitrarily deep module nests. i.e. submodules of OurModule .. code-block:: chapel module ChildModule { proc foo(){ writeln( "ChildModule.foo()"); } } module SiblingModule { proc foo(){ writeln( "SiblingModule.foo()" ); } } } // end OurModule Using ``OurModule`` also uses all the modules it uses. Since ``OurModule`` uses ``Time``, we also use ``Time``. .. code-block:: chapel use OurModule; At this point we have not used ``ChildModule`` or ``SiblingModule`` so their symbols (i.e. ``foo`` ) are not available to us. However, the module names are available, and we can explicitly call ``foo()`` through them. .. code-block:: chapel SiblingModule.foo(); OurModule.ChildModule.foo(); Now we use ``ChildModule``, enabling unqualified calls. .. code-block:: chapel use ChildModule; foo(); .. primers-yminutes-parallelism: Parallelism ----------- In other languages, parallelism is typically done with complicated libraries and strange class structure hierarchies. Chapel has it baked right into the language. We can declare a main procedure, but all the code above main still gets executed. .. code-block:: chapel proc main(){ writeln("PARALLELISM START"); A ``begin`` statement will spin the body of that statement off into one new task. A ``sync`` statement will ensure that the progress of the main task will not progress until the children have synced back up. .. code-block:: chapel sync { begin { // Start of new task's body var a = 0; for i in 1..1000 do a += 1; writeln( "Done: ", a); } // End of new tasks body writeln( "spun off a task!"); } writeln( "Back together" ); proc printFibb( n: int ){ writeln( "fibonacci(",n,") = ", fibonacci( n ) ); } A ``cobegin`` statement will spin each statement of the body into one new task Notice here that the prints from each statement may happen in any order. .. code-block:: chapel cobegin { printFibb( 20 ); // new task printFibb( 10 ); // new task printFibb( 5 ); // new task { // This is a nested statement body and thus is a single statement // to the parent statement, executed by a single task. writeln( "this gets" ); writeln( "executed as" ); writeln( "a whole" ); } } A ``coforall`` loop will create a new task for EACH iteration. Again we see that prints happen in any order. NOTE: ``coforall`` should be used only for creating tasks! Using it to iterating over a structure is very a bad idea! .. code-block:: chapel var num_tasks = 10; // Number of tasks we want coforall taskID in 1..#num_tasks { writeln( "Hello from task# ", taskID ); } ``forall`` loops are another parallel loop, but only create a smaller number of tasks, specifically ``--dataParTasksPerLocale=`` number of tasks. .. code-block:: chapel forall i in 1..100 { write( i, ", "); } writeln( ); Here we see that there are sections that are in order, followed by a section that would not follow ( e.g. 1, 2, 3, 7, 8, 9, 4, 5, 6, ). This is because each task is taking on a chunk of the range 1..10 (1..3, 4..6, or 7..9) doing that chunk serially, but each task happens in parallel. Your results may depend on your machine and configuration For both the ``forall`` and ``coforall`` loops, the execution of the parent task will not continue until all the children sync up. ``forall`` loops are particularly useful for parallel iteration over arrays. Lets run an experiment to see how much faster a parallel loop is .. code-block:: chapel use Time; // Import the Time module to use Timer objects var timer: Timer; var myBigArray: [{1..4000,1..4000}] real; // Large array we will write into Serial Experiment: .. code-block:: chapel timer.start( ); // Start timer for (x,y) in myBigArray.domain { // Serial iteration myBigArray[x,y] = (x:real) / (y:real); } timer.stop( ); // Stop timer writeln( "Serial: ", timer.elapsed( ) ); // Print elapsed time timer.clear( ); // Clear timer for parallel loop Parallel Experiment: .. code-block:: chapel timer.start( ); // start timer forall (x,y) in myBigArray.domain { // Parallel iteration myBigArray[x,y] = (x:real) / (y:real); } timer.stop( ); // Stop timer writeln( "Parallel: ", timer.elapsed( ) ); // Print elapsed time timer.clear( ); You may have noticed that (depending on how many cores you have) the parallel loop went faster than the serial loop. The bracket style loop-expression described much earlier implicitly uses a ``forall`` loop. .. code-block:: chapel [ val in myBigArray ] val = 1 / val; // Parallel operation Atomic variables, common to many languages, are ones whose operations occur uninterrupted. Multiple threads can therefore modify atomic variables and can know that their values are safe. Chapel atomic variables can be of type ``bool``, ``int``, ``uint``, and ``real``. .. code-block:: chapel var uranium: atomic int; uranium.write( 238 ); // atomically write a variable writeln( uranium.read() ); // atomically read a variable Atomic operations are described as functions, so you can define your own. .. code-block:: chapel uranium.sub( 3 ); // atomically subtract a variable writeln( uranium.read() ); var replaceWith = 239; var was = uranium.exchange( replaceWith ); writeln( "uranium was ", was, " but is now ", replaceWith ); var isEqualTo = 235; if ( uranium.compareExchange( isEqualTo, replaceWith ) ) { writeln( "uranium was equal to ", isEqualTo, " so replaced value with ", replaceWith ); } else { writeln( "uranium was not equal to ", isEqualTo, " so value stays the same... whatever it was" ); } sync { begin { // Reader task writeln( "Reader: waiting for uranium to be ", isEqualTo ); uranium.waitFor( isEqualTo ); writeln( "Reader: uranium was set (by someone) to ", isEqualTo ); } begin { // Writer task writeln( "Writer: will set uranium to the value ", isEqualTo, " in..." ); countdown( 3 ); uranium.write( isEqualTo ); } } ``sync`` variables have two states: empty and full. If you read an empty variable or write a full variable, you are waited until the variable is full or empty again. .. code-block:: chapel var someSyncVar$: sync int; // varName$ is a convention not a law. sync { begin { // Reader task writeln( "Reader: waiting to read." ); var read_sync = someSyncVar$; writeln( "Reader: value is ", read_sync ); } begin { // Writer task writeln( "Writer: will write in..." ); countdown( 3 ); someSyncVar$ = 123; } } ``single`` vars can only be written once. A read on an unwritten ``single`` results in a wait, but when the variable has a value it can be read indefinitely. .. code-block:: chapel var someSingleVar$: single int; // varName$ is a convention not a law. sync { begin { // Reader task writeln( "Reader: waiting to read." ); for i in 1..5 { var read_single = someSingleVar$; writeln( "Reader: iteration ", i,", and the value is ", read_single ); } } begin { // Writer task writeln( "Writer: will write in..." ); countdown( 3 ); someSingleVar$ = 5; // first and only write ever. } } Heres an example using atomics and a ``sync`` variable to create a count-down mutex (also known as a multiplexer). .. code-block:: chapel var count: atomic int; // our counter var lock$: sync bool; // the mutex lock count.write( 2 ); // Only let two tasks in at a time. lock$.writeXF( true ); // Set lock$ to full (unlocked) // Note: The value doesnt actually matter, just the state // (full:unlocked / empty:locked) // Also, writeXF() fills (F) the sync var regardless of its state (X) coforall task in 1..#5 { // Generate tasks // Create a barrier do { lock$; // Read lock$ (wait) } while ( count.read() < 1 ); // Keep waiting until a spot opens up count.sub(1); // decrement the counter lock$.writeXF( true ); // Set lock$ to full (signal) // Actual 'work' writeln( "Task #", task, " doing work." ); sleep( 2 ); count.add( 1 ); // Increment the counter lock$.writeXF( true ); // Set lock$ to full (signal) } We can define the operations ``+ * & | ^ && || min max minloc maxloc`` over an entire array using scans and reductions. Reductions apply the operation over the entire array and result in a scalar value. .. code-block:: chapel var listOfValues: [1..10] int = [15,57,354,36,45,15,456,8,678,2]; var sumOfValues = + reduce listOfValues; var maxValue = max reduce listOfValues; // 'max' give just max value ``maxloc`` gives max value and index of the max value. Note: We have to zip the array and domain together with the zip iterator. .. code-block:: chapel var (theMaxValue, idxOfMax) = maxloc reduce zip(listOfValues, listOfValues.domain); writeln( (sumOfValues, maxValue, idxOfMax, listOfValues[ idxOfMax ] ) ); Scans apply the operation incrementally and return an array with the values of the operation at that index as it progressed through the array from ``array.domain.low`` to ``array.domain.high``. .. code-block:: chapel var runningSumOfValues = + scan listOfValues; var maxScan = max scan listOfValues; writeln( runningSumOfValues ); writeln( maxScan ); } // end main()