Ignore:
Timestamp:
Oct 3, 2017, 3:09:12 PM (5 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, 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, resolv-new, with_gc
Children:
3628765
Parents:
e1ff775
Message:

Added internals section and updated v0.10 up to chapter 4

File:
1 edited

Legend:

Unmodified
Added
Removed
  • doc/proposals/concurrency/text/cforall.tex

    re1ff775 rdcfc4b3  
    55% ======================================================================
    66
    7 As mentionned in the introduction, the document presents the design for the concurrency features in \CFA. Since it is a new language here is a quick review of the language specifically tailored to the features needed to support concurrency.
     7This thesis presents the design for a set of concurrency features in \CFA. Since it is a new dialect of C, the following is a quick introduction to the language, specifically tailored to the features needed to support concurrency.
    88
    9 \CFA is a extension of ISO C and therefore supports much of the same paradigms as C. It is a non-object oriented system level language, meaning it has very most of the major abstractions have either no runtime cost or can be opt-out easily. Like C, the basics of \CFA revolve around structures and routines, which are thin abstractions over assembly. The vast majority of the code produced by a \CFA compiler respects memory-layouts and calling-conventions laid out by C. However, while \CFA is not an object-oriented language according to a strict definition. It does have some notion of objects, most importantly construction and destruction of objects. Most of the following pieces of code can be found as is 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 received (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 pieces of code can be found on the \CFA website \cite{www-cfa}
    1010
    1111\section{References}
    1212
    13 Like \CC, \CFA introduces references as an alternative to pointers. In regards to concurrency, the semantics difference between pointers and references aren't particularly relevant but since this document uses mostly references here is a quick overview of the semantics :
     13Like \CC, \CFA introduces references 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 :
    1414\begin{cfacode}
    1515int x, *p1 = &x, **p2 = &p1, ***p3 = &p2,
    1616&r1 = x,    &&r2 = r1,   &&&r3 = r2;
    17 ***p3 = 3;                              // change x
    18 r3 = 3;                                 // change x, ***r3
    19 **p3 = ...;                             // change p1
    20 &r3 = ...;                              // change r1, (&*)**r3
    21 *p3 = ...;                              // change p2
    22 &&r3 = ...;                             // change r2, (&(&*)*)*r3
    23 &&&r3 = p3;                             // change r3 to p3, (&(&(&*)*)*)r3
    24 int y, z, & ar[3] = { x, y, z };        // initialize array of references
    25 &ar[1] = &z;                            // change reference array element
    26 typeof( ar[1] ) p;                      // is int, i.e., the type of referenced object
    27 typeof( &ar[1] ) q;                     // is int &, i.e., the type of reference
    28 sizeof( ar[1] ) == sizeof( int );       // is true, i.e., the size of referenced object
    29 sizeof( &ar[1] ) == sizeof( int *);     // is true, i.e., the size of a reference
     17***p3 = 3;                                                      //change x
     18r3    = 3;                                                      //change x, ***r3
     19**p3  = ...;                                            //change p1
     20*p3   = ...;                                            //change p2
     21int y, z, & ar[3] = {x, y, z};          //initialize array of references
     22typeof( ar[1]) p;                                       //is int, i.e., the type of referenced object
     23typeof(&ar[1]) q;                                       //is int &, i.e., the type of reference
     24sizeof( ar[1]) == sizeof(int);          //is true, i.e., the size of referenced object
     25sizeof(&ar[1]) == sizeof(int *);        //is true, i.e., the size of a reference
    3026\end{cfacode}
    3127The important thing 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.
     
    3329\section{Overloading}
    3430
    35 Another important feature \CFA has in common with \CC is function overloading :
     31Another important feature of \CFA is function overloading as in Java and \CC, where routine with the same name are selected based on the numbers 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.
    3632\begin{cfacode}
    37 // selection based on type and number of parameters
    38 void f( void );                         // (1)
    39 void f( char );                         // (2)
    40 void f( int, double );                  // (3)
    41 f();                                    // select (1)
    42 f( 'a' );                               // select (2)
    43 f( 3, 5.2 );                            // select (3)
     33//selection based on type and number of parameters
     34void f(void);                   //(1)
     35void f(char);                   //(2)
     36void f(int, double);    //(3)
     37f();                                    //select (1)
     38f('a');                                 //select (2)
     39f(3, 5.2);                              //select (3)
    4440
    45 // selection based on  type and number of returns
    46 char f( int );                          // (1)
    47 double f( int );                        // (2)
    48 [ int, double ] f( int );               // (3)
    49 char c = f( 3 );                        // select (1)
    50 double d = f( 4 );                      // select (2)
    51 [ int, double ] t = f( 5 );             // select (3)
     41//selection based on  type and number of returns
     42char   f(int);                  //(1)
     43double f(int);                  //(2)
     44char   c = f(3);                //select (1)
     45double d = f(4);                //select (2)
    5246\end{cfacode}
    53 This feature is particularly important for concurrency since the runtime system relies on creating different types do represent concurrency objects. Therefore, overloading is necessary to prevent the need for long prefixes and other naming conventions that prevent clashes. As seen in chapter \ref{basics}, the main is an example of routine that benefits from overloading when concurrency in introduced.
     47This 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}, routines main is an example that benefits from overloading.
    5448
    5549\section{Operators}
    5650Overloading 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 :
    5751\begin{cfacode}
    58 int ++?( int op );                      // unary prefix increment
    59 int ?++( int op );                      // unary postfix increment
    60 int ?+?( int op1, int op2 );            // binary plus
    61 int ?<=?( int op1, int op2 );           // binary less than
    62 int ?=?( int & op1, int op2 );          // binary assignment
    63 int ?+=?( int & op1, int op2 );         // binary plus-assignment
     52int ++? (int op);                       //unary prefix increment
     53int ?++ (int op);                       //unary postfix increment
     54int ?+? (int op1, int op2);             //binary plus
     55int ?<=?(int op1, int op2);             //binary less than
     56int ?=? (int & op1, int op2);           //binary assignment
     57int ?+=?(int & op1, int op2);           //binary plus-assignment
    6458
    65 struct S { int i, j; };
    66 S ?+?( S op1, S op2 ) {                 // add two structures
    67         return (S){ op1.i + op2.i, op1.j + op2.j };
     59struct S {int i, j;};
     60S ?+?(S op1, S op2) {                           //add two structures
     61        return (S){op1.i + op2.i, op1.j + op2.j};
    6862}
    69 S s1 = { 1, 2 }, s2 = { 2, 3 }, s3;
    70 s3 = s1 + s2;                           // compute sum: s3 == { 2, 5 }
     63S s1 = {1, 2}, s2 = {2, 3}, s3;
     64s3 = s1 + s2;                                           //compute sum: s3 == {2, 5}
    7165\end{cfacode}
    72 
    73 Since concurrency does not use operator overloading, this feature is more important as an introduction for the syntax of constructors.
     66While concurrency does not use operator overloading directly, this feature is more important as an introduction for the syntax of constructors.
    7467
    7568\section{Constructors/Destructors}
    76 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 \& Destructors are a the core of the features required for concurrency and parallelism. \CFA uses the following syntax for constructors and destructors :
     69Object 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 :
    7770\begin{cfacode}
    7871struct S {
     
    8073        int * ia;
    8174};
    82 void ?{}( S & s, int asize ) with s {   // constructor operator
    83         size = asize;                   // initialize fields
    84         ia = calloc( size, sizeof( S ) );
     75void ?{}(S & s, int asize) {    //constructor operator
     76        s.size = asize;                         //initialize fields
     77        s.ia = calloc(size, sizeof(S));
    8578}
    86 void ^?{}( S & s ) with s {             // destructor operator
    87         free( ia );                     // de-initialization fields
     79void ^?{}(S & s) {                              //destructor operator
     80        free(ia);                                       //de-initialization fields
    8881}
    8982int main() {
    90         S x = { 10 }, y = { 100 };      // implict calls: ?{}( x, 10 ), ?{}( y, 100 )
    91         ...                             // use x and y
    92         ^x{};  ^y{};                    // explicit calls to de-initialize
    93         x{ 20 };  y{ 200 };             // explicit calls to reinitialize
    94         ...                             // reuse x and y
    95 }                                       // implict calls: ^?{}( y ), ^?{}( x )
     83        S x = {10}, y = {100};          //implict calls: ?{}(x, 10), ?{}(y, 100)
     84        ...                                                     //use x and y
     85        ^x{};  ^y{};                            //explicit calls to de-initialize
     86        x{20};  y{200};                         //explicit calls to reinitialize
     87        ...                                                     //reuse x and y
     88}                                                               //implict calls: ^?{}(y), ^?{}(x)
    9689\end{cfacode}
    97 The language guarantees that every object and all their fields are constructed. Like \CC construction is automatically done on declaration and destruction done when the declared variables reach the end of its scope.
     90The 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.
     91\begin{cfacode}
     92{
     93        struct S s = {10};      //allocation, call constructor
     94        ...
     95}                                               //deallocation, call destructor
     96struct S * s = new();   //allocation, call constructor
     97...
     98delete(s);                              //deallocation, call destructor
     99\end{cfacode}
     100Note 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.
    98101
    99 For more information see \cite{cforall-ug,rob-thesis,www-cfa}.
     102For more information on \CFA see \cite{cforall-ug,rob-thesis,www-cfa}.
Note: See TracChangeset for help on using the changeset viewer.