Changes in / [e84382b:b51e5fdb]
- Location:
- doc
- Files:
-
- 7 edited
Legend:
- Unmodified
- Added
- Removed
-
doc/bibliography/pl.bib
re84382b rb51e5fdb 5205 5205 year = 1984, 5206 5206 series = {Computers and their Applications}, 5207 address = {Market Cross House, Cooper Street, Chichester, West Sussex, PO19 1EB, England}, 5207 address = {Market Cross House, Cooper Street, Chichester, West Sussex, 5208 PO19 1EB, England}, 5208 5209 summary = { 5209 5210 The principles of Procedural Abstraction, Data Type Completeness, … … 5257 5258 } 5258 5259 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}, 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, 5271 5268 } 5272 5269 … … 5341 5338 5342 5339 @article{psa:persistence, 5343 keywords = {persistence, first-class procedures, closure, PS-Algol, Abstract Data Types}, 5340 keywords = {persistence, first-class procedures, closure, PS-Algol, 5341 Abstract Data Types}, 5344 5342 contributer = {gjditchfield@plg}, 5345 5343 author = {Malcolm P. Atkinson and Ronald Morrison}, … … 5372 5370 5373 5371 @article{Procol89, 5374 keywords = {active objects, object-oriented languages, object-based languages, explicit per-object protocol}, 5372 keywords = {active objects, object-oriented languages, 5373 object-based languages, explicit per-object protocol}, 5375 5374 contributer = {akgoel@plg}, 5376 5375 author = {Jan van den Bos and Chris Laffra}, … … 5384 5383 note = {Proceedings of the OOPSLA'89 Conference, Oct. 1--6, 1989, New Orleans, Lousiana}, 5385 5384 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,5396 5385 } 5397 5386 … … 6086 6075 6087 6076 @inproceedings{Leissa14, 6088 title = { {S}ierra: a {SIMD} extension for {C}++},6077 title = {Sierra: a SIMD extension for C++}, 6089 6078 author = {Lei{\ss}a, Roland and Haffner, Immanuel and Hack, Sebastian}, 6090 6079 booktitle = {Proceedings of the 2014 Workshop on Workshop on programming models for SIMD/Vector processing}, -
doc/papers/general/Paper.tex
re84382b rb51e5fdb 368 368 Hence, programmers can easily form local environments, adding and modifying appropriate functions, to maximize reuse of other existing functions and types. 369 369 370 Unconstruction is a mechanism to distribute @forall@ over related routines/types (see @stack@ examples in Section~\ref{sec:eval}):371 \begin{cfa}372 forall( 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}378 Each block declaration is prefixed with the initial @forall@ clause significantly reducing duplication.379 380 370 381 371 \subsection{Traits} … … 846 836 % \end{cfa} 847 837 % so the thunk provides flattening and structuring conversions to inferred functions, improving the compatibility of tuples and polymorphism. 848 % These thunks are generated locally using gcc nested-functions, rather ho isting them to the external scope, so they can easily access local state.838 % These thunks are generated locally using gcc nested-functions, rather hositing them to the external scope, so they can easily access local state. 849 839 850 840 … … 1177 1167 \lstMakeShortInline@% 1178 1168 \end{cquote} 1179 The target label must be below the @fallthrough@, \ie @fallthrough@ cannot form a loop, and the label may not be nested in a control struct ure, \ie it must be at the same level as the @case@ clauses;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; 1180 1170 the target label may be case @default@. 1181 1171 … … 2165 2155 \begin{cfa} 2166 2156 struct W { 2167 2168 2169 2157 double stones; 2158 W() { stones = 0.0; } 2159 W( double w ) { stones = w; } 2170 2160 }; 2171 2161 W operator+( W l, W r ) { … … 2729 2719 2730 2720 \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. 2731 Specific difference between \CFA and \CC have been identified in prior sections, with a final observation that \CFA has equal or few er tokens to express the same notion in manycases.2732 The key difference in design philosophies is that \CFA is easier for C programmers to understandby maintaining a procedural paradigm and avoiding complex interactions among extensions.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. 2733 2723 \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. 2734 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.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. 2735 2725 2736 2726 There are several other C extension-languages with less usage and even more dramatic changes than \CC. … … 2738 2728 Other languages extend C with more focused features. 2739 2729 CUDA~\cite{Nickolls08}, ispc~\cite{Pharr12}, and Sierra~\cite{Leissa14} add data-parallel primitives to C or \CC; 2740 such features have not yet been added to \CFA, but are easily incorporated within itsdesign.2741 Final ly, some C extensions (or suggested extensions) attempt to provide a more memory-safe C~\cite{Boehm88,Rafkind09};2742 type-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.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. 2743 2733 2744 2734 … … 2851 2841 struct stack_node * n = s->head; 2852 2842 s->head = n->next; 2853 void * v= n->value;2843 void * x = n->value; 2854 2844 free( n ); 2855 return v;2845 return x; 2856 2846 } 2857 2847 \end{cfa} … … 2907 2897 \end{cfa} 2908 2898 2909 \begin{comment}2910 forall( otype T ) {2911 struct stack_node {2912 T value;2913 stack_node(T) * next;2914 };2915 struct stack { stack_node(T) * head; };2916 void clear( stack(T) & s ) with( s ) {2917 for ( stack_node(T) * next = head; next; ) {2918 stack_node(T) * crnt = next;2919 next = crnt->next;2920 ^(*crnt){};2921 free(crnt);2922 }2923 head = 0;2924 }2925 void ?{}( stack(T) & s ) { (s.head){ 0 }; }2926 void ?{}( stack(T) & s, stack(T) t ) {2927 stack_node(T) ** crnt = &s.head;2928 for ( stack_node(T) * next = t.head; next; next = next->next ) {2929 *crnt = alloc();2930 ((*crnt)->value){ next->value };2931 crnt = &(*crnt)->next;2932 }2933 *crnt = 0;2934 }2935 stack(T) ?=?( stack(T) & s, stack(T) t ) {2936 if ( s.head == t.head ) return s;2937 clear( s );2938 s{ t };2939 return s;2940 }2941 void ^?{}( stack(T) & s) { clear( s ); }2942 _Bool empty( const stack(T) & s ) { return s.head == 0; }2943 void push( stack(T) & s, T value ) with( s ) {2944 stack_node(T) * n = alloc();2945 (*n){ value, head };2946 head = n;2947 }2948 T pop( stack(T) & s ) with( s ) {2949 stack_node(T) * n = head;2950 head = n->next;2951 T v = n->value;2952 ^(*n){};2953 free( n );2954 return v;2955 }2956 }2957 \end{comment}2958 2959 2899 \medskip\noindent 2960 2900 \CC … … 2967 2907 }; 2968 2908 node * head; 2969 stack() : head( nullptr ) {}2970 stack( const stack<T> & o) { copy( o ); }2971 stack( stack<T> && o ) : head( o.head ) { o.head = nullptr; }2972 2909 void clear() { 2973 2910 for ( node * next = head; next; ) { … … 2986 2923 *crnt = nullptr; 2987 2924 } 2925 stack() : head( nullptr) {} 2926 stack( const stack<T> & o ) { copy( o ); } 2988 2927 ~stack() { clear(); } 2989 stack & operator= ( const stack<T> & o 2928 stack & operator= ( const stack<T> & o) { 2990 2929 if ( this == &o ) return *this; 2991 2930 clear(); … … 2998 2937 node * n = head; 2999 2938 head = n->next; 3000 T v= std::move( n->value );2939 T x = std::move( n->value ); 3001 2940 delete n; 3002 return v;2941 return x; 3003 2942 } 3004 2943 }; … … 3011 2950 struct node { 3012 2951 ptr<object> value; 3013 node 3014 node( const object & v, node * n = nullptr) : value( v.new_copy() ), next( n ) {}2952 node* next; 2953 node( const object & v, node * n ) : value( v.new_copy() ), next( n ) {} 3015 2954 }; 3016 node 2955 node* head; 3017 2956 void clear() { 3018 2957 for ( node * next = head; next; ) { … … 3033 2972 stack() : head( nullptr ) {} 3034 2973 stack( const stack & o ) { copy( o ); } 3035 ~stack() { clear(); }2974 ~stack() { clear(); } 3036 2975 stack & operator= ( const stack & o ) { 3037 2976 if ( this == &o ) return *this; … … 3045 2984 node * n = head; 3046 2985 head = n->next; 3047 ptr<object> v= std::move( n->value );2986 ptr<object> x = std::move( n->value ); 3048 2987 delete n; 3049 return v;2988 return x; 3050 2989 } 3051 2990 }; -
doc/papers/general/evaluation/c-stack.c
re84382b rb51e5fdb 3 3 4 4 struct stack_node { 5 void 6 struct stack_node 5 void* value; 6 struct stack_node* next; 7 7 }; 8 9 void 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 }18 8 19 9 struct stack new_stack() { return (struct stack){ NULL }; /***/ } 20 10 21 void copy_stack( struct stack * s, const struct stack * t, void * (*copy)( const void * )) {22 struct stack_node 23 for ( struct stack_node 24 *crnt = malloc( sizeof(struct stack_node)); /***/25 (*crnt)->value = copy( next->value);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); 26 16 crnt = &(*crnt)->next; 27 17 } 28 18 *crnt = NULL; 29 19 } 30 struct stack * assign_stack( struct stack * s, const struct stack * t, 31 void * (*copy_el)( const void * ), void (*free_el)( void * ) ) { 20 21 struct stack* assign_stack(struct stack* s, const struct stack* t, 22 void* (*copy_el)(const void*), void (*free_el)(void*)) { 32 23 if ( s->head == t->head ) return s; 33 24 clear_stack( s, free_el ); /***/ … … 36 27 } 37 28 38 _Bool stack_empty( const struct stack * s ) { return s->head == NULL; } 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 } 39 38 40 void push_stack( struct stack * s, void * value ) { 41 struct stack_node * n = malloc( sizeof(struct stack_node) ); /***/ 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)); /***/ 42 43 *n = (struct stack_node){ value, s->head }; /***/ 43 44 s->head = n; 44 45 } 45 46 46 void * pop_stack( struct stack * s) {47 struct stack_node 47 void* pop_stack(struct stack* s) { 48 struct stack_node* n = s->head; 48 49 s->head = n->next; 49 void * v= n->value;50 free( n);51 return v;50 void* x = n->value; 51 free(n); 52 return x; 52 53 } -
doc/papers/general/evaluation/cfa-stack.c
re84382b rb51e5fdb 6 6 stack_node(T) * next; 7 7 }; 8 9 forall( 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 }18 8 19 9 forall( otype T ) void ?{}( stack(T) & s ) { (s.head){ 0 }; } … … 54 44 return v; 55 45 } 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
re84382b rb51e5fdb 2 2 #include <utility> 3 3 4 template<typename T> structstack {4 template<typename T> class stack { 5 5 struct node { 6 6 T value; 7 node * next; 8 node( const T & v, node * n = nullptr ) : value( v ), next( n ) {} 7 node* next; 8 9 node( const T& v, node* n = nullptr ) : value(v), next(n) {} 9 10 }; 10 node 11 node* head; 11 12 12 stack() : head( nullptr ) {} 13 stack( const stack<T> & o ) { copy( o ); } 14 stack( stack<T> && o ) : head( o.head ) { o.head = nullptr; } 15 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: 16 22 void clear() { 17 for ( node* next = head; next; ) {18 node 23 for ( node* next = head; next; ) { 24 node* crnt = next; 19 25 next = crnt->next; 20 26 delete crnt; … … 23 29 } 24 30 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 31 stack() : head(nullptr) {} 32 stack(const stack<T>& o) { copy(o); } 34 33 ~stack() { clear(); } 35 34 36 stack & operator= ( const stack<T> & o) {35 stack& operator= (const stack<T>& o) { 37 36 if ( this == &o ) return *this; 38 37 clear(); 39 copy( o);38 copy(o); 40 39 return *this; 41 40 } … … 43 42 bool empty() const { return head == nullptr; } 44 43 45 void push( const T & value) { head = new node{ value, head }; /***/ }44 void push(const T& value) { head = new node{ value, head }; /***/ } 46 45 47 46 T pop() { 48 node 47 node* n = head; 49 48 head = n->next; 50 T v = std::move( n->value);49 T x = std::move(n->value); 51 50 delete n; 52 return v;51 return x; 53 52 } 54 53 }; -
doc/papers/general/evaluation/cpp-vstack.cpp
re84382b rb51e5fdb 2 2 #include <utility> 3 3 4 stack::node::node( const object & v, node * n ) : value( v.new_copy() ), next( n ) {} 4 stack::node::node( const object& v, node* n ) : value( v.new_copy() ), next( n ) {} 5 6 void stack::copy(const stack& o) { 7 node** crnt = &head; 8 for ( node* next = o.head; next; next = next->next ) { 9 *crnt = new node{ *next->value }; /***/ 10 crnt = &(*crnt)->next; 11 } 12 *crnt = nullptr; 13 } 14 15 stack::stack() : head(nullptr) {} 16 stack::stack(const stack& o) { copy(o); } 17 stack::~stack() { clear(); } 18 19 stack& stack::operator= (const stack& o) { 20 if ( this == &o ) return *this; 21 clear(); 22 copy(o); 23 return *this; 24 } 5 25 6 26 void stack::clear() { 7 for ( node* next = head; next; ) {8 node 27 for ( node* next = head; next; ) { 28 node* crnt = next; 9 29 next = crnt->next; 10 30 delete crnt; … … 13 33 } 14 34 15 void stack::copy( const stack & o ) {16 node ** crnt = &head;17 for ( node * next = o.head; next; next = next->next ) {18 *crnt = new node{ *next->value }; /***/19 crnt = &(*crnt)->next;20 }21 *crnt = nullptr;22 }23 24 stack::stack() : head( nullptr ) {}25 stack::stack( const stack & o ) { copy( o ); }26 stack::stack( stack && o ) : head( o.head ) { o.head = nullptr; }27 stack::~stack() { clear(); }28 29 stack & stack::operator=( const stack & o ) {30 if ( this == &o ) return *this;31 clear();32 copy( o );33 return *this;34 }35 36 stack & stack::operator=( stack && o ) {37 if ( this == &o ) return *this;38 head = o.head;39 o.head = nullptr;40 return *this;41 }42 35 43 36 bool stack::empty() const { return head == nullptr; } 44 37 45 void stack::push( const object & value) { head = new node{ value, head }; /***/ }38 void stack::push(const object& value) { head = new node{ value, head }; /***/ } 46 39 47 40 ptr<object> stack::pop() { 48 node 41 node* n = head; 49 42 head = n->next; 50 ptr<object> v = std::move( n->value);43 ptr<object> x = std::move(n->value); 51 44 delete n; 52 return v;45 return x; 53 46 } -
doc/papers/general/evaluation/cpp-vstack.hpp
re84382b rb51e5fdb 2 2 #include "object.hpp" 3 3 4 structstack {4 class stack { 5 5 struct node { 6 6 ptr<object> value; 7 node * next; 8 node( const object & v, node * n = nullptr ); 7 node* next; 8 9 node( const object& v, node* n = nullptr ); 9 10 }; 10 node * head; 11 node* head; 12 13 void copy(const stack& o); 14 public: 15 stack(); 16 stack(const stack& o); 17 ~stack(); 18 stack& operator= (const stack& o); 11 19 12 20 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 21 bool empty() const; 22 void push( const object & value);22 void push(const object& value); 23 23 ptr<object> pop(); 24 24 };
Note: See TracChangeset
for help on using the changeset viewer.