Changeset a2ea829 for doc/proposals/concurrency/text/cforall.tex
- Timestamp:
- Nov 6, 2017, 12:23:13 PM (6 years ago)
- Branches:
- ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
- Children:
- b9d0fb6
- Parents:
- bbeb908
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
doc/proposals/concurrency/text/cforall.tex
rbbeb908 ra2ea829 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 : [Where to I get the C11 reference manual?]}, 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 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 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} 10 11 11 12 \section{References} 12 13 13 Like \CC, \CFA introduces re ferences as an alternative to pointers. In regards to concurrency, the semantics difference between pointers and references are not particularly relevant but since this document uses mostly references here is a quick overview of the semantics:14 Like \CC, \CFA introduces rebindable 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: 14 15 \begin{cfacode} 15 16 int x, *p1 = &x, **p2 = &p1, ***p3 = &p2, 16 &r1 = x, &&r2 = r1, &&&r3 = r2;17 &r1 = x, &&r2 = r1, &&&r3 = r2; 17 18 ***p3 = 3; //change x 18 19 r3 = 3; //change x, ***r3 … … 25 26 sizeof(&ar[1]) == sizeof(int *); //is true, i.e., the size of a reference 26 27 \end{cfacode} 27 The important t hing to take away from this code snippet is that references offer a handle to an object much like pointers but which is automatically derefferenced when convinient.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. 28 29 29 30 \section{Overloading} 30 31 31 Another important feature of \CFA is function overloading as in Java and \CC, where routine with the same name are selected based on the numbersand 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.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. 32 33 \begin{cfacode} 33 34 //selection based on type and number of parameters … … 45 46 double d = f(4); //select (2) 46 47 \end{cfacode} 47 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 s mainis an example that benefits from overloading.48 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. 48 49 49 50 \section{Operators} 50 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 would be, like so:51 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.: 51 52 \begin{cfacode} 52 53 int ++? (int op); //unary prefix increment … … 101 102 102 103 \section{Parametric Polymorphism} 103 Routines in \CFA can also be reused for multiple types. This is done using the \code{forall} clause which gives \CFA it's name. \code{forall} clauses allow seperatly compiled routines to support generic usage over multiple types. For example, the following sum function will work for any type which supportconstruction from 0 and addition :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 : 104 105 \begin{cfacode} 105 106 //constraint type, 0 and + … … 116 117 \end{cfacode} 117 118 118 Since writing constraints on types can become cumbersome for more constrained functions, \CFA also has the concept of traits. Traits are named collection of constraints whichcan be used both instead and in addition to regular constraints:119 Since writing constraints on types can become cumbersome for more constrained functions, \CFA also has the concept of traits. Traits are named collection of constraints that can be used both instead and in addition to regular constraints: 119 120 \begin{cfacode} 120 121 trait sumable( otype T ) { … … 130 131 131 132 \section{with Clause/Statement} 132 Since \CFA lacks the concept of a receiver, certain functions end-up needing to repeat variable names often , to solve this \CFA offers the \code{with} statementwhich opens an aggregate scope making its fields directly accessible (like Pascal).133 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). 133 134 \begin{cfacode} 134 135 struct S { int i, j; }; 135 int mem(S & this) with this//with clause136 int mem(S & this) with (this) //with clause 136 137 i = 1; //this->i 137 138 j = 2; //this->j … … 140 141 struct S1 { ... } s1; 141 142 struct S2 { ... } s2; 142 with s1//with statement143 with (s1) //with statement 143 144 { 144 145 //access fields of s1 145 146 //without qualification 146 with s2//nesting147 with (s2) //nesting 147 148 { 148 149 //access fields of s1 and s2 … … 150 151 } 151 152 } 152 with s1, s2//scopes open in parallel153 with (s1, s2) //scopes open in parallel 153 154 { 154 155 //access fields of s1 and s2
Note: See TracChangeset
for help on using the changeset viewer.