source: src/libcfa/concurrency/kernel.c @ eb2e723

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since eb2e723 was eb2e723, checked in by Thierry Delisle <tdelisle@…>, 6 years ago

First prototype of kernel with proper startup and shutdown, not yet implemented for i386

  • Property mode set to 100644
File size: 7.7 KB
Line 
1//                              -*- Mode: CFA -*-
2//
3// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
4//
5// The contents of this file are covered under the licence agreement in the
6// file "LICENCE" distributed with Cforall.
7//
8// kernel.c --
9//
10// Author           : Thierry Delisle
11// Created On       : Tue Jan 17 12:27:26 2016
12// Last Modified By : Thierry Delisle
13// Last Modified On : --
14// Update Count     : 0
15//
16
17//Header
18#include "kernel"
19
20//C Includes
21#include <stddef.h>
22extern "C" {
23#include <sys/resource.h>
24}
25
26//CFA Includes
27#include "libhdr.h"
28#include "threads"
29
30//Private includes
31#define __CFA_INVOKE_PRIVATE__
32#include "invoke.h"
33
34processor * systemProcessor;
35thread_h * mainThread;
36
37void kernel_startup(void)  __attribute__((constructor(101)));
38void kernel_shutdown(void) __attribute__((destructor(101)));
39
40void ?{}(processor * this) {
41        this->ctx = NULL;
42        this->thread_index = 0;
43        this->thread_count = 10;
44        this->terminated = false;
45
46        for(int i = 0; i < 10; i++) {
47                this->threads[i] = NULL;
48        }
49
50        LIB_DEBUG_PRINTF("Processor : ctor for core %p (core spots %d)\n", this, this->thread_count);
51}
52
53void ^?{}(processor * this) {
54
55}
56
57//-----------------------------------------------------------------------------
58// Processor coroutine
59struct processorCtx_t {
60        processor * proc;
61        coroutine c;
62};
63
64DECL_COROUTINE(processorCtx_t)
65
66void ?{}(processorCtx_t * this, processor * proc) {
67        (&this->c){};
68        this->proc = proc;
69}
70
71void CtxInvokeProcessor(processor * proc) {
72        processorCtx_t proc_cor_storage = {proc};
73        resume( &proc_cor_storage );
74}
75
76//-----------------------------------------------------------------------------
77// Processor running routines
78void main(processorCtx_t * ctx);
79thread_h * nextThread(processor * this);
80void runThread(processor * this, thread_h * dst);
81void spin(processor * this, unsigned int * spin_count);
82
83void main(processorCtx_t * ctx) {
84        processor * this = ctx->proc;
85        LIB_DEBUG_PRINTF("Kernel : core %p starting\n", this);
86
87        thread_h * readyThread = NULL;
88        for( unsigned int spin_count = 0; ! this->terminated; spin_count++ ) {
89               
90                readyThread = nextThread(this);
91
92                if(readyThread) {
93                        runThread(this, readyThread);
94                        spin_count = 0;
95                } else {
96                        spin(this, &spin_count);
97                }               
98        }
99
100        LIB_DEBUG_PRINTF("Kernel : core %p terminated\n", this);
101}
102
103thread_h * nextThread(processor * this) {
104        for(int i = 0; i < this->thread_count; i++) {
105                this->thread_index = (this->thread_index + 1) % this->thread_count;     
106               
107                thread_h * thrd = this->threads[this->thread_index];
108                if(thrd) return thrd;
109        }
110
111        return NULL;
112}
113
114void runThread(processor * this, thread_h * dst) {
115        coroutine * proc_ctx = get_coroutine(this->ctx);
116        coroutine * thrd_ctx = get_coroutine(dst);
117        thrd_ctx->last = proc_ctx;
118
119        // context switch to specified coroutine
120        // Which is now the current_coroutine
121        LIB_DEBUG_PRINTF("Kernel : switching to ctx %p (from %p, current %p)\n", thrd_ctx, proc_ctx, current_coroutine);
122        current_coroutine = thrd_ctx;
123        CtxSwitch( proc_ctx->stack.context, thrd_ctx->stack.context );
124        current_coroutine = proc_ctx;
125        LIB_DEBUG_PRINTF("Kernel : returned from ctx %p (to %p, current %p)\n", thrd_ctx, proc_ctx, current_coroutine);
126
127        // when CtxSwitch returns we are back in the processor coroutine
128}
129
130void spin(processor * this, unsigned int * spin_count) {
131        (*spin_count)++;
132}
133
134//-----------------------------------------------------------------------------
135// Kernel runner (Temporary)
136
137void scheduler_add( thread_h * thrd ) {
138        LIB_DEBUG_PRINTF("Kernel : scheduling %p on core %p (%d spots)\n", thrd, systemProcessor, systemProcessor->thread_count);
139        for(int i = 0; i < systemProcessor->thread_count; i++) {
140                if(systemProcessor->threads[i] == NULL) {
141                        systemProcessor->threads[i] = thrd;
142                        return;
143                }
144        }
145        assert(false);
146}
147
148void scheduler_remove( thread_h * thrd ) {
149        LIB_DEBUG_PRINTF("Kernel : unscheduling %p from core %p\n", thrd, systemProcessor);
150        for(int i = 0; i < systemProcessor->thread_count; i++) {
151                if(systemProcessor->threads[i] == thrd) {
152                        systemProcessor->threads[i] = NULL;
153                        break;
154                }
155        }
156        for(int i = 0; i < systemProcessor->thread_count; i++) {
157                if(systemProcessor->threads[i] != NULL) {
158                        return;
159                }
160        }
161        LIB_DEBUG_PRINTF("Kernel : terminating core %p\n", systemProcessor);   
162        systemProcessor->terminated = true;
163}
164
165//-----------------------------------------------------------------------------
166// Kernel storage
167#define KERNEL_STORAGE(T,X) static char X##_storage[sizeof(T)]
168
169KERNEL_STORAGE(processorCtx_t, systemProcessorCtx);
170KERNEL_STORAGE(processor, systemProcessor);
171KERNEL_STORAGE(thread_h, mainThread);
172KERNEL_STORAGE(machine_context_t, mainThread_context);
173
174//-----------------------------------------------------------------------------
175// Main thread construction
176struct mainThread_info_t {
177        machine_context_t ctx; 
178        unsigned int size;              // size of stack
179        void *base;                             // base of stack
180        void *storage;                  // pointer to stack
181        void *limit;                    // stack grows towards stack limit
182        void *context;                  // address of cfa_context_t
183        void *top;                              // address of top of storage
184};
185
186void ?{}( mainThread_info_t * this ) {
187        CtxGet( &this->ctx );
188        this->base = this->ctx.FP;
189        this->storage = this->ctx.SP;
190
191        rlimit r;
192        int ret = getrlimit( RLIMIT_STACK, &r);
193        this->size = r.rlim_cur;
194
195        this->limit = (void *)(((intptr_t)this->base) - this->size);
196        this->context = &mainThread_context_storage;
197        this->top = this->base;
198}
199
200void ?{}( coStack_t * this, mainThread_info_t * info) {
201        this->size = info->size;
202        this->storage = info->storage;
203        this->limit = info->limit;
204        this->base = info->base;
205        this->context = info->context;
206        this->top = info->top;
207        this->userStack = true;
208}
209
210void ?{}( coroutine * this, mainThread_info_t * info) {
211        (&this->stack){ info }; 
212        this->name = "Main Thread";
213        this->errno_ = 0;
214        this->state = Inactive;
215        this->notHalted = true;
216}
217
218void ?{}( thread_h * this, mainThread_info_t * info) {
219        (&this->c){ info };
220}
221
222//-----------------------------------------------------------------------------
223// Kernel boot procedures
224void kernel_startup(void) {
225
226        // SKULLDUGGERY: the mainThread steals the process main thread
227        // which will then be scheduled by the systemProcessor normally
228        LIB_DEBUG_PRINTF("Kernel : Starting\n");       
229
230        mainThread_info_t ctx;
231        LIB_DEBUG_PRINTF("Kernel :    base : %p\n", ctx.base );
232        LIB_DEBUG_PRINTF("Kernel :     top : %p\n", ctx.top );
233        LIB_DEBUG_PRINTF("Kernel :   limit : %p\n", ctx.limit );
234        LIB_DEBUG_PRINTF("Kernel :    size : %x\n", ctx.size );
235        LIB_DEBUG_PRINTF("Kernel : storage : %p\n", ctx.storage );
236        LIB_DEBUG_PRINTF("Kernel : context : %p\n", ctx.context );
237
238        // Start by initializing the main thread
239        mainThread = (thread_h *)&mainThread_storage;
240        LIB_DEBUG_PRINTF("Kernel : Main thread : %p\n", mainThread );
241        mainThread{ &ctx };
242
243        // // Initialize the system processor
244        systemProcessor = (processor *)&systemProcessor_storage;
245        systemProcessor{};
246
247        // Initialize the system processor ctx
248        // (the coroutine that contains the processing control flow)
249        systemProcessor->ctx = (processorCtx_t *)&systemProcessorCtx_storage;
250        systemProcessor->ctx{ systemProcessor };
251
252        scheduler_add(mainThread);
253
254        current_coroutine = &mainThread->c;
255
256        LIB_DEBUG_PRINTF("Kernel : Starting system processor\n");       
257        resume(systemProcessor->ctx);
258
259        LIB_DEBUG_PRINTF("Kernel : Started\n--------------------------------------------------\n\n");
260}
261void kernel_shutdown(void) {
262        LIB_DEBUG_PRINTF("\n--------------------------------------------------\nKernel : Shutting down");
263
264        LIB_DEBUG_PRINTF("Unscheduling main thread\n");
265        scheduler_remove(mainThread);
266
267        LIB_DEBUG_PRINTF("Suspending main\n");
268        suspend();
269
270        LIB_DEBUG_PRINTF("Kernel : Control return to initial process thread\n");
271
272        ^(systemProcessor->ctx){};
273        ^(systemProcessor){};
274
275        ^(mainThread){};
276
277        LIB_DEBUG_PRINTF("Kernel : Shutdown complete\n");       
278}
279
280// Local Variables: //
281// mode: c //
282// tab-width: 4 //
283// End: //
Note: See TracBrowser for help on using the repository browser.