Changes in / [52142c2:e3fea42]


Ignore:
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/concurrency/CtxSwitch-x86_64.S

    r52142c2 re3fea42  
    8787CtxInvokeStub:
    8888        movq %rbx, %rdi
    89         movq %r12, %rsi
    90         jmp *%r13
     89        jmp *%r12
    9190        .size  CtxInvokeStub, .-CtxInvokeStub
    9291

  • libcfa/src/concurrency/coroutine.cfa

    r52142c2 re3fea42  
    187187// is not inline (We can't inline Cforall in C)
    188188extern "C" {
    189         void __leave_coroutine( struct coroutine_desc * src ) {
     189        void __suspend_internal(void) {
     190                suspend();
     191        }
     192
     193        void __leave_coroutine( coroutine_desc * src ) {
    190194                coroutine_desc * starter = src->cancellation != 0 ? src->last : src->starter;
    191195
    … …  
    203207                CoroutineCtxSwitch( src, starter );
    204208        }
    205 
    206         struct coroutine_desc * __finish_coroutine(void) {
    207                 struct coroutine_desc * cor = kernelTLS.this_thread->curr_cor;
    208 
    209                 if(cor->state == Primed) {
    210                         suspend();
    211                 }
    212 
    213                 cor->state = Active;
    214 
    215                 return cor;
    216         }
    217209}
    218210

  • libcfa/src/concurrency/coroutine.hfa

    r52142c2 re3fea42  
    6161// Start coroutine routines
    6262extern "C" {
    63         void CtxInvokeCoroutine(void (*main)(void *), void * this);
     63      forall(dtype T | is_coroutine(T))
     64      void CtxInvokeCoroutine(T * this);
    6465
    65         forall(dtype T)
    66         void CtxStart(void (*main)(T &), struct coroutine_desc * cor, T & this, void (*invoke)(void (*main)(void *), void *));
     66      forall(dtype T | is_coroutine(T))
     67      void CtxStart(T * this, void ( *invoke)(T *));
    6768
    6869        extern void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
    … …  
    128129
    129130        if( unlikely(dst->context.SP == 0p) ) {
    130                 TL_GET( this_thread )->curr_cor = dst;
    131131                __stack_prepare(&dst->stack, 65000);
    132                 CtxStart(main, dst, cor, CtxInvokeCoroutine);
    133                 TL_GET( this_thread )->curr_cor = src;
     132                CtxStart(&cor, CtxInvokeCoroutine);
    134133        }
    135134

  • libcfa/src/concurrency/invoke.c

    r52142c2 re3fea42  
    2929// Called from the kernel when starting a coroutine or task so must switch back to user mode.
    3030
    31 extern void __leave_coroutine ( struct coroutine_desc * );
    32 extern struct coroutine_desc * __finish_coroutine(void);
    33 extern void __leave_thread_monitor();
     31extern void __suspend_internal(void);
     32extern void __leave_coroutine( struct coroutine_desc * );
     33extern void __finish_creation( struct thread_desc * );
     34extern void __leave_thread_monitor( struct thread_desc * this );
    3435extern void disable_interrupts() OPTIONAL_THREAD;
    3536extern void enable_interrupts( __cfaabi_dbg_ctx_param );
    … …  
    3738void CtxInvokeCoroutine(
    3839        void (*main)(void *),
     40        struct coroutine_desc *(*get_coroutine)(void *),
    3941        void *this
    4042) {
    41         // Finish setting up the coroutine by setting its state
    42         struct coroutine_desc * cor = __finish_coroutine();
     43        struct coroutine_desc* cor = get_coroutine( this );
    4344
    44         // Call the main of the coroutine
     45        if(cor->state == Primed) {
     46                __suspend_internal();
     47        }
     48
     49        cor->state = Active;
     50
    4551        main( this );
    4652
    … …  
    7783
    7884void CtxInvokeThread(
     85        void (*dtor)(void *),
    7986        void (*main)(void *),
     87        struct thread_desc *(*get_thread)(void *),
    8088        void *this
    8189) {
     90        // Fetch the thread handle from the user defined thread structure
     91        struct thread_desc* thrd = get_thread( this );
     92
     93        // First suspend, once the thread arrives here,
     94        // the function pointer to main can be invalidated without risk
     95        __finish_creation( thrd );
     96
    8297        // Officially start the thread by enabling preemption
    8398        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    93108        // The order of these 4 operations is very important
    94109        //Final suspend, should never return
    95         __leave_thread_monitor();
     110        __leave_thread_monitor( thrd );
    96111        __cabi_abort( "Resumed dead thread" );
    97112}
    98113
     114
    99115void CtxStart(
    100116        void (*main)(void *),
    101         struct coroutine_desc * cor,
     117        struct coroutine_desc *(*get_coroutine)(void *),
    102118        void *this,
    103119        void (*invoke)(void *)
    104120) {
     121        struct coroutine_desc * cor = get_coroutine( this );
    105122        struct __stack_t * stack = cor->stack.storage;
    106123
    … …  
    121138
    122139        fs->dummyReturn = NULL;
    123         fs->argument[0] = main;     // argument to invoke
    124         fs->argument[1] = this;     // argument to invoke
     140        fs->argument[0] = this;     // argument to invoke
    125141        fs->rturn = invoke;
    126142
    … …  
    140156        fs->dummyReturn = NULL;
    141157        fs->rturn = CtxInvokeStub;
    142         fs->fixedRegisters[0] = main;
    143         fs->fixedRegisters[1] = this;
    144         fs->fixedRegisters[2] = invoke;
     158        fs->fixedRegisters[0] = this;
     159        fs->fixedRegisters[1] = invoke;
    145160
    146161#elif defined( __ARM_ARCH )
    147 #error ARM needs to be upgrade to use to parameters like X86/X64 (A.K.A. : I broke this and do not know how to fix it)
     162
    148163        struct FakeStack {
    149164                float fpRegs[16];                       // floating point registers

  • libcfa/src/concurrency/kernel.cfa

    r52142c2 re3fea42  
    469469        );
    470470
    471         Abort( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
     471        Abort( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" ); 
    472472
    473473        Abort( pthread_create( pthread, &attr, start, arg ), "pthread_create" );
    … …  
    490490        verify( ! kernelTLS.preemption_state.enabled );
    491491
    492         kernelTLS.this_thread->curr_cor = dst;
    493492        __stack_prepare( &dst->stack, 65000 );
    494         CtxStart(main, dst, this->runner, CtxInvokeCoroutine);
     493        CtxStart(&this->runner, CtxInvokeCoroutine);
    495494
    496495        verify( ! kernelTLS.preemption_state.enabled );
    … …  
    506505        CtxSwitch( &src->context, &dst->context );
    507506        // when CtxSwitch returns we are back in the src coroutine
    508 
    509         mainThread->curr_cor = &mainThread->self_cor;
    510507
    511508        // set state of new coroutine to active

  • libcfa/src/concurrency/kernel_private.hfa

    r52142c2 re3fea42  
    8888// Threads
    8989extern "C" {
    90       void CtxInvokeThread(void (*main)(void *), void * this);
     90      forall(dtype T | is_thread(T))
     91      void CtxInvokeThread(T * this);
    9192}
    9293

  • libcfa/src/concurrency/monitor.cfa

    r52142c2 re3fea42  
    243243        // last routine called by a thread.
    244244        // Should never return
    245         void __leave_thread_monitor() {
    246                 thread_desc * thrd = TL_GET( this_thread );
     245        void __leave_thread_monitor( thread_desc * thrd ) {
    247246                monitor_desc * this = &thrd->self_mon;
    248247

  • libcfa/src/concurrency/thread.cfa

    r52142c2 re3fea42  
    5858void ?{}( scoped(T)& this ) with( this ) {
    5959        handle{};
    60         __thrd_start(handle, main);
     60        __thrd_start(handle);
    6161}
    6262
    … …  
    6464void ?{}( scoped(T)& this, P params ) with( this ) {
    6565        handle{ params };
    66         __thrd_start(handle, main);
     66        __thrd_start(handle);
    6767}
    6868
    … …  
    7575// Starting and stopping threads
    7676forall( dtype T | is_thread(T) )
    77 void __thrd_start( T & this, void (*main_p)(T &) ) {
     77void __thrd_start( T& this ) {
    7878        thread_desc * this_thrd = get_thread(this);
    7979        thread_desc * curr_thrd = TL_GET( this_thread );
    8080
    8181        disable_interrupts();
    82         CtxStart(main_p, get_coroutine(this), this, CtxInvokeThread);
    83 
     82        CtxStart(&this, CtxInvokeThread);
    8483        this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
    8584        verify( this_thrd->context.SP );
    86         // CtxSwitch( &curr_thrd->context, &this_thrd->context );
     85        CtxSwitch( &curr_thrd->context, &this_thrd->context );
    8786
    8887        ScheduleThread(this_thrd);
    8988        enable_interrupts( __cfaabi_dbg_ctx );
     89}
     90
     91extern "C" {
     92        // KERNEL ONLY
     93        void __finish_creation(thread_desc * this) {
     94                // set new coroutine that the processor is executing
     95                // and context switch to it
     96                verify( kernelTLS.this_thread != this );
     97                verify( kernelTLS.this_thread->context.SP );
     98                CtxSwitch( &this->context, &kernelTLS.this_thread->context );
     99        }
    90100}
    91101

  • libcfa/src/concurrency/thread.hfa

    r52142c2 re3fea42  
    5454
    5555forall( dtype T | is_thread(T) )
    56 void __thrd_start( T & this, void (*)(T &) );
     56void __thrd_start( T & this );
    5757
    5858//-----------------------------------------------------------------------------

  • src/Concurrency/Keywords.cc

    r52142c2 re3fea42  
    716716                                new UntypedExpr(
    717717                                        new NameExpr( "__thrd_start" ),
    718                                         { new VariableExpr( param ), new NameExpr("main") }
     718                                        { new VariableExpr( param ) }
    719719                                )
    720720                        )
Note: See TracChangeset for help on using the changeset viewer.