Index: doc/theses/colby_parsons_MMAth/benchmarks/channels/plotData.py
===================================================================
--- doc/theses/colby_parsons_MMAth/benchmarks/channels/plotData.py	(revision 65ef0cd7e951937056fb71e81989690e7e2717cc)
+++ doc/theses/colby_parsons_MMAth/benchmarks/channels/plotData.py	(revision c4497e344090425432cb947a2c39c2e0b09efcd6)
@@ -62,4 +62,5 @@
 procCount = 0
 currVariant = 0
+experiment_duration = 10
 name = ""
 var_name = ""
@@ -107,5 +108,5 @@
     
     lineArr = line.split()
-    tempData[count] = float(lineArr[-1])
+    tempData[count] = float(lineArr[-1]) / experiment_duration
     count += 1
     if count == numTimes:
Index: doc/theses/colby_parsons_MMAth/benchmarks/mutex_stmt/plotData.py
===================================================================
--- doc/theses/colby_parsons_MMAth/benchmarks/mutex_stmt/plotData.py	(revision 65ef0cd7e951937056fb71e81989690e7e2717cc)
+++ doc/theses/colby_parsons_MMAth/benchmarks/mutex_stmt/plotData.py	(revision c4497e344090425432cb947a2c39c2e0b09efcd6)
@@ -60,4 +60,5 @@
 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,5 +81,5 @@
     
     lineArr = line.split()
-    tempData[count] = float(lineArr[-1])
+    tempData[count] = float(lineArr[-1]) / experiment_duration
     count += 1
     if count == numTimes:
Index: doc/theses/colby_parsons_MMAth/benchmarks/waituntil/cfa/future.cfa
===================================================================
--- doc/theses/colby_parsons_MMAth/benchmarks/waituntil/cfa/future.cfa	(revision 65ef0cd7e951937056fb71e81989690e7e2717cc)
+++ doc/theses/colby_parsons_MMAth/benchmarks/waituntil/cfa/future.cfa	(revision c4497e344090425432cb947a2c39c2e0b09efcd6)
@@ -7,40 +7,133 @@
 #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,18 +143,7 @@
 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,12 +151,8 @@
 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,22 +161,21 @@
 	  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);
Index: doc/theses/colby_parsons_MMAth/benchmarks/waituntil/cfa/sidechan.cfa
===================================================================
--- doc/theses/colby_parsons_MMAth/benchmarks/waituntil/cfa/sidechan.cfa	(revision 65ef0cd7e951937056fb71e81989690e7e2717cc)
+++ doc/theses/colby_parsons_MMAth/benchmarks/waituntil/cfa/sidechan.cfa	(revision c4497e344090425432cb947a2c39c2e0b09efcd6)
@@ -37,5 +37,5 @@
 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,5 +49,5 @@
 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++ ) {
Index: doc/theses/colby_parsons_MMAth/benchmarks/waituntil/run
===================================================================
--- doc/theses/colby_parsons_MMAth/benchmarks/waituntil/run	(revision 65ef0cd7e951937056fb71e81989690e7e2717cc)
+++ doc/theses/colby_parsons_MMAth/benchmarks/waituntil/run	(revision c4497e344090425432cb947a2c39c2e0b09efcd6)
@@ -85,14 +85,16 @@
 }
 
-# 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,6 +105,6 @@
 spin=${false}
 contend=${false}
-sidechan=${false}
-# future=${false}
+# sidechan=${false}
+future=${false}
 
 runCFA=${true}
@@ -164,10 +166,7 @@
 
 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,5 +246,5 @@
         ${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,23 +261,25 @@
 
 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
+
Index: doc/theses/colby_parsons_MMAth/benchmarks/waituntil/ucpp/future.cc
===================================================================
--- doc/theses/colby_parsons_MMAth/benchmarks/waituntil/ucpp/future.cc	(revision 65ef0cd7e951937056fb71e81989690e7e2717cc)
+++ doc/theses/colby_parsons_MMAth/benchmarks/waituntil/ucpp/future.cc	(revision c4497e344090425432cb947a2c39c2e0b09efcd6)
@@ -3,40 +3,133 @@
 #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,18 +140,7 @@
 	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,12 +149,8 @@
 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,23 +159,21 @@
 	  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;
Index: libcfa/prelude/prelude-gen.cc
===================================================================
--- libcfa/prelude/prelude-gen.cc	(revision 65ef0cd7e951937056fb71e81989690e7e2717cc)
+++ libcfa/prelude/prelude-gen.cc	(revision c4497e344090425432cb947a2c39c2e0b09efcd6)
@@ -159,5 +159,5 @@
 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;
Index: libcfa/src/concurrency/actor.hfa
===================================================================
--- libcfa/src/concurrency/actor.hfa	(revision 65ef0cd7e951937056fb71e81989690e7e2717cc)
+++ libcfa/src/concurrency/actor.hfa	(revision c4497e344090425432cb947a2c39c2e0b09efcd6)
@@ -390,5 +390,5 @@
 struct actor {
     size_t ticket;	                                    // executor-queue handle
-    allocation allocation_;			                    // allocation action
+    allocation alloc;			                    // allocation action
     inline virtual_dtor;
 };
@@ -398,5 +398,5 @@
     // 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,6 +407,6 @@
 
 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,22 +427,27 @@
 
 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,5 +456,6 @@
 }
 static inline void set_allocation( message & this, allocation state ) {
-    this.allocation_ = state;
+    CFA_DEBUG( if ( state == Nodelete ) state = Finished; )
+    this.alloc = state;
 }
 
@@ -459,5 +465,5 @@
     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,5 +677,5 @@
 
 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,11 +688,11 @@
 // 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; }
+
Index: src/AST/Decl.cpp
===================================================================
--- src/AST/Decl.cpp	(revision 65ef0cd7e951937056fb71e81989690e7e2717cc)
+++ src/AST/Decl.cpp	(revision c4497e344090425432cb947a2c39c2e0b09efcd6)
@@ -115,5 +115,6 @@
 	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") ];
 }
 
Index: src/Validate/LinkReferenceToTypes.cpp
===================================================================
--- src/Validate/LinkReferenceToTypes.cpp	(revision 65ef0cd7e951937056fb71e81989690e7e2717cc)
+++ src/Validate/LinkReferenceToTypes.cpp	(revision c4497e344090425432cb947a2c39c2e0b09efcd6)
@@ -264,15 +264,8 @@
 
 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 );