Changes in / [e59f0bf:8b001bd]


Ignore:
Location:
doc
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • doc/bibliography/pl.bib

    re59f0bf r8b001bd  
    52055205    year        = 1984,
    52065206    series      = {Computers and their Applications},
    5207     address     = {Market Cross House, Cooper Street, Chichester, West Sussex,
    5208         PO19 1EB, England},
     5207    address     = {Market Cross House, Cooper Street, Chichester, West Sussex, PO19 1EB, England},
    52095208    summary     = {
    52105209        The principles of Procedural Abstraction, Data Type Completeness,
    … …  
    52585257}
    52595258
    5260 @book{PowerPC,
    5261     key         = {PowerPC processor},
    5262     title       = {Programming Environments Manual for 32-Bit Implementations of the PowerPC ArchitectureARM Architecture},
    5263     publisher   = {Freescale Semiconductor},
    5264     volume      = {MPCFPE32B},
    5265     edition     = {Rev. 3},
    5266     month       = 9,
    5267     year        = 2005,
     5259@inproceedings{Rafkind09,
     5260    keywords    = {accurate, C programming language, conservative, garbage collection, precise},
     5261    contributer = {pabuhr@plg},
     5262    author      = {Rafkind, Jon and Wick, Adam and Regehr, John and Flatt, Matthew},
     5263    title       = {Precise Garbage Collection for C},
     5264    booktitle   = {Proceedings of the 2009 International Symposium on Memory Management},
     5265    series      = {ISMM '09},
     5266    year        = {2009},
     5267    location    = {Dublin, Ireland},
     5268    pages       = {39-48},
     5269    publisher   = {ACM},
     5270    address     = {New York, NY, USA},
    52685271}
    52695272
    … …  
    53385341
    53395342@article{psa:persistence,
    5340     keywords    = {persistence, first-class procedures, closure, PS-Algol,
    5341         Abstract Data Types},
     5343    keywords    = {persistence, first-class procedures, closure, PS-Algol, Abstract Data Types},
    53425344    contributer = {gjditchfield@plg},
    53435345    author      = {Malcolm P. Atkinson and Ronald Morrison},
    … …  
    53705372
    53715373@article{Procol89,
    5372     keywords    = {active objects, object-oriented languages,
    5373         object-based languages, explicit per-object protocol},
     5374    keywords    = {active objects, object-oriented languages, object-based languages, explicit per-object protocol},
    53745375    contributer = {akgoel@plg},
    53755376    author      = {Jan van den Bos and Chris Laffra},
    … …  
    53835384    note        = {Proceedings of the OOPSLA'89 Conference, Oct. 1--6, 1989, New Orleans, Lousiana},
    53845385    abstract    = {},
     5386}
     5387
     5388@book{PowerPC,
     5389    key         = {PowerPC processor},
     5390    title       = {Programming Environments Manual for 32-Bit Implementations of the PowerPC ArchitectureARM Architecture},
     5391    publisher   = {Freescale Semiconductor},
     5392    volume      = {MPCFPE32B},
     5393    edition     = {Rev. 3},
     5394    month       = 9,
     5395    year        = 2005,
    53855396}
    53865397
    … …  
    60756086
    60766087@inproceedings{Leissa14,
    6077     title       = {Sierra: a SIMD extension for C++},
     6088    title       = {{S}ierra: a {SIMD} extension for {C}++},
    60786089    author      = {Lei{\ss}a, Roland and Haffner, Immanuel and Hack, Sebastian},
    60796090    booktitle   = {Proceedings of the 2014 Workshop on Workshop on programming models for SIMD/Vector processing},

  • doc/papers/general/Paper.tex

    re59f0bf r8b001bd  
    368368Hence, programmers can easily form local environments, adding and modifying appropriate functions, to maximize reuse of other existing functions and types.
    369369
     370Unconstruction is a mechanism to distribute @forall@ over related routines/types (see @stack@ examples in Section~\ref{sec:eval}):
     371\begin{cfa}
     372forall( otype T ) {                                                     $\C{// forall block}$
     373        struct stack { stack_node(T) * head; }; $\C{// generic type}$
     374        void push( stack(T) & s, T value ) ...  $\C{// generic operations}$
     375        T pop( stack(T) & s ) ...
     376}
     377\end{cfa}
     378Each block declaration is prefixed with the initial @forall@ clause significantly reducing duplication.
     379
    370380
    371381\subsection{Traits}
    … …  
    836846% \end{cfa}
    837847% so the thunk provides flattening and structuring conversions to inferred functions, improving the compatibility of tuples and polymorphism.
    838 % These thunks are generated locally using gcc nested-functions, rather hositing them to the external scope, so they can easily access local state.
     848% These thunks are generated locally using gcc nested-functions, rather hoisting them to the external scope, so they can easily access local state.
    839849
    840850
    … …  
    11671177\lstMakeShortInline@%
    11681178\end{cquote}
    1169 The target label must be below the @fallthrough@, \ie @fallthrough@ cannot form a loop, and the label may not be nested in a control structor, \ie it must be at the same level as the @case@ clauses;
     1179The target label must be below the @fallthrough@, \ie @fallthrough@ cannot form a loop, and the label may not be nested in a control structure, \ie it must be at the same level as the @case@ clauses;
    11701180the target label may be case @default@.
    11711181
    … …  
    21552165\begin{cfa}
    21562166struct W {
    2157     double stones;
    2158     W() { stones = 0.0; }
    2159     W( double w ) { stones = w; }
     2167        double stones;
     2168        W() { stones = 0.0; }
     2169        W( double w ) { stones = w; }
    21602170};
    21612171W operator+( W l, W r ) {
    … …  
    27192729
    27202730\CC is the best known C-based language, and is similar to \CFA in that both are extensions to C with source and runtime backwards compatibility.
    2721 Specific difference between \CFA and \CC have been identified in prior sections, with a final observation that \CFA has equal or few tokens to express the same notion in several cases.
    2722 The key difference between design philosophies is that \CFA is easier for C programmers to understand, by maintaining a procedural paradigm and avoiding complex interactions among extensions.
     2731Specific difference between \CFA and \CC have been identified in prior sections, with a final observation that \CFA has equal or fewer tokens to express the same notion in many cases.
     2732The key difference in design philosophies is that \CFA is easier for C programmers to understand by maintaining a procedural paradigm and avoiding complex interactions among extensions.
    27232733\CC, on the other hand, has multiple overlapping features (such as the three forms of polymorphism), many of which have complex interactions with its object-oriented design.
    2724 As a result, \CC has a steep learning curve for even experienced C programmers, especially when attempting to maintain performance equivalent to C legacy code.
     2734As a result, \CC has a steep learning curve for even experienced C programmers, especially when attempting to maintain performance equivalent to C legacy-code.
    27252735
    27262736There are several other C extension-languages with less usage and even more dramatic changes than \CC.
    … …  
    27282738Other languages extend C with more focused features.
    27292739CUDA~\cite{Nickolls08}, ispc~\cite{Pharr12}, and Sierra~\cite{Leissa14} add data-parallel primitives to C or \CC;
    2730 such features have not yet been added to \CFA, but are not precluded by the design.
    2731 Finaly, some C extensions (or suggested extensions) attempt to provide a more memory-safe C~\cite{Boehm88};
    2732 type-checked polymorphism in \CFA covers several of C's memory-safety holes, but more aggressive approaches such as annotating all pointer types with their nullability are contradictory to \CFA's backwards compatibility goals.
     2740such features have not yet been added to \CFA, but are easily incorporated within its design.
     2741Finally, some C extensions (or suggested extensions) attempt to provide a more memory-safe C~\cite{Boehm88,Rafkind09};
     2742type-checked polymorphism in \CFA covers several of C's memory-safety issues, but more aggressive approaches such as annotating all pointer types with their nullability are contradictory to \CFA's backwards compatibility goals.
    27332743
    27342744
    … …  
    28412851        struct stack_node * n = s->head;
    28422852        s->head = n->next;
    2843         void * x = n->value;
     2853        void * v = n->value;
    28442854        free( n );
    2845         return x;
     2855        return v;
    28462856}
    28472857\end{cfa}
    … …  
    29042914                T value;
    29052915                node * next;
    2906                 node( const T & v, node * n = nullptr ) : value( v), next( n) {}
     2916                node( const T & v, node * n = nullptr ) : value( v ), next( n ) {}
    29072917        };
    29082918        node * head;
     2919        stack() : head( nullptr ) {}
     2920        stack( const stack<T> & o) { copy( o ); }
     2921        stack( stack<T> && o ) : head( o.head ) { o.head = nullptr; }
    29092922        void clear() {
    29102923                for ( node * next = head; next; ) {
    … …  
    29152928                head = nullptr;
    29162929        }
    2917         void copy( const stack<T> & o) {
     2930        void copy( const stack<T> & o ) {
    29182931                node ** crnt = &head;
    2919                 for ( node * next = o.head;; next; next = next->next ) {
     2932                for ( node * next = o.head; next; next = next->next ) {
    29202933                        *crnt = new node{ next->value }; /***/
    29212934                        crnt = &(*crnt)->next;
    … …  
    29232936                *crnt = nullptr;
    29242937        }
    2925         stack() : head( nullptr) {}
    2926         stack( const stack<T> & o) { copy( o); }
    2927         stack( stack<T> && o) : head( o.head) { o.head = nullptr; }
    29282938        ~stack() { clear(); }
    2929         stack & operator= ( const stack<T> & o) {
     2939        stack & operator= ( const stack<T> & o ) {
    29302940                if ( this == &o ) return *this;
    29312941                clear();
    2932                 copy( o);
     2942                copy( o );
    29332943                return *this;
    29342944        }
    2935         stack & operator= ( stack<T> && o) {
     2945        stack & operator= ( stack<T> && o ) {
    29362946                if ( this == &o ) return *this;
    29372947                head = o.head;
    … …  
    29402950        }
    29412951        bool empty() const { return head == nullptr; }
    2942         void push( const T & value) { head = new node{ value, head };  /***/ }
     2952        void push( const T & value ) { head = new node{ value, head };  /***/ }
    29432953        T pop() {
    29442954                node * n = head;
    29452955                head = n->next;
    2946                 T x = std::move( n->value);
     2956                T v = std::move( n->value );
    29472957                delete n;
    2948                 return x;
     2958                return v;
    29492959        }
    29502960};
    … …  
    29572967        struct node {
    29582968                ptr<object> value;
    2959                 node* next;
    2960                 node( const object & v, node * n ) : value( v.new_copy() ), next( n ) {}
     2969                node * next;
     2970                node( const object & v, node * n = nullptr ) : value( v.new_copy() ), next( n ) {}
    29612971        };
    2962         node* head;
     2972        node * head;
    29632973        void clear() {
    29642974                for ( node * next = head; next; ) {
    … …  
    29812991        stack( stack && o ) : head( o.head ) { o.head = nullptr; }
    29822992        ~stack() { clear(); }
    2983         stack & operator= ( const stack & o ) {
     2993        stack & operator=( const stack & o ) {
    29842994                if ( this == &o ) return *this;
    29852995                clear();
    … …  
    29872997                return *this;
    29882998        }
    2989         stack & operator= ( stack && o ) {
     2999        stack & operator=( stack && o ) {
    29903000                if ( this == &o ) return *this;
    29913001                head = o.head;
    … …  
    29983008                node * n = head;
    29993009                head = n->next;
    3000                 ptr<object> x = std::move( n->value );
     3010                ptr<object> v = std::move( n->value );
    30013011                delete n;
    3002                 return x;
     3012                return v;
    30033013        }
    30043014};

  • doc/papers/general/evaluation/c-stack.c

    re59f0bf r8b001bd  
    33
    44struct stack_node {
    5         void* value;
    6         struct stack_node* next;
     5        void * value;
     6        struct stack_node * next;
    77};
     8
     9void clear_stack( struct stack * s, void (*free_el)( void * ) ) {
     10        for ( struct stack_node * next = s->head; next; ) {
     11                struct stack_node * crnt = next;
     12                next = crnt->next;
     13                free_el( crnt->value );
     14                free( crnt );
     15        }
     16        s->head = NULL;
     17}
    818
    919struct stack new_stack() { return (struct stack){ NULL }; /***/ }
    1020
    11 void copy_stack(struct stack* s, const struct stack* t, void* (*copy)(const void*)) {
    12         struct stack_node** crnt = &s->head;
    13         for ( struct stack_node* next = t->head; next; next = next->next ) {
    14                 *crnt = malloc(sizeof(struct stack_node)); /***/
    15                 (*crnt)->value = copy(next->value);
     21void copy_stack( struct stack * s, const struct stack * t, void * (*copy)( const void * ) ) {
     22        struct stack_node ** crnt = &s->head;
     23        for ( struct stack_node * next = t->head; next; next = next->next ) {
     24                *crnt = malloc( sizeof(struct stack_node) ); /***/
     25                (*crnt)->value = copy( next->value );
    1626                crnt = &(*crnt)->next;
    1727        }
    1828        *crnt = NULL;
    1929}
    20 
    21 struct stack* assign_stack(struct stack* s, const struct stack* t,
    22                 void* (*copy_el)(const void*), void (*free_el)(void*)) {
     30struct stack * assign_stack( struct stack * s, const struct stack * t,
     31                void * (*copy_el)( const void * ), void (*free_el)( void * ) ) {
    2332        if ( s->head == t->head ) return s;
    2433        clear_stack( s, free_el ); /***/
    … …  
    2736}
    2837
    29 void clear_stack(struct stack* s, void (*free_el)(void*)) {
    30     for ( struct stack_node* next = s->head; next; ) {
    31                 struct stack_node* crnt = next;
    32                 next = crnt->next;
    33                 free_el(crnt->value);
    34                 free(crnt);
    35         }
    36         s->head = NULL;
    37 }
     38_Bool stack_empty( const struct stack * s ) { return s->head == NULL; }
    3839
    39 _Bool stack_empty(const struct stack* s) { return s->head == NULL; }
    40 
    41 void push_stack(struct stack* s, void* value) {
    42         struct stack_node* n = malloc(sizeof(struct stack_node)); /***/
     40void push_stack( struct stack * s, void * value ) {
     41        struct stack_node * n = malloc( sizeof(struct stack_node) ); /***/
    4342        *n = (struct stack_node){ value, s->head }; /***/
    4443        s->head = n;
    4544}
    4645
    47 void* pop_stack(struct stack* s) {
    48         struct stack_node* n = s->head;
     46void * pop_stack( struct stack * s ) {
     47        struct stack_node * n = s->head;
    4948        s->head = n->next;
    50         void* x = n->value;
    51         free(n);
    52         return x;
     49        void * v = n->value;
     50        free( n );
     51        return v;
    5352}

  • doc/papers/general/evaluation/cfa-stack.c

    re59f0bf r8b001bd  
    66        stack_node(T) * next;
    77};
     8
     9forall( otype T ) void clear( stack(T) & s ) with( s ) {
     10        for ( stack_node(T) * next = head; next; ) {
     11                stack_node(T) * crnt = next;
     12                next = crnt->next;
     13                ^(*crnt){};
     14                free(crnt);
     15        }
     16        head = 0;
     17}
    818
    919forall( otype T ) void ?{}( stack(T) & s ) { (s.head){ 0 }; }
    … …  
    4454        return v;
    4555}
    46 
    47 forall( otype T ) void clear( stack(T) & s ) with( s ) {
    48         for ( stack_node(T) * next = head; next; ) {
    49                 stack_node(T) * crnt = next;
    50                 next = crnt->next;
    51                 ^(*crnt){};
    52                 free(crnt);
    53         }
    54         head = 0;
    55 }

  • doc/papers/general/evaluation/cpp-stack.hpp

    re59f0bf r8b001bd  
    22#include <utility>
    33
    4 template<typename T> class stack {
     4template<typename T> struct stack {
    55        struct node {
    66                T value;
    7                 node* next;
     7                node * next;
     8                node( const T & v, node * n = nullptr ) : value( v ), next( n ) {}
     9        };
     10        node * head;
    811
    9                 node( const T& v, node* n = nullptr ) : value(v), next(n) {}
    10         };
    11         node* head;
     12        stack() : head( nullptr ) {}
     13        stack( const stack<T> & o) { copy( o ); }
     14        stack( stack<T> && o ) : head( o.head ) { o.head = nullptr; }
    1215
    13         void copy(const stack<T>& o) {
    14                 node** crnt = &head;
    15                 for ( node* next = o.head; next; next = next->next ) {
    16                         *crnt = new node{ next->value }; /***/
    17                         crnt = &(*crnt)->next;
    18                 }
    19                 *crnt = nullptr;
    20         }
    21 public:
    2216        void clear() {
    23             for ( node* next = head; next; ) {
    24                         node* crnt = next;
     17                for ( node * next = head; next; ) {
     18                        node * crnt = next;
    2519                        next = crnt->next;
    2620                        delete crnt;
    … …  
    2923        }
    3024
    31         stack() : head(nullptr) {}
    32         stack(const stack<T>& o) { copy(o); }
    33         stack(stack<T>&& o) : head(o.head) { o.head = nullptr; }
     25        void copy( const stack<T> & o ) {
     26                node ** crnt = &head;
     27                for ( node * next = o.head; next; next = next->next ) {
     28                        *crnt = new node{ next->value }; /***/
     29                        crnt = &(*crnt)->next;
     30                }
     31                *crnt = nullptr;
     32        }
     33
    3434        ~stack() { clear(); }
    3535
    36         stack& operator= (const stack<T>& o) {
     36        stack & operator= ( const stack<T> & o ) {
    3737                if ( this == &o ) return *this;
    3838                clear();
    39                 copy(o);
     39                copy( o );
    4040                return *this;
    4141        }
    4242
    43         stack& operator= (stack<T>&& o) {
     43        stack & operator= ( stack<T> && o ) {
    4444                if ( this == &o ) return *this;
    4545                head = o.head;
    … …  
    5050        bool empty() const { return head == nullptr; }
    5151
    52         void push(const T& value) { head = new node{ value, head };  /***/ }
     52        void push( const T & value ) { head = new node{ value, head };  /***/ }
    5353
    5454        T pop() {
    55                 node* n = head;
     55                node * n = head;
    5656                head = n->next;
    57                 T x = std::move(n->value);
     57                T v = std::move( n->value );
    5858                delete n;
    59                 return x;
     59                return v;
    6060        }
    6161};

  • doc/papers/general/evaluation/cpp-vstack.cpp

    re59f0bf r8b001bd  
    22#include <utility>
    33
    4 stack::node::node( const object& v, node* n ) : value( v.new_copy() ), next( n ) {}
     4stack::node::node( const object & v, node * n ) : value( v.new_copy() ), next( n ) {}
    55
    6 void stack::copy(const stack& o) {
    7         node** crnt = &head;
    8         for ( node* next = o.head; next; next = next->next ) {
     6void stack::clear() {
     7        for ( node * next = head; next; ) {
     8                node * crnt = next;
     9                next = crnt->next;
     10                delete crnt;
     11        }
     12        head = nullptr;
     13}
     14
     15void stack::copy( const stack & o ) {
     16        node ** crnt = &head;
     17        for ( node * next = o.head; next; next = next->next ) {
    918                *crnt = new node{ *next->value }; /***/
    1019                crnt = &(*crnt)->next;
    … …  
    1322}
    1423
    15 stack::stack() : head(nullptr) {}
    16 stack::stack(const stack& o) { copy(o); }
    17 stack::stack(stack&& o) : head(o.head) { o.head = nullptr; }
     24stack::stack() : head( nullptr ) {}
     25stack::stack( const stack & o ) { copy( o ); }
     26stack::stack( stack && o ) : head( o.head ) { o.head = nullptr; }
    1827stack::~stack() { clear(); }
    1928
    20 stack& stack::operator= (const stack& o) {
     29stack & stack::operator=( const stack & o ) {
    2130        if ( this == &o ) return *this;
    2231        clear();
    23         copy(o);
     32        copy( o );
    2433        return *this;
    2534}
    2635
    27 stack& stack::operator= (stack&& o) {
     36stack & stack::operator=( stack && o ) {
    2837        if ( this == &o ) return *this;
    2938        head = o.head;
    … …  
    3241}
    3342
    34 void stack::clear() {
    35     for ( node* next = head; next; ) {
    36                 node* crnt = next;
    37                 next = crnt->next;
    38                 delete crnt;
    39         }
    40         head = nullptr;
    41 }
    42 
    43 
    4443bool stack::empty() const { return head == nullptr; }
    4544
    46 void stack::push(const object& value) { head = new node{ value, head }; /***/ }
     45void stack::push( const object & value ) { head = new node{ value, head }; /***/ }
    4746
    4847ptr<object> stack::pop() {
    49         node* n = head;
     48        node * n = head;
    5049        head = n->next;
    51         ptr<object> x = std::move(n->value);
     50        ptr<object> v = std::move( n->value );
    5251        delete n;
    53         return x;
     52        return v;
    5453}

  • doc/papers/general/evaluation/cpp-vstack.hpp

    re59f0bf r8b001bd  
    22#include "object.hpp"
    33
    4 class stack {
     4struct stack {
    55        struct node {
    66                ptr<object> value;
    7                 node* next;
    8 
    9                 node( const object& v, node* n = nullptr );
     7                node * next;
     8                node( const object & v, node * n = nullptr );
    109        };
    11         node* head;
    12 
    13         void copy(const stack& o);
    14 public:
    15         stack();
    16         stack(const stack& o);
    17         stack(stack&& o);
    18         ~stack();
    19         stack& operator= (const stack& o);
    20         stack& operator= (stack&& o);
     10        node * head;
    2111
    2212        void clear();
     13        void copy( const stack & o );
     14
     15        stack();
     16        stack( const stack & o );
     17        stack( stack && o );
     18        ~stack();
     19        stack& operator=( const stack& o );
     20        stack& operator=( stack && o );
     21
    2322        bool empty() const;
    24         void push(const object& value);
     23        void push( const object & value );
    2524        ptr<object> pop();
    2625};
Note: See TracChangeset for help on using the changeset viewer.