Changes in / [dbae916:c19ca4b]

Files:

• doc/theses/colby_parsons_MMAth/benchmarks/actors/plotData.py (modified) (1 diff)
• libcfa/src/Makefile.am (modified) (2 diffs)
• libcfa/src/concurrency/actor.hfa (modified) (7 diffs)
• libcfa/src/virtual_dtor.hfa (deleted)
• src/Concurrency/Actors.cpp (modified) (10 diffs)
• src/Concurrency/Actors.hpp (modified) (1 diff)
• src/Virtual/VirtualDtor.cpp (deleted)
• src/Virtual/VirtualDtor.hpp (deleted)
• src/Virtual/module.mk (modified) (1 diff)
• src/main.cc (modified) (2 diffs)
• tests/concurrent/actors/.expect/inherit.txt (deleted)
• tests/concurrent/actors/executor.cfa (modified) (1 diff)
• tests/concurrent/actors/inherit.cfa (deleted)
• tests/concurrent/actors/poison.cfa (modified) (2 diffs)

doc/theses/colby_parsons_MMAth/benchmarks/actors/plotData.py

@@ -169 +169 @@
                     else:
                         plt.ylim(0, None)
-                    plt.xticks(procs)
                     ax.legend(names)
                     # fig.savefig("plots/" + machineName + name + ".png")

libcfa/src/Makefile.am

@@ -48 +48 @@
         math.hfa \
         time_t.hfa \
-    virtual_dtor.hfa \
         bits/algorithm.hfa \
         bits/align.hfa \
@@ -69 +68 @@
         vec/vec2.hfa \
         vec/vec3.hfa \
-        vec/vec4.hfa 
+        vec/vec4.hfa
 
 inst_headers_src = \

libcfa/src/concurrency/actor.hfa

@@ -5 +5 @@
 #include <kernel.hfa>
 #include <iofwd.hfa>
-#include <virtual_dtor.hfa>
 
 #ifdef __CFA_DEBUG__
@@ -358 +357 @@
     if ( seperate_clus ) delete( cluster );
 
-    #ifdef STATS // print formatted stats
+    #ifdef STATS
     printf("    Actor System Stats:\n");
     printf("\tActors Created:\t\t\t\t%lu\n\tMessages Sent:\t\t\t\t%lu\n", __num_actors_stats, __all_processed);
@@ -389 +388 @@
 static executor * __actor_executor_ = 0p;
 static bool __actor_executor_passed = false;            // was an executor passed to start_actor_system
-static size_t __num_actors_ = 0;                                        // number of actor objects in system
+static size_t __num_actors_ = 0;                                // number of actor objects in system
 static struct thread$ * __actor_executor_thd = 0p;              // used to wake executor after actors finish
 struct actor {
-    size_t ticket;                                          // executor-queue handle
+    size_t ticket;                              // executor-queue handle
     Allocation allocation_;                                         // allocation action
-    inline virtual_dtor;
 };
 
@@ -408 +406 @@
     #endif
 }
