source: libcfa/src/concurrency/coroutine.hfa @ 5b11c25

arm-ehcleanup-dtorsjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-expr
Last change on this file since 5b11c25 was 5b11c25, checked in by Thierry Delisle <tdelisle@…>, 3 years ago

Added new suspen_then function which runs a callback in the middle of susending

  • Property mode set to 100644
File size: 9.3 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 --
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 18:23:45 2018
13// Update Count     : 8
14//
15
16#pragma once
17
18#include <assert.h>
19#include "invoke.h"
20
21//-----------------------------------------------------------------------------
22// Coroutine trait
23// Anything that implements this trait can be resumed.
24// Anything that is resumed is a coroutine.
25trait is_coroutine(dtype T) {
26      void main(T & this);
27      coroutine_desc * get_coroutine(T & this);
28};
29
30#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
31
32//-----------------------------------------------------------------------------
33// Ctors and dtors
34// void ?{}( coStack_t & this );
35// void ^?{}( coStack_t & this );
36
37void ?{}( coroutine_desc & this, const char * name, void * storage, size_t storageSize );
38void ^?{}( coroutine_desc & this );
39
40static inline void ?{}( coroutine_desc & this)                                       { this{ "Anonymous Coroutine", NULL, 0 }; }
41static inline void ?{}( coroutine_desc & this, size_t stackSize)                     { this{ "Anonymous Coroutine", NULL, stackSize }; }
42static inline void ?{}( coroutine_desc & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
43static inline void ?{}( coroutine_desc & this, const char * name)                    { this{ name, NULL, 0 }; }
44static inline void ?{}( coroutine_desc & this, const char * name, size_t stackSize ) { this{ name, NULL, stackSize }; }
45
46//-----------------------------------------------------------------------------
47// Public coroutine API
48static inline void suspend(void);
49
50forall(dtype T | is_coroutine(T))
51static inline void resume(T & cor);
52
53forall(dtype T | is_coroutine(T))
54void prime(T & cor);
55
56//-----------------------------------------------------------------------------
57// PRIVATE exposed because of inline
58
59// Start coroutine routines
60extern "C" {
61      forall(dtype T | is_coroutine(T))
62      void CtxInvokeCoroutine(T * this);
63
64      forall(dtype T | is_coroutine(T))
65      void CtxStart(T * this, void ( *invoke)(T *));
66
67        extern void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
68
69        extern void CtxSwitch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("CtxSwitch");
70        extern void CtxStore ( struct __stack_context_t * from, __attribute__((noreturn)) void (*__callback)(void) ) asm ("CtxStore");
71        extern void CtxRet   ( struct __stack_context_t * to ) asm ("CtxRet") __attribute__ ((__noreturn__));
72}
73
74// Private wrappers for context switch and stack creation
75// Wrapper for co
76static inline void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
77        // set state of current coroutine to inactive
78        src->state = src->state == Halted ? Halted : Inactive;
79
80        // set new coroutine that task is executing
81        TL_GET( this_thread )->curr_cor = dst;
82
83        // context switch to specified coroutine
84        verify( dst->context.SP );
85        CtxSwitch( &src->context, &dst->context );
86        // when CtxSwitch returns we are back in the src coroutine
87
88        // set state of new coroutine to active
89        src->state = Active;
90
91        if( unlikely(src->cancellation != NULL) ) {
92                _CtxCoroutine_Unwind(src->cancellation, src);
93        }
94}
95
96extern void __stack_prepare   ( __stack_info_t * this, size_t size /* ignored if storage already allocated */);
97
98// Suspend implementation inlined for performance
99static inline void suspend(void) {
100        // optimization : read TLS once and reuse it
101        // Safety note: this is preemption safe since if
102        // preemption occurs after this line, the pointer
103        // will also migrate which means this value will
104        // stay in syn with the TLS
105        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
106
107        assertf( src->last != 0,
108                "Attempt to suspend coroutine \"%.256s\" (%p) that has never been resumed.\n"
109                "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
110                src->name, src );
111        assertf( src->last->state != Halted,
112                "Attempt by coroutine \"%.256s\" (%p) to suspend back to terminated coroutine \"%.256s\" (%p).\n"
113                "Possible cause is terminated coroutine's main routine has already returned.",
114                src->name, src, src->last->name, src->last );
115
116        CoroutineCtxSwitch( src, src->last );
117}
118
119// Resume implementation inlined for performance
120forall(dtype T | is_coroutine(T))
121static inline void resume(T & cor) {
122        // optimization : read TLS once and reuse it
123        // Safety note: this is preemption safe since if
124        // preemption occurs after this line, the pointer
125        // will also migrate which means this value will
126        // stay in syn with the TLS
127        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
128        coroutine_desc * dst = get_coroutine(cor);
129
130        if( unlikely(dst->context.SP == NULL) ) {
131                __stack_prepare(&dst->stack, 65000);
132                CtxStart(&cor, CtxInvokeCoroutine);
133        }
134
135        // not resuming self ?
136        if ( src != dst ) {
137                assertf( dst->state != Halted ,
138                        "Attempt by coroutine %.256s (%p) to resume terminated coroutine %.256s (%p).\n"
139                        "Possible cause is terminated coroutine's main routine has already returned.",
140                        src->name, src, dst->name, dst );
141
142                // set last resumer
143                dst->last = src;
144                dst->starter = dst->starter ? dst->starter : src;
145        }
146
147        // always done for performance testing
148        CoroutineCtxSwitch( src, dst );
149}
150
151static inline void resume(coroutine_desc * dst) {
152        // optimization : read TLS once and reuse it
153        // Safety note: this is preemption safe since if
154        // preemption occurs after this line, the pointer
155        // will also migrate which means this value will
156        // stay in syn with the TLS
157        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
158
159        // not resuming self ?
160        if ( src != dst ) {
161                assertf( dst->state != Halted ,
162                        "Attempt by coroutine %.256s (%p) to resume terminated coroutine %.256s (%p).\n"
163                        "Possible cause is terminated coroutine's main routine has already returned.",
164                        src->name, src, dst->name, dst );
165
166                // set last resumer
167                dst->last = src;
168        }
169
170        // always done for performance testing
171        CoroutineCtxSwitch( src, dst );
172}
173
174static inline void suspend_then(fptr_t call) {
175        // optimization : read TLS once and reuse it
176        // Safety note: this is preemption safe since if
177        // preemption occurs after this line, the pointer
178        // will also migrate which means this value will
179        // stay in syn with the TLS
180        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
181
182        assertf( src->last != 0,
183                "Attempt to suspend coroutine \"%.256s\" (%p) that has never been resumed.\n"
184                "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
185                src->name, src );
186        assertf( src->last->state != Halted,
187                "Attempt by coroutine \"%.256s\" (%p) to suspend back to terminated coroutine \"%.256s\" (%p).\n"
188                "Possible cause is terminated coroutine's main routine has already returned.",
189                src->name, src, src->last->name, src->last );
190
191        src->state = PreInactive;
192
193      // context switch to specified coroutine
194      assert( src->context.SP );
195
196        __attribute__((noreturn)) void __suspend_callback(void) {
197                call();
198
199                // set state of current coroutine to inactive
200                src->state = src->state == Halted ? Halted : Inactive;
201
202                TL_GET( this_thread )->curr_cor = src->last;
203
204                // context switch to specified coroutine
205                assert( src->last->context.SP );
206                CtxRet( &src->last->context );
207
208                abort();
209        }
210      CtxStore( &src->context, __suspend_callback );
211        // when CtxStore returns we are back in the src coroutine
212
213        // set state of new coroutine to active
214        src->state = Active;
215
216        if( unlikely(src->cancellation != NULL) ) {
217                _CtxCoroutine_Unwind(src->cancellation, src);
218        }
219
220        return;
221}
222
223// static inline void suspend_return(void) {
224//      // optimization : read TLS once and reuse it
225//      // Safety note: this is preemption safe since if
226//      // preemption occurs after this line, the pointer
227//      // will also migrate which means this value will
228//      // stay in syn with the TLS
229//      coroutine_desc * src = TL_GET( this_thread )->curr_cor;
230
231//      assertf( src->last != 0,
232//              "Attempt to suspend coroutine \"%.256s\" (%p) that has never been resumed.\n"
233//              "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
234//              src->name, src );
235//      assertf( src->last->state != Halted,
236//              "Attempt by coroutine \"%.256s\" (%p) to suspend back to terminated coroutine \"%.256s\" (%p).\n"
237//              "Possible cause is terminated coroutine's main routine has already returned.",
238//              src->name, src, src->last->name, src->last );
239
240//      // Safety note : Preemption must be disabled here since kernelTLS.this_coroutine must always be up to date
241//       verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate );
242//       disable_interrupts();
243
244//       // set state of current coroutine to inactive
245//       src->state = src->state == Halted ? Halted : Inactive;
246
247//       // set new coroutine that task is executing
248//       kernelTLS.this_coroutine = dst;
249
250//       // context switch to specified coroutine
251//       assert( src->stack.context );
252//      CtxRet( src->stack.context );
253
254//      abort();
255// }
256
257// Local Variables: //
258// mode: c //
259// tab-width: 4 //
260// End: //
Note: See TracBrowser for help on using the repository browser.