Changeset 17af7d1


Ignore:
Timestamp:
Mar 17, 2017, 11:34:15 AM (5 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
b32ada31
Parents:
9f1695b
Message:

Some clean-up of runtime code

Location:
src
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • src/benchmark/CorCtxSwitch.c

    r9f1695b r17af7d1  
    2424
    2525struct GreatSuspender {
    26         coroutine_desc c;
     26        coroutine_desc __cor;
    2727};
    2828
  • src/benchmark/bench.c

    r9f1695b r17af7d1  
    8686//=======================================
    8787
    88 struct CoroutineDummy { coroutine_desc c; };
     88struct CoroutineDummy { coroutine_desc __cor; };
    8989DECL_COROUTINE(CoroutineDummy);
    9090void main(CoroutineDummy * this) {}
     
    119119struct CoroutineResume {
    120120    int N;
    121     coroutine_desc c;
     121    coroutine_desc __cor;
    122122};
    123123
     
    150150//=======================================
    151151
    152 struct ThreadDummy { thread_desc t; };
     152struct ThreadDummy { thread_desc __thrd; };
    153153DECL_THREAD(ThreadDummy);
    154154void main(ThreadDummy * this) {}
     
    180180    int N;
    181181    long long result;
    182     thread_desc t;
     182    thread_desc __thrd;
    183183};
    184184
  • src/benchmark/csv-data.c

    r9f1695b r17af7d1  
    2626
    2727struct GreatSuspender {
    28         coroutine_desc c;
     28        coroutine_desc __cor;
    2929};
    3030
  • src/examples/multicore.c

    r9f1695b r17af7d1  
    22#include <thread>
    33
    4 struct MyThread { thread_desc t; };
     4struct MyThread { thread_desc __thrd; };
    55
    66DECL_THREAD(MyThread);
  • src/libcfa/concurrency/coroutine

    r9f1695b r17af7d1  
    3030};
    3131
    32 #define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->c; } void main(X* this)
     32#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->__cor; } void main(X* this)
    3333
    3434//-----------------------------------------------------------------------------
  • src/libcfa/concurrency/invoke.c

    r9f1695b r17af7d1  
    6464
    6565      struct thread_desc* thrd = get_thread( this );
    66       struct coroutine_desc* cor = &thrd->c;
     66      struct coroutine_desc* cor = &thrd->cor;
    6767      cor->state = Active;
    6868
     
    9292        struct FakeStack {
    9393            void *fixedRegisters[3];                    // fixed registers ebx, edi, esi (popped on 1st uSwitch, values unimportant)
    94             uint32_t mxcr;                              // SSE Status and Control bits (control bits are preserved across function calls)
    95             uint16_t fcw;                               // X97 FPU control word (preserved across function calls)
    96             void *rturn;                                // where to go on return from uSwitch
     94            uint32_t mxcr;                        // SSE Status and Control bits (control bits are preserved across function calls)
     95          uint16_t fcw;                         // X97 FPU control word (preserved across function calls)
     96            void *rturn;                          // where to go on return from uSwitch
    9797            void *dummyReturn;                          // fake return compiler would have pushed on call to uInvoke
    9898            void *argument[3];                          // for 16-byte ABI, 16-byte alignment starts here
     
    106106        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->argument[0] = this;     // argument to invoke
    107107        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = invoke;
     108      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
     109      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
    108110
    109111#elif defined( __x86_64__ )
    110112
    111113      struct FakeStack {
    112             void *fixedRegisters[5];                    // fixed registers rbx, r12, r13, r14, r15
    113             uint32_t mxcr;                              // SSE Status and Control bits (control bits are preserved across function calls)
    114             uint16_t fcw;                               // X97 FPU control word (preserved across function calls)
    115             void *rturn;                                // where to go on return from uSwitch
    116             void *dummyReturn;                          // NULL return address to provide proper alignment
     114            void *fixedRegisters[5];            // fixed registers rbx, r12, r13, r14, r15
     115            uint32_t mxcr;                      // SSE Status and Control bits (control bits are preserved across function calls)
     116            uint16_t fcw;                       // X97 FPU control word (preserved across function calls)
     117            void *rturn;                        // where to go on return from uSwitch
     118            void *dummyReturn;                  // NULL return address to provide proper alignment
    117119      };
    118120
  • src/libcfa/concurrency/invoke.h

    r9f1695b r17af7d1  
    2828      #define unlikely(x)    __builtin_expect(!!(x), 0)
    2929      #define thread_local _Thread_local
    30       #define SCHEDULER_CAPACITY 10
    3130
    3231      struct spinlock {
     
    6059
    6160      struct coStack_t {
    62             unsigned int size;                // size of stack
    63             void *storage;                            // pointer to stack
    64             void *limit;                              // stack grows towards stack limit
    65             void *base;                               // base of stack
    66             void *context;                            // address of cfa_context_t
    67             void *top;                                // address of top of storage
    68             bool userStack;     
     61            unsigned int size;                  // size of stack
     62            void *storage;                      // pointer to stack
     63            void *limit;                        // stack grows towards stack limit
     64            void *base;                         // base of stack
     65            void *context;                      // address of cfa_context_t
     66            void *top;                          // address of top of storage
     67            bool userStack;                     // whether or not the user allocated the stack
    6968      };
    7069
     
    7271
    7372      struct coroutine_desc {
    74             struct coStack_t stack;
    75             const char *name;                         // textual name for coroutine/task, initialized by uC++ generated code
    76             int errno_;                               // copy of global UNIX variable errno
    77             enum coroutine_state state;       // current execution status for coroutine
    78             struct coroutine_desc *starter;           // first coroutine to resume this one
    79             struct coroutine_desc *last;                      // last coroutine to resume this one
     73            struct coStack_t stack;             // stack information of the coroutine
     74            const char *name;                   // textual name for coroutine/task, initialized by uC++ generated code
     75            int errno_;                         // copy of global UNIX variable errno
     76            enum coroutine_state state;         // current execution status for coroutine
     77            struct coroutine_desc *starter;     // first coroutine to resume this one
     78            struct coroutine_desc *last;              // last coroutine to resume this one
    8079      };
    8180
    8281      struct thread_desc {
    83             struct coroutine_desc c;                 // coroutine body used to store context
     82            struct coroutine_desc cor;            // coroutine body used to store context
    8483            struct signal_once terminated;      // indicate if execuation state is not halted
    85             struct thread_desc * next;               // instrusive link field for threads
     84            struct thread_desc * next;          // instrusive link field for threads
    8685      };
    8786
  • src/libcfa/concurrency/kernel.c

    r9f1695b r17af7d1  
    107107
    108108void ?{}( thread_desc * this, current_stack_info_t * info) {
    109         (&this->c){ info };
     109        (&this->cor){ info };
    110110}
    111111
     
    113113// Processor coroutine
    114114void ?{}(processorCtx_t * this, processor * proc) {
    115         (&this->c){};
     115        (&this->__cor){};
    116116        this->proc = proc;
    117117        proc->runner = this;
     
    119119
    120120void ?{}(processorCtx_t * this, processor * proc, current_stack_info_t * info) {
    121         (&this->c){ info };
     121        (&this->__cor){ info };
    122122        this->proc = proc;
    123123        proc->runner = this;
     
    255255        processorCtx_t proc_cor_storage = { proc, &info };
    256256
    257         LIB_DEBUG_PRINTF("Coroutine : created stack %p\n", proc_cor_storage.c.stack.base);
     257        LIB_DEBUG_PRINTF("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
    258258
    259259        //Set global state
    260         proc->current_coroutine = &proc->runner->c;
     260        proc->current_coroutine = &proc->runner->__cor;
    261261        proc->current_thread = NULL;
    262262
     
    268268        // back to here. Instead directly call the main since we already are on the
    269269        // appropriate stack.
    270         proc_cor_storage.c.state = Active;
     270        proc_cor_storage.__cor.state = Active;
    271271      main( &proc_cor_storage );
    272       proc_cor_storage.c.state = Halted;
     272      proc_cor_storage.__cor.state = Halted;
    273273
    274274        // Main routine of the core returned, the core is now fully terminated
     
    359359        this_processor = systemProcessor;
    360360        this_processor->current_thread = mainThread;
    361         this_processor->current_coroutine = &mainThread->c;
     361        this_processor->current_coroutine = &mainThread->cor;
    362362
    363363        // SKULLDUGGERY: Force a context switch to the system processor to set the main thread's context to the current UNIX
  • src/libcfa/concurrency/kernel_private.h

    r9f1695b r17af7d1  
    3535struct processorCtx_t {
    3636        processor * proc;
    37         coroutine_desc c;
     37        coroutine_desc __cor;
    3838};
    3939
  • src/libcfa/concurrency/monitor

    r9f1695b r17af7d1  
    3434}
    3535
    36 //Basic entering routine
    37 void enter(monitor_desc *);
    38 void leave(monitor_desc *);
    39 
    4036//Array entering routine
    4137void enter(monitor_desc **, int count);
     
    4945static inline int ?<?(monitor_desc* lhs, monitor_desc* rhs) {
    5046        return ((intptr_t)lhs) < ((intptr_t)rhs);
    51 }
    52 
    53 static inline void ?{}( monitor_guard_t * this, monitor_desc ** m ) {
    54         this->m = m;
    55         this->count = 1;
    56         enter( *this->m );
    5747}
    5848
  • src/libcfa/concurrency/monitor.c

    r9f1695b r17af7d1  
    7474void enter(monitor_desc ** monitors, int count) {
    7575        for(int i = 0; i < count; i++) {
    76                 // printf("%d\n", i);
    7776                enter( monitors[i] );
    7877        }
     
    8180void leave(monitor_desc ** monitors, int count) {
    8281        for(int i = count - 1; i >= 0; i--) {
    83                 // printf("%d\n", i);
    8482                leave( monitors[i] );
    8583        }
  • src/libcfa/concurrency/thread

    r9f1695b r17af7d1  
    3333};
    3434
    35 #define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->t; } void main(X* this)
     35#define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->__thrd; } void main(X* this)
    3636
    3737forall( dtype T | is_thread(T) )
    3838static inline coroutine_desc* get_coroutine(T* this) {
    39         return &get_thread(this)->c;
     39        return &get_thread(this)->cor;
    4040}
    4141
    4242static inline coroutine_desc* get_coroutine(thread_desc* this) {
    43         return &this->c;
     43        return &this->cor;
    4444}
    4545
  • src/libcfa/concurrency/thread.c

    r9f1695b r17af7d1  
    4242
    4343void ?{}(thread_desc* this) {
    44         (&this->c){};
    45         this->c.name = "Anonymous Coroutine";
     44        (&this->cor){};
     45        this->cor.name = "Anonymous Coroutine";
    4646        (&this->terminated){};
    4747        this->next = NULL;
     
    4949
    5050void ^?{}(thread_desc* this) {
    51         ^(&this->c){};
     51        ^(&this->cor){};
    5252}
    5353
     
    120120extern "C" {
    121121        void __thread_signal_termination( thread_desc * this ) {
    122                 this->c.state = Halted;
     122                this->cor.state = Halted;
    123123                LIB_DEBUG_PRINTF("Thread end : %p\n", this);
    124124                signal( &this->terminated );   
  • src/tests/coroutine.c

    r9f1695b r17af7d1  
    44struct Fibonacci {
    55      int fn; // used for communication
    6       coroutine_desc c;
     6      coroutine_desc __cor;
    77};
    88
     
    1212
    1313coroutine_desc* get_coroutine(Fibonacci* this) {
    14       return &this->c;
     14      return &this->__cor;
    1515}
    1616
     
    1818#ifdef MORE_DEBUG
    1919      sout | "Starting main of coroutine " | this | endl;
    20       sout | "Started from " | this->c.last | endl;
     20      sout | "Started from " | this->__cor.last | endl;
    2121#endif
    2222      int fn1, fn2;             // retained between resumes
  • src/tests/monitor.c

    r9f1695b r17af7d1  
    3131}
    3232
    33 struct MyThread { thread_desc t; };
     33struct MyThread { thread_desc __thrd; };
    3434
    3535DECL_THREAD(MyThread);
  • src/tests/multi-monitor.c

    r9f1695b r17af7d1  
    2121
    2222struct MyThread {
    23         thread_desc t;
     23        thread_desc __thrd;
    2424        int target;
    2525};
  • src/tests/thread.c

    r9f1695b r17af7d1  
    44#include <thread>
    55
    6 struct First { thread_desc t; signal_once* lock; };
    7 struct Second { thread_desc t; signal_once* lock; };
     6struct First { thread_desc __thrd; signal_once* lock; };
     7struct Second { thread_desc __thrd; signal_once* lock; };
    88
    99DECL_THREAD(First);
Note: See TracChangeset for help on using the changeset viewer.