source: libcfa/src/concurrency/coroutine.cfa

Last change on this file was e84ab3d, checked in by Thierry Delisle <tdelisle@…>, 3 months ago

Step 1 of changing $thread to thread$

  • Property mode set to 100644
File size: 9.5 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// coroutine.c --
8//
9// Author           : Thierry Delisle
10// Created On       : Mon Nov 28 12:27:26 2016
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Tue Dec 15 12:06:04 2020
13// Update Count     : 23
14//
15
16#define __cforall_thread__
17#define _GNU_SOURCE
18
19#include "coroutine.hfa"
20
21#include <stddef.h>
22#include <malloc.h>
23#include <errno.h>
24#include <string.h>
25#include <unistd.h>
26#include <sys/mman.h>                                                                   // mprotect
27#include <unwind.h>
28
29#include "kernel_private.hfa"
30#include "exception.hfa"
31#include "math.hfa"
32
33#define CFA_COROUTINE_USE_MMAP 0
34
35#define __CFA_INVOKE_PRIVATE__
36#include "invoke.h"
37
38extern "C" {
39        void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine$ *) __attribute__ ((__noreturn__));
40        static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) __attribute__ ((__noreturn__));
41        static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) {
42                abort();
43        }
44
45        extern void CtxRet( struct __stack_context_t * to ) asm ("CtxRet") __attribute__ ((__noreturn__));
46}
47
48//-----------------------------------------------------------------------------
49forall(T &)
50void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src) {
51        dst->virtual_table = src->virtual_table;
52        dst->the_coroutine = src->the_coroutine;
53        dst->the_exception = src->the_exception;
54}
55
56forall(T &)
57const char * msg(CoroutineCancelled(T) *) {
58        return "CoroutineCancelled(...)";
59}
60
61// This code should not be inlined. It is the error path on resume.
62forall(T & | is_coroutine(T))
63void __cfaehm_cancelled_coroutine(
64                T & cor, coroutine$ * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ) {
65        verify( desc->cancellation );
66        desc->state = Cancelled;
67        exception_t * except = __cfaehm_cancellation_exception( desc->cancellation );
68
69        // TODO: Remove explitate vtable set once trac#186 is fixed.
70        CoroutineCancelled(T) except;
71        except.virtual_table = &_default_vtable;
72        except.the_coroutine = &cor;
73        except.the_exception = except;
74        // Why does this need a cast?
75        throwResume (CoroutineCancelled(T) &)except;
76
77        except->virtual_table->free( except );
78        free( desc->cancellation );
79        desc->cancellation = 0p;
80}
81
82//-----------------------------------------------------------------------------
83// Global state variables
84
85// minimum feasible stack size in bytes
86static const size_t MinStackSize = 1000;
87extern size_t __page_size;                              // architecture pagesize HACK, should go in proper runtime singleton
88extern int __map_prot;
89
90void __stack_prepare( __stack_info_t * this, size_t create_size );
91void __stack_clean  ( __stack_info_t * this );
92
93//-----------------------------------------------------------------------------
94// Coroutine ctors and dtors
95void ?{}( __stack_info_t & this, void * storage, size_t storageSize ) {
96        this.storage   = (__stack_t *)storage;
97
98        // Did we get a piece of storage ?
99        if (this.storage || storageSize != 0) {
100                // We either got a piece of storage or the user asked for a specific size
101                // Immediately create the stack
102                // (This is slightly unintuitive that non-default sized coroutines create are eagerly created
103                // but it avoids that all coroutines carry an unnecessary size)
104                verify( storageSize != 0 );
105                __stack_prepare( &this, storageSize );
106        }
107}
108
109void ^?{}(__stack_info_t & this) {
110        bool userStack = ((intptr_t)this.storage & 0x1) != 0;
111        if ( ! userStack && this.storage ) {
112                __stack_clean( &this );
113        }
114}
115
116void ?{}( coroutine$ & this, const char name[], void * storage, size_t storageSize ) with( this ) {
117        (this.context){0p, 0p};
118        (this.stack){storage, storageSize};
119        this.name = name;
120        state = Start;
121        starter = 0p;
122        last = 0p;
123        cancellation = 0p;
124}
125
126void ^?{}(coroutine$& this) {
127        if(this.state != Halted && this.state != Start && this.state != Primed) {
128                coroutine$ * src = active_coroutine();
129                coroutine$ * dst = &this;
130
131                struct _Unwind_Exception storage;
132                storage.exception_class = -1;
133                storage.exception_cleanup = _CtxCoroutine_UnwindCleanup;
134                this.cancellation = &storage;
135                this.last = src;
136
137                // not resuming self ?
138                if ( src == dst ) {
139                        abort( "Attempt by coroutine %.256s (%p) to terminate itself.\n", src->name, src );
140                }
141
142                $ctx_switch( src, dst );
143        }
144}
145
146// Part of the Public API
147// Not inline since only ever called once per coroutine
148forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)); })
149void prime(T& cor) {
150        coroutine$* this = get_coroutine(cor);
151        assert(this->state == Start);
152
153        this->state = Primed;
154        resume(cor);
155}
156
157[void *, size_t] __stack_alloc( size_t storageSize ) {
158        const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
159        assert(__page_size != 0l);
160        size_t size = libCeiling( storageSize, 16 ) + stack_data_size;
161        size = ceiling(size, __page_size);
162
163        // If we are running debug, we also need to allocate a guardpage to catch stack overflows.
164        void * storage;
165        #if CFA_COROUTINE_USE_MMAP
166                storage = mmap(0p, size + __page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
167                if(storage == ((void*)-1)) {
168                        abort( "coroutine stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
169                }
170                if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
171                        abort( "coroutine stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
172                } // if
173                storage = (void *)(((intptr_t)storage) + __page_size);
174        #else
175                __cfaabi_dbg_debug_do(
176                        storage = memalign( __page_size, size + __page_size );
177                );
178                __cfaabi_dbg_no_debug_do(
179                        storage = (void*)malloc(size);
180                );
181
182                __cfaabi_dbg_debug_do(
183                        if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
184                                abort( "__stack_alloc : internal error, mprotect failure, error(%d) %s.", (int)errno, strerror( (int)errno ) );
185                        }
186                        storage = (void *)(((intptr_t)storage) + __page_size);
187                );
188        #endif
189        __cfaabi_dbg_print_safe("Kernel : Created stack %p of size %zu\n", storage, size);
190
191        verify( ((intptr_t)storage & (libAlign() - 1)) == 0ul );
192        return [storage, size];
193}
194
195void __stack_clean  ( __stack_info_t * this ) {
196        void * storage = this->storage->limit;
197
198        #if CFA_COROUTINE_USE_MMAP
199                size_t size = ((intptr_t)this->storage->base) - ((intptr_t)this->storage->limit) + sizeof(__stack_t);
200                storage = (void *)(((intptr_t)storage) - __page_size);
201                if(munmap(storage, size + __page_size) == -1) {
202                        abort( "coroutine stack destruction : internal error, munmap failure, error(%d) %s.", errno, strerror( errno ) );
203                }
204        #else
205                __cfaabi_dbg_debug_do(
206                        storage = (char*)(storage) - __page_size;
207                        if ( mprotect( storage, __page_size, __map_prot ) == -1 ) {
208                                abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
209                        }
210                );
211
212                free( storage );
213        #endif
214        __cfaabi_dbg_print_safe("Kernel : Deleting stack %p\n", storage);
215}
216
217void __stack_prepare( __stack_info_t * this, size_t create_size ) {
218        const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
219        bool userStack;
220        void * storage;
221        size_t size;
222        if ( !this->storage ) {
223                userStack = false;
224                [storage, size] = __stack_alloc( create_size );
225        } else {
226                userStack = true;
227                __cfaabi_dbg_print_safe("Kernel : stack obj %p using user stack %p(%zd bytes)\n", this, this->storage, (intptr_t)this->storage->limit - (intptr_t)this->storage->base);
228
229                // The stack must be aligned, advance the pointer to the next align data
230                storage = (void*)libCeiling( (intptr_t)this->storage, libAlign());
231
232                // The size needs to be shrinked to fit all the extra data structure and be aligned
233                ptrdiff_t diff = (intptr_t)storage - (intptr_t)this->storage;
234                size = libFloor(create_size - stack_data_size - diff, libAlign());
235        } // if
236        assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %zd bytes for a stack.", size, MinStackSize );
237
238        this->storage = (__stack_t *)((intptr_t)storage + size - sizeof(__stack_t));
239        this->storage->limit = storage;
240        this->storage->base  = (void*)((intptr_t)storage + size - sizeof(__stack_t));
241        this->storage->exception_context.top_resume = 0p;
242        this->storage->exception_context.current_exception = 0p;
243        __attribute__((may_alias)) intptr_t * istorage = (intptr_t*)&this->storage;
244        *istorage |= userStack ? 0x1 : 0x0;
245}
246
247// We need to call suspend from invoke.c, so we expose this wrapper that
248// is not inline (We can't inline Cforall in C)
249extern "C" {
250        void __cfactx_cor_leave( struct coroutine$ * src ) {
251                coroutine$ * starter = src->cancellation != 0 ? src->last : src->starter;
252
253                src->state = Halted;
254
255                assertf( starter != 0,
256                        "Attempt to suspend/leave coroutine \"%.256s\" (%p) that has never been resumed.\n"
257                        "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
258                        src->name, src );
259                assertf( starter->state != Halted,
260                        "Attempt by coroutine \"%.256s\" (%p) to suspend/leave back to terminated coroutine \"%.256s\" (%p).\n"
261                        "Possible cause is terminated coroutine's main routine has already returned.",
262                        src->name, src, starter->name, starter );
263
264                $ctx_switch( src, starter );
265        }
266
267        struct coroutine$ * __cfactx_cor_finish(void) {
268                struct coroutine$ * cor = active_coroutine();
269
270                // get the active thread once
271                thread$ * athrd = active_thread();
272
273                /* paranoid */ verify( athrd->corctx_flag );
274                athrd->corctx_flag = false;
275
276                if(cor->state == Primed) {
277                        __cfactx_suspend();
278                }
279
280                cor->state = Active;
281
282                return cor;
283        }
284}
285
286// Local Variables: //
287// mode: c //
288// tab-width: 4 //
289// End: //
Note: See TracBrowser for help on using the repository browser.