source: libcfa/src/concurrency/coroutine.cfa @ 147a137

Last change on this file since 147a137 was 147a137, checked in by caparsons <caparson@…>, 7 months ago

added enable/disable ehm with no params for coroutines

  • Property mode set to 100644
File size: 13.6 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 : Mon Sep 18 21:47:12 2023
13// Update Count     : 25
14//
15
16#define __cforall_thread__
17
18#include "coroutine.hfa"
19
20#include <stddef.h>
21#include <malloc.h>
22#include <errno.h>
23#include <string.h>
24#include <unistd.h>
25#include <sys/mman.h>                                                                   // mprotect
26#include <unwind.h>
27
28#include "kernel/private.hfa"
29#include "exception.hfa"
30#include "exception.h"
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) libcfa_public {
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) *) libcfa_public {
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)) ) libcfa_public {
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// helper for popping from coroutine's ehm buffer
83inline nonlocal_exception * pop_ehm_head( coroutine$ * this ) {
84    lock( this->ehm_state.buffer_lock __cfaabi_dbg_ctx2 );
85    nonlocal_exception * nl_ex = pop_head( this->ehm_state.ehm_buffer );
86    unlock( this->ehm_state.buffer_lock );
87    return nl_ex;
88}
89
90//-----------------------------------------------------------------------------
91// Global state variables
92
93// minimum feasible stack size in bytes
94static const size_t MinStackSize = 1000;
95extern size_t __page_size;                              // architecture pagesize HACK, should go in proper runtime singleton
96extern int __map_prot;
97
98void __stack_prepare( __stack_info_t * this, size_t create_size );
99static void __stack_clean  ( __stack_info_t * this );
100
101//-----------------------------------------------------------------------------
102// Coroutine ctors and dtors
103void ?{}( __stack_info_t & this, void * storage, size_t storageSize ) {
104        this.storage   = (__stack_t *)storage;
105
106        // Did we get a piece of storage ?
107        if (this.storage || storageSize != 0) {
108                // We either got a piece of storage or the user asked for a specific size
109                // Immediately create the stack
110                // (This is slightly unintuitive that non-default sized coroutines create are eagerly created
111                // but it avoids that all coroutines carry an unnecessary size)
112                verify( storageSize != 0 );
113                __stack_prepare( &this, storageSize );
114        }
115}
116
117void ^?{}(__stack_info_t & this) {
118        bool userStack = ((intptr_t)this.storage & 0x1) != 0;
119        if ( ! userStack && this.storage ) {
120                __stack_clean( &this );
121        }
122}
123
124void ?{}( coroutine$ & this, const char name[], void * storage, size_t storageSize ) libcfa_public with( this ) {
125        (this.context){0p, 0p};
126        (this.stack){storage, storageSize};
127        this.name = name;
128        state = Start;
129        starter = 0p;
130        last = 0p;
131        cancellation = 0p;
132    ehm_state.ehm_buffer{};
133    ehm_state.buffer_lock{};
134    ehm_state.ehm_enabled = false;
135}
136
137void ^?{}(coroutine$& this) libcfa_public {
138    // handle any leftover pending non-local exceptions
139    nonlocal_exception * nl_ex = pop_ehm_head( &this );
140    unsigned unhandled_ex = 0;
141   
142    // if any leftover exceptions handle
143    while ( nl_ex != 0p ){
144        unhandled_ex++;
145        free( nl_ex->the_exception );
146        free( nl_ex );
147        nl_ex = pop_ehm_head( &this );
148    }
149
150    #ifdef __CFA_DEBUG__
151    if ( unhandled_ex > 0 )
152        printf( "Warning: Coroutine %p exited with %u pending nonlocal exceptions.\n", &this, unhandled_ex );
153    #endif
154
155        if(this.state != Halted && this.state != Start && this.state != Primed) {
156                coroutine$ * src = active_coroutine();
157                coroutine$ * dst = &this;
158
159                struct _Unwind_Exception storage;
160                storage.exception_class = -1;
161                storage.exception_cleanup = _CtxCoroutine_UnwindCleanup;
162                this.cancellation = &storage;
163                this.last = src;
164
165                // not resuming self ?
166                if ( src == dst ) {
167                        abort( "Attempt by coroutine %.256s (%p) to terminate itself.\n", src->name, src );
168                }
169
170                $ctx_switch( src, dst );
171        }
172}
173
174// Part of the Public API
175// Not inline since only ever called once per coroutine
176forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled(T)); })
177void prime(T& cor) libcfa_public {
178        coroutine$* this = get_coroutine(cor);
179        assert(this->state == Start);
180
181        this->state = Primed;
182        resume(cor);
183}
184
185static [void *, size_t] __stack_alloc( size_t storageSize ) {
186        const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
187        assert(__page_size != 0l);
188        size_t size = libCeiling( storageSize, 16 ) + stack_data_size;
189        size = ceiling(size, __page_size);
190
191        // If we are running debug, we also need to allocate a guardpage to catch stack overflows.
192        void * storage;
193        #if CFA_COROUTINE_USE_MMAP
194                storage = mmap(0p, size + __page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
195                if(storage == ((void*)-1)) {
196                        abort( "coroutine stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
197                }
198                if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
199                        abort( "coroutine stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
200                } // if
201                storage = (void *)(((intptr_t)storage) + __page_size);
202        #else
203                __cfaabi_dbg_debug_do(
204                        storage = memalign( __page_size, size + __page_size );
205                );
206                __cfaabi_dbg_no_debug_do(
207                        storage = (void*)malloc(size);
208                );
209
210                __cfaabi_dbg_debug_do(
211                        if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
212                                abort( "__stack_alloc : internal error, mprotect failure, error(%d) %s.", (int)errno, strerror( (int)errno ) );
213                        }
214                        storage = (void *)(((intptr_t)storage) + __page_size);
215                );
216        #endif
217        __cfaabi_dbg_print_safe("Kernel : Created stack %p of size %zu\n", storage, size);
218
219        verify( ((intptr_t)storage & (libAlign() - 1)) == 0ul );
220        return [storage, size];
221}
222
223static void __stack_clean  ( __stack_info_t * this ) {
224        void * storage = this->storage->limit;
225
226        #if CFA_COROUTINE_USE_MMAP
227                size_t size = ((intptr_t)this->storage->base) - ((intptr_t)this->storage->limit) + sizeof(__stack_t);
228                storage = (void *)(((intptr_t)storage) - __page_size);
229                if(munmap(storage, size + __page_size) == -1) {
230                        abort( "coroutine stack destruction : internal error, munmap failure, error(%d) %s.", errno, strerror( errno ) );
231                }
232        #else
233                __cfaabi_dbg_debug_do(
234                        storage = (char*)(storage) - __page_size;
235                        if ( mprotect( storage, __page_size, __map_prot ) == -1 ) {
236                                abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
237                        }
238                );
239
240                free( storage );
241        #endif
242        __cfaabi_dbg_print_safe("Kernel : Deleting stack %p\n", storage);
243}
244
245void __stack_prepare( __stack_info_t * this, size_t create_size ) libcfa_public {
246        const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
247        bool userStack;
248        void * storage;
249        size_t size;
250        if ( !this->storage ) {
251                userStack = false;
252                [storage, size] = __stack_alloc( create_size );
253        } else {
254                userStack = true;
255                __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);
256
257                // The stack must be aligned, advance the pointer to the next align data
258                storage = (void*)libCeiling( (intptr_t)this->storage, libAlign());
259
260                // The size needs to be shrinked to fit all the extra data structure and be aligned
261                ptrdiff_t diff = (intptr_t)storage - (intptr_t)this->storage;
262                size = libFloor(create_size - stack_data_size - diff, libAlign());
263        } // if
264        assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %zd bytes for a stack.", size, MinStackSize );
265
266        this->storage = (__stack_t *)((intptr_t)storage + size - sizeof(__stack_t));
267        this->storage->limit = storage;
268        this->storage->base  = (void*)((intptr_t)storage + size - sizeof(__stack_t));
269        this->storage->exception_context.top_resume = 0p;
270        this->storage->exception_context.current_exception = 0p;
271        __attribute__((may_alias)) intptr_t * istorage = (intptr_t*)&this->storage;
272        *istorage |= userStack ? 0x1 : 0x0;
273}
274
275// We need to call suspend from invoke.c, so we expose this wrapper that
276// is not inline (We can't inline Cforall in C)
277extern "C" {
278        void __cfactx_cor_leave( struct coroutine$ * src ) {
279                coroutine$ * starter = src->cancellation != 0 ? src->last : src->starter;
280
281                src->state = Halted;
282
283                assertf( starter != 0,
284                        "Attempt to suspend/leave coroutine \"%.256s\" (%p) that has never been resumed.\n"
285                        "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
286                        src->name, src );
287                assertf( starter->state != Halted,
288                        "Attempt by coroutine \"%.256s\" (%p) to suspend/leave back to terminated coroutine \"%.256s\" (%p).\n"
289                        "Possible cause is terminated coroutine's main routine has already returned.",
290                        src->name, src, starter->name, starter );
291
292                $ctx_switch( src, starter );
293        }
294
295        struct coroutine$ * __cfactx_cor_finish(void) {
296                struct coroutine$ * cor = active_coroutine();
297
298                // get the active thread once
299                thread$ * athrd = active_thread();
300
301                /* paranoid */ verify( athrd->corctx_flag );
302                athrd->corctx_flag = false;
303
304                if(cor->state == Primed) {
305                        __cfactx_suspend();
306                }
307
308                cor->state = Active;
309
310                return cor;
311        }
312}
313
314
315////////////////////////////////////////////////////////////////////////////////////////////////////
316// non local ehm routines
317
318void defaultResumeAtHandler( exception_t * except ) {
319    __cfaehm_allocate_exception( except );
320    free( except );
321    __cfaehm_begin_unwind( (void(*)(exception_t *))defaultTerminationHandler );
322}
323
324bool poll( coroutine$ * cor ) libcfa_public {
325    nonlocal_exception * nl_ex = pop_ehm_head( cor );
326
327    // if no exceptions return false
328    if ( nl_ex == 0p ) return false;
329   
330    // otherwise loop and throwResume all pending exceptions
331    while ( nl_ex != 0p ){
332        exception_t * ex = nl_ex->the_exception;
333        free( nl_ex );
334        __cfaehm_throw_resume( ex, defaultResumeAtHandler );
335       
336        // only reached if resumption handled. other dealloc handled in defaultResumeAtHandler
337        free( ex );
338        nl_ex = pop_ehm_head( cor );
339    }
340   
341    return true;
342}
343
344bool poll() libcfa_public { return poll( active_coroutine() ); }
345void enable_ehm() libcfa_public { active_coroutine()->ehm_state.ehm_enabled = true; }
346void disable_ehm() libcfa_public { active_coroutine()->ehm_state.ehm_enabled = false; }
347bool checked_poll() libcfa_public { return active_coroutine()->ehm_state.ehm_enabled ? poll( active_coroutine() ) : false; }
348coroutine$ * resumer() libcfa_public { return active_coroutine()->last; }
349coroutine$ * first_resumer() libcfa_public { return active_coroutine()->starter; }
350
351// user facing ehm operations
352forall(T & | is_coroutine(T)) {
353    // enable/disable non-local exceptions
354    void enable_ehm( T & cor ) libcfa_public { get_coroutine( cor )->ehm_state.ehm_enabled = true; }
355    void disable_ehm( T & cor ) libcfa_public { get_coroutine( cor )->ehm_state.ehm_enabled = false; }
356
357    // poll for non-local exceptions
358    bool poll( T & cor ) libcfa_public { return poll( get_coroutine( cor ) ); }
359
360    // poll iff nonlocal ehm is enabled
361    bool checked_poll( T & cor ) libcfa_public { return get_coroutine( cor )->ehm_state.ehm_enabled ? poll( cor ) : false; }
362
363    coroutine$ * resumer( T & cor ) libcfa_public { return get_coroutine( cor )->last; }
364    coroutine$ * first_resumer( T & cor ) libcfa_public { return get_coroutine( cor )->starter; }
365}
366
367// resume non local exception at receiver (i.e. enqueue in ehm buffer)
368forall(exceptT *, T & | ehm_resume_at( exceptT, T ))
369void resumeAt( T & receiver, exceptT & ex ) libcfa_public {
370    coroutine$ * cor = get_coroutine( receiver );
371    nonlocal_exception * nl_ex = alloc();
372    exceptT * ex_copy = alloc();
373    memcpy( ex_copy, &ex, sizeof(exceptT) );
374    (*nl_ex){ (exception_t *)ex_copy };
375    lock( cor->ehm_state.buffer_lock __cfaabi_dbg_ctx2 );
376    append( cor->ehm_state.ehm_buffer, nl_ex );
377    unlock( cor->ehm_state.buffer_lock );
378}
379
380forall(exceptT * | { void $throwResume(exceptT &); })
381void resumeAt( coroutine$ * receiver, exceptT & ex ) libcfa_public {
382    nonlocal_exception * nl_ex = alloc();
383    exceptT * ex_copy = alloc();
384    memcpy( ex_copy, &ex, sizeof(exceptT) );
385    (*nl_ex){ (exception_t *)ex_copy };
386    lock( receiver->ehm_state.buffer_lock __cfaabi_dbg_ctx2 );
387    append( receiver->ehm_state.ehm_buffer, nl_ex );
388    unlock( receiver->ehm_state.buffer_lock );
389}
390
391// Local Variables: //
392// mode: c //
393// tab-width: 4 //
394// End: //
Note: See TracBrowser for help on using the repository browser.