source: libcfa/src/concurrency/coroutine.cfa @ f23b685

aaron-thesisarm-ehcleanup-dtorsdeferred_resnjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprno_listpersistent-indexer
Last change on this file since f23b685 was f23b685, checked in by Thierry Delisle <tdelisle@…>, 3 years ago

added some comments and moved a line to ease coroutine cancellation

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