Changeset bd4d011 for src

Timestamp:

Mar 23, 2017, 3:05:36 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

ae6f1ec

Parents:

bcda04c

Message:

Implemented thread keyword

Location:

src

Files:

• Concurrency/Keywords.cc (modified) (13 diffs)
• Parser/lex.ll (modified) (1 diff)
• libcfa/concurrency/thread (modified) (1 diff)
• libcfa/concurrency/thread.c (modified) (4 diffs)
• tests/monitor.c (modified) (2 diffs)
• tests/thread.c (modified) (2 diffs)

src/Concurrency/Keywords.cc

@@ -17 +17 @@
 #include "Concurrency/Keywords.h"
 
+#include "InitTweak/InitTweak.h"
 #include "SymTab/AddVisit.h"
 #include "SynTree/Declaration.h"
@@ -53 +54 @@
           public:
 
-                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error ) :
-                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ) {}
+                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main ) :
+                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ) {}
 
                 virtual ~ConcurrentSueKeyword() {}
@@ -73 +74 @@
                 const std::string getter_name;
                 const std::string context_error;
+                bool needs_main;
 
                 std::list< Declaration * > declsToAdd, declsToAddAfter;
@@ -95 +97 @@
                         "__thrd",
                         "get_thread",
-                        "thread keyword requires threads to be in scope, add #include <thread>"
+                        "thread keyword requires threads to be in scope, add #include <thread>",
+                        true
                 )
                 {}
@@ -125 +128 @@
                         "__cor",
                         "get_coroutine",
-                        "coroutine keyword requires coroutines to be in scope, add #include <coroutine>"
+                        "coroutine keyword requires coroutines to be in scope, add #include <coroutine>",
+                        true
                 )
                 {}
@@ -155 +159 @@
                         "__mon",
                         "get_monitor",
-                        "monitor keyword requires monitors to be in scope, add #include <monitor>"
+                        "monitor keyword requires monitors to be in scope, add #include <monitor>",
+                        false
                 )
                 {}
@@ -198 +203 @@
         };
 
+        //-----------------------------------------------------------------------------
+        //Handles mutex routines definitions :
+        // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
+        //                                                                       monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
+        //                                                                       monitor_guard_t __guard = { __monitors, 2 };
+        //    /*Some code*/                                       =>           /*Some code*/
+        // }                                                               }
+        //
+        class ThreadStarter final : public Visitor {
+          public:
+
+                using Visitor::visit;
+                virtual void visit( FunctionDecl * decl ) override final;
+
+                void addStartStatement( FunctionDecl * decl, DeclarationWithType * param );
+
+                static void implement( std::list< Declaration * > & translationUnit ) {
+                        ThreadStarter impl;
+                        acceptAll( translationUnit, impl );
+                }
+        };
+
         //=============================================================================================
         // General entry routine
@@ -212 +239 @@
 
         void implementThreadStarter( std::list< Declaration * > & translationUnit ) {
-
+                ThreadStarter   ::implement( translationUnit );
         }
 
@@ -246 +273 @@
                 forward->get_members().clear();
 
-                FunctionType * type = new FunctionType( noQualifiers, false );
+                FunctionType * get_type = new FunctionType( noQualifiers, false );
                 ObjectDecl * this_decl = new ObjectDecl(
                         "this",
@@ -262 +289 @@
                 );
 
