Changeset 1c01c58

Timestamp:

Sep 9, 2020, 5:03:40 PM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

b9fa85b, c402739

Parents:

2b7f6f0

Message:

Rather large commit to get coroutine cancellation working.

This includes what you would expect, like new code in exceptions and a new
test, but it also includes a bunch of other things.

New coroutine state, currently just marks that the stack was cancelled. New
helpers for checking code structure and generating vtables. Changes to the
coroutine interface so resume may throw exceptions on cancellation, plus the
exception type that is thrown. Changes to the coroutine keyword generation to
generate exception code for each type of coroutine.

Files:

• libcfa/src/concurrency/coroutine.cfa (modified) (2 diffs)
• libcfa/src/concurrency/coroutine.hfa (modified) (4 diffs)
• libcfa/src/concurrency/exception.cfa (modified) (1 diff)
• libcfa/src/concurrency/exception.hfa (modified) (2 diffs)
• libcfa/src/concurrency/invoke.h (modified) (1 diff)
• libcfa/src/exception.h (modified) (3 diffs)
• libcfa/src/exception.hfa (modified) (2 diffs)
• src/Common/Examine.cc (added)
• src/Common/Examine.h (added)
• src/Common/module.mk (modified) (1 diff)
• src/Concurrency/Keywords.cc (modified) (16 diffs)
• src/Virtual/Tables.cc (added)
• src/Virtual/Tables.h (added)
• src/Virtual/module.mk (modified) (1 diff)
• tests/exceptions/cancel/.expect/coroutine.txt (added)
• tests/exceptions/cancel/coroutine.cfa (added)

libcfa/src/concurrency/coroutine.cfa

@@ -47 +47 @@
 
 //-----------------------------------------------------------------------------
+FORALL_DATA_INSTANCE(CoroutineCancelled,
+                (dtype coroutine_t | sized(coroutine_t)), (coroutine_t))
+
+struct __cfaehm_node {
+        struct _Unwind_Exception unwind_exception;
+        struct __cfaehm_node * next;
+        int handler_index;
+};
+
+forall(dtype T)
+void mark_exception(CoroutineCancelled(T) *) {}
+
+forall(dtype T | sized(T))
+void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src) {
+        dst->the_coroutine = src->the_coroutine;
+        dst->the_exception = src->the_exception;
+}
+
+forall(dtype T)
+const char * msg(CoroutineCancelled(T) *) {
+        return "CoroutineCancelled(...)";
+}
+
+// This code should not be inlined. It is the error path on resume.
+forall(dtype T | is_coroutine(T))
+void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc ) {
+        verify( desc->cancellation );
+        desc->state = Cancelled;
+        exception_t * except = (exception_t *)(1 + (__cfaehm_node *)desc->cancellation);
+
+        CoroutineCancelled(T) except;
+        except.the_coroutine = &cor;
+        except.the_exception = except;
+        throwResume except;
+
+        except->virtual_table->free( except );
+        free( desc->cancellation );
+        desc->cancellation = 0p;
+}
+
+//-----------------------------------------------------------------------------
 // Global state variables
 
@@ -180 +221 @@
         this->storage->limit = storage;
         this->storage->base  = (void*)((intptr_t)storage + size);
+        this->storage->exception_context.top_resume = 0p;
+        this->storage->exception_context.current_exception = 0p;
         __attribute__((may_alias)) intptr_t * istorage = (intptr_t*)&this->storage;
         *istorage |= userStack ? 0x1 : 0x0;

libcfa/src/concurrency/coroutine.hfa

@@ -18 +18 @@
 #include <assert.h>
 #include "invoke.h"
+#include "../exception.hfa"
+
+//-----------------------------------------------------------------------------
+// Exception thrown from resume when a coroutine stack is cancelled.
+// Should not have to be be sized (see trac #196).
+FORALL_DATA_EXCEPTION(CoroutineCancelled,
+                (dtype coroutine_t | sized(coroutine_t)), (coroutine_t)) (
+        coroutine_t * the_coroutine;
+        exception_t * the_exception;
+);
+
+forall(dtype T)
+void mark_exception(CoroutineCancelled(T) *);
+
+forall(dtype T | sized(T))
+void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src);
+
+forall(dtype T)
+const char * msg(CoroutineCancelled(T) *);
 
 //-----------------------------------------------------------------------------
