Changes in / [297cf18:adf34b3]


Ignore:
Location:
libcfa/src/concurrency
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/concurrency/coroutine.cfa

    r297cf18 radf34b3  
    2828#include "kernel_private.hfa"
    2929#include "exception.hfa"
    30 #include "math.hfa"
    3130
    3231#define __CFA_INVOKE_PRIVATE__
    … …  
    8887
    8988void __stack_prepare( __stack_info_t * this, size_t create_size );
    90 void __stack_clean  ( __stack_info_t * this );
    9189
    9290//-----------------------------------------------------------------------------
    … …  
    109107        bool userStack = ((intptr_t)this.storage & 0x1) != 0;
    110108        if ( ! userStack && this.storage ) {
    111                 __stack_clean( &this );
    112                 // __attribute__((may_alias)) intptr_t * istorage = (intptr_t *)&this.storage;
    113                 // *istorage &= (intptr_t)-1;
    114 
    115                 // void * storage = this.storage->limit;
    116                 // __cfaabi_dbg_debug_do(
    117                 //      storage = (char*)(storage) - __page_size;
    118                 //      if ( mprotect( storage, __page_size, PROT_READ | PROT_WRITE ) == -1 ) {
    119                 //              abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
    120                 //      }
    121                 // );
    122                 // __cfaabi_dbg_print_safe("Kernel : Deleting stack %p\n", storage);
    123                 // free( storage );
     109                __attribute__((may_alias)) intptr_t * istorage = (intptr_t *)&this.storage;
     110                *istorage &= (intptr_t)-1;
     111
     112                void * storage = this.storage->limit;
     113                __cfaabi_dbg_debug_do(
     114                        storage = (char*)(storage) - __page_size;
     115                        if ( mprotect( storage, __page_size, PROT_READ | PROT_WRITE ) == -1 ) {
     116                                abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
     117                        }
     118                );
     119                __cfaabi_dbg_print_safe("Kernel : Deleting stack %p\n", storage);
     120                free( storage );
    124121        }
    125122}
    … …  
    170167        assert(__page_size != 0l);
    171168        size_t size = libCeiling( storageSize, 16 ) + stack_data_size;
    172         size = ceiling(size, __page_size);
    173169
    174170        // If we are running debug, we also need to allocate a guardpage to catch stack overflows.
    175171        void * storage;
    176         // __cfaabi_dbg_debug_do(
    177         //      storage = memalign( __page_size, size + __page_size );
    178         // );
    179         // __cfaabi_dbg_no_debug_do(
    180         //      storage = (void*)malloc(size);
    181         // );
    182 
    183         // __cfaabi_dbg_print_safe("Kernel : Created stack %p of size %zu\n", storage, size);
    184         // __cfaabi_dbg_debug_do(
    185         //      if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
    186         //              abort( "__stack_alloc : internal error, mprotect failure, error(%d) %s.", (int)errno, strerror( (int)errno ) );
    187         //      }
    188         //      storage = (void *)(((intptr_t)storage) + __page_size);
    189         // );
    190         storage = mmap(0p, size + __page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
    191         if(storage == ((void*)-1)) {
    192                 abort( "coroutine stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
    193         }
    194         if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
    195                 abort( "coroutine stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
    196         } // if
    197         storage = (void *)(((intptr_t)storage) + __page_size);
     172        __cfaabi_dbg_debug_do(
     173                storage = memalign( __page_size, size + __page_size );
     174        );
     175        __cfaabi_dbg_no_debug_do(
     176                storage = (void*)malloc(size);
     177        );
     178
     179        __cfaabi_dbg_print_safe("Kernel : Created stack %p of size %zu\n", storage, size);
     180        __cfaabi_dbg_debug_do(
     181                if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
     182                        abort( "__stack_alloc : internal error, mprotect failure, error(%d) %s.", (int)errno, strerror( (int)errno ) );
     183                }
     184                storage = (void *)(((intptr_t)storage) + __page_size);
     185        );
    198186
    199187        verify( ((intptr_t)storage & (libAlign() - 1)) == 0ul );
    200188        return [storage, size];
    201 }
    202 
    203 void __stack_clean  ( __stack_info_t * this ) {
    204         size_t size = ((intptr_t)this->storage->base) - ((intptr_t)this->storage->limit) + sizeof(__stack_t);
    205         void * storage = this->storage->limit;
    206 
    207         storage = (void *)(((intptr_t)storage) - __page_size);
    208         if(munmap(storage, size + __page_size) == -1) {
    209                 abort( "coroutine stack destruction : internal error, munmap failure, error(%d) %s.", errno, strerror( errno ) );
    210         }
    211189}
    212190
    … …  
    232210        assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %zd bytes for a stack.", size, MinStackSize );
    233211
    234         this->storage = (__stack_t *)((intptr_t)storage + size - sizeof(__stack_t));
     212        this->storage = (__stack_t *)((intptr_t)storage + size);
    235213        this->storage->limit = storage;
    236         this->storage->base  = (void*)((intptr_t)storage + size - sizeof(__stack_t));
     214        this->storage->base  = (void*)((intptr_t)storage + size);
    237215        this->storage->exception_context.top_resume = 0p;
    238216        this->storage->exception_context.current_exception = 0p;

  • libcfa/src/concurrency/coroutine.hfa

    r297cf18 radf34b3  
    102102}
    103103
    104 extern void __stack_prepare( __stack_info_t * this, size_t size /* ignored if storage already allocated */);
    105 extern void __stack_clean  ( __stack_info_t * this );
    106 
     104extern void __stack_prepare   ( __stack_info_t * this, size_t size /* ignored if storage already allocated */);
    107105
    108106// Suspend implementation inlined for performance

  • libcfa/src/concurrency/io/setup.cfa

    r297cf18 radf34b3  
    132132                // Wait for the io poller thread to finish
    133133
    134                 __destroy_pthread( iopoll.thrd, iopoll.stack, 0p );
     134                pthread_join( iopoll.thrd, 0p );
     135                free( iopoll.stack );
    135136
    136137                int ret = close(iopoll.epollfd);

  • libcfa/src/concurrency/kernel/startup.cfa

    r297cf18 radf34b3  
    2929#include "kernel_private.hfa"
    3030#include "startup.hfa"          // STARTUP_PRIORITY_XXX
    31 #include "math.hfa"
    3231
    3332//-----------------------------------------------------------------------------
    … …  
    540539}
    541540
    542 extern size_t __page_size;
    543541void ^?{}(processor & this) with( this ){
    544542        if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) {
    … …  
    552550        }
    553551
    554         __destroy_pthread( kernel_thread, this.stack, 0p );
     552        int err = pthread_join( kernel_thread, 0p );
     553        if( err != 0 ) abort("KERNEL ERROR: joining processor %p caused error %s\n", &this, strerror(err));
     554
     555        free( this.stack );
    555556
    556557        disable_interrupts();
    … …  
    677678
    678679        void * stack;
    679         #warning due to the thunk problem, stack creation uses mmap, revert to malloc once this goes away
    680         // __cfaabi_dbg_debug_do(
    681         //      stack = memalign( __page_size, stacksize + __page_size );
    682         //      // pthread has no mechanism to create the guard page in user supplied stack.
    683         //      if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
    684         //              abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
    685         //      } // if
    686         // );
    687         // __cfaabi_dbg_no_debug_do(
    688         //      stack = malloc( stacksize );
    689         // );
    690         stacksize = ceiling( stacksize, __page_size ) + __page_size;
    691         stack = mmap(0p, stacksize, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
    692         if(stack == ((void*)-1)) {
    693                 abort( "pthread stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
    694         }
    695         if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
    696                 abort( "pthread stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
    697         } // if
     680        __cfaabi_dbg_debug_do(
     681                stack = memalign( __page_size, stacksize + __page_size );
     682                // pthread has no mechanism to create the guard page in user supplied stack.
     683                if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
     684                        abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
     685                } // if
     686        );
     687        __cfaabi_dbg_no_debug_do(
     688                stack = malloc( stacksize );
     689        );
    698690
    699691        check( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
    … …  
    702694        return stack;
    703695}
    704 
    705 void __destroy_pthread( pthread_t pthread, void * stack, void ** retval ) {
    706         int err = pthread_join( pthread, retval );
    707         if( err != 0 ) abort("KERNEL ERROR: joining pthread %p caused error %s\n", (void*)pthread, strerror(err));
    708 
    709         pthread_attr_t attr;
    710 
    711         check( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
    712 
    713         size_t stacksize;
    714         // default stack size, normally defined by shell limit
    715         check( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
    716         assert( stacksize >= PTHREAD_STACK_MIN );
    717         stacksize += __page_size;
    718 
    719         if(munmap(stack, stacksize) == -1) {
    720                 abort( "pthread stack destruction : internal error, munmap failure, error(%d) %s.", errno, strerror( errno ) );
    721         }
    722 }
    723 
    724696
    725697#if defined(__CFA_WITH_VERIFY__)

  • libcfa/src/concurrency/kernel_private.hfa

    r297cf18 radf34b3  
    4949
    5050void * __create_pthread( pthread_t *, void * (*)(void *), void * );
    51 void __destroy_pthread( pthread_t pthread, void * stack, void ** retval );
    5251
    5352

  • libcfa/src/concurrency/preemption.cfa

    r297cf18 radf34b3  
    575575        // Wait for the preemption thread to finish
    576576
    577         __destroy_pthread( alarm_thread, alarm_stack, 0p );
     577        pthread_join( alarm_thread, 0p );
     578        free( alarm_stack );
    578579
    579580        // Preemption is now fully stopped
Note: See TracChangeset for help on using the changeset viewer.