+static inline void ^?{}( actor & this ) {}
 
 static inline void check_actor( actor & this ) {
@@ -431 +430 @@
 struct message {
     Allocation allocation_;                     // allocation action
-    inline virtual_dtor;
 };
 
-static inline void ?{}( message & this ) {
-    this.allocation_ = Nodelete;
-}
+static inline void ?{}( message & this ) { this.allocation_ = Nodelete; }
 static inline void ?{}( message & this, Allocation allocation ) {
     memcpy( &this.allocation_, &allocation, sizeof(allocation) ); // optimization to elide ctor
     verifyf( this.allocation_ != Finished, "The Finished Allocation status is not supported for message types.\n");
 }
-static inline void ^?{}( message & this ) with(this) {
-    CFA_DEBUG( if ( allocation_ == Nodelete ) printf("A message at location %p was allocated but never sent.\n", &this); )
+static inline void ^?{}( message & this ) {
+    CFA_DEBUG( if ( this.allocation_ == Nodelete ) printf("A message at location %p was allocated but never sent.\n", &this); )
 }
 
 static inline void check_message( message & this ) {
-    switch ( this.allocation_ ) {                                               // analyze message status
-        case Nodelete: CFA_DEBUG(this.allocation_ = Finished); break;
+    #ifdef __CFA_DEBUG__
+    Allocation temp = this.allocation_;
+    this.allocation_ = Finished;
+    switch ( temp )
+    #else
+    switch ( this.allocation_ )
+    #endif
+    {                                           // analyze message status
+        case Nodelete: break;
         case Delete: delete( &this ); break;
         case Destroy: ^?{}(this); break;
@@ -453 +456 @@
     } // switch
 }
-static inline void set_allocation( message & this, Allocation state ) {
-    this.allocation_ = state;
-}
+static inline void set_allocation( message & this, Allocation state ) { this.allocation_ = state; }
 
 static inline void deliver_request( request & this ) {
@@ -687 +688 @@
 Allocation receive( actor & this, __DestroyMsg & msg ) { return Destroy; }
 Allocation receive( actor & this, __FinishedMsg & msg ) { return Finished; }
-

src/Concurrency/Actors.cpp

@@ -45 +45 @@
     // finds and sets a ptr to the actor, message, and request structs, which are needed in the next pass
     void previsit( const StructDecl * decl ) {
-        if ( !decl->body ) return;
-        if ( decl->name == "actor" ) {
-            actorStructDecls.insert( decl ); // skip inserting fwd decl
+        GuardValue(insideStruct);
+        insideStruct = true;
+        parentDecl = mutate( decl );
+        if( decl->name == "actor" ) {
+            if ( actorDecl ) actorStructDecls.insert( decl ); // skip inserting fwd decl
             *actorDecl = decl;
-        } else if( decl->name == "message" ) {
-            messageStructDecls.insert( decl ); // skip inserting fwd decl
+        }
+        if( decl->name == "message" ) {
+            if ( msgDecl ) messageStructDecls.insert( decl ); // skip inserting fwd decl
             *msgDecl = decl;
-        } else if( decl->name == "request" ) *requestDecl = decl;
-        else {
-            GuardValue(insideStruct);
-            insideStruct = true;
-            parentDecl = mutate( decl );
-        }
+        }
+        if( decl->name == "request" ) *requestDecl = decl;
         }
 
@@ -71 +70 @@
     }
 
-    // this collects the derived actor and message struct decl ptrs
+    // this collects the valid actor and message struct decl pts
     void postvisit( const StructInstType * node ) {
         if ( ! *actorDecl || ! *msgDecl ) return;
         if ( insideStruct && !namedDecl ) {
-            auto actorIter = actorStructDecls.find( node->aggr() );    
-            if ( actorIter != actorStructDecls.end() ) {
+            if ( node->aggr() == *actorDecl ) {
                 actorStructDecls.insert( parentDecl );
-                return;
-            }
-            auto messageIter = messageStructDecls.find( node->aggr() );
-            if ( messageIter != messageStructDecls.end() ) {
+            } else if ( node->aggr() == *msgDecl ) {
                 messageStructDecls.insert( parentDecl );
             }
@@ -191 +186 @@
 };
 
-// generates the definitions of send operators for actors
-// collects data needed for next pass that does the circular defn resolution 
-//     for message send operators (via table above)
-struct GenFuncsCreateTables : public ast::WithDeclsToAdd<> {
+struct GenReceiveDecls : public ast::WithDeclsToAdd<> {
     unordered_set<const StructDecl *> & actorStructDecls;
     unordered_set<const StructDecl *>  & messageStructDecls;
@@ -203 +195 @@
     FwdDeclTable & forwardDecls;
 
-    // generates the operator for actor message sends
         void postvisit( const FunctionDecl * decl ) {
         // return if not of the form receive( param1, param2 ) or if it is a forward decl
@@ -222 +213 @@
         auto messageIter = messageStructDecls.find( arg2InstType->aggr() );
         if ( actorIter != actorStructDecls.end() && messageIter != messageStructDecls.end() ) {
+
+            // check that we have found all the decls we need from <actor.hfa>
+            if ( !*allocationDecl || !*requestDecl ) 
+                SemanticError( decl->location, "using actors requires a header, add #include <actor.hfa>\n" );
+
             //////////////////////////////////////////////////////////////////////
             // The following generates this send message operator routine for all receive(derived_actor &, derived_msg &) functions
@@ -351 +347 @@
             // forward decls to resolve use before decl problem for '|' routines
             forwardDecls.insertDecl( *actorIter, *messageIter , ast::deepCopy( sendOperatorFunction ) );
+            // forwardDecls.push_back( ast::deepCopy( sendOperatorFunction ) );
 
             sendOperatorFunction->stmts = sendBody;
@@ -358 +355 @@
 
   public:
-    GenFuncsCreateTables( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls,
+    GenReceiveDecls( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls,
         const StructDecl ** requestDecl, const EnumDecl ** allocationDecl, const StructDecl ** actorDecl, const StructDecl ** msgDecl, 
         FwdDeclTable & forwardDecls ) : actorStructDecls(actorStructDecls), messageStructDecls(messageStructDecls), 
@@ -364 +361 @@
 };
 
-
-// separate pass is needed since this pass resolves circular defn issues
-// generates the forward declarations of the send operator for actor routines
-struct FwdDeclOperator : public ast::WithDeclsToAdd<> {
+struct GenFwdDecls : public ast::WithDeclsToAdd<> {
     unordered_set<const StructDecl *> & actorStructDecls;
     unordered_set<const StructDecl *>  & messageStructDecls;
     FwdDeclTable & forwardDecls;
 
-    // handles forward declaring the message operator
     void postvisit( const StructDecl * decl ) {
         list<FunctionDecl *> toAddAfter;
@@ -399 +392 @@
 
   public:
-    FwdDeclOperator( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls, 
-        FwdDeclTable & forwardDecls ) : actorStructDecls(actorStructDecls), messageStructDecls(messageStructDecls), forwardDecls(forwardDecls) {}
+    GenFwdDecls( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls, 
+        FwdDeclTable & forwardDecls ) : actorStructDecls(actorStructDecls), messageStructDecls(messageStructDecls),
+        forwardDecls(forwardDecls) {}
 };
 
@@ -426 +420 @@
     Pass<CollectactorStructDecls>::run( translationUnit, actorStructDecls, messageStructDecls, requestDecl, 
         allocationDecl, actorDecl, msgDecl );
-
-    // check that we have found all the decls we need from <actor.hfa>, if not no need to run the rest of this pass
-    if ( !allocationDeclPtr || !requestDeclPtr || !actorDeclPtr || !msgDeclPtr ) 
-        return;
-
+        
     // second pass locates all receive() routines that overload the generic receive fn
     // it then generates the appropriate operator '|' send routines for the receive routines
-    Pass<GenFuncsCreateTables>::run( translationUnit, actorStructDecls, messageStructDecls, requestDecl, 
+    Pass<GenReceiveDecls>::run( translationUnit, actorStructDecls, messageStructDecls, requestDecl, 
         allocationDecl, actorDecl, msgDecl, forwardDecls );
 
     // The third pass forward declares operator '|' send routines
-    Pass<FwdDeclOperator>::run( translationUnit, actorStructDecls, messageStructDecls, forwardDecls );
+    Pass<GenFwdDecls>::run( translationUnit, actorStructDecls, messageStructDecls, forwardDecls );
 }
 

src/Concurrency/Actors.hpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Actors.hpp -- Implement concurrency constructs from their keywords.
+// Keywords.h -- Implement concurrency constructs from their keywords.
 //
 // Author           : Colby Parsons

src/Virtual/module.mk

@@ -19 +19 @@
         Virtual/ExpandCasts.h \
         Virtual/Tables.cc \
-        Virtual/Tables.h \
-        Virtual/VirtualDtor.cpp \
-        Virtual/VirtualDtor.hpp
+        Virtual/Tables.h

src/main.cc

@@ -82 +82 @@
 #include "Validate/VerifyCtorDtorAssign.hpp" // for verifyCtorDtorAssign
 #include "Virtual/ExpandCasts.h"            // for expandCasts
-#include "Virtual/VirtualDtor.hpp"           // for implementVirtDtors
 
 static void NewPass( const char * const name ) {
@@ -342 +341 @@
 
                 PASS( "Implement Actors", Concurrency::implementActors( transUnit ) );
-        PASS( "Implement Virtual Destructors", Virtual::implementVirtDtors(transUnit) );
-        
                 PASS( "Implement Mutex", Concurrency::implementMutex( transUnit ) );
                 PASS( "Implement Thread Start", Concurrency::implementThreadStarter( transUnit ) );

tests/concurrent/actors/executor.cfa

@@ -15 +15 @@
 };
 void ?{}( d_actor & this ) with(this) {
+    ((actor &)this){};
     id = ids++;
     gstart = (&this + (id / Set * Set - id)); // remember group-start array-element

tests/concurrent/actors/poison.cfa

@@ -5 +5 @@
 #include <stdio.h>
 
-struct Server { int val; inline actor; };
-
-void ?{}( Server & this ) { this.val = 999; }
-void ^?{}( Server & this ) { this.val = 777; }
+struct Server { inline actor; };
 
 int main() {
@@ -15 +12 @@
     sout | "Finished";
     {
-        start_actor_system();
-        Server s[10];
-        for ( i; 10 ) {
-            s[i] << FinishedMsg;
-        }
-        stop_actor_system();
+    start_actor_system();
+    Server s[10];
+    for ( i; 10 ) {
+        s[i] << FinishedMsg;
+    }
+    stop_actor_system();
     }
 
     sout | "Delete";
     {
-        start_actor_system();
-        for ( i; 10 ) {
-            Server * s = alloc();
-            (*s){};
-            (*s) << DeleteMsg;
-        }
-        stop_actor_system();
+    start_actor_system();
+    for ( i; 10 ) {
+        Server * s = alloc();
+        (*s){};
+        (*s) << DeleteMsg;
+    }
+    stop_actor_system();
     }
 
     sout | "Destroy";
     {
-        start_actor_system();
-        Server s[10];
-        for ( i; 10 )
-            s[i] << DestroyMsg;
-        stop_actor_system();
-        for ( i; 10 )
-            if (s[i].val != 777)
-                sout | "Error: dtor not called correctly.";
+    start_actor_system();
+    Server s[10];
+    for ( i; 10 ) {
+        s[i] << DestroyMsg;
+    }
+    stop_actor_system();
     }