Ignore:
Timestamp:
Nov 29, 2017, 2:50:33 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:
875a72f
Parents:
8a0a64d9
Message:

Renamed internal stuff to cfaabi_...

Location:
src/libcfa/concurrency
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/concurrency/alarm.c

    r8a0a64d9 r36982fc  
    110110}
    111111
    112 LIB_DEBUG_DO( bool validate( alarm_list_t * this ) {
     112__cfaabi_dbg_debug_do( bool validate( alarm_list_t * this ) {
    113113        alarm_node_t ** it = &this->head;
    114114        while( (*it) ) {
    … …  
    186186
    187187        disable_interrupts();
    188         lock( event_kernel->lock DEBUG_CTX2 );
     188        lock( event_kernel->lock __cfaabi_dbg_ctx2 );
    189189        {
    190190                verify( validate( alarms ) );
    … …  
    198198        unlock( event_kernel->lock );
    199199        this->set = true;
    200         enable_interrupts( DEBUG_CTX );
     200        enable_interrupts( __cfaabi_dbg_ctx );
    201201}
    202202
    203203void unregister_self( alarm_node_t * this ) {
    204204        disable_interrupts();
    205         lock( event_kernel->lock DEBUG_CTX2 );
     205        lock( event_kernel->lock __cfaabi_dbg_ctx2 );
    206206        {
    207207                verify( validate( &event_kernel->alarms ) );
    … …  
    209209        }
    210210        unlock( event_kernel->lock );
    211         enable_interrupts( DEBUG_CTX );
     211        enable_interrupts( __cfaabi_dbg_ctx );
    212212        this->set = false;
    213213}

  • src/libcfa/concurrency/coroutine.c

    r8a0a64d9 r36982fc  
    7676void ^?{}(coStack_t & this) {
    7777        if ( ! this.userStack && this.storage ) {
    78                 LIB_DEBUG_DO(
     78                __cfaabi_dbg_debug_do(
    7979                        if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
    8080                                abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
    … …  
    131131
    132132                // assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment
    133                 LIB_DEBUG_DO( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) );
    134                 LIB_NO_DEBUG_DO( this->storage = malloc( cxtSize + this->size + 8 ) );
     133                __cfaabi_dbg_debug_do( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) );
     134                __cfaabi_dbg_no_debug_do( this->storage = malloc( cxtSize + this->size + 8 ) );
    135135
    136                 LIB_DEBUG_DO(
     136                __cfaabi_dbg_debug_do(
    137137                        if ( mprotect( this->storage, pageSize, PROT_NONE ) == -1 ) {
    138138                                abortf( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) );
    … …  
    144144                } // if
    145145
    146                 LIB_DEBUG_DO( this->limit = (char *)this->storage + pageSize );
    147                 LIB_NO_DEBUG_DO( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment
     146                __cfaabi_dbg_debug_do( this->limit = (char *)this->storage + pageSize );
     147                __cfaabi_dbg_no_debug_do( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment
    148148
    149149        } else {

  • src/libcfa/concurrency/invoke.c

    r8a0a64d9 r36982fc  
    3131extern void __leave_thread_monitor( struct thread_desc * this );
    3232extern void disable_interrupts();
    33 extern void enable_interrupts( DEBUG_CTX_PARAM );
     33extern void enable_interrupts( __cfaabi_dbg_ctx_param );
    3434
    3535void CtxInvokeCoroutine(
    36       void (*main)(void *),
    37       struct coroutine_desc *(*get_coroutine)(void *),
    38       void *this
     36        void (*main)(void *),
     37        struct coroutine_desc *(*get_coroutine)(void *),
     38        void *this
    3939) {
    40       // LIB_DEBUG_PRINTF("Invoke Coroutine : Received %p (main %p, get_c %p)\n", this, main, get_coroutine);
     40        struct coroutine_desc* cor = get_coroutine( this );
    4141
    42       struct coroutine_desc* cor = get_coroutine( this );
     42        if(cor->state == Primed) {
     43                __suspend_internal();
     44        }
    4345
    44       if(cor->state == Primed) {
    45             __suspend_internal();
    46       }
     46        cor->state = Active;
    4747
    48       cor->state = Active;
     48        main( this );
    4949
    50       main( this );
     50        cor->state = Halted;
    5151
    52       cor->state = Halted;
    53 
    54       //Final suspend, should never return
    55       __leave_coroutine();
    56       abortf("Resumed dead coroutine");
     52        //Final suspend, should never return
     53        __leave_coroutine();
     54        abortf("Resumed dead coroutine");
    5755}
    5856
    5957void CtxInvokeThread(
    60       void (*dtor)(void *),
    61       void (*main)(void *),
    62       struct thread_desc *(*get_thread)(void *),
    63       void *this
     58        void (*dtor)(void *),
     59        void (*main)(void *),
     60        struct thread_desc *(*get_thread)(void *),
     61        void *this
    6462) {
    65       // First suspend, once the thread arrives here,
    66       // the function pointer to main can be invalidated without risk
    67       __suspend_internal();
     63        // First suspend, once the thread arrives here,
     64        // the function pointer to main can be invalidated without risk
     65        __suspend_internal();
    6866
    69       // Fetch the thread handle from the user defined thread structure
    70       struct thread_desc* thrd = get_thread( this );
     67        // Fetch the thread handle from the user defined thread structure
     68        struct thread_desc* thrd = get_thread( this );
    7169
    72       // Officially start the thread by enabling preemption
    73       enable_interrupts( DEBUG_CTX );
     70        // Officially start the thread by enabling preemption
     71        enable_interrupts( __cfaabi_dbg_ctx );
    7472
    75       // Call the main of the thread
    76       main( this );
     73        // Call the main of the thread
     74        main( this );
    7775
    78       // To exit a thread we must :
    79       // 1 - Mark it as halted
    80       // 2 - Leave its monitor
    81       // 3 - Disable the interupts
    82       // 4 - Final suspend
    83       // The order of these 4 operations is very important
    84       //Final suspend, should never return
    85       __leave_thread_monitor( thrd );
    86       abortf("Resumed dead thread");
     76        // To exit a thread we must :
     77        // 1 - Mark it as halted
     78        // 2 - Leave its monitor
     79        // 3 - Disable the interupts
     80        // 4 - Final suspend
     81        // The order of these 4 operations is very important
     82        //Final suspend, should never return
     83        __leave_thread_monitor( thrd );
     84        abortf("Resumed dead thread");
    8785}
    8886
    8987
    9088void CtxStart(
    91       void (*main)(void *),
    92       struct coroutine_desc *(*get_coroutine)(void *),
    93       void *this,
    94       void (*invoke)(void *)
     89        void (*main)(void *),
     90        struct coroutine_desc *(*get_coroutine)(void *),
     91        void *this,
     92        void (*invoke)(void *)
    9593) {
    96       // LIB_DEBUG_PRINTF("StartCoroutine : Passing in %p (main %p) to invoke (%p) from start (%p)\n", this, main, invoke, CtxStart);
    97 
    98       struct coStack_t* stack = &get_coroutine( this )->stack;
     94        struct coStack_t* stack = &get_coroutine( this )->stack;
    9995
    10096#if defined( __i386__ )
    … …  
    10399            void *fixedRegisters[3];                    // fixed registers ebx, edi, esi (popped on 1st uSwitch, values unimportant)
    104100            uint32_t mxcr;                        // SSE Status and Control bits (control bits are preserved across function calls)
    105           uint16_t fcw;                         // X97 FPU control word (preserved across function calls)
     101            uint16_t fcw;                         // X97 FPU control word (preserved across function calls)
    106102            void *rturn;                          // where to go on return from uSwitch
    107103            void *dummyReturn;                          // fake return compiler would have pushed on call to uInvoke
    … …  
    116112        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->argument[0] = this;     // argument to invoke
    117113        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = invoke;
    118       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
    119       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
     114        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
     115        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
    120116
    121117#elif defined( __x86_64__ )
    122118
    123       struct FakeStack {
    124             void *fixedRegisters[5];            // fixed registers rbx, r12, r13, r14, r15
    125             uint32_t mxcr;                      // SSE Status and Control bits (control bits are preserved across function calls)
    126             uint16_t fcw;                       // X97 FPU control word (preserved across function calls)
    127             void *rturn;                        // where to go on return from uSwitch
    128             void *dummyReturn;                  // NULL return address to provide proper alignment
    129       };
     119        struct FakeStack {
     120                void *fixedRegisters[5];            // fixed registers rbx, r12, r13, r14, r15
     121                uint32_t mxcr;                      // SSE Status and Control bits (control bits are preserved across function calls)
     122                uint16_t fcw;                       // X97 FPU control word (preserved across function calls)
     123                void *rturn;                        // where to go on return from uSwitch
     124                void *dummyReturn;                  // NULL return address to provide proper alignment
     125        };
    130126
    131       ((struct machine_context_t *)stack->context)->SP = (char *)stack->base - sizeof( struct FakeStack );
    132       ((struct machine_context_t *)stack->context)->FP = NULL;          // terminate stack with NULL fp
     127        ((struct machine_context_t *)stack->context)->SP = (char *)stack->base - sizeof( struct FakeStack );
     128        ((struct machine_context_t *)stack->context)->FP = NULL;                // terminate stack with NULL fp
    133129
    134       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->dummyReturn = NULL;
    135       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = CtxInvokeStub;
    136       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[0] = this;
    137       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[1] = invoke;
    138       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
    139       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
     130        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->dummyReturn = NULL;
     131        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = CtxInvokeStub;
     132        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[0] = this;
     133        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[1] = invoke;
     134        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
     135        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
    140136#else
    141       #error Only __i386__ and __x86_64__ is supported for threads in cfa
     137        #error Only __i386__ and __x86_64__ is supported for threads in cfa
    142138#endif
    143139}

  • src/libcfa/concurrency/kernel.c

    r8a0a64d9 r36982fc  
    150150
    151151        this.runner = &runner;
    152         LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", &runner);
     152        __cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner);
    153153        runner{ &this };
    154154}
    … …  
    156156void ^?{}(processor & this) {
    157157        if( ! this.do_terminate ) {
    158                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);
     158                __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
    159159                this.do_terminate = true;
    160160                P( this.terminated );
    … …  
    181181        processor * this = runner.proc;
    182182
    183         LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
     183        __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
    184184
    185185        {
    … …  
    187187                preemption_scope scope = { this };
    188188
    189                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
     189                __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
    190190
    191191                thread_desc * readyThread = NULL;
    … …  
    213213                }
    214214
    215                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p stopping\n", this);
     215                __cfaabi_dbg_print_safe("Kernel : core %p stopping\n", this);
    216216        }
    217217
    218218        V( this->terminated );
    219219
    220         LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
     220        __cfaabi_dbg_print_safe("Kernel : core %p terminated\n", this);
    221221}
    222222
    … …  
    292292        processorCtx_t proc_cor_storage = { proc, &info };
    293293
    294         LIB_DEBUG_PRINT_SAFE("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
     294        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
    295295
    296296        //Set global state
    … …  
    299299
    300300        //We now have a proper context from which to schedule threads
    301         LIB_DEBUG_PRINT_SAFE("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
     301        __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
    302302
    303303        // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't
    … …  
    310310
    311311        // Main routine of the core returned, the core is now fully terminated
    312         LIB_DEBUG_PRINT_SAFE("Kernel : core %p main ended (%p)\n", proc, proc->runner);
     312        __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, proc->runner);
    313313
    314314        return NULL;
    … …  
    316316
    317317void start(processor * this) {
    318         LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this);
     318        __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
    319319
    320320        pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
    321321
    322         LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
     322        __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
    323323}
    324324
    … …  
    334334        verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
    335335
    336         lock(   this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
     336        lock(   this_processor->cltr->ready_queue_lock __cfaabi_dbg_ctx2 );
    337337        append( this_processor->cltr->ready_queue, thrd );
    338338        unlock( this_processor->cltr->ready_queue_lock );
    … …  
    343343thread_desc * nextThread(cluster * this) {
    344344        verify( disable_preempt_count > 0 );
    345         lock( this->ready_queue_lock DEBUG_CTX2 );
     345        lock( this->ready_queue_lock __cfaabi_dbg_ctx2 );
    346346        thread_desc * head = pop_head( this->ready_queue );
    347347        unlock( this->ready_queue_lock );
    … …  
    355355        suspend();
    356356        verify( disable_preempt_count > 0 );
    357         enable_interrupts( DEBUG_CTX );
     357        enable_interrupts( __cfaabi_dbg_ctx );
    358358}
    359359
    … …  
    367367        verify( disable_preempt_count > 0 );
    368368
    369         enable_interrupts( DEBUG_CTX );
     369        enable_interrupts( __cfaabi_dbg_ctx );
    370370}
    371371
    … …  
    381381        verify( disable_preempt_count > 0 );
    382382
    383         enable_interrupts( DEBUG_CTX );
     383        enable_interrupts( __cfaabi_dbg_ctx );
    384384}
    385385
    … …  
    395395        verify( disable_preempt_count > 0 );
    396396
    397         enable_interrupts( DEBUG_CTX );
     397        enable_interrupts( __cfaabi_dbg_ctx );
    398398}
    399399
    … …  
    408408        verify( disable_preempt_count > 0 );
    409409
    410         enable_interrupts( DEBUG_CTX );
     410        enable_interrupts( __cfaabi_dbg_ctx );
    411411}
    412412
    … …  
    423423        verify( disable_preempt_count > 0 );
    424424
    425         enable_interrupts( DEBUG_CTX );
     425        enable_interrupts( __cfaabi_dbg_ctx );
    426426}
    427427
    … …  
    441441// Kernel boot procedures
    442442void kernel_startup(void) {
    443         LIB_DEBUG_PRINT_SAFE("Kernel : Starting\n");
     443        __cfaabi_dbg_print_safe("Kernel : Starting\n");
    444444
    445445        // Start by initializing the main thread
    … …  
    450450        (*mainThread){ &info };
    451451
    452         LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
     452        __cfaabi_dbg_print_safe("Kernel : Main thread ready\n");
    453453
    454454        // Initialize the main cluster
    … …  
    456456        (*mainCluster){};
    457457
    458         LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n");
     458        __cfaabi_dbg_print_safe("Kernel : main cluster ready\n");
    459459
    460460        // Initialize the main processor and the main processor ctx
    … …  
    483483
    484484        // THE SYSTEM IS NOW COMPLETELY RUNNING
    485         LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n");
    486 
    487         enable_interrupts( DEBUG_CTX );
     485        __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
     486
     487        enable_interrupts( __cfaabi_dbg_ctx );
    488488}
    489489
    490490void kernel_shutdown(void) {
    491         LIB_DEBUG_PRINT_SAFE("\n--------------------------------------------------\nKernel : Shutting down\n");
     491        __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
    492492
    493493        disable_interrupts();
    … …  
    513513        ^(mainThread){};
    514514
    515         LIB_DEBUG_PRINT_SAFE("Kernel : Shutdown complete\n");
     515        __cfaabi_dbg_print_safe("Kernel : Shutdown complete\n");
    516516}
    517517
    … …  
    523523        // abort cannot be recursively entered by the same or different processors because all signal handlers return when
    524524        // the globalAbort flag is true.
    525         lock( kernel_abort_lock DEBUG_CTX2 );
     525        lock( kernel_abort_lock __cfaabi_dbg_ctx2 );
    526526
    527527        // first task to abort ?
    … …  
    548548
    549549        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
    550         __lib_debug_write( abort_text, len );
     550        __cfaabi_dbg_bits_write( abort_text, len );
    551551
    552552        if ( thrd != this_coroutine ) {
    553553                len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine->name, this_coroutine );
    554                 __lib_debug_write( abort_text, len );
     554                __cfaabi_dbg_bits_write( abort_text, len );
    555555        }
    556556        else {
    557                 __lib_debug_write( ".\n", 2 );
     557                __cfaabi_dbg_bits_write( ".\n", 2 );
    558558        }
    559559}
    560560
    561561extern "C" {
    562         void __lib_debug_acquire() {
    563                 lock( kernel_debug_lock DEBUG_CTX2 );
    564         }
    565 
    566         void __lib_debug_release() {
     562        void __cfaabi_dbg_bits_acquire() {
     563                lock( kernel_debug_lock __cfaabi_dbg_ctx2 );
     564        }
     565
     566        void __cfaabi_dbg_bits_release() {
    567567                unlock( kernel_debug_lock );
    568568        }
    … …  
    582582
    583583void P(semaphore & this) {
    584         lock( this.lock DEBUG_CTX2 );
     584        lock( this.lock __cfaabi_dbg_ctx2 );
    585585        this.count -= 1;
    586586        if ( this.count < 0 ) {
    … …  
    598598void V(semaphore & this) {
    599599        thread_desc * thrd = NULL;
    600         lock( this.lock DEBUG_CTX2 );
     600        lock( this.lock __cfaabi_dbg_ctx2 );
    601601        this.count += 1;
    602602        if ( this.count <= 0 ) {

  • src/libcfa/concurrency/kernel_private.h

    r8a0a64d9 r36982fc  
    3030        void disable_interrupts();
    3131        void enable_interrupts_noPoll();
    32         void enable_interrupts( DEBUG_CTX_PARAM );
     32        void enable_interrupts( __cfaabi_dbg_ctx_param );
    3333}
    3434
    … …  
    3939        disable_interrupts();
    4040        ScheduleThread( thrd );
    41         enable_interrupts( DEBUG_CTX );
     41        enable_interrupts( __cfaabi_dbg_ctx );
    4242}
    4343thread_desc * nextThread(cluster * this);

  • src/libcfa/concurrency/monitor.c

    r8a0a64d9 r36982fc  
    9191        static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
    9292                // Lock the monitor spinlock
    93                 DO_LOCK( this->lock DEBUG_CTX2 );
     93                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
    9494                thread_desc * thrd = this_thread;
    9595
    96                 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
     96                __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
    9797
    9898                if( !this->owner ) {
    … …  
    100100                        set_owner( this, thrd );
    101101
    102                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon is free \n");
     102                        __cfaabi_dbg_print_safe("Kernel :  mon is free \n");
    103103                }
    104104                else if( this->owner == thrd) {
    … …  
    106106                        this->recursion += 1;
    107107
    108                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon already owned \n");
     108                        __cfaabi_dbg_print_safe("Kernel :  mon already owned \n");
    109109                }
    110110                else if( is_accepted( this, group) ) {
    … …  
    115115                        reset_mask( this );
    116116
    117                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts \n");
     117                        __cfaabi_dbg_print_safe("Kernel :  mon accepts \n");
    118118                }
    119119                else {
    120                         LIB_DEBUG_PRINT_SAFE("Kernel :  blocking \n");
     120                        __cfaabi_dbg_print_safe("Kernel :  blocking \n");
    121121
    122122                        // Some one else has the monitor, wait in line for it
    … …  
    124124                        BlockInternal( &this->lock );
    125125
    126                         LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered  mon %p\n", thrd, this);
     126                        __cfaabi_dbg_print_safe("Kernel : %10p Entered  mon %p\n", thrd, this);
    127127
    128128                        // BlockInternal will unlock spinlock, no need to unlock ourselves
    … …  
    130130                }
    131131
    132                 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered  mon %p\n", thrd, this);
     132                __cfaabi_dbg_print_safe("Kernel : %10p Entered  mon %p\n", thrd, this);
    133133
    134134                // Release the lock and leave
    … …  
    139139        static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
    140140                // Lock the monitor spinlock
    141                 DO_LOCK( this->lock DEBUG_CTX2 );
     141                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
    142142                thread_desc * thrd = this_thread;
    143143
    144                 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
     144                __cfaabi_dbg_print_safe("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
    145145
    146146
    147147                if( !this->owner ) {
    148                         LIB_DEBUG_PRINT_SAFE("Kernel : Destroying free mon %p\n", this);
     148                        __cfaabi_dbg_print_safe("Kernel : Destroying free mon %p\n", this);
    149149
    150150                        // No one has the monitor, just take it
    … …  
    164164                __monitor_group_t group = { &this, 1, func };
    165165                if( is_accepted( this, group) ) {
    166                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts dtor, block and signal it \n");
     166                        __cfaabi_dbg_print_safe("Kernel :  mon accepts dtor, block and signal it \n");
    167167
    168168                        // Wake the thread that is waiting for this
    … …  
    183183                }
    184184                else {
    185                         LIB_DEBUG_PRINT_SAFE("Kernel :  blocking \n");
     185                        __cfaabi_dbg_print_safe("Kernel :  blocking \n");
    186186
    187187                        wait_ctx( this_thread, 0 )
    … …  
    196196                }
    197197
    198                 LIB_DEBUG_PRINT_SAFE("Kernel : Destroying %p\n", this);
     198                __cfaabi_dbg_print_safe("Kernel : Destroying %p\n", this);
    199199
    200200        }
    … …  
    203203        void __leave_monitor_desc( monitor_desc * this ) {
    204204                // Lock the monitor spinlock, DO_LOCK to reduce contention
    205                 DO_LOCK( this->lock DEBUG_CTX2 );
    206 
    207                 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
     205                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
     206
     207                __cfaabi_dbg_print_safe("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
    208208
    209209                verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", this_thread, this->owner, this->recursion, this );
    … …  
    215215                // it means we don't need to do anything
    216216                if( this->recursion != 0) {
    217                         LIB_DEBUG_PRINT_SAFE("Kernel :  recursion still %d\n", this->recursion);
     217                        __cfaabi_dbg_print_safe("Kernel :  recursion still %d\n", this->recursion);
    218218                        unlock( this->lock );
    219219                        return;
    … …  
    232232        // Leave single monitor for the last time
    233233        void __leave_dtor_monitor_desc( monitor_desc * this ) {
    234                 LIB_DEBUG_DO(
     234                __cfaabi_dbg_debug_do(
    235235                        if( this_thread != this->owner ) {
    236236                                abortf("Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner);
    … …  
    249249
    250250                // Lock the monitor now
    251                 DO_LOCK( this->lock DEBUG_CTX2 );
     251                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
    252252
    253253                disable_interrupts();
    … …  
    308308        (this_thread->monitors){m, count, func};
    309309
    310         // LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
     310        // __cfaabi_dbg_print_safe("MGUARD : enter %d\n", count);
    311311
    312312        // Enter the monitors in order
    … …  
    314314        enter( group );
    315315
    316         // LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n");
     316        // __cfaabi_dbg_print_safe("MGUARD : entered\n");
    317317}
    318318
    … …  
    320320// Dtor for monitor guard
    321321void ^?{}( monitor_guard_t & this ) {
    322         // LIB_DEBUG_PRINT_SAFE("MGUARD : leaving %d\n", this.count);
     322        // __cfaabi_dbg_print_safe("MGUARD : leaving %d\n", this.count);
    323323
    324324        // Leave the monitors in order
    325325        leave( this.m, this.count );
    326326
    327         // LIB_DEBUG_PRINT_SAFE("MGUARD : left\n");
     327        // __cfaabi_dbg_print_safe("MGUARD : left\n");
    328328
    329329        // Restore thread context
    … …  
    430430
    431431        //Some more checking in debug
    432         LIB_DEBUG_DO(
     432        __cfaabi_dbg_debug_do(
    433433                thread_desc * this_thrd = this_thread;
    434434                if ( this.monitor_count != this_thrd->monitors.size ) {
    … …  
    487487        set_owner( monitors, count, signallee );
    488488
    489         LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
     489        __cfaabi_dbg_print_buffer_decl( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
    490490
    491491        //Everything is ready to go to sleep
    … …  
    496496
    497497
    498         LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :   signal_block returned\n" );
     498        __cfaabi_dbg_print_buffer_local( "Kernel :   signal_block returned\n" );
    499499
    500500        //We are back, restore the masks and recursions
    … …  
    535535        __lock_size_t actual_count = aggregate( mon_storage, mask );
    536536
    537         LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);
     537        __cfaabi_dbg_print_buffer_decl( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);
    538538
    539539        if(actual_count == 0) return;
    540540
    541         LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : waitfor internal proceeding\n");
     541        __cfaabi_dbg_print_buffer_local( "Kernel : waitfor internal proceeding\n");
    542542
    543543        // Create storage for monitor context
    … …  
    556556                        __acceptable_t& accepted = mask[index];
    557557                        if( accepted.is_dtor ) {
    558                                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : dtor already there\n");
     558                                __cfaabi_dbg_print_buffer_local( "Kernel : dtor already there\n");
    559559                                verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
    560560
    … …  
    568568                        }
    569569                        else {
    570                                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, baton-passing\n");
     570                                __cfaabi_dbg_print_buffer_local( "Kernel : thread present, baton-passing\n");
    571571
    572572                                // Create the node specific to this wait operation
    … …  
    576576                                monitor_save;
    577577
    578                                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :  baton of %d monitors : ", count );
     578                                __cfaabi_dbg_print_buffer_local( "Kernel :  baton of %d monitors : ", count );
    579579                                #ifdef __CFA_DEBUG_PRINT__
    580580                                        for( int i = 0; i < count; i++) {
    581                                                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "%p %p ", monitors[i], monitors[i]->signal_stack.top );
     581                                                __cfaabi_dbg_print_buffer_local( "%p %p ", monitors[i], monitors[i]->signal_stack.top );
    582582                                        }
    583583                                #endif
    584                                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "\n");
     584                                __cfaabi_dbg_print_buffer_local( "\n");
    585585
    586586                                // Set the owners to be the next thread
    … …  
    593593                                monitor_restore;
    594594
    595                                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, returned\n");
     595                                __cfaabi_dbg_print_buffer_local( "Kernel : thread present, returned\n");
    596596                        }
    597597
    598                         LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
     598                        __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
    599599                        return;
    600600                }
    … …  
    603603
    604604        if( duration == 0 ) {
    605                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : non-blocking, exiting\n");
     605                __cfaabi_dbg_print_buffer_local( "Kernel : non-blocking, exiting\n");
    606606
    607607                unlock_all( locks, count );
    608608
    609                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
     609                __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
    610610                return;
    611611        }
    … …  
    614614        verifyf( duration < 0, "Timeout on waitfor statments not supported yet.");
    615615
    616         LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : blocking waitfor\n");
     616        __cfaabi_dbg_print_buffer_local( "Kernel : blocking waitfor\n");
    617617
    618618        // Create the node specific to this wait operation
    … …  
    636636        monitor_restore;
    637637
    638         LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : exiting\n");
    639 
    640         LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
     638        __cfaabi_dbg_print_buffer_local( "Kernel : exiting\n");
     639
     640        __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
    641641}
    642642
    … …  
    645645
    646646static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
    647         // LIB_DEBUG_PRINT_SAFE("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
     647        // __cfaabi_dbg_print_safe("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
    648648
    649649        //Pass the monitor appropriately
    … …  
    677677static inline thread_desc * next_thread( monitor_desc * this ) {
    678678        //Check the signaller stack
    679         LIB_DEBUG_PRINT_SAFE("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
     679        __cfaabi_dbg_print_safe("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
    680680        __condition_criterion_t * urgent = pop( this->signal_stack );
    681681        if( urgent ) {
    … …  
    729729        for( __lock_size_t i = 0; i < count; i++) {
    730730                (criteria[i]){ monitors[i], waiter };
    731                 LIB_DEBUG_PRINT_SAFE( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
     731                __cfaabi_dbg_print_safe( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
    732732                push( criteria[i].target->signal_stack, &criteria[i] );
    733733        }
    … …  
    738738static inline void lock_all( __spinlock_t * locks [], __lock_size_t count ) {
    739739        for( __lock_size_t i = 0; i < count; i++ ) {
    740                 DO_LOCK( *locks[i] DEBUG_CTX2 );
     740                DO_LOCK( *locks[i] __cfaabi_dbg_ctx2 );
    741741        }
    742742}
    … …  
    745745        for( __lock_size_t i = 0; i < count; i++ ) {
    746746                __spinlock_t * l = &source[i]->lock;
    747                 DO_LOCK( *l DEBUG_CTX2 );
     747                DO_LOCK( *l __cfaabi_dbg_ctx2 );
    748748                if(locks) locks[i] = l;
    749749        }
    … …  
    803803        for(    int i = 0; i < count; i++ ) {
    804804
    805                 // LIB_DEBUG_PRINT_SAFE( "Checking %p for %p\n", &criteria[i], target );
     805                // __cfaabi_dbg_print_safe( "Checking %p for %p\n", &criteria[i], target );
    806806                if( &criteria[i] == target ) {
    807807                        criteria[i].ready = true;
    808                         // LIB_DEBUG_PRINT_SAFE( "True\n" );
     808                        // __cfaabi_dbg_print_safe( "True\n" );
    809809                }
    810810
    … …  
    812812        }
    813813
    814         LIB_DEBUG_PRINT_SAFE( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
     814        __cfaabi_dbg_print_safe( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
    815815        return ready2run ? node->waiting_thread : NULL;
    816816}
    … …  
    819819        thread_desc * thrd = this_thread;
    820820        if( !this.monitors ) {
    821                 // LIB_DEBUG_PRINT_SAFE("Branding\n");
     821                // __cfaabi_dbg_print_safe("Branding\n");
    822822                assertf( thrd->monitors.data != NULL, "No current monitor to brand condition %p", thrd->monitors.data );
    823823                this.monitor_count = thrd->monitors.size;

  • src/libcfa/concurrency/preemption.c

    r8a0a64d9 r36982fc  
    148148//=============================================================================================
    149149
    150 LIB_DEBUG_DO( static thread_local void * last_interrupt = 0; )
     150__cfaabi_dbg_debug_do( static thread_local void * last_interrupt = 0; )
    151151
    152152extern "C" {
    … …  
    159159        // Enable interrupts by decrementing the counter
    160160        // If counter reaches 0, execute any pending CtxSwitch
    161         void enable_interrupts( DEBUG_CTX_PARAM ) {
     161        void enable_interrupts( __cfaabi_dbg_ctx_param ) {
    162162                processor * proc   = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
    163163                thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
    … …  
    173173
    174174                // For debugging purposes : keep track of the last person to enable the interrupts
    175                 LIB_DEBUG_DO( proc->last_enable = caller; )
     175                __cfaabi_dbg_debug_do( proc->last_enable = caller; )
    176176        }
    177177
    … …  
    233233// Called from kernel_startup
    234234void kernel_start_preemption() {
    235         LIB_DEBUG_PRINT_SAFE("Kernel : Starting preemption\n");
     235        __cfaabi_dbg_print_safe("Kernel : Starting preemption\n");
    236236
    237237        // Start with preemption disabled until ready
    … …  
    255255// Called from kernel_shutdown
    256256void kernel_stop_preemption() {
    257         LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopping\n");
     257        __cfaabi_dbg_print_safe("Kernel : Preemption stopping\n");
    258258
    259259        // Block all signals since we are already shutting down
    … …  
    271271        // Preemption is now fully stopped
    272272
    273         LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopped\n");
     273        __cfaabi_dbg_print_safe("Kernel : Preemption stopped\n");
    274274}
    275275
    … …  
    297297// Receives SIGUSR1 signal and causes the current thread to yield
    298298void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) {
    299         LIB_DEBUG_DO( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); )
     299        __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); )
    300300
    301301        // Check if it is safe to preempt here
    … …  
    346346                assertf(sig == SIGALRM, "Kernel Internal Error, sigwait: Unexpected signal %d (%d : %d)\n", sig, info.si_code, info.si_value.sival_int);
    347347
    348                 // LIB_DEBUG_PRINT_SAFE("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
     348                // __cfaabi_dbg_print_safe("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
    349349                // Switch on the code (a.k.a. the sender) to
    350350                switch( info.si_code )
    … …  
    354354                case SI_TIMER:
    355355                case SI_KERNEL:
    356                         // LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n");
    357                         lock( event_kernel->lock DEBUG_CTX2 );
     356                        // __cfaabi_dbg_print_safe("Kernel : Preemption thread tick\n");
     357                        lock( event_kernel->lock __cfaabi_dbg_ctx2 );
    358358                        tick_preemption();
    359359                        unlock( event_kernel->lock );
    … …  
    368368
    369369EXIT:
    370         LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread stopping\n");
     370        __cfaabi_dbg_print_safe("Kernel : Preemption thread stopping\n");
    371371        return NULL;
    372372}
    … …  
    380380
    381381        if ( sigaction( sig, &act, NULL ) == -1 ) {
    382                 LIB_DEBUG_PRINT_BUFFER_DECL(
     382                __cfaabi_dbg_print_buffer_decl(
    383383                        " __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
    384384                        sig, handler, flags, errno, strerror( errno )
    … …  
    397397
    398398        if ( sigaction( sig, &act, NULL ) == -1 ) {
    399                 LIB_DEBUG_PRINT_BUFFER_DECL(
     399                __cfaabi_dbg_print_buffer_decl(
    400400                        " __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",
    401401                        sig, errno, strerror( errno )
    … …  
    409409//=============================================================================================
    410410
    411 LIB_DEBUG_DO(
     411__cfaabi_dbg_debug_do(
    412412        static void __kernel_backtrace( int start ) {
    413413                // skip first N stack frames
    … …  
    476476
    477477// void sigHandler_segv( __CFA_SIGPARMS__ ) {
    478 //      LIB_DEBUG_DO(
     478//      __cfaabi_dbg_debug_do(
    479479//              #ifdef __USE_STREAM__
    480480//              serr    | "*CFA runtime error* program cfa-cpp terminated with"
    … …  
    493493// void sigHandler_abort( __CFA_SIGPARMS__ ) {
    494494//      // skip first 6 stack frames
    495 //      LIB_DEBUG_DO( __kernel_backtrace( 6 ); )
     495//      __cfaabi_dbg_debug_do( __kernel_backtrace( 6 ); )
    496496
    497497//      // reset default signal handler

  • src/libcfa/concurrency/thread.c

    r8a0a64d9 r36982fc  
    7272        thrd_c->last = this_coroutine;
    7373
    74         // LIB_DEBUG_PRINT_SAFE("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
     74        // __cfaabi_dbg_print_safe("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
    7575
    7676        disable_interrupts();
    … …  
    8282
    8383        ScheduleThread(thrd_h);
    84         enable_interrupts( DEBUG_CTX );
     84        enable_interrupts( __cfaabi_dbg_ctx );
    8585}
    8686
Note: See TracChangeset for help on using the changeset viewer.