source: src/libcfa/concurrency/coroutine.c @ b69ea6b

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

Updated alarm to use bits/cfatime and fixed preemption for coroutines

  • Property mode set to 100644
File size: 5.7 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 : Thu Feb  8 16:10:31 2018
13// Update Count     : 4
14//
15
16#include "coroutine"
17
18extern "C" {
19#include <stddef.h>
20#include <malloc.h>
21#include <errno.h>
22#include <string.h>
23#include <unistd.h>
24#include <sys/mman.h>
25}
26
27#include "kernel_private.h"
28
29#define __CFA_INVOKE_PRIVATE__
30#include "invoke.h"
31
32//-----------------------------------------------------------------------------
33// Global state variables
34
35// minimum feasible stack size in bytes
36#define MinStackSize 1000
37static size_t pageSize = 0;                             // architecture pagesize HACK, should go in proper runtime singleton
38
39//-----------------------------------------------------------------------------
40// Coroutine ctors and dtors
41void ?{}(coStack_t& this) with( this ) {
42        size            = 65000;        // size of stack
43        storage = NULL; // pointer to stack
44        limit           = NULL; // stack grows towards stack limit
45        base            = NULL; // base of stack
46        context = NULL; // address of cfa_context_t
47        top             = NULL; // address of top of storage
48        userStack       = false;
49}
50
51void ?{}(coStack_t& this, size_t size) {
52        this{};
53        this.size = size;
54
55        create_stack(&this, this.size);
56}
57
58void ?{}(coroutine_desc& this) {
59        this{ "Anonymous Coroutine" };
60}
61
62void ?{}(coroutine_desc& this, const char * name) with( this ) {
63        this.name = name;
64        errno_ = 0;
65        state = Start;
66        starter = NULL;
67        last = NULL;
68}
69
70void ?{}(coroutine_desc& this, size_t size) {
71        this{};
72        (this.stack){size};
73}
74
75void ^?{}(coStack_t & this) {
76        if ( ! this.userStack && this.storage ) {
77                __cfaabi_dbg_debug_do(
78                        if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
79                                abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
80                        }
81                );
82                free( this.storage );
83        }
84}
85
86void ^?{}(coroutine_desc& this) {}
87
88// Part of the Public API
89// Not inline since only ever called once per coroutine
90forall(dtype T | is_coroutine(T))
91void prime(T& cor) {
92        coroutine_desc* this = get_coroutine(cor);
93        assert(this->state == Start);
94
95        this->state = Primed;
96        resume(cor);
97}
98
99// Wrapper for co
100void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
101        verify( preemption.enabled || this_processor->do_terminate );
102        disable_interrupts();
103
104        // set state of current coroutine to inactive
105        src->state = src->state == Halted ? Halted : Inactive;
106
107        // set new coroutine that task is executing
108        this_coroutine = dst;
109
110        // context switch to specified coroutine
111        assert( src->stack.context );
112        CtxSwitch( src->stack.context, dst->stack.context );
113        // when CtxSwitch returns we are back in the src coroutine
114
115        // set state of new coroutine to active
116        src->state = Active;
117
118        enable_interrupts( __cfaabi_dbg_ctx );
119        verify( preemption.enabled || this_processor->do_terminate );
120} //ctxSwitchDirect
121
122void create_stack( coStack_t* this, unsigned int storageSize ) with( *this ) {
123        //TEMP HACK do this on proper kernel startup
124        if(pageSize == 0ul) pageSize = sysconf( _SC_PAGESIZE );
125
126        size_t cxtSize = libCeiling( sizeof(machine_context_t), 8 ); // minimum alignment
127
128        if ( (intptr_t)storage == 0 ) {
129                userStack = false;
130                size = libCeiling( storageSize, 16 );
131                // use malloc/memalign because "new" raises an exception for out-of-memory
132
133                // assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment
134                __cfaabi_dbg_debug_do( storage = memalign( pageSize, cxtSize + size + pageSize ) );
135                __cfaabi_dbg_no_debug_do( storage = malloc( cxtSize + size + 8 ) );
136
137                __cfaabi_dbg_debug_do(
138                        if ( mprotect( storage, pageSize, PROT_NONE ) == -1 ) {
139                                abort( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) );
140                        } // if
141                );
142
143                if ( (intptr_t)storage == 0 ) {
144                        abort( "Attempt to allocate %zd bytes of storage for coroutine or task execution-state but insufficient memory available.", size );
145                } // if
146
147                __cfaabi_dbg_debug_do( limit = (char *)storage + pageSize );
148                __cfaabi_dbg_no_debug_do( limit = (char *)libCeiling( (unsigned long)storage, 16 ) ); // minimum alignment
149
150        } else {
151                assertf( ((size_t)storage & (libAlign() - 1)) != 0ul, "Stack storage %p for task/coroutine must be aligned on %d byte boundary.", storage, (int)libAlign() );
152                userStack = true;
153                size = storageSize - cxtSize;
154
155                if ( size % 16 != 0u ) size -= 8;
156
157                limit = (char *)libCeiling( (unsigned long)storage, 16 ); // minimum alignment
158        } // if
159        assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", size, MinStackSize );
160
161        base = (char *)limit + size;
162        context = base;
163        top = (char *)context + cxtSize;
164}
165
166// We need to call suspend from invoke.c, so we expose this wrapper that
167// is not inline (We can't inline Cforall in C)
168extern "C" {
169        void __suspend_internal(void) {
170                suspend();
171        }
172
173        void __leave_coroutine(void) {
174                coroutine_desc * src = this_coroutine;          // optimization
175
176                assertf( src->starter != 0,
177                        "Attempt to suspend/leave coroutine \"%.256s\" (%p) that has never been resumed.\n"
178                        "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
179                        src->name, src );
180                assertf( src->starter->state != Halted,
181                        "Attempt by coroutine \"%.256s\" (%p) to suspend/leave back to terminated coroutine \"%.256s\" (%p).\n"
182                        "Possible cause is terminated coroutine's main routine has already returned.",
183                        src->name, src, src->starter->name, src->starter );
184
185                CoroutineCtxSwitch( src, src->starter );
186        }
187}
188
189// Local Variables: //
190// mode: c //
191// tab-width: 4 //
192// End: //
Note: See TracBrowser for help on using the repository browser.