Changeset 65deb18

Timestamp:

Jan 30, 2018, 3:52:42 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

f792cb8

Parents:

5b51f5e

Message:

Kernel now properly uses with statments

Location:

src/libcfa

Files:

• bits/containers.h (modified) (3 diffs)
• concurrency/coroutine.c (modified) (2 diffs)
• concurrency/kernel.c (modified) (13 diffs)
• concurrency/preemption.c (modified) (2 diffs)
• concurrency/thread.c (modified) (2 diffs)
• interpose.h (modified) (1 diff)

src/libcfa/bits/containers.h

@@ -140 +140 @@
 
 #ifdef __cforall
+
         forall(dtype T | is_node(T))
-        static inline void ?{}( __queue(T) & this ) {
-                (this.head){ NULL };
-                (this.tail){ &this.head };
+        static inline void ?{}( __queue(T) & this ) with( this ) {
+                head{ NULL };
+                tail{ &head };
         }
 
         forall(dtype T | is_node(T) | sized(T))
-        static inline void append( __queue(T) & this, T * val ) {
-                verify(this.tail != NULL);
-                *this.tail = val;
-                this.tail = &get_next( *val );
+        static inline void append( __queue(T) & this, T * val ) with( this ) {
+                verify(tail != NULL);
+                *tail = val;
+                tail = &get_next( *val );
         }
 
@@ -167 +168 @@
 
         forall(dtype T | is_node(T) | sized(T))
-        static inline T * remove( __queue(T) & this, T ** it ) {
+        static inline T * remove( __queue(T) & this, T ** it ) with( this ) {
                 T * val = *it;
                 verify( val );
@@ -173 +174 @@
                 (*it) = get_next( *val );
 
-                if( this.tail == &get_next( *val ) ) {
-                        this.tail = it;
+                if( tail == &get_next( *val ) ) {
+                        tail = it;
                 }
 
                 get_next( *val ) = NULL;
 
-                verify( (this.head == NULL) == (&this.head == this.tail) );
-                verify( *this.tail == NULL );
+                verify( (head == NULL) == (&head == tail) );
+                verify( *tail == NULL );
                 return val;
         }
 #endif
+
+//-----------------------------------------------------------------------------
+// Tools
+//-----------------------------------------------------------------------------
+#ifdef __cforall
+
+#endif

src/libcfa/concurrency/coroutine.c

@@ -118 +118 @@
 } //ctxSwitchDirect
 
-void create_stack( coStack_t* this, unsigned int storageSize ) {
+void create_stack( coStack_t* this, unsigned int storageSize ) with( *this ) {
         //TEMP HACK do this on proper kernel startup
         if(pageSize == 0ul) pageSize = sysconf( _SC_PAGESIZE );
@@ -124 +124 @@
         size_t cxtSize = libCeiling( sizeof(machine_context_t), 8 ); // minimum alignment
 
-        if ( (intptr_t)this->storage == 0 ) {
-                this->userStack = false;
-                this->size = libCeiling( storageSize, 16 );
+        if ( (intptr_t)storage == 0 ) {
+                userStack = false;
+                size = libCeiling( storageSize, 16 );
                 // use malloc/memalign because "new" raises an exception for out-of-memory
 
                 // assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment
-                __cfaabi_dbg_debug_do( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) );
-                __cfaabi_dbg_no_debug_do( this->storage = malloc( cxtSize + this->size + 8 ) );
+                __cfaabi_dbg_debug_do( storage = memalign( pageSize, cxtSize + size + pageSize ) );
+                __cfaabi_dbg_no_debug_do( storage = malloc( cxtSize + size + 8 ) );
 
                 __cfaabi_dbg_debug_do(
-                        if ( mprotect( this->storage, pageSize, PROT_NONE ) == -1 ) {
+                        if ( mprotect( storage, pageSize, PROT_NONE ) == -1 ) {
                                 abortf( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) );
                         } // if
                 );
 
-                if ( (intptr_t)this->storage == 0 ) {
-                        abortf( "Attempt to allocate %d bytes of storage for coroutine or task execution-state but insufficient memory available.", this->size );
+                if ( (intptr_t)storage == 0 ) {
+                        abortf( "Attempt to allocate %d bytes of storage for coroutine or task execution-state but insufficient memory available.", size );
                 } // if
 
-                __cfaabi_dbg_debug_do( this->limit = (char *)this->storage + pageSize );
-                __cfaabi_dbg_no_debug_do( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment
+                __cfaabi_dbg_debug_do( limit = (char *)storage + pageSize );
+                __cfaabi_dbg_no_debug_do( limit = (char *)libCeiling( (unsigned long)storage, 16 ) ); // minimum alignment
 
         } else {
-                assertf( ((size_t)this->storage & (libAlign() - 1)) != 0ul, "Stack storage %p for task/coroutine must be aligned on %d byte boundary.", this->storage, (int)libAlign() );
-                this->userStack = true;
-                this->size = storageSize - cxtSize;
+                assertf( ((size_t)storage & (libAlign() - 1)) != 0ul, "Stack storage %p for task/coroutine must be aligned on %d byte boundary.", storage, (int)libAlign() );
+                userStack = true;
+                size = storageSize - cxtSize;
 
-                if ( this->size % 16 != 0u ) this->size -= 8;
+                if ( size % 16 != 0u ) size -= 8;
 
-                this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ); // minimum alignment
+                limit = (char *)libCeiling( (unsigned long)storage, 16 ); // minimum alignment
         } // if
-        assertf( this->size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", this->size, MinStackSize );
+        assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", size, MinStackSize );
 
-        this->base = (char *)this->limit + this->size;
-        this->context = this->base;
-        this->top = (char *)this->context + cxtSize;
+        base = (char *)limit + size;
+        context = base;
+        top = (char *)context + cxtSize;
 }
 

src/libcfa/concurrency/kernel.c

@@ -85 +85 @@
 }
 
-void ?{}( coStack_t & this, current_stack_info_t * info) {
-        this.size = info->size;
-        this.storage = info->storage;
-        this.limit = info->limit;
-        this.base = info->base;
-        this.context = info->context;
-        this.top = info->top;
-        this.userStack = true;
-}
-
-void ?{}( coroutine_desc & this, current_stack_info_t * info) {
-        (this.stack){ info };
-        this.name = "Main Thread";
-        this.errno_ = 0;
-        this.state = Start;
-        this.starter = NULL;
-}
-
-void ?{}( thread_desc & this, current_stack_info_t * info) {
-        (this.self_cor){ info };
+void ?{}( coStack_t & this, current_stack_info_t * info) with( this ) {
+        size      = info->size;
+        storage   = info->storage;
+        limit     = info->limit;
+        base      = info->base;
+        context   = info->context;
+        top       = info->top;
+        userStack = true;
+}
+
+void ?{}( coroutine_desc & this, current_stack_info_t * info) with( this ) {
+        stack{ info };
+        name = "Main Thread";
+        errno_ = 0;
+        state = Start;
+        starter = NULL;
+}
+
+void ?{}( thread_desc & this, current_stack_info_t * info) with( this ) {
+        self_cor{ info };
 }
 
@@ -131 +131 @@
 void ?{}(processor & this, cluster * cltr) {
         this.cltr = cltr;
-        (this.terminated){ 0 };
+        this.terminated{ 0 };
         this.do_terminate = false;
         this.preemption_alarm = NULL;
@@ -141 +141 @@
 void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) {
         this.cltr = cltr;
-        (this.terminated){ 0 };
+        this.terminated{ 0 };
         this.do_terminate = false;
         this.preemption_alarm = NULL;
@@ -152 +152 @@
 }
 
-void ^?{}(processor & this) {
-        if( ! this.do_terminate ) {
+void ^?{}(processor & this) with( this ){
+        if( ! do_terminate ) {
                 __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
-                this.do_terminate = true;
-                P( this.terminated );
-                pthread_join( this.kernel_thread, NULL );
-        }
-}
-
-void ?{}(cluster & this) {
-        (this.ready_queue){};
-        ( this.ready_queue_lock ){};
-
-        this.preemption = default_preemption();
+                do_terminate = true;
+                P( terminated );
+                pthread_join( kernel_thread, NULL );
+        }
+}
+
+void ?{}(cluster & this) with( this ) {
+        ready_queue{};
+        ready_queue_lock{};
+
+        preemption = default_preemption();
 }
 
@@ -238 +238 @@
 // Once a thread has finished running, some of
 // its final actions must be executed from the kernel
-void finishRunning(processor * this) {
-        if( this->finish.action_code == Release ) {
-                unlock( *this->finish.lock );
-        }
-        else if( this->finish.action_code == Schedule ) {
-                ScheduleThread( this->finish.thrd );
-        }
-        else if( this->finish.action_code == Release_Schedule ) {
-                unlock( *this->finish.lock );
-                ScheduleThread( this->finish.thrd );
-        }
-        else if( this->finish.action_code == Release_Multi ) {
-                for(int i = 0; i < this->finish.lock_count; i++) {
-                        unlock( *this->finish.locks[i] );
+void finishRunning(processor * this) with( this->finish ) {
+        if( action_code == Release ) {
+                unlock( *lock );
+        }
+        else if( action_code == Schedule ) {
+                ScheduleThread( thrd );
+        }
+        else if( action_code == Release_Schedule ) {
+                unlock( *lock );
+                ScheduleThread( thrd );
+        }
+        else if( action_code == Release_Multi ) {
+                for(int i = 0; i < lock_count; i++) {
+                        unlock( *locks[i] );
                 }
         }
-        else if( this->finish.action_code == Release_Multi_Schedule ) {
-                for(int i = 0; i < this->finish.lock_count; i++) {
-                        unlock( *this->finish.locks[i] );
+        else if( action_code == Release_Multi_Schedule ) {
+                for(int i = 0; i < lock_count; i++) {
+                        unlock( *locks[i] );
                 }
-                for(int i = 0; i < this->finish.thrd_count; i++) {
-                        ScheduleThread( this->finish.thrds[i] );
+                for(int i = 0; i < thrd_count; i++) {
+                        ScheduleThread( thrds[i] );
                 }
         }
         else {
-                assert(this->finish.action_code == No_Action);
+                assert(action_code == No_Action);
         }
 }
@@ -332 +332 @@
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
-        lock(   this_processor->cltr->ready_queue_lock __cfaabi_dbg_ctx2 );
-        append( this_processor->cltr->ready_queue, thrd );
-        unlock( this_processor->cltr->ready_queue_lock );
-
-        verify( disable_preempt_count > 0 );
-}
-
-thread_desc * nextThread(cluster * this) {
-        verify( disable_preempt_count > 0 );
-        lock( this->ready_queue_lock __cfaabi_dbg_ctx2 );
-        thread_desc * head = pop_head( this->ready_queue );
-        unlock( this->ready_queue_lock );
+        with( *this_processor->cltr ) {
+                lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
+                append( ready_queue, thrd );
+                unlock( ready_queue_lock );
+        }
+
+        verify( disable_preempt_count > 0 );
+}
+
+thread_desc * nextThread(cluster * this) with( *this ) {
+        verify( disable_preempt_count > 0 );
+        lock( ready_queue_lock __cfaabi_dbg_ctx2 );
+        thread_desc * head = pop_head( ready_queue );
+        unlock( ready_queue_lock );
         verify( disable_preempt_count > 0 );
         return head;
@@ -359 +361 @@
         disable_interrupts();
         this_processor->finish.action_code = Release;
-        this_processor->finish.lock = lock;
+        this_processor->finish.lock        = lock;
 
         verify( disable_preempt_count > 0 );
@@ -369 +371 @@
 
 void BlockInternal( thread_desc * thrd ) {
-        assert(thrd);
         disable_interrupts();
-        assert( thrd->self_cor.state != Halted );
         this_processor->finish.action_code = Schedule;
-        this_processor->finish.thrd = thrd;
+        this_processor->finish.thrd        = thrd;
 
         verify( disable_preempt_count > 0 );
@@ -386 +386 @@
         disable_interrupts();
         this_processor->finish.action_code = Release_Schedule;
-        this_processor->finish.lock = lock;
-        this_processor->finish.thrd = thrd;
+        this_processor->finish.lock        = lock;
+        this_processor->finish.thrd        = thrd;
 
         verify( disable_preempt_count > 0 );
@@ -399 +399 @@
         disable_interrupts();
         this_processor->finish.action_code = Release_Multi;
-        this_processor->finish.locks = locks;
-        this_processor->finish.lock_count = count;
+        this_processor->finish.locks       = locks;
+        this_processor->finish.lock_count  = count;
 
         verify( disable_preempt_count > 0 );
@@ -412 +412 @@
         disable_interrupts();
         this_processor->finish.action_code = Release_Multi_Schedule;
-        this_processor->finish.locks = locks;
-        this_processor->finish.lock_count = lock_count;
-        this_processor->finish.thrds = thrds;
-        this_processor->finish.thrd_count = thrd_count;
+        this_processor->finish.locks       = locks;
+        this_processor->finish.lock_count  = lock_count;
+        this_processor->finish.thrds       = thrds;
+        this_processor->finish.thrd_count  = thrd_count;
 
         verify( disable_preempt_count > 0 );
@@ -427 +427 @@
         verify( disable_preempt_count > 0 );
         this_processor->finish.action_code = thrd ? Release_Schedule : Release;
-        this_processor->finish.lock = lock;
-        this_processor->finish.thrd = thrd;
+        this_processor->finish.lock        = lock;
+        this_processor->finish.thrd        = thrd;
 
         suspend();
@@ -579 +579 @@
 void ^?{}(semaphore & this) {}
 
-void P(semaphore & this) {
-        lock( this.lock __cfaabi_dbg_ctx2 );
-        this.count -= 1;
-        if ( this.count < 0 ) {
+void P(semaphore & this) with( this ){
+        lock( lock __cfaabi_dbg_ctx2 );
+        count -= 1;
+        if ( count < 0 ) {
                 // queue current task
-                append( this.waiting, (thread_desc *)this_thread );
+                append( waiting, (thread_desc *)this_thread );
 
                 // atomically release spin lock and block
-                BlockInternal( &this.lock );
+                BlockInternal( &lock );
         }
         else {
-            unlock( this.lock );
-        }
-}
-
-void V(semaphore & this) {
+            unlock( lock );
+        }
+}
+
+void V(semaphore & this) with( this ) {
         thread_desc * thrd = NULL;
-        lock( this.lock __cfaabi_dbg_ctx2 );
-        this.count += 1;
-        if ( this.count <= 0 ) {
+        lock( lock __cfaabi_dbg_ctx2 );
+        count += 1;
+        if ( count <= 0 ) {
                 // remove task at head of waiting list
-                thrd = pop_head( this.waiting );
-        }
-
-        unlock( this.lock );
+                thrd = pop_head( waiting );
+        }
+
+        unlock( lock );
 
         // make new owner

src/libcfa/concurrency/preemption.c

@@ -70 +70 @@
 static pthread_t alarm_thread;                        // pthread handle to alarm thread
 
-void ?{}(event_kernel_t & this) {
-        (this.alarms){};
-        (this.lock){};
+void ?{}(event_kernel_t & this) with( this ) {
+        alarms{};
+        lock{};
 }
 
@@ -159 +159 @@
         // If counter reaches 0, execute any pending CtxSwitch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-                processor * proc   = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
+                processor   * proc = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
                 thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
 

src/libcfa/concurrency/thread.c

@@ -31 +31 @@
 // Thread ctors and dtors
 
-void ?{}(thread_desc& this) {
-        (this.self_cor){};
-        this.self_cor.name = "Anonymous Coroutine";
-        this.self_mon.owner = &this;
-        this.self_mon.recursion = 1;
-        this.self_mon_p = &this.self_mon;
-        this.next = NULL;
+void ?{}(thread_desc& this) with( this ) {
+        self_cor{};
+        self_cor.name = "Anonymous Coroutine";
+        self_mon.owner = &this;
+        self_mon.recursion = 1;
+        self_mon_p = &self_mon;
+        next = NULL;
 
-        (this.monitors){ &this.self_mon_p, 1, (fptr_t)0 };
+        monitors{ &self_mon_p, 1, (fptr_t)0 };
 }
 
-void ^?{}(thread_desc& this) {
-        ^(this.self_cor){};
+void ^?{}(thread_desc& this) with( this ) {
+        ^self_cor{};
 }
 
 forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
-void ?{}( scoped(T)& this ) {
-        (this.handle){};
-        __thrd_start(this.handle);
+void ?{}( scoped(T)& this ) with( this ) {
+        handle{};
+        __thrd_start(handle);
 }
 
 forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
-void ?{}( scoped(T)& this, P params ) {
-        (this.handle){ params };
-        __thrd_start(this.handle);
+void ?{}( scoped(T)& this, P params ) with( this ) {
+        handle{ params };
+        __thrd_start(handle);
 }
 
 forall( dtype T | sized(T) | is_thread(T) )
-void ^?{}( scoped(T)& this ) {
-        ^(this.handle){};
+void ^?{}( scoped(T)& this ) with( this ) {
+        ^handle{};
 }
 
@@ -68 +68 @@
 void __thrd_start( T& this ) {
         coroutine_desc* thrd_c = get_coroutine(this);
-        thread_desc*  thrd_h = get_thread   (this);
+        thread_desc   * thrd_h = get_thread   (this);
         thrd_c->last = this_coroutine;
 

src/libcfa/interpose.h

@@ -16 +16 @@
 #pragma once
 
-void * interpose_symbol( const char* symbol, , const char *version );
+void * interpose_symbol( const char* symbol, const char *version );
 
 extern __typeof__( abort ) libc_abort __attribute__(( noreturn ));