Index: libcfa/prelude/prelude-gen.cc =================================================================== --- libcfa/prelude/prelude-gen.cc (revision 9cb4fc85f7e0b0b69ea1c7eed832b4357e6aa200) +++ libcfa/prelude/prelude-gen.cc (revision f1c1339e829313edbd1b7faa98f6529025d7f5db) @@ -10,6 +10,6 @@ // Created On : Sat Feb 16 08:44:58 2019 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Mar 8 16:00:22 2019 -// Update Count : 26 +// Last Modified On : Tue Mar 19 08:19:35 2019 +// Update Count : 28 // @@ -208,7 +208,7 @@ cout << "void ?{} (" << type << " &);" << endl; cout << "void ?{} (" << type << " &, " << type << ");" << endl; - cout << type << " ?=? (" << type << " &, " << type << ")"; + cout << type << " ?=? (" << type << " &, " << type << ")"; if ( do_volatile ) { - cout << ", ?=?(volatile " << type << " &, " << type << ")"; + cout << ", ?=?(volatile " << type << " &, " << type << ")"; } cout << ";" << endl; @@ -217,5 +217,7 @@ otype("zero_t"); + cout << endl; otype("one_t"); + cout << endl; otype("_Bool", true); cout << endl; @@ -225,4 +227,5 @@ cout << "void ?{}(" << type.name << " &, " << type.name << ");" << endl; cout << "void ?{}(" << type.name << " &, zero_t);" << endl; + cout << "void ?{}(" << type.name << " &, one_t);" << endl; cout << "void ^?{}(" << type.name << " &);" << endl; cout << endl; Index: libcfa/src/concurrency/coroutine.hfa =================================================================== --- libcfa/src/concurrency/coroutine.hfa (revision 9cb4fc85f7e0b0b69ea1c7eed832b4357e6aa200) +++ libcfa/src/concurrency/coroutine.hfa (revision f1c1339e829313edbd1b7faa98f6529025d7f5db) @@ -46,5 +46,5 @@ //----------------------------------------------------------------------------- // Public coroutine API -static inline void suspend(); +static inline void suspend(void); forall(dtype T | is_coroutine(T)) @@ -71,5 +71,5 @@ // Suspend implementation inlined for performance -static inline void suspend() { +static inline void suspend(void) { // optimization : read TLS once and reuse it // Safety note: this is preemption safe since if Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision 9cb4fc85f7e0b0b69ea1c7eed832b4357e6aa200) +++ src/Parser/lex.ll (revision f1c1339e829313edbd1b7faa98f6529025d7f5db) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Sun Mar 10 09:13:09 2019 - * Update Count : 706 + * Last Modified On : Wed Mar 13 14:54:30 2019 + * Update Count : 707 */ @@ -226,4 +226,5 @@ char { KEYWORD_RETURN(CHAR); } choose { KEYWORD_RETURN(CHOOSE); } // CFA +coerce { KEYWORD_RETURN(COERCE); } // CFA _Complex { KEYWORD_RETURN(COMPLEX); } // C99 __complex { KEYWORD_RETURN(COMPLEX); } // GCC Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 9cb4fc85f7e0b0b69ea1c7eed832b4357e6aa200) +++ src/Parser/parser.yy (revision f1c1339e829313edbd1b7faa98f6529025d7f5db) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 21 08:45:07 2019 -// Update Count : 4232 +// Last Modified On : Fri Mar 15 14:25:43 2019 +// Update Count : 4248 // @@ -265,5 +265,5 @@ %token RESTRICT // C99 %token ATOMIC // C11 -%token FORALL MUTEX VIRTUAL // CFA +%token FORALL MUTEX VIRTUAL COERCE // CFA %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED %token BOOL COMPLEX IMAGINARY // C99 @@ -795,4 +795,5 @@ | '(' type_no_function ')' cast_expression { $$ = new ExpressionNode( build_cast( $2, $4 ) ); } + // keyword cast cannot be grouped because of reduction in aggregate_key | '(' COROUTINE '&' ')' cast_expression // CFA { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Coroutine, $5 ) ); } @@ -806,6 +807,24 @@ | '(' VIRTUAL type_no_function ')' cast_expression // CFA { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild< Expression >( $5 ), maybeMoveBuildType( $3 ) ) ); } + | '(' RETURN type_no_function ')' cast_expression // CFA + { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; } + | '(' COERCE type_no_function ')' cast_expression // CFA + { SemanticError( yylloc, "Coerce cast is currently unimplemented." ); $$ = nullptr; } + | '(' qualifier_cast_list ')' cast_expression // CFA + { SemanticError( yylloc, "Qualifier cast is currently unimplemented." ); $$ = nullptr; } // | '(' type_no_function ')' tuple // { $$ = new ExpressionNode( build_cast( $2, $4 ) ); } + ; + +qualifier_cast_list: + cast_modifier type_qualifier_name + | cast_modifier MUTEX + | qualifier_cast_list cast_modifier type_qualifier_name + | qualifier_cast_list cast_modifier MUTEX + ; + +cast_modifier: + '-' + | '+' ; Index: tests/concurrent/examples/quickSort.generic.cfa =================================================================== --- tests/concurrent/examples/quickSort.generic.cfa (revision f1c1339e829313edbd1b7faa98f6529025d7f5db) +++ tests/concurrent/examples/quickSort.generic.cfa (revision f1c1339e829313edbd1b7faa98f6529025d7f5db) @@ -0,0 +1,186 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// quickSort.c -- In-place concurrent quick-sort: threads are created to partition to a specific depth, then sequential +// recursive-calls are use to sort each partition. +// +// Author : Peter A. Buhr +// Created On : Wed Dec 6 12:15:52 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Fri Mar 15 14:52:41 2019 +// Update Count : 147 +// + +#include +#include +#include +#include +#include // strcmp + +forall( otype T | { int ? pivot after the pivot + do { + while ( values[left] < pivot ) left += 1; // changed values[left] < pivot + while ( pivot < values[right] ) right -= 1; + if ( left <= right ) { + swap = values[left]; // interchange values + values[left] = values[right]; + values[right] = swap; + left += 1; + right -= 1; + } // if + } while ( left <= right ); + + // restrict number of tasks to slightly greater than number of processors + if ( depth > 0 ) { + depth -= 1; + Quicksort(T) rqs = { values, low, right, depth }; // concurrently sort upper half + //Quicksort lqs( values, left, high, depth ); // concurrently sort lower half + sort( values, left, high, depth ); // concurrently sort lower half + } else { + sort( values, low, right, 0 ); // sequentially sort lower half + sort( values, left, high, 0 ); // sequentially sort upper half + } // if + } // if + } // sort + + with( qs ) { + sort( values, low, high, depth ); + } // with + } // main +} + +bool convert( int & val, const char * nptr ) { // convert C string to integer + char * eptr; + int temp = strto( nptr, &eptr, 10 ); // do not change val on false + // true => entire string valid with no extra characters + return *nptr != '\0' && *eptr == '\0' ? val = temp, true : false; +} // convert + +void usage( char * argv[] ) { + sout | "Usage:" | argv[0] | "( -s unsorted-file [ sorted-file ] | -t size (>= 0) [ depth (>= 0) ] )"; + exit( EXIT_FAILURE ); // TERMINATE! +} // usage + + +#define ELEMTYPE int + +int main( int argc, char * argv[] ) { + ifstream & unsortedfile = sin; + ofstream & sortedfile = sout; // default value + int depth = 0, size; + + if ( argc != 1 ) { // do not use defaults + if ( argc < 2 || argc > 4 ) usage( argv ); // wrong number of options + if ( strcmp( argv[1], "-t" ) == 0 ) { // timing ? + &unsortedfile = (ifstream *)0; // no input + choose ( argc ) { + case 4: + if ( ! convert( depth, argv[3] ) || depth < 0 ) usage( argv ); + fallthrough; + case 3: + if ( ! convert( size, argv[2] ) || size < 0 ) usage( argv ); + } // choose + } else { // sort file + choose ( argc ) { + case 3: + &sortedfile = new( (const char *)argv[2] ); // open the output file + if ( fail( sortedfile ) ) { + serr | "Error! Could not open sorted output file \"" | argv[2] | "\""; + usage( argv ); + } // if + fallthrough; + case 2: + &unsortedfile = new( (const char *)argv[1] ); // open the input file + if ( fail( unsortedfile ) ) { + serr | "Error! Could not open unsorted input file \"" | argv[1] | "\""; + usage( argv ); + } // if + } // choose + } // if + } // if + sortedfile | nlOff; // turn off auto newline + + enum { ValuesPerLine = 22 }; // number of values printed per line + + if ( &unsortedfile ) { // generate output ? + for () { + unsortedfile | size; // read number of elements in the list + if ( eof( unsortedfile ) ) break; + ELEMTYPE * values = alloc( size ); // values to be sorted, too large to put on stack + for ( int counter = 0; counter < size; counter += 1 ) { // read unsorted numbers + unsortedfile | values[counter]; + if ( counter != 0 && counter % ValuesPerLine == 0 ) sortedfile | nl | " "; + sortedfile | values[counter]; + if ( counter < size - 1 && (counter + 1) % ValuesPerLine != 0 ) sortedfile | ' '; + } // for + sortedfile | nl; + if ( size > 0 ) { // values to sort ? + Quicksort(ELEMTYPE) QS = { values, size - 1, 0 }; // sort values + } // wait until sort tasks terminate + for ( int counter = 0; counter < size; counter += 1 ) { // print sorted list + if ( counter != 0 && counter % ValuesPerLine == 0 ) sortedfile | nl | " "; + sortedfile | values[counter]; + if ( counter < size - 1 && (counter + 1) % ValuesPerLine != 0 ) sortedfile | ' '; + } // for + sortedfile | nl | nl; + + delete( values ); + } // for + if ( &unsortedfile != &sin ) delete( &unsortedfile ); // close input/output files + if ( &sortedfile != &sout ) delete( &sortedfile ); + } else { + processor processors[ (1 << depth) - 1 ] __attribute__(( unused )); // create 2^depth-1 kernel threads + + ELEMTYPE * values = alloc( size ); // values to be sorted, too large to put on stack + for ( int counter = 0; counter < size; counter += 1 ) { // generate unsorted numbers + values[counter] = size - counter; // descending values + } // for + { + Quicksort(ELEMTYPE) QS = { values, size - 1, depth }; // sort values + } // wait until sort tasks terminate + + // for ( int counter = 0; counter < size - 1; counter += 1 ) { // check sorting + // if ( values[counter] > values[counter + 1] ) abort(); + // } // for + + delete( values ); + } // if +} // main + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa quickSort.generic.cfa" // +// End: // Index: tests/coroutine/.expect/devicedriver.txt =================================================================== --- tests/coroutine/.expect/devicedriver.txt (revision f1c1339e829313edbd1b7faa98f6529025d7f5db) +++ tests/coroutine/.expect/devicedriver.txt (revision f1c1339e829313edbd1b7faa98f6529025d7f5db) @@ -0,0 +1,8 @@ +msg:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +msg:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +msg: +msg:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc +msg:escapeSTXescapeESCescapeETX +CRC failure +STX in message +message too long Index: tests/coroutine/devicedriver.cfa =================================================================== --- tests/coroutine/devicedriver.cfa (revision f1c1339e829313edbd1b7faa98f6529025d7f5db) +++ tests/coroutine/devicedriver.cfa (revision f1c1339e829313edbd1b7faa98f6529025d7f5db) @@ -0,0 +1,85 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// devicedriver.cfa -- +// +// Author : Peter A. Buhr +// Created On : Sat Mar 16 15:30:34 2019 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Mar 18 08:29:20 2019 +// Update Count : 79 +// + +#include +#include + +enum Status { CONT, MSG, ESTX, ELNTH, ECRC }; +coroutine Driver { + Status status; + char * msg, byte; +}; // Driver + +void ?{}( Driver & d, char * m ) { d.msg = m; } +Status next( Driver & d, char b ) with( d ) { + byte = b; resume( d ); return status; +} // next + +void main( Driver & d ) with( d ) { + enum { STX = '\002', ESC = '\033', ETX = '\003', MaxMsg = 64 }; + unsigned short int crc; // error checking + msg: for () { // parse message + status = CONT; + unsigned int lnth = 0, sum = 0; + while ( byte != STX ) suspend(); + emsg: for () { + suspend(); + choose ( byte ) { // process byte + case STX: + status = ESTX; suspend(); continue msg; + case ETX: + break emsg; + case ESC: + suspend(); + } // choose + if ( lnth >= MaxMsg ) { // buffer full ? + status = ELNTH; suspend(); continue msg; + } // if + msg[lnth++] = byte; + sum += byte; + } // for + msg[lnth] = '\0'; // terminate string + suspend(); + crc = (unsigned char)byte << 8; // prevent sign extension for signed char + suspend(); + status = (crc | (unsigned char)byte) == sum ? MSG : ECRC; + suspend(); + } // for +} // main + +int main() { + char msg[65], byte; + Driver driver = { msg }; + eof: for () { // read until end of file + sin | byte; // read one character + if ( eof( sin ) ) break eof; // eof ? + choose( next( driver, byte ) ) { // analyse character + case MSG: + sout | "msg:" | msg; + case ESTX: + sout | "STX in message"; + case ELNTH: + sout | "message too long"; + case ECRC: + sout | "CRC failure"; + default: ; + } // choose + } // for +} // main + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa -g -Wall -Wextra devicedriver.cfa" // +// End: // Index: tests/forall.cfa =================================================================== --- tests/forall.cfa (revision 9cb4fc85f7e0b0b69ea1c7eed832b4357e6aa200) +++ tests/forall.cfa (revision f1c1339e829313edbd1b7faa98f6529025d7f5db) @@ -10,6 +10,6 @@ // Created On : Wed May 9 08:48:15 2018 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Nov 6 17:53:43 2018 -// Update Count : 31 +// Last Modified On : Tue Mar 19 08:29:38 2019 +// Update Count : 32 // @@ -53,6 +53,4 @@ right = temp; } - -void ?{}( int & c, zero_t ) { c = 0; } // not in prelude trait sumable( otype T ) { Index: tests/rational.cfa =================================================================== --- tests/rational.cfa (revision 9cb4fc85f7e0b0b69ea1c7eed832b4357e6aa200) +++ tests/rational.cfa (revision f1c1339e829313edbd1b7faa98f6529025d7f5db) @@ -10,6 +10,6 @@ // Created On : Mon Mar 28 08:43:12 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Dec 4 21:46:42 2018 -// Update Count : 69 +// Last Modified On : Tue Mar 19 08:30:28 2019 +// Update Count : 73 // @@ -19,8 +19,4 @@ #include -// UNNECESSARY, FIX ME -void ?{}( int & this ) { this = 0; } -void ?{}( int & this, zero_t ) { this = 0; } -void ?{}( int & this, one_t ) { this = 1; } double convert( int i ) { return (double)i; } int convert( double d ) { return (int)d; }