source: libcfa/src/concurrency/coroutine.cfa @ 920dca3

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum
Last change on this file since 920dca3 was ada0246d, checked in by Peter A. Buhr <pabuhr@…>, 4 years ago

create heap.hfa, use it in malloc.h, and cleanup includes with respect to extern "C"

  • Property mode set to 100644
File size: 7.1 KB
RevLine 
[6a3d2e7]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//
[75a17f1]7// coroutine.c --
[6a3d2e7]8//
9// Author           : Thierry Delisle
10// Created On       : Mon Nov 28 12:27:26 2016
[6b0b624]11// Last Modified By : Peter A. Buhr
[ada0246d]12// Last Modified On : Tue May 26 22:06:09 2020
13// Update Count     : 21
[6a3d2e7]14//
15
[2026bb6]16#define __cforall_thread__
17
[58b6d1b]18#include "coroutine.hfa"
[bd98b58]19
[6a3d2e7]20#include <stddef.h>
21#include <malloc.h>
22#include <errno.h>
23#include <string.h>
24#include <unistd.h>
[ada0246d]25#include <sys/mman.h>                                                                   // mprotect
26extern "C" {
27// use this define to make unwind.h play nice, definitely a hack
[76e069f]28#define HIDE_EXPORTS
29#include <unwind.h>
30#undef HIDE_EXPORTS
[6a3d2e7]31}
32
[73abe95]33#include "kernel_private.hfa"
[6a3d2e7]34
35#define __CFA_INVOKE_PRIVATE__
36#include "invoke.h"
37
[76e069f]38extern "C" {
[ac2b598]39        void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__));
[b2f6113]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        }
[f019069]44
45        extern void CtxRet( struct __stack_context_t * to ) asm ("CtxRet") __attribute__ ((__noreturn__));
[76e069f]46}
47
[6a3d2e7]48//-----------------------------------------------------------------------------
49// Global state variables
50
51// minimum feasible stack size in bytes
52#define MinStackSize 1000
[b2f6113]53extern size_t __page_size;                              // architecture pagesize HACK, should go in proper runtime singleton
54
55void __stack_prepare( __stack_info_t * this, size_t create_size );
[6a3d2e7]56
57//-----------------------------------------------------------------------------
58// Coroutine ctors and dtors
[b2f6113]59void ?{}( __stack_info_t & this, void * storage, size_t storageSize ) {
60        this.storage   = (__stack_t *)storage;
61
62        // Did we get a piece of storage ?
63        if (this.storage || storageSize != 0) {
64                // We either got a piece of storage or the user asked for a specific size
65                // Immediately create the stack
66                // (This is slightly unintuitive that non-default sized coroutines create are eagerly created
67                // but it avoids that all coroutines carry an unnecessary size)
68                verify( storageSize != 0 );
69                __stack_prepare( &this, storageSize );
70        }
[6a3d2e7]71}
72
[b2f6113]73void ^?{}(__stack_info_t & this) {
[8c01e1b]74        bool userStack = ((intptr_t)this.storage & 0x1) != 0;
75        if ( ! userStack && this.storage ) {
[ffe2fad]76                __attribute__((may_alias)) intptr_t * istorage = (intptr_t *)&this.storage;
77                *istorage &= (intptr_t)-1;
78
[8c01e1b]79                void * storage = this.storage->limit;
[b2f6113]80                __cfaabi_dbg_debug_do(
81                        storage = (char*)(storage) - __page_size;
82                        if ( mprotect( storage, __page_size, PROT_READ | PROT_WRITE ) == -1 ) {
83                                abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
84                        }
85                );
86                __cfaabi_dbg_print_safe("Kernel : Deleting stack %p\n", storage);
87                free( storage );
88        }
[6a3d2e7]89}
90
[ac2b598]91void ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize ) with( this ) {
[524627e]92        (this.context){0p, 0p};
[b2f6113]93        (this.stack){storage, storageSize};
94        this.name = name;
95        state = Start;
[524627e]96        starter = 0p;
97        last = 0p;
98        cancellation = 0p;
[6a3d2e7]99}
100
[ac2b598]101void ^?{}($coroutine& this) {
[3623f9d]102        if(this.state != Halted && this.state != Start && this.state != Primed) {
[ac2b598]103                $coroutine * src = TL_GET( this_thread )->curr_cor;
104                $coroutine * dst = &this;
[b2f6113]105
106                struct _Unwind_Exception storage;
107                storage.exception_class = -1;
108                storage.exception_cleanup = _CtxCoroutine_UnwindCleanup;
109                this.cancellation = &storage;
110                this.last = src;
111
112                // not resuming self ?
113                if ( src == dst ) {
114                        abort( "Attempt by coroutine %.256s (%p) to terminate itself.\n", src->name, src );
115                }
116
[ac2b598]117                $ctx_switch( src, dst );
[b2f6113]118        }
[76e069f]119}
[6a3d2e7]120
121// Part of the Public API
122// Not inline since only ever called once per coroutine
123forall(dtype T | is_coroutine(T))
[83a071f9]124void prime(T& cor) {
[ac2b598]125        $coroutine* this = get_coroutine(cor);
[b2f6113]126        assert(this->state == Start);
[6a3d2e7]127
[b2f6113]128        this->state = Primed;
129        resume(cor);
[6a3d2e7]130}
131
[b2f6113]132[void *, size_t] __stack_alloc( size_t storageSize ) {
[0030ada3]133        const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
[b2f6113]134        assert(__page_size != 0l);
135        size_t size = libCeiling( storageSize, 16 ) + stack_data_size;
136
137        // If we are running debug, we also need to allocate a guardpage to catch stack overflows.
138        void * storage;
139        __cfaabi_dbg_debug_do(
140                storage = memalign( __page_size, size + __page_size );
141        );
142        __cfaabi_dbg_no_debug_do(
143                storage = (void*)malloc(size);
144        );
145
146        __cfaabi_dbg_print_safe("Kernel : Created stack %p of size %zu\n", storage, size);
147        __cfaabi_dbg_debug_do(
148                if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
149                        abort( "__stack_alloc : internal error, mprotect failure, error(%d) %s.", (int)errno, strerror( (int)errno ) );
150                }
151                storage = (void *)(((intptr_t)storage) + __page_size);
152        );
153
154        verify( ((intptr_t)storage & (libAlign() - 1)) == 0ul );
155        return [storage, size];
156}
[6a3d2e7]157
[b2f6113]158void __stack_prepare( __stack_info_t * this, size_t create_size ) {
[0030ada3]159        const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
[b2f6113]160        bool userStack;
161        void * storage;
162        size_t size;
163        if ( !this->storage ) {
164                userStack = false;
165                [storage, size] = __stack_alloc( create_size );
166        } else {
167                userStack = true;
[69a61d2]168                __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);
[b2f6113]169
170                // The stack must be aligned, advance the pointer to the next align data
171                storage = (void*)libCeiling( (intptr_t)this->storage, libAlign());
172
173                // The size needs to be shrinked to fit all the extra data structure and be aligned
174                ptrdiff_t diff = (intptr_t)storage - (intptr_t)this->storage;
175                size = libFloor(create_size - stack_data_size - diff, libAlign());
176        } // if
177        assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", size, MinStackSize );
178
179        this->storage = (__stack_t *)((intptr_t)storage + size);
180        this->storage->limit = storage;
181        this->storage->base  = (void*)((intptr_t)storage + size);
[ffe2fad]182        __attribute__((may_alias)) intptr_t * istorage = (intptr_t*)&this->storage;
183        *istorage |= userStack ? 0x1 : 0x0;
[6a3d2e7]184}
185
[0c92c9f]186// We need to call suspend from invoke.c, so we expose this wrapper that
187// is not inline (We can't inline Cforall in C)
188extern "C" {
[ac2b598]189        void __cfactx_cor_leave( struct $coroutine * src ) {
190                $coroutine * starter = src->cancellation != 0 ? src->last : src->starter;
[b2f6113]191
192                src->state = Halted;
193
194                assertf( starter != 0,
195                        "Attempt to suspend/leave coroutine \"%.256s\" (%p) that has never been resumed.\n"
196                        "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
197                        src->name, src );
198                assertf( starter->state != Halted,
199                        "Attempt by coroutine \"%.256s\" (%p) to suspend/leave back to terminated coroutine \"%.256s\" (%p).\n"
200                        "Possible cause is terminated coroutine's main routine has already returned.",
201                        src->name, src, starter->name, starter );
202
[ac2b598]203                $ctx_switch( src, starter );
[b2f6113]204        }
[09f357ec]205
[ac2b598]206        struct $coroutine * __cfactx_cor_finish(void) {
207                struct $coroutine * cor = kernelTLS.this_thread->curr_cor;
[09f357ec]208
209                if(cor->state == Primed) {
[427854b]210                        __cfactx_suspend();
[09f357ec]211                }
212
213                cor->state = Active;
214
215                return cor;
216        }
[0c92c9f]217}
218
[6a3d2e7]219// Local Variables: //
220// mode: c //
221// tab-width: 4 //
[4aa2fb2]222// End: //
Note: See TracBrowser for help on using the repository browser.