@@ -23 +42 @@
 // Anything that implements this trait can be resumed.
 // Anything that is resumed is a coroutine.
-trait is_coroutine(dtype T) {
-      void main(T & this);
-      $coroutine * get_coroutine(T & this);
+trait is_coroutine(dtype T | sized(T)
+                | is_resumption_exception(CoroutineCancelled(T))
+                | VTABLE_ASSERTION(CoroutineCancelled, (T))) {
+        void main(T & this);
+        $coroutine * get_coroutine(T & this);
 };
 
@@ -112 +133 @@
         }
 }
+
+forall(dtype T | is_coroutine(T))
+void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc );
 
 // Resume implementation inlined for performance
@@ -145 +169 @@
         // always done for performance testing
         $ctx_switch( src, dst );
+        if ( unlikely(dst->cancellation) ) {
+                __cfaehm_cancelled_coroutine( cor, dst );
+        }
 
         return cor;

libcfa/src/concurrency/exception.cfa

@@ -57 +57 @@
 
 STOP_AT_END_FUNCTION(coroutine_cancelstop,
-        // TODO: Instead pass information to the last resumer.
+        struct $coroutine * src = ($coroutine *)stop_param;
+        struct $coroutine * dst = src->last;
+
+        $ctx_switch( src, dst );
         abort();
 )

libcfa/src/concurrency/exception.hfa

@@ -18 +18 @@
 #include "bits/defs.hfa"
 #include "invoke.h"
-struct _Unwind_Exception;
-
-// It must also be usable as a C header file.
 
 #ifdef __cforall
 extern "C" {
+
+#define HIDE_EXPORTS
 #endif
+#include "unwind.h"
 
 struct exception_context_t * this_exception_context(void) OPTIONAL_THREAD;
@@ -32 +32 @@
 
 #ifdef __cforall
+#undef HIDE_EXPORTS
 }
 #endif

libcfa/src/concurrency/invoke.h

@@ -68 +68 @@
         };
 
