Changeset fdae913

Timestamp:

Mar 15, 2019, 3:43:39 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

42f1279c

Parents:

b419abb

Message:

modify persistent map to not re-initialize history nodes facing deletion

Location:

src

Files:

• Common/PersistentMap.h (modified) (8 diffs)
• SymTab/Indexer.cc (modified) (1 diff)

src/Common/PersistentMap.h ¶

@@ -114 +114 @@
         }
 
+        /// check if this is the only reference to itself
+        /// NOTE: optimizations employing this function are not thread-safe
+        bool is_shared(long local_ptrs = 0) const {
+                // 2 accounts for both the pointer which owns "this" and the one created for its use_count
+                return (this->shared_from_this().use_count() - local_ptrs) > 2;
+        }
+
 public:
         using size_type = std::size_t;
@@ -144 +151 @@
                 // remove map from base
                 Base base_map = base->take_as<Base>();
-                base->reset_as_base();
-                // xxx -- investigate checking ref-count and omitting re-initialization if 1
 
                 // switch base to inverse of self and mutate base map
@@ -153 +158 @@
                                 auto it = base_map.find( self.key );
 
-                                base->init<Ins>( 
-                                        mut_this->shared_from_this(), std::move(self.key), std::move(it->second) );
-                                base->mode = INS;
+                                if ( base->is_shared( 1 ) ) {
+                                        base->reset_as_base();
+                                        base->init<Ins>( 
+                                                mut_this->shared_from_this(), std::move(self.key), std::move(it->second) );
+                                        base->mode = INS;
+                                }
 
                                 base_map.erase( it );
@@ -163 +171 @@
                                 Ins& self = mut_this->as<Ins>();
 
-                                base->init<Rem>( mut_this->shared_from_this(), self.key );
-                                base->mode = REM;
+                                if ( base->is_shared( 1 ) ) {
+                                        base->reset_as_base();
+                                        base->init<Rem>( mut_this->shared_from_this(), self.key );
+                                        base->mode = REM;
+                                }
 
                                 base_map.emplace( std::move(self.key), std::move(self.val) );
@@ -173 +184 @@
                                 auto it = base_map.find( self.key );
 
-                                base->init<Ins>( 
-                                        mut_this->shared_from_this(), std::move(self.key), std::move(it->second) );
-                                base->mode = UPD;
+                                if ( base->is_shared( 1 ) ) {
+                                        base->reset_as_base();
+                                        base->init<Ins>( 
+                                                mut_this->shared_from_this(), std::move(self.key), std::move(it->second) );
+                                        base->mode = UPD;
+                                }
 
                                 it->second = std::move(self.val);
@@ -240 +254 @@
                 // transfer map to new node
                 Ptr ret = std::make_shared<Self>( take_as<Base>() );
-                reset_as_base();
                 Base& base_map = ret->as<Base>();
 
@@ -246 +259 @@
                 auto it = base_map.find( k );
                 if ( it == base_map.end() ) {
-                        // set self to REM node and insert into base
-                        init<Rem>( ret, k );
-                        mode = REM;
+                        if ( is_shared() ) {
+                                // set self to REM node and insert into base
+                                reset_as_base();
+                                init<Rem>( ret, k );
+                                mode = REM;
+                        }
 
                         base_map.emplace_hint( it, std::forward<K>(k), std::forward<V>(v) );
                 } else {
-                        // set self to UPD node and modify base
-                        init<Ins>( ret, std::forward<K>(k), std::move(it->second) );
-                        mode = UPD;
+                        if ( is_shared() ) {
+                                // set self to UPD node and modify base
+                                reset_as_base();
+                                init<Ins>( ret, std::forward<K>(k), std::move(it->second) );
+                                mode = UPD;
+                        }
 
                         it->second = std::forward<V>(v);
@@ -271 +290 @@
                 // transfer map to new node
                 Ptr ret = std::make_shared<Self>( take_as<Base>() );
-                reset_as_base();
                 Base& base_map = ret->as<Base>();
 
-                // set self to INS node and remove from base
-                init<Ins>( ret, k, base_map[k] );
-                mode = INS;
+                if ( is_shared() ) {
+                        // set self to INS node and remove from base
+                        reset_as_base();
+                        init<Ins>( ret, k, base_map[k] );
+                        mode = INS;
+                }
 
                 base_map.erase( k );

src/SymTab/Indexer.cc ¶

@@ -189 +189 @@
         void Indexer::leaveScope() {
                 if ( repScope == scope ) {
-                        // replace all maps and scope index with previous scope's versions
                         Ptr prev = prevScope;           // make sure prevScope stays live
                         *this = std::move(*prevScope);  // replace with previous scope