source: libcfa/src/concurrency/coroutine.hfa @ b583113

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since b583113 was b583113, checked in by Andrew Beach <ajbeach@…>, 6 months ago

Recovered the polymorphic CoroutineCancelled? exception. The interface might need a bit of polish.

  • 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 --
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 : Tue Feb  4 12:29:26 2020
13// Update Count     : 11
14//
15
16#pragma once
17
18#include <assert.h>
19#include "invoke.h"
20#include "../exception.hfa"
21
22//-----------------------------------------------------------------------------
23// Exception thrown from resume when a coroutine stack is cancelled.
24EHM_FORALL_EXCEPTION(CoroutineCancelled, (coroutine_t &), (coroutine_t)) (
25        coroutine_t * the_coroutine;
26        exception_t * the_exception;
27);
28
29forall(T &)
30void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src);
31
32forall(T &)
33const char * msg(CoroutineCancelled(T) *);
34
35//-----------------------------------------------------------------------------
36// Coroutine trait
37// Anything that implements this trait can be resumed.
38// Anything that is resumed is a coroutine.
39trait is_coroutine(T & | IS_RESUMPTION_EXCEPTION(CoroutineCancelled, (T))) {
40        void main(T & this);
41        $coroutine * get_coroutine(T & this);
42};
43
44#define DECL_COROUTINE(X) static inline $coroutine* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
45
46//-----------------------------------------------------------------------------
47// Ctors and dtors
48// void ?{}( coStack_t & this );
49// void ^?{}( coStack_t & this );
50
51void  ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize );
52void ^?{}( $coroutine & this );
53
54static inline void ?{}( $coroutine & this)                                       { this{ "Anonymous Coroutine", 0p, 0 }; }
55static inline void ?{}( $coroutine & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
56static inline void ?{}( $coroutine & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
57static inline void ?{}( $coroutine & this, const char name[])                    { this{ name, 0p, 0 }; }
58static inline void ?{}( $coroutine & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
59
60//-----------------------------------------------------------------------------
61// Public coroutine API
62forall(T & | is_coroutine(T) | { _EHM_VTABLE_TYPE(CoroutineCancelled)(T) & const _default_vtable; })
63void prime(T & cor);
64
65static inline struct $coroutine * active_coroutine() { return active_thread()->curr_cor; }
66
67//-----------------------------------------------------------------------------
68// PRIVATE exposed because of inline
69
70// Start coroutine routines
71extern "C" {
72        void __cfactx_invoke_coroutine(void (*main)(void *), void * this);
73
74        forall(T &)
75        void __cfactx_start(void (*main)(T &), struct $coroutine * cor, T & this, void (*invoke)(void (*main)(void *), void *));
76
77        extern void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__));
78
79        extern void __cfactx_switch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("__cfactx_switch");
80}
81
82// Private wrappers for context switch and stack creation
83// Wrapper for co
84static inline void $ctx_switch( $coroutine * src, $coroutine * dst ) __attribute__((nonnull (1, 2))) {
85        // set state of current coroutine to inactive
86        src->state = src->state == Halted ? Halted : Blocked;
87
88        // set new coroutine that task is executing
89        active_thread()->curr_cor = dst;
90
91        // context switch to specified coroutine
92        verify( dst->context.SP );
93        __cfactx_switch( &src->context, &dst->context );
94        // when __cfactx_switch returns we are back in the src coroutine
95
96        // set state of new coroutine to active
97        src->state = Active;
98
99        if( unlikely(src->cancellation != 0p) ) {
100                __cfactx_coroutine_unwind(src->cancellation, src);
101        }
102}
103
104extern void __stack_prepare( __stack_info_t * this, size_t size /* ignored if storage already allocated */);
105extern void __stack_clean  ( __stack_info_t * this );
106
107
108// Suspend implementation inlined for performance
109extern "C" {
110        static inline void __cfactx_suspend(void) {
111                // optimization : read TLS once and reuse it
112                // Safety note: this is preemption safe since if
113                // preemption occurs after this line, the pointer
114                // will also migrate which means this value will
115                // stay in syn with the TLS
116                $coroutine * src = active_coroutine();
117
118                assertf( src->last != 0,
119                        "Attempt to suspend coroutine \"%.256s\" (%p) that has never been resumed.\n"
120                        "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
121                        src->name, src );
122                assertf( src->last->state != Halted,
123                        "Attempt by coroutine \"%.256s\" (%p) to suspend back to terminated coroutine \"%.256s\" (%p).\n"
124                        "Possible cause is terminated coroutine's main routine has already returned.",
125                        src->name, src, src->last->name, src->last );
126
127                $ctx_switch( src, src->last );
128        }
129}
130
131forall(T & | is_coroutine(T))
132void __cfaehm_cancelled_coroutine(
133        T & cor, $coroutine * desc, _EHM_VTABLE_TYPE(CoroutineCancelled)(T) & const _default_vtable );
134
135// Resume implementation inlined for performance
136forall(T & | is_coroutine(T) | { _EHM_VTABLE_TYPE(CoroutineCancelled)(T) & const _default_vtable; })
137static inline T & resume(T & cor) {
138        // optimization : read TLS once and reuse it
139        // Safety note: this is preemption safe since if
140        // preemption occurs after this line, the pointer
141        // will also migrate which means this value will
142        // stay in syn with the TLS
143        $coroutine * src = active_coroutine();
144        $coroutine * dst = get_coroutine(cor);
145
146        if( unlikely(dst->context.SP == 0p) ) {
147                __stack_prepare(&dst->stack, 65000);
148                __cfactx_start(main, dst, cor, __cfactx_invoke_coroutine);
149        }
150
151        // not resuming self ?
152        if ( src != dst ) {
153                assertf( dst->state != Halted ,
154                        "Attempt by coroutine %.256s (%p) to resume terminated coroutine %.256s (%p).\n"
155                        "Possible cause is terminated coroutine's main routine has already returned.",
156                        src->name, src, dst->name, dst );
157
158                // set last resumer
159                dst->last = src;
160                dst->starter = dst->starter ? dst->starter : src;
161        }
162
163        // always done for performance testing
164        $ctx_switch( src, dst );
165        if ( unlikely(dst->cancellation) ) {
166                __cfaehm_cancelled_coroutine( cor, dst, _default_vtable );
167        }
168
169        return cor;
170}
171
172static inline void resume( $coroutine * dst ) __attribute__((nonnull (1))) {
173        // optimization : read TLS once and reuse it
174        // Safety note: this is preemption safe since if
175        // preemption occurs after this line, the pointer
176        // will also migrate which means this value will
177        // stay in syn with the TLS
178        $coroutine * src = active_coroutine();
179
180        // not resuming self ?
181        if ( src != dst ) {
182                assertf( dst->state != Halted ,
183                        "Attempt by coroutine %.256s (%p) to resume terminated coroutine %.256s (%p).\n"
184                        "Possible cause is terminated coroutine's main routine has already returned.",
185                        src->name, src, dst->name, dst );
186
187                // set last resumer
188                dst->last = src;
189        }
190
191        // always done for performance testing
192        $ctx_switch( src, dst );
193}
194
195// Local Variables: //
196// mode: c //
197// tab-width: 4 //
198// End: //
Note: See TracBrowser for help on using the repository browser.