Index: libcfa/src/concurrency/actor.hfa
===================================================================
--- libcfa/src/concurrency/actor.hfa	(revision 5c473c9dbcc4de6a9df8d8dbee78df82ffe4c734)
+++ libcfa/src/concurrency/actor.hfa	(revision 98a2b1dcb5b037f88a8c2c8d5eb5c131908de6db)
@@ -24,4 +24,7 @@
 // Define if executor is created in a separate cluster
 #define __DEFAULT_EXECUTOR_SEPCLUS__ false
+
+// when you flip this make sure to recompile compiler and flip the appropriate flag there too in Actors.cpp
+#define __ALLOC 0
 
 // forward decls
@@ -58,18 +61,27 @@
 struct copy_queue {
     dlist( request ) list;
+    #if ! __ALLOC
     request * buffer;
     size_t count, buffer_size, index;
+    #endif
 };
 static inline void ?{}( copy_queue & this ) {}
 static inline void ?{}( copy_queue & this, size_t buf_size ) with(this) { 
     list{};
+    #if ! __ALLOC
     buffer_size = buf_size;
     buffer = aalloc( buffer_size );
     count = 0;
     index = 0;
-}
-static inline void ^?{}( copy_queue & this ) with(this) { adelete(buffer); }
+    #endif
+}
+static inline void ^?{}( copy_queue & this ) with(this) {
+    #if ! __ALLOC
+    adelete(buffer);
+    #endif
+}
 
 static inline void insert( copy_queue & this, request & elem ) with(this) {
+    #if ! __ALLOC
     if ( count < buffer_size ) { // fast path ( no alloc )
         buffer[count]{ elem };
@@ -80,4 +92,7 @@
     (*new_elem){ elem };
     insert_last( list, *new_elem );
+    #else
+    insert_last( list, elem );
+    #endif
 }
 
@@ -86,4 +101,5 @@
 // should_delete is an output param
 static inline request & remove( copy_queue & this, bool & should_delete ) with(this) {
+    #if ! __ALLOC
     if ( count > 0 ) {
         count--;
@@ -93,23 +109,34 @@
         return buffer[old_idx];
     }
+    #endif
     should_delete = true;
     return try_pop_front( list );
 }
 
-static inline bool isEmpty( copy_queue & this ) with(this) { return count == 0 && list`isEmpty; }
+static inline bool isEmpty( copy_queue & this ) with(this) {
+    #if ! __ALLOC
+    return count == 0 && list`isEmpty;
+    #else
+    return list`isEmpty;
+    #endif
+}
 
 static size_t __buffer_size = 10; // C_TODO: rework this to be passed from executor through ctors (no need for global)
 struct work_queue {
-    futex_mutex mutex_lock; 
+    __spinlock_t mutex_lock;
+    copy_queue owned_queue;
     copy_queue * c_queue; // C_TODO: try putting this on the stack with ptr juggling
+
 }; // work_queue
 static inline void ?{}( work_queue & this ) with(this) { 
-    c_queue = alloc();
-    (*c_queue){ __buffer_size }; // C_TODO: support passing copy buff size as arg to executor
-}
-static inline void ^?{}( work_queue & this ) with(this) { delete( c_queue ); }
+    // c_queue = alloc();
+    // (*c_queue){ __buffer_size };
+    owned_queue{ __buffer_size };
+    c_queue = &owned_queue;
+}
+// static inline void ^?{}( work_queue & this ) with(this) { delete( c_queue ); }
 
 static inline void insert( work_queue & this, request & elem ) with(this) {
-    lock( mutex_lock );
+    lock( mutex_lock __cfaabi_dbg_ctx2 );
     insert( *c_queue, elem );
     unlock( mutex_lock );
@@ -117,5 +144,5 @@
 
 static inline void transfer( work_queue & this, copy_queue ** transfer_to ) with(this) {
-    lock( mutex_lock );
+    lock( mutex_lock __cfaabi_dbg_ctx2 );
     // swap copy queue ptrs
     copy_queue * temp = *transfer_to;
@@ -126,4 +153,5 @@
 
 thread worker {
+    copy_queue owned_queue;
     work_queue * request_queues;
     copy_queue * current_queue;
@@ -135,10 +163,12 @@
     ((thread &)this){ clu };
     this.request_queues = request_queues;
-    this.current_queue = alloc();
-    (*this.current_queue){ __buffer_size };
+    // this.current_queue = alloc();
+    // (*this.current_queue){ __buffer_size };
+    this.owned_queue{ __buffer_size };
+    this.current_queue = &this.owned_queue;
     this.start = start;
     this.range = range;
 }
-static inline void ^?{}( worker & mutex this ) with(this) { delete( current_queue ); }
+// static inline void ^?{}( worker & mutex this ) with(this) { delete( current_queue ); }
 
 struct executor {