Changeset c4497e3

Timestamp:

Jun 26, 2023, 10:11:03 PM (22 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

b9c06b98

Parents:

65ef0cd (diff), 917e1fd (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• doc/theses/colby_parsons_MMAth/benchmarks/channels/plotData.py (modified) (2 diffs)
• doc/theses/colby_parsons_MMAth/benchmarks/mutex_stmt/plotData.py (modified) (2 diffs)
• doc/theses/colby_parsons_MMAth/benchmarks/waituntil/cfa/future.cfa (modified) (4 diffs)
• doc/theses/colby_parsons_MMAth/benchmarks/waituntil/cfa/sidechan.cfa (modified) (2 diffs)
• doc/theses/colby_parsons_MMAth/benchmarks/waituntil/run (modified) (5 diffs)
• doc/theses/colby_parsons_MMAth/benchmarks/waituntil/ucpp/future.cc (modified) (4 diffs)
• libcfa/prelude/prelude-gen.cc (modified) (1 diff)
• libcfa/src/concurrency/actor.hfa (modified) (8 diffs)
• src/AST/Decl.cpp (modified) (1 diff)
• src/Validate/LinkReferenceToTypes.cpp (modified) (1 diff)

doc/theses/colby_parsons_MMAth/benchmarks/channels/plotData.py ¶

@@ -62 +62 @@
 procCount = 0
 currVariant = 0
+experiment_duration = 10
 name = ""
 var_name = ""
@@ -107 +108 @@
     
     lineArr = line.split()
-    tempData[count] = float(lineArr[-1])
+    tempData[count] = float(lineArr[-1]) / experiment_duration
     count += 1
     if count == numTimes:

doc/theses/colby_parsons_MMAth/benchmarks/mutex_stmt/plotData.py ¶

@@ -60 +60 @@
 name = "Aggregate Lock"
 var_name = ""
+experiment_duration = 10
 sendData = [0.0 for j in range(numVariants)]
 data = [[0.0 for i in range(len(procs))] for j in range(numVariants)]
@@ -80 +81 @@
     
     lineArr = line.split()
-    tempData[count] = float(lineArr[-1])
+    tempData[count] = float(lineArr[-1]) / experiment_duration
     count += 1
     if count == numTimes:

doc/theses/colby_parsons_MMAth/benchmarks/waituntil/cfa/future.cfa ¶

@@ -7 +7 @@
 #include <string.h>
 
-size_t Clients = 1, Time = 10;
+// #define ANDOR
+
+size_t Processors = 2, Time = 10;
 
 size_t globalTotal = 0;
 future(size_t) A, B, C;
-volatile bool server_done_loop = false;
-volatile bool client_done_loop = false;
+volatile bool done_loop = false;
 volatile bool client_done = false;
 volatile bool server_done = false;
 
-volatile size_t client_count = 0;
-volatile size_t client_loop_count = 0;
+static inline void wait() {
+    #ifdef OR
+    waituntil( A ) { get( A ); }
+    or waituntil( B ) { get( B ); }
+    or waituntil( C ) { get( C ); }
+    #endif
+    #ifdef AND
+    waituntil( A ) { get( A ); }
+    and waituntil( B ) { get( B ); }
+    #endif
+    #ifdef AND3
+    waituntil( A ) { get( A ); }
+    and waituntil( B ) { get( B ); }
+    and waituntil( C ) { get( C ); }
+    #endif
+    #ifdef ANDOR
+    waituntil( A ) { get( A ); }
+    and waituntil( B ) { get( B ); }
+    or waituntil( C ) { get( C ); }
+    #endif
+    #ifdef ORAND
+    (waituntil( A ) { get( A ); }
+    or waituntil( B ) { get( B ); })
+    and waituntil( C ) { get( C ); }
+    #endif
+    #ifdef BASIC
+    get( A );
+    #endif
+}
+
+static inline fulfill( size_t i ) {
+    #ifdef OR
+    if ( i % 3 == 0 ) {
+        fulfil(A, i);
+    } else if ( i % 3 == 1 ) {
+        fulfil(B, i);
+    } else {
+        fulfil(C, i);
+    }
+    #endif
+    #ifdef AND
+    if ( i % 2 == 0 ) {
+        fulfil(A, i);
+        fulfil(B, i);
+    } else {
+        fulfil(B, i);
+        fulfil(A, i);
+    }
+    #endif
+    #ifdef AND3
+    if ( i % 6 == 0 ) {
+        fulfil(A, i);
+        fulfil(B, i);
+        fulfil(C, i);
+    } else if ( i % 6 == 1 ) {
+        fulfil(A, i);
+        fulfil(C, i);
+        fulfil(B, i);
+    } else if ( i % 6 == 2 ) {
+        fulfil(B, i);
+        fulfil(A, i);
+        fulfil(C, i);
+    } else if ( i % 6 == 3 ) {
+        fulfil(B, i);
+        fulfil(C, i);
+        fulfil(A, i);
+    } else if ( i % 6 == 4 ) {
+        fulfil(C, i);
+        fulfil(A, i);
+        fulfil(B, i);
+    } else if ( i % 6 == 5 ) {
+        fulfil(C, i);
+        fulfil(B, i);
+        fulfil(A, i);
+    }
+    #endif
+    #ifdef ANDOR
+    if ( i % 4 == 0 ) {
+        fulfil(A, i);
+        fulfil(B, i);
+    } else if ( i % 4 == 1 ) {
+        fulfil(A, i);
+        fulfil(C, i);
+    } else if ( i % 4 == 2 ) {
+        fulfil(B, i);
+        fulfil(C, i);
+    } else {
+        fulfil(C, i);
+    }
+    #endif
+    #ifdef ORAND
+    if ( i % 4 == 0 ) {
+        fulfil(A, i);
+        fulfil(C, i);
+    } else if ( i % 4 == 1 ) {
+        fulfil(C, i);
+        fulfil(A, i);
+    } else if ( i % 4 == 2 ) {
+        fulfil(B, i);
+        fulfil(C, i);
+    } else {
+        fulfil(C, i);
+        fulfil(B, i);
+    }
+    #endif
+    #ifdef BASIC
+    fulfil(A, i);
+    #endif
+}
+
 thread Client {};
 void main( Client & this ) {
     size_t i = 0;
-    for(;; i++ ) {
-        waituntil( A ) { get(A); }
-        and waituntil( B ) { get(B); }
-        or waituntil( C ) { get(C); }
-
-        // needs to check after waituntil for termination synchronization
-        if ( client_done ) break;
-
-        // Barrier-like synch needed to reset futures safely
-        if ( __atomic_add_fetch( &client_count, 1, __ATOMIC_SEQ_CST ) == Clients ) { // synchronize reset
-            client_count = 0;
-            reset( A );
-            reset( B );
-            reset( C );
-            client_done_loop = true; // unblock clients
-        }
-        while( !client_done_loop ) {} // client barrier
-        if ( __atomic_add_fetch( &client_loop_count, 1, __ATOMIC_SEQ_CST ) == Clients ) { 
-            client_done_loop = false; // reset barrier before clients can proceed past waituntil
-            server_done_loop = true; // unblock server to restart iteration
-            client_loop_count = 0;
-        }
+    for(; !client_done; i++ ) {
+        wait();
+        reset( A );
+        reset( B );
+        reset( C );
+        done_loop = true;
     }
     __atomic_fetch_add( &globalTotal, i, __ATOMIC_SEQ_CST );
@@ -50 +143 @@
 void main( Server & this ) {
     for( size_t i = 0; !server_done; i++ ) {
-        if ( i % 4 == 0 ) {
-            fulfil(A, i);
-            fulfil(B, i);
-        } else if ( i % 4 == 1 ) {
-            fulfil(A, i);
-            fulfil(C, i);
-        } else if ( i % 4 == 2 ) {
-            fulfil(B, i);
-            fulfil(C, i);
-        } else {
-            fulfil(C, i);
-        }
-        while( !server_done_loop && !server_done ) {} // server barrier
-        server_done_loop = false; // reset server barrier
+        fulfill( i );
+        while( !done_loop ) {}
+        done_loop = false;
     }
 }
@@ -69 +151 @@
 int main( int argc, char * argv[] ) {
     switch ( argc ) {
-          case 3:
-                if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
-                        Time = atoi( argv[2] );
-                } // if
           case 2:
                 if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
-                        Clients = atoi( argv[1] );
-                        if ( Clients < 1 ) goto Usage;
+                        Time = atoi( argv[1] );
+                        if ( Time < 0 ) goto Usage;
                 } // if
           case 1:                                                                                       // use defaults
@@ -83 +161 @@
           Usage:
                 sout | "Usage: " | argv[0]
-             | " [ clients (> 0) | 'd' (default " | Clients
-                         | ") ] [ time (>= 0) | 'd' (default " | Time
+             | "[ time (>= 0) | 'd' (default " | Time
                          | ") ]" ;
                 exit( EXIT_FAILURE );
         } // switch
-    processor p[Clients];
+    processor p[Processors - 1];
 
     {
-        Client c[Clients];
+        Server s;
         {
-            Server s;
+            Client c;
 
             sleep(Time`s);
-            server_done = true;
+
+            client_done = true;
         }
-        while( available(A) || available(B) || available(C) ) {}
-        client_done = true;
-        fulfil( C, 0 );
+        server_done = true;
+        done_loop = true;
     }
     printf("%zu\n", globalTotal);

doc/theses/colby_parsons_MMAth/benchmarks/waituntil/cfa/sidechan.cfa ¶

@@ -37 +37 @@
 thread Consumer {};
 void main( Consumer & this ) {
-    int idx = __atomic_fetch_add( &cons_counter, 1, __ATOMIC_SEQ_CST ) % Channels;
+    const int idx = __atomic_fetch_add( &cons_counter, 1, __ATOMIC_SEQ_CST ) % Channels;
     size_t val, i = 0;
     try {
@@ -49 +49 @@
 thread Producer {};
 void main( Producer & this ) {
-    int idx = __atomic_fetch_add( &prod_counter, 1, __ATOMIC_SEQ_CST ) % Channels;
+    const int idx = __atomic_fetch_add( &prod_counter, 1, __ATOMIC_SEQ_CST ) % Channels;
     try {
         for( size_t i = 0;; i++ ) {

doc/theses/colby_parsons_MMAth/benchmarks/waituntil/run ¶

@@ -85 +85 @@
 }
 
-# numtimes=5
-numtimes=1
+numtimes=3
+# numtimes=1
 
 # num_threads='2 4 8 16 24 32'
-# side_chan_threads='6 12 18 24 30' # must be mults of 6
+side_chan_threads='6 12 18 24 30' # must be mults of 6
 num_threads='2'
-side_chan_threads='6'
+# side_chan_threads='6'
 
 chan_size='10'
 future_time='10'
+future_flags=('-DOR' '-DAND3' '-DANDOR' '-DORAND')
+future_names=('OR' 'AND' 'ANDOR' 'ORAND')
 
 # toggle benchmarks
@@ -103 +105 @@
 spin=${false}
 contend=${false}
-sidechan=${false}
-# future=${false}
+# sidechan=${false}
+future=${false}
 
 runCFA=${true}
@@ -164 +166 @@
 
 run_future() {
-    for p in ${num_threads} ; do
-        pre_args=$(( ${p} - 1 ))
-        affinity ${p}
-        preprint="${p}\t"
-        repeat_command taskset -c ${taskset} ./a.${hostname} ${pre_args} ${post_args}
-    done
+    affinity 2
+    preprint="2\t"
+    repeat_command taskset -c ${taskset} ./a.${hostname} ${post_args}
 }
 
@@ -247 +246 @@
         ${cfa} ${cfa_flags} sidechan.cfa -o a.${hostname} > /dev/null 2>&1
         run_side_chan
-        rm a.${hostname}
+        # rm a.${hostname}
         cd - > /dev/null
     fi # done CFA
@@ -262 +261 @@
 
 if [ ${future} -eq ${true} ] ; then
-    echo "future: "
     post_args=${future_time}
-    if [ ${runCFA} -eq ${true} ] ; then
-        cd cfa # CFA RUN
-        print_header 'CFA'
-        ${cfa} ${cfa_flags} future.cfa -o a.${hostname} > /dev/null 2>&1
-        run_future
-        rm a.${hostname}
-        cd - > /dev/null
-    fi # done CFA
-
-    if [ ${runUCPP} -eq ${true} ] ; then
-        cd ucpp
-        print_header 'uC++'
-        ${UCPP} ${UCPPflags} future.cc -o a.${hostname} > /dev/null 2>&1
-        run_future
-        rm a.${hostname}
-        cd - > /dev/null
-    fi # done Go
-fi
-
+    for i in ${!future_flags[@]}; do
+        echo 'future '${future_names[$i]}':'
+        if [ ${runCFA} -eq ${true} ] ; then
+            cd cfa # CFA RUN
+            print_header 'CFA'
+            ${cfa} ${cfa_flags} ${future_flags[$i]} future.cfa -o a.${hostname} > /dev/null 2>&1
+            run_future
+            rm a.${hostname}
+            cd - > /dev/null
+        fi # done CFA
+
+        if [ ${runUCPP} -eq ${true} ] ; then
+            cd ucpp
+            print_header 'uC++'
+            ${UCPP} ${UCPPflags} ${future_flags[$i]} future.cc -o a.${hostname} > /dev/null 2>&1
+            run_future
+            rm a.${hostname}
+            cd - > /dev/null
+        fi # done Go
+    done
+fi
+

doc/theses/colby_parsons_MMAth/benchmarks/waituntil/ucpp/future.cc ¶

@@ -3 +3 @@
 #include <uFuture.h>
 
-size_t Clients = 2, Time = 10;
+// #define ANDOR
 
+size_t Processors = 2, Time = 10;
 size_t globalTotal = 0;
-Future_ISM<size_t> A, B, C;
-volatile bool server_done_loop = false;
-volatile bool client_done_loop = false;
+volatile bool done_loop = false;
 volatile bool client_done = false;
 volatile bool server_done = false;
 
-volatile size_t client_count = 0;
-volatile size_t client_loop_count = 0;
+Future_ISM<size_t> A, B, C;
+
+static inline void wait() {
+    #ifdef OR
+    _Select( A ) { A(); }
+    or _Select( B ) { B(); }
+    or _Select( C ) { C(); }
+    #endif
+    #ifdef AND
+    _Select( A ) { A(); }
+    and _Select( B ) { B(); }
+    #endif
+    #ifdef AND3
+    _Select( A ) { A(); }
+    and _Select( B ) { B(); }
+    and _Select( C ) { C(); }
+    #endif
+    #ifdef ANDOR
+    _Select( A ) { A(); }
+    and _Select( B ) { B(); }
+    or _Select( C ) { C(); }
+    #endif
+    #ifdef ORAND
+    (_Select( A ) { A(); }
+    or _Select( B ) { B(); })
+    and _Select( C ) { C(); }
+    #endif
+    #ifdef BASIC
+    A();
+    #endif
+}
+
+static inline void fulfill( size_t i ) {
+    #ifdef OR
+    if ( i % 3 == 0 ) {
+        A.delivery(i);
+    } else if ( i % 3 == 1 ) {
+        B.delivery(i);
+    } else {
+        C.delivery(i);
+    }
+    #endif
+    #ifdef AND
+    if ( i % 2 == 0 ) {
+        A.delivery(i);
+        B.delivery(i);
+    } else {
+        B.delivery(i);
+        A.delivery(i);
+    }
+    #endif
+    #ifdef AND3
+    if ( i % 6 == 0 ) {
+        A.delivery(i);
+        B.delivery(i);
+        C.delivery(i);
+    } else if ( i % 6 == 1 ) {
+        A.delivery(i);
+        C.delivery(i);
+        B.delivery(i);
+    } else if ( i % 6 == 2 ) {
+        B.delivery(i);
+        A.delivery(i);
+        C.delivery(i);
+    } else if ( i % 6 == 3 ) {
+        B.delivery(i);
+        C.delivery(i);
+        A.delivery(i);
+    } else if ( i % 6 == 4 ) {
+        C.delivery(i);
+        A.delivery(i);
+        B.delivery(i);
+    } else if ( i % 6 == 5 ) {
+        C.delivery(i);
+        B.delivery(i);
+        A.delivery(i);
+    }
+    #endif
+    #ifdef ANDOR
+    if ( i % 4 == 0 ) {
+        A.delivery(i);
+        B.delivery(i);
+    } else if ( i % 4 == 1 ) {
+        A.delivery(i);
+        C.delivery(i);
+    } else if ( i % 4 == 2 ) {
+        B.delivery(i);
+        C.delivery(i);
+    } else {
+        C.delivery(i);
+    }
+    #endif
+    #ifdef ORAND
+    if ( i % 4 == 0 ) {
+        A.delivery(i);
+        C.delivery(i);
+    } else if ( i % 4 == 1 ) {
+        C.delivery(i);
+        A.delivery(i);
+    } else if ( i % 4 == 2 ) {
+        B.delivery(i);
+        C.delivery(i);
+    } else {
+        C.delivery(i);
+        B.delivery(i);
+    }
+    #endif
+    #ifdef BASIC
+    A.delivery(i);
+    #endif
+}
+
 _Task Client {
         void main() {
                 size_t i = 0;
-        for(;; i++ ) {
-            _Select( A ) { A(); }
-            and _Select( B ) { B(); }
-            or _Select( C ) { C(); }
-
-            // needs to check after waituntil for termination synchronization
-            if ( client_done ) break;
-            
-            // Barrier-like synch needed to reset futures safely
-            if ( __atomic_add_fetch(&client_count, 1, __ATOMIC_SEQ_CST) == Clients ) {
-                client_count = 0;
-                A.reset();
-                B.reset();
-                C.reset();
-                client_done_loop = true;
-            }
-            while( !client_done_loop ) {} // client barrier
-            if ( __atomic_add_fetch( &client_loop_count, 1, __ATOMIC_SEQ_CST ) == Clients ) { 
-                client_done_loop = false; // reset barrier before clients can proceed past waituntil
-                server_done_loop = true; // unblock server to restart iteration
-                client_loop_count = 0;
-            }
+        for(; !client_done; i++ ) {
+            wait();
+            A.reset();
+            B.reset();
+            C.reset();
+            done_loop = true;
         }
         __atomic_fetch_add( &globalTotal, i, __ATOMIC_SEQ_CST );
@@ -47 +140 @@
         void main() {
                 for( size_t i = 0; !server_done; i++ ) {
-            if ( i % 4 == 0 ) {
-                A.delivery(i);
-                B.delivery(i);
-            } else if ( i % 4 == 1 ) {
-                A.delivery(i);
-                C.delivery(i);
-            } else if ( i % 4 == 2 ) {
-                B.delivery(i);
-                C.delivery(i);
-            } else {
-                C.delivery(i);
-            }
-            while( !server_done_loop && !server_done ) {} // server barrier
-            server_done_loop = false; // reset server barrier
+            fulfill( i );
+            while( !done_loop ) {}
+            done_loop = false;
         }
         }
@@ -67 +149 @@
 int main( int argc, char * argv[] ) {
         switch ( argc ) {
-          case 3:
-                if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
-                        Time = atoi( argv[2] );
-                } // if
           case 2:
                 if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
-                        Clients = atoi( argv[1] );
-                        if ( Clients < 1 ) goto Usage;
+                        Time = atoi( argv[1] );
+                        if ( Time < 0 ) goto Usage;
                 } // if
           case 1:                                                                                       // use defaults
@@ -81 +159 @@
           Usage:
                 cerr << "Usage: " << argv[0]
-             << " [ clients (> 0) | 'd' (default " << Clients
-                         << ") ] [ time (>= 0) | 'd' (default " << Time
+             << "[ time (>= 0) | 'd' (default " << Time
                          << ") ]" ;
                 exit( EXIT_FAILURE );
         } // switch
-    uProcessor p[Clients];
+    uProcessor p[Processors - 1];
 
     {
-        Client c[Clients];
+        Server s;
         {
-            Server s;
+            Client c;
 
             uBaseTask::sleep( uDuration( Time ) );
 
-            server_done = true;
+            client_done = true;
         }
-        while( A.available() || B.available() || C.available() ) {}
-        client_done = true;
-        C.delivery(1); // can't deliver 0 since it causes ambiguity
+        server_done = true;
+        done_loop = true;
     }
     cout << globalTotal << endl;

libcfa/prelude/prelude-gen.cc ¶

@@ -159 +159 @@
 int main() {
         cout << "# 2 \"prelude.cfa\"  // needed for error messages from this file" << endl;
-        cout << "forall( T & ) trait sized {};" << endl;
+        cout << "forall( T * ) trait sized {};" << endl;
 
         cout << "//////////////////////////" << endl;

libcfa/src/concurrency/actor.hfa ¶

@@ -390 +390 @@
 struct actor {
     size_t ticket;                                          // executor-queue handle
-    allocation allocation_;                                         // allocation action
+    allocation alloc;                                       // allocation action
     inline virtual_dtor;
 };
@@ -398 +398 @@
     // member must be called to end it
     DEBUG_ABORT( __actor_executor_ == 0p, "Creating actor before calling start_actor_system() can cause undefined behaviour.\n" );
-    allocation_ = Nodelete;
+    alloc = Nodelete;
     ticket = __get_next_ticket( *__actor_executor_ );
     __atomic_fetch_add( &__num_actors_, 1, __ATOMIC_RELAXED );
@@ -407 +407 @@
 
 static inline void check_actor( actor & this ) {
-    if ( this.allocation_ != Nodelete ) {
-        switch( this.allocation_ ) {
+    if ( this.alloc != Nodelete ) {
+        switch( this.alloc ) {
             case Delete: delete( &this ); break;
             case Destroy:
@@ -427 +427 @@
 
 struct message {
-    allocation allocation_;                     // allocation action
+    allocation alloc;                   // allocation action
     inline virtual_dtor;
 };
 
 static inline void ?{}( message & this ) {
-    this.allocation_ = Nodelete;
+    this.alloc = Nodelete;
 }
 static inline void ?{}( message & this, allocation alloc ) {
-    memcpy( &this.allocation_, &alloc, sizeof(allocation) ); // optimization to elide ctor
-    DEBUG_ABORT( this.allocation_ == Finished, "The Finished allocation status is not supported for message types.\n" );
+    memcpy( &this.alloc, &alloc, sizeof(allocation) ); // optimization to elide ctor
+    CFA_DEBUG( if( this.alloc == Finished ) this.alloc = Nodelete; )
 }
 static inline void ^?{}( message & this ) with(this) {
-    CFA_DEBUG( if ( allocation_ == Nodelete ) printf("A message at location %p was allocated but never sent.\n", &this); )
+    CFA_DEBUG(
+                if ( alloc == Nodelete ) {
+                        printf( "CFA warning (UNIX pid:%ld) : program terminating with message %p allocated but never sent.\n",
+                                        (long int)getpid(), &this );
+                }
+        )
 }
 
 static inline void check_message( message & this ) {
-    switch ( this.allocation_ ) {                                               // analyze message status
-        case Nodelete: CFA_DEBUG( this.allocation_ = Finished ); break;
+    switch ( this.alloc ) {                                             // analyze message status
+        case Nodelete: CFA_DEBUG( this.alloc = Finished ); break;
         case Delete: delete( &this ); break;
         case Destroy: ^?{}( this ); break;
@@ -451 +456 @@
 }
 static inline void set_allocation( message & this, allocation state ) {
-    this.allocation_ = state;
+    CFA_DEBUG( if ( state == Nodelete ) state = Finished; )
+    this.alloc = state;
 }
 
@@ -459 +465 @@
     message * base_msg;
     allocation temp = this.fn( *this.receiver, *this.msg, &base_actor, &base_msg );
-    base_actor->allocation_ = temp;
+    memcpy( &base_actor->alloc, &temp, sizeof(allocation) ); // optimization to elide ctor
     check_message( *base_msg );
     check_actor( *base_actor );
@@ -671 +677 @@
 
 static inline void stop_actor_system() {
-    park( ); // will be unparked when actor system is finished
+    park( ); // unparked when actor system is finished
 
     if ( !__actor_executor_passed ) delete( __actor_executor_ );
@@ -682 +688 @@
 // Default messages to send to any actor to change status
 // assigned at creation to __base_msg_finished to avoid unused message warning
-message __base_msg_finished @= { .allocation_ : Finished };
-struct __delete_msg_t { inline message; } delete_msg = __base_msg_finished;
-struct __destroy_msg_t { inline message; } destroy_msg = __base_msg_finished;
-struct __finished_msg_t { inline message; } finished_msg = __base_msg_finished;
-
-allocation receive( actor & this, __delete_msg_t & msg ) { return Delete; }
-allocation receive( actor & this, __destroy_msg_t & msg ) { return Destroy; }
-allocation receive( actor & this, __finished_msg_t & msg ) { return Finished; }
-
+message __base_msg_finished @= { .alloc : Finished };
+struct delete_message_t { inline message; } delete_msg = __base_msg_finished;
+struct destroy_msg_t { inline message; } destroy_msg = __base_msg_finished;
+struct finished_msg_t { inline message; } finished_msg = __base_msg_finished;
+
+allocation receive( actor & this, delete_message_t & msg ) { return Delete; }
+allocation receive( actor & this, destroy_msg_t & msg ) { return Destroy; }
+allocation receive( actor & this, finished_msg_t & msg ) { return Finished; }
+

src/AST/Decl.cpp ¶

@@ -115 +115 @@
         static_assert( sizeof(kindNames) / sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "typeString: kindNames is out of sync." );
         assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." );
-        return sized ? kindNames[ kind ] : &kindNames[ kind ][ sizeof("sized") ]; // sizeof includes '\0'
+        // sizeof("sized") includes '\0' and gives the offset to remove "sized ".
+        return sized ? kindNames[ kind ] : &kindNames[ kind ][ sizeof("sized") ];
 }
 

src/Validate/LinkReferenceToTypes.cpp ¶

@@ -264 +264 @@
 
 ast::TraitDecl const * LinkTypesCore::postvisit( ast::TraitDecl const * decl ) {
-        auto mut = ast::mutate( decl );
-        if ( mut->name == "sized" ) {
-                // "sized" is a special trait - flick the sized status on for the type variable.
-                assertf( mut->params.size() == 1, "Built-in trait 'sized' has incorrect number of parameters: %zd", decl->params.size() );
-                ast::TypeDecl * td = mut->params.front().get_and_mutate();
-                td->sized = true;
-        }
-
         // There is some overlap with code from decayForallPointers,
         // perhaps reorganization or shared helper functions are called for.
         // Move assertions from type parameters into the body of the trait.
+        auto mut = ast::mutate( decl );
         for ( ast::ptr<ast::TypeDecl> const & td : decl->params ) {
                 auto expanded = expandAssertions( td->assertions );