-        enum __Coroutine_State { Halted, Start, Primed, Blocked, Ready, Active };
+        enum __Coroutine_State { Halted, Start, Primed, Blocked, Ready, Active, Cancelled };
 
         struct $coroutine {

libcfa/src/exception.h

@@ -76 +76 @@
 // implemented in the .c file either so they all have to be inline.
 
-trait is_exception(dtype T) {
+trait is_exception(dtype exceptT) {
         /* The first field must be a pointer to a virtual table.
          * That virtual table must be a decendent of the base exception virtual tab$
          */
-        void mark_exception(T *);
+        void mark_exception(exceptT *);
         // This is never used and should be a no-op.
 };
 
-trait is_termination_exception(dtype T | is_exception(T)) {
-        void defaultTerminationHandler(T &);
+trait is_termination_exception(dtype exceptT | is_exception(exceptT)) {
+        void defaultTerminationHandler(exceptT &);
 };
 
-trait is_resumption_exception(dtype T | is_exception(T)) {
-        void defaultResumptionHandler(T &);
+trait is_resumption_exception(dtype exceptT | is_exception(exceptT)) {
+        void defaultResumptionHandler(exceptT &);
 };
 
-forall(dtype T | is_termination_exception(T))
-static inline void $throw(T & except) {
+forall(dtype exceptT | is_termination_exception(exceptT))
+static inline void $throw(exceptT & except) {
         __cfaehm_throw_terminate(
                 (exception_t *)&except,
@@ -100 +100 @@
 }
 
-forall(dtype T | is_resumption_exception(T))
-static inline void $throwResume(T & except) {
+forall(dtype exceptT | is_resumption_exception(exceptT))
+static inline void $throwResume(exceptT & except) {
         __cfaehm_throw_resume(
                 (exception_t *)&except,
@@ -108 +108 @@
 }
 
-forall(dtype T | is_exception(T))
-static inline void cancel_stack(T & except) __attribute__((noreturn)) {
+forall(dtype exceptT | is_exception(exceptT))
+static inline void cancel_stack(exceptT & except) __attribute__((noreturn)) {
         __cfaehm_cancel_stack( (exception_t *)&except );
 }
 
-forall(dtype T | is_exception(T))
-static inline void defaultTerminationHandler(T & except) {
+forall(dtype exceptT | is_exception(exceptT))
+static inline void defaultTerminationHandler(exceptT & except) {
         return cancel_stack( except );
 }
 
-forall(dtype T | is_exception(T))
-static inline void defaultResumptionHandler(T & except) {
+forall(dtype exceptT | is_exception(exceptT))
+static inline void defaultResumptionHandler(exceptT & except) {
         throw except;
 }

libcfa/src/exception.hfa

@@ -192 +192 @@
                 size_t size; \
                 void (*copy)(exception_name * this, exception_name * other); \
-                void (*free)(exception_name & this); \
+                void (*^?{})(exception_name & this); \
                 const char * (*msg)(exception_name * this); \
                 _CLOSE
@@ -213 +213 @@
                 size_t size; \
                 void (*copy)(exception_name parameters * this, exception_name parameters * other); \
-                void (*free)(exception_name parameters & this); \
+                void (*^?{})(exception_name parameters & this); \
                 const char * (*msg)(exception_name parameters * this); \
                 _CLOSE

src/Common/module.mk

@@ -22 +22 @@
       Common/ErrorObjects.h \
       Common/Eval.cc \
+      Common/Examine.cc \
+      Common/Examine.h \
       Common/FilterCombos.h \
       Common/Indenter.h \

src/Concurrency/Keywords.cc

@@ -19 +19 @@
 #include <string>                         // for string, operator==
 
+#include <iostream>
+
+#include "Common/Examine.h"               // for isMainFor
 #include "Common/PassVisitor.h"           // for PassVisitor
 #include "Common/SemanticError.h"         // for SemanticError
@@ -34 +37 @@
 #include "SynTree/Type.h"                 // for StructInstType, Type, PointerType
 #include "SynTree/Visitor.h"              // for Visitor, acceptAll
+#include "Virtual/Tables.h"
 
 class Attribute;
 
 namespace Concurrency {
+        inline static std::string getVTableName( std::string const & exception_name ) {
+                return exception_name.empty() ? std::string() : Virtual::vtableTypeName(exception_name);
+        }
+
         //=============================================================================================
         // Pass declarations
@@ -54 +62 @@
           public:
 
-                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main, AggregateDecl::Aggregate cast_target ) :
-                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ), cast_target( cast_target ) {}
+                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name,
+                        std::string&& getter_name, std::string&& context_error, std::string&& exception_name,
+                        bool needs_main, AggregateDecl::Aggregate cast_target ) :
+                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ),
+                  context_error( context_error ), vtable_name( getVTableName( exception_name ) ),
+                  needs_main( needs_main ), cast_target( cast_target ) {}
 
                 virtual ~ConcurrentSueKeyword() {}
@@ -63 +75 @@
 
                 void handle( StructDecl * );
+                void addVtableForward( StructDecl * );
                 FunctionDecl * forwardDeclare( StructDecl * );
                 ObjectDecl * addField( StructDecl * );
@@ -76 +89 @@
                 const std::string getter_name;
                 const std::string context_error;
+                const std::string vtable_name;
                 bool needs_main;
                 AggregateDecl::Aggregate cast_target;
@@ -81 +95 @@
                 StructDecl   * type_decl = nullptr;
                 FunctionDecl * dtor_decl = nullptr;
+                StructDecl * vtable_decl = nullptr;
         };
 
@@ -101 +116 @@
                         "get_thread",
                         "thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
+                        "",
                         true,
                         AggregateDecl::Thread
@@ -133 +149 @@
                         "get_coroutine",
                         "coroutine keyword requires coroutines to be in scope, add #include <coroutine.hfa>\n",
+                        "CoroutineCancelled",
                         true,
                         AggregateDecl::Coroutine
@@ -167 +184 @@
                         "get_monitor",
                         "monitor keyword requires monitors to be in scope, add #include <monitor.hfa>\n",
+                        "",
                         false,
                         AggregateDecl::Monitor
@@ -198 +216 @@
                         "get_generator",
                         "Unable to find builtin type $generator\n",
+                        "",
                         true,
                         AggregateDecl::Generator
@@ -231 +250 @@
 
         private:
-                DeclarationWithType * is_main( FunctionDecl * );
                 bool is_real_suspend( FunctionDecl * );
 
@@ -359 +377 @@
                         handle( decl );
                 }
+                else if ( !vtable_decl && vtable_name == decl->name && decl->body ) {
+                        vtable_decl = decl;
+                }
+                // Might be able to get ride of is target.
+                assert( is_target(decl) == (cast_target == decl->kind) );
                 return decl;
         }
 
         DeclarationWithType * ConcurrentSueKeyword::postmutate( FunctionDecl * decl ) {
-                if( !type_decl ) return decl;
-                if( !CodeGen::isDestructor( decl->name ) ) return decl;
-
-                auto params = decl->type->parameters;
-                if( params.size() != 1 ) return decl;
-
-                auto type = dynamic_cast<ReferenceType*>( params.front()->get_type() );
-                if( !type ) return decl;
-
-                auto stype = dynamic_cast<StructInstType*>( type->base );
-                if( !stype ) return decl;
-                if( stype->baseStruct != type_decl ) return decl;
-
-                if( !dtor_decl ) dtor_decl = decl;
+                if ( type_decl && isDestructorFor( decl, type_decl ) )
+                        dtor_decl = decl;
+                else if ( vtable_name.empty() )
+                        ;
+                else if ( auto param = isMainFor( decl, cast_target ) ) {
+                        // This should never trigger.
+                        assert( vtable_decl );
+                        // Should be safe because of isMainFor.
+                        StructInstType * struct_type = static_cast<StructInstType *>(
+                                static_cast<ReferenceType *>( param->get_type() )->base );
+                        assert( struct_type );
+
+                        declsToAddAfter.push_back( Virtual::makeVtableInstance( vtable_decl, {
+                                new TypeExpr( struct_type->clone() ),
+                        }, struct_type, nullptr ) );
+                }
+
                 return decl;
         }
@@ -400 +426 @@
                 if( !dtor_decl ) SemanticError( decl, context_error );
 
+                addVtableForward( decl );
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
                 addRoutines( field, func );
+        }
+
+        void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
+                if ( vtable_decl ) {
+                        declsToAddBefore.push_back( Virtual::makeVtableForward( vtable_decl, {
+                                new TypeExpr( new StructInstType( noQualifiers, decl ) ),
+                        } ) );
+                // Its only an error if we want a vtable and don't have one.
+                } else if ( ! vtable_name.empty() ) {
+                        SemanticError( decl, context_error );
+                }
         }
 
@@ -528 +566 @@
         // Suspend keyword implementation
         //=============================================================================================
-        DeclarationWithType * SuspendKeyword::is_main( FunctionDecl * func) {
-                if(func->name != "main") return nullptr;
-                if(func->type->parameters.size() != 1) return nullptr;
-
-                auto param = func->type->parameters.front();
-
-                auto type  = dynamic_cast<ReferenceType * >(param->get_type());
-                if(!type) return nullptr;
-
-                auto obj   = dynamic_cast<StructInstType *>(type->base);
-                if(!obj) return nullptr;
-
-                if(!obj->baseStruct->is_generator()) return nullptr;
-
-                return param;
-        }
-
         bool SuspendKeyword::is_real_suspend( FunctionDecl * func ) {
                 if(isMangled(func->linkage)) return false; // the real suspend isn't mangled
@@ -565 +586 @@
 
                 // Is this the main of a generator?
-                auto param = is_main( func );
+                auto param = isMainFor( func, AggregateDecl::Aggregate::Generator );
                 if(!param) return;
 
@@ -1033 +1054 @@
 // tab-width: 4 //
 // End: //
+

src/Virtual/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += Virtual/ExpandCasts.cc Virtual/ExpandCasts.h
+SRC += Virtual/ExpandCasts.cc Virtual/ExpandCasts.h \
+        Virtual/Tables.cc Virtual/Tables.h
+
+SRCDEMANGLE += Virtual/Tables.cc