Changeset a14926b

Timestamp:

Jan 5, 2023, 8:48:09 AM (16 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

3d4b7cc7

Parents:

a7662b8 (diff), d99a716 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• libcfa/src/concurrency/invoke.h (modified) (1 diff)
• libcfa/src/concurrency/locks.hfa (modified) (2 diffs)
• src/AST/Pass.hpp (modified) (2 diffs)
• src/AST/Pass.proto.hpp (modified) (2 diffs)
• src/GenPoly/Box.cc (modified) (3 diffs)

libcfa/src/concurrency/invoke.h

@@ -215 +215 @@
                 struct __thread_user_link cltr_link;
 
-                // used to store state between clh lock/unlock
-                volatile bool * clh_prev;
-
                 // used to point to this thd's current clh node
                 volatile bool * clh_node;

libcfa/src/concurrency/locks.hfa

@@ -228 +228 @@
 struct clh_lock {
         volatile bool * volatile tail;
+    volatile bool * volatile head;
 };
 
@@ -237 +238 @@
         *(curr_thd->clh_node) = false;
         volatile bool * prev = __atomic_exchange_n((bool **)(&l.tail), (bool *)(curr_thd->clh_node), __ATOMIC_SEQ_CST);
-        while(!__atomic_load_n(prev, __ATOMIC_ACQUIRE)) Pause();
-        curr_thd->clh_prev = prev;
+        while(!__atomic_load_n(prev, __ATOMIC_SEQ_CST)) Pause();
+    __atomic_store_n((bool **)(&l.head), (bool *)curr_thd->clh_node, __ATOMIC_SEQ_CST);
+    curr_thd->clh_node = prev;
 }
 
 static inline void unlock(clh_lock & l) {
-        thread$ * curr_thd = active_thread();
-        __atomic_store_n(curr_thd->clh_node, true, __ATOMIC_RELEASE);
-        curr_thd->clh_node = curr_thd->clh_prev;
+        __atomic_store_n((bool *)(l.head), true, __ATOMIC_SEQ_CST);
 }
 

src/AST/Pass.hpp

@@ -86 +86 @@
         {
                 // After the pass is constructed, check if it wants the have a pointer to the wrapping visitor
-                type * const * visitor = __pass::visitor(core, 0);
-                if(visitor) {
+                type * const * visitor = __pass::visitor( core, 0 );
+                if ( visitor ) {
                         *const_cast<type **>( visitor ) = this;
                 }
@@ -98 +98 @@
 
         /// If the core defines a result, call it if possible, otherwise return it.
-        inline auto get_result() -> decltype( __pass::get_result( core, '0' ) ) {
-                return __pass::get_result( core, '0' );
+        inline auto get_result() -> decltype( __pass::result::get( core, '0' ) ) {
+                return __pass::result::get( core, '0' );
         }
 

src/AST/Pass.proto.hpp

@@ -489 +489 @@
                 template<typename core_t>
                 static inline auto replace( core_t &, long, const ast::TypeInstType *& ) {}
-
         } // namespace forall
 
@@ -506 +505 @@
         }
 
-        template<typename core_t>
-        static inline auto get_result( core_t & core, char ) -> decltype( core.result() ) {
-                return core.result();
-        }
-
-        template<typename core_t>
-        static inline auto get_result( core_t & core, int ) -> decltype( core.result ) {
-                return core.result;
-        }
-
-        template<typename core_t>
-        static inline void get_result( core_t &, long ) {}
+        // For passes, usually utility passes, that have a result.
+        namespace result {
+                template<typename core_t>
+                static inline auto get( core_t & core, char ) -> decltype( core.result() ) {
+                        return core.result();
+                }
+
+                template<typename core_t>
+                static inline auto get( core_t & core, int ) -> decltype( core.result ) {
+                        return core.result;
+                }
+
+                template<typename core_t>
+                static inline void get( core_t &, long ) {}
+        }
 } // namespace __pass
 } // namespace ast

src/GenPoly/Box.cc

@@ -424 +424 @@
         namespace {
                 std::string makePolyMonoSuffix( FunctionType const * function, const TyVarMap &tyVars ) {
-                        std::stringstream name;
-
                         // NOTE: this function previously used isPolyObj, which failed to produce
                         // the correct thing in some situations. It's not clear to me why this wasn't working.
@@ -432 +430 @@
                         // to take those polymorphic types as pointers. Therefore, there can be two different functions
                         // with the same mangled name, so we need to further mangle the names.
+                        std::stringstream name;
                         for ( DeclarationWithType const * const ret : function->returnVals ) {
-                                if ( isPolyType( ret->get_type(), tyVars ) ) {
-                                        name << "P";
-                                } else {
-                                        name << "M";
-                                }
-                        }
-                        name << "_";
+                                name << ( isPolyType( ret->get_type(), tyVars ) ? 'P' : 'M' );
+                        }
+                        name << '_';
                         for ( DeclarationWithType const * const arg : function->parameters ) {
-                                if ( isPolyType( arg->get_type(), tyVars ) ) {
-                                        name << "P";
-                                } else {
-                                        name << "M";
-                                }
-                        } // for
+                                name << ( isPolyType( arg->get_type(), tyVars ) ? 'P' : 'M' );
+                        }
                         return name.str();
                 }
@@ -565 +556 @@
                         // even when converted to strings, sort in the original order.
                         // (At least, that is the best explination I have.)
-                        for ( std::pair<std::string, TypeDecl::Data> const & tyParam : exprTyVars ) {
+                        for ( std::pair<const std::string, TypeDecl::Data> const & tyParam : exprTyVars ) {
                                 if ( !tyParam.second.isComplete ) continue;
                                 Type *concrete = env->lookup( tyParam.first );