-                type->get_parameters().push_back( this_decl );
-                type->get_returnVals().push_back(
+                get_type->get_parameters().push_back( this_decl );
+                get_type->get_returnVals().push_back(
                         new ObjectDecl(
                                 "ret",
@@ -284 +311 @@
                         Type::Static,
                         LinkageSpec::Cforall,
-                        type,
+                        get_type,
                         nullptr,
                         noAttributes,
@@ -290 +317 @@
                 );
 
+                FunctionDecl * main_decl = nullptr;
+
+                if( needs_main ) {
+                        FunctionType * main_type = new FunctionType( noQualifiers, false );
+                        
+                        main_type->get_parameters().push_back( this_decl->clone() );
+
+                        main_decl = new FunctionDecl(
+                                "main",
+                                noStorage,
+                                LinkageSpec::Cforall,
+                                main_type,
+                                nullptr
+                        );
+                }
+
                 declsToAdd.push_back( forward );
+                if( needs_main ) declsToAdd.push_back( main_decl );
                 declsToAdd.push_back( get_decl );
 
@@ -455 +499 @@
                 body->push_front( new DeclStmt( noLabels, monitors) );
         }
+
+        //=============================================================================================
+        // General entry routine
+        //=============================================================================================
+        void ThreadStarter::visit(FunctionDecl * decl) {
+                if( ! InitTweak::isConstructor(decl->get_name()) ) return;
+
+                DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
+                auto ptr = dynamic_cast< PointerType * >( param->get_type() );
+                // if( ptr ) std::cerr << "FRED1" << std::endl;
+                auto type  = dynamic_cast< StructInstType * >( ptr->get_base() );
+                // if( type ) std::cerr << "FRED2" << std::endl;
+                if( type && type->get_baseStruct()->is_thread() ) {
+                        addStartStatement( decl, param );
+                }
+        }
+
+        void ThreadStarter::addStartStatement( FunctionDecl * decl, DeclarationWithType * param ) {
+                CompoundStmt * stmt = decl->get_statements();
+
+                if( ! stmt ) return;
+
+                stmt->push_back( 
+                        new ExprStmt(
+                                noLabels,
+                                new UntypedExpr(
+                                        new NameExpr( "__thrd_start" ),
+                                        { new VariableExpr( param ) }
+                                )
+                        )
+                );
+        }
 };

src/Parser/lex.ll

@@ -256 +256 @@
 struct                  { KEYWORD_RETURN(STRUCT); }
 switch                  { KEYWORD_RETURN(SWITCH); }
-_Thread                 { KEYWORD_RETURN(THREAD); }                             // C11
+thread                  { KEYWORD_RETURN(THREAD); }                             // C11
 _Thread_local   { KEYWORD_RETURN(THREADLOCAL); }                // C11
 throw                   { KEYWORD_RETURN(THROW); }                              // CFA

src/libcfa/concurrency/thread

@@ -56 +56 @@
 thread_desc * this_thread(void);
 
+forall( dtype T | is_thread(T) )
+void __thrd_start( T* this );
+
 //-----------------------------------------------------------------------------
 // Ctors and dtors

src/libcfa/concurrency/thread.c

@@ -31 +31 @@
 
 //-----------------------------------------------------------------------------
-// Forward declarations
-forall( dtype T | is_thread(T) )
-void start( T* this );
-
-//-----------------------------------------------------------------------------
 // Thread ctors and dtors
 
@@ -53 +48 @@
 void ?{}( scoped(T)* this ) {
         (&this->handle){};
-        start(&this->handle);
+        __thrd_start(&this->handle);
 }
 
@@ -59 +54 @@
 void ?{}( scoped(T)* this, P params ) {
         (&this->handle){ params };
-        start(&this->handle);
+        __thrd_start(&this->handle);
 }
 
@@ -70 +65 @@
 // Starting and stopping threads
 forall( dtype T | is_thread(T) )
-void start( T* this ) {
+void __thrd_start( T* this ) {
         coroutine_desc* thrd_c = get_coroutine(this);
         thread_desc*  thrd_h = get_thread   (this);

src/tests/monitor.c

@@ -26 +26 @@
 }
 
-struct MyThread { thread_desc __thrd; };
-
-DECL_THREAD(MyThread);
-
-void ?{}( MyThread * this ) {}
-void ^?{}( MyThread * mutex this ) {}
+thread MyThread {};
 
 void main( MyThread* this ) {
@@ -43 +38 @@
         processor p;
         {
-                scoped(MyThread) f[4];
+                MyThread f[4];
         }
         sout | global.value | endl;

src/tests/thread.c

@@ -4 +4 @@
 #include <thread>
 
-struct First { thread_desc __thrd; signal_once* lock; };
-struct Second { thread_desc __thrd; signal_once* lock; };
+// thread First;
+// void main(First* this);
 
-DECL_THREAD(First);
-DECL_THREAD(Second);
+// thread Second;
+// void main(Second* this);
+
+thread First  { signal_once* lock; };
+thread Second { signal_once* lock; };
 
 void ?{}( First * this, signal_once* lock ) { this->lock = lock; }
 void ?{}( Second * this, signal_once* lock ) { this->lock = lock; }
-
-void ^?{}( First  * mutex this ) {}
-void ^?{}( Second * mutex this ) {}
 
 void main(First* this) {
@@ -39 +39 @@
                 processor p;
                 {
-                        scoped(First)  f = { &lock };
-                        scoped(Second) s = { &lock };
+                        First  f = { &lock };
+                        Second s = { &lock };
                 }
         }