- File:
-
- 1 edited
-
doc/proposals/concurrency/text/cforall.tex (modified) (9 diffs)
Legend:
- Unmodified
- Added
- Removed
-
doc/proposals/concurrency/text/cforall.tex
ra2ea829 rcf966b5 1 1 % ====================================================================== 2 2 % ====================================================================== 3 \chapter{ CforallOverview}3 \chapter{\CFA Overview} 4 4 % ====================================================================== 5 5 % ====================================================================== … … 7 7 The following is a quick introduction to the \CFA language, specifically tailored to the features needed to support concurrency. 8 8 9 \CFA is a extension of ISO-C and therefore supports all of the same paradigms as C. It is a non-object oriented system language, meaning most of the major abstractions have either no runtime overhead or can be opt-out easily. Like C, the basics of \CFA revolve around structures and routines, which are thin abstractions over machine code. The vast majority of the code produced by the \CFA translator respects memory-layouts and calling-conventions laid out by C. Interestingly, while \CFA is not an object-oriented language, lacking the concept of a receiver (e.g., this), it does have some notion of objects\footnote{C defines the term objects as : ``region of data storage in the execution environment, the contents of which can represent10 values'' \cite[3.15]{C11}}, most importantly construction and destruction of objects. Most of the following code examples can be found on the \CFA website\cite{www-cfa}9 \CFA is an extension of ISO-C and therefore supports all of the same paradigms as C. It is a non-object-oriented system-language, meaning most of the major abstractions have either no runtime overhead or can be opt-out easily. Like C, the basics of \CFA revolve around structures and routines, which are thin abstractions over machine code. The vast majority of the code produced by the \CFA translator respects memory-layouts and calling-conventions laid out by C. Interestingly, while \CFA is not an object-oriented language, lacking the concept of a receiver (e.g., {\tt this}), it does have some notion of objects\footnote{C defines the term objects as : ``region of data storage in the execution environment, the contents of which can represent 10 values''~\cite[3.15]{C11}}, most importantly construction and destruction of objects. Most of the following code examples can be found on the \CFA website~\cite{www-cfa} 11 11 12 % ====================================================================== 12 13 \section{References} 13 14 14 Like \CC, \CFA introduces rebind able references providing multiple dereferecing as an alternative to pointers. In regards to concurrency, the semantic difference between pointers and references are not particularly relevant, but since this document uses mostly references, here is a quick overview of the semantics:15 Like \CC, \CFA introduces rebind-able references providing multiple dereferencing as an alternative to pointers. In regards to concurrency, the semantic difference between pointers and references are not particularly relevant, but since this document uses mostly references, here is a quick overview of the semantics: 15 16 \begin{cfacode} 16 17 int x, *p1 = &x, **p2 = &p1, ***p3 = &p2, … … 21 22 *p3 = ...; //change p2 22 23 int y, z, & ar[3] = {x, y, z}; //initialize array of references 23 typeof( ar[1]) p; //is int, i.e., the type of referenced object24 typeof(&ar[1]) q; //is int &, i.e., the type of reference25 sizeof( ar[1]) == sizeof(int); //is true, i.e., the size of referenced object26 sizeof(&ar[1]) == sizeof(int *); //is true, i.e., the size of a reference24 typeof( ar[1]) p; //is int, referenced object type 25 typeof(&ar[1]) q; //is int &, reference type 26 sizeof( ar[1]) == sizeof(int); //is true, referenced object size 27 sizeof(&ar[1]) == sizeof(int *); //is true, reference size 27 28 \end{cfacode} 28 The important take away from this code example is that references offer a handle to an object, much like pointers, but which is automatically dereferenced for convinience.29 The important take away from this code example is that a reference offers a handle to an object, much like a pointer, but which is automatically dereferenced for convenience. 29 30 31 % ====================================================================== 30 32 \section{Overloading} 31 33 32 Another important feature of \CFA is function overloading as in Java and \CC, where routines with the same name are selected based on the number and type of the arguments. As well, \CFA uses the return type as part of the selection criteria, as in Ada \cite{Ada}. For routines with multiple parameters and returns, the selection is complex.34 Another important feature of \CFA is function overloading as in Java and \CC, where routines with the same name are selected based on the number and type of the arguments. As well, \CFA uses the return type as part of the selection criteria, as in Ada~\cite{Ada}. For routines with multiple parameters and returns, the selection is complex. 33 35 \begin{cfacode} 34 36 //selection based on type and number of parameters … … 48 50 This feature is particularly important for concurrency since the runtime system relies on creating different types to represent concurrency objects. Therefore, overloading is necessary to prevent the need for long prefixes and other naming conventions that prevent name clashes. As seen in chapter \ref{basics}, routine \code{main} is an example that benefits from overloading. 49 51 52 % ====================================================================== 50 53 \section{Operators} 51 54 Overloading also extends to operators. The syntax for denoting operator-overloading is to name a routine with the symbol of the operator and question marks where the arguments of the operation occur, e.g.: … … 67 70 While concurrency does not use operator overloading directly, this feature is more important as an introduction for the syntax of constructors. 68 71 72 % ====================================================================== 69 73 \section{Constructors/Destructors} 70 74 Object life-time is often a challenge in concurrency. \CFA uses the approach of giving concurrent meaning to object life-time as a mean of synchronization and/or mutual exclusion. Since \CFA relies heavily on the life time of objects, constructors and destructors are a core feature required for concurrency and parallelism. \CFA uses the following syntax for constructors and destructors : … … 82 86 } 83 87 int main() { 84 S x = {10}, y = {100}; //implic t calls: ?{}(x, 10), ?{}(y, 100)88 S x = {10}, y = {100}; //implicit calls: ?{}(x, 10), ?{}(y, 100) 85 89 ... //use x and y 86 90 ^x{}; ^y{}; //explicit calls to de-initialize 87 91 x{20}; y{200}; //explicit calls to reinitialize 88 92 ... //reuse x and y 89 } //implic t calls: ^?{}(y), ^?{}(x)93 } //implicit calls: ^?{}(y), ^?{}(x) 90 94 \end{cfacode} 91 95 The language guarantees that every object and all their fields are constructed. Like \CC, construction of an object is automatically done on allocation and destruction of the object is done on deallocation. Allocation and deallocation can occur on the stack or on the heap. … … 99 103 delete(s); //deallocation, call destructor 100 104 \end{cfacode} 101 Note that like \CC, \CFA introduces \code{new} and \code{delete}, which behave like \code{malloc} and \code{free} in addition to constructing and destructing objects, after calling \code{malloc} and before calling \code{free} respectively.105 Note that like \CC, \CFA introduces \code{new} and \code{delete}, which behave like \code{malloc} and \code{free} in addition to constructing and destructing objects, after calling \code{malloc} and before calling \code{free}, respectively. 102 106 107 % ====================================================================== 103 108 \section{Parametric Polymorphism} 104 Routines in \CFA can also be reused for multiple types. This capability is done using the \code{forall} clause which gives \CFA its name. \code{forall} clauses allow separately compiled routines to support generic usage over multiple types. For example, the following sum function works for any type that supports construction from 0 and addition :109 Routines in \CFA can also be reused for multiple types. This capability is done using the \code{forall} clause, which gives \CFA its name. \code{forall} clauses allow separately compiled routines to support generic usage over multiple types. For example, the following sum function works for any type that supports construction from 0 and addition : 105 110 \begin{cfacode} 106 111 //constraint type, 0 and + … … 130 135 \end{cfacode} 131 136 137 Note that the type use for assertions can be either an \code{otype} or a \code{dtype}. Types declares as \code{otype} refer to ``complete'' objects, i.e., objects with a size, a default constructor, a copy constructor, a destructor and an assignment operator. Using \code{dtype} on the other hand has none of these assumptions but is extremely restrictive, it only guarantees the object is addressable. 138 139 % ====================================================================== 132 140 \section{with Clause/Statement} 133 141 Since \CFA lacks the concept of a receiver, certain functions end-up needing to repeat variable names often. To remove this inconvenience, \CFA provides the \code{with} statement, which opens an aggregate scope making its fields directly accessible (like Pascal). … … 135 143 struct S { int i, j; }; 136 144 int mem(S & this) with (this) //with clause 137 i = 1; //this->i138 j = 2; //this->j145 i = 1; //this->i 146 j = 2; //this->j 139 147 } 140 148 int foo() { 141 149 struct S1 { ... } s1; 142 150 struct S2 { ... } s2; 143 with (s1) //with statement151 with (s1) //with statement 144 152 { 145 //access fields of s1 146 //without qualification 153 //access fields of s1 without qualification 147 154 with (s2) //nesting 148 155 { 149 //access fields of s1 and s2 150 //without qualification 156 //access fields of s1 and s2 without qualification 151 157 } 152 158 } 153 with (s1, s2) //scopes open in parallel159 with (s1, s2) //scopes open in parallel 154 160 { 155 //access fields of s1 and s2 156 //without qualification 161 //access fields of s1 and s2 without qualification 157 162 } 158 163 }
Note:
See TracChangeset
for help on using the changeset viewer.
