Changeset d318a18 for src/Common

Timestamp:

Jul 18, 2018, 5:18:29 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env

Children:

eff03a94

Parents:

5c14030

Message:

Fix assorted memory bugs with persistent-array environment

Location:

src/Common

Files:

• GC.cc (modified) (2 diffs)
• GC.h (modified) (1 diff)
• PersistentDisjointSet.h (modified) (3 diffs)
• PersistentMap.h (modified) (4 diffs)

src/Common/GC.cc

@@ -41 +41 @@
 
 const GC& GC::operator<< (const GC_Object* obj) const {
-        if( obj )
-        {
+        if( obj ) {
                 if( obj->mark != this->mark ) {
                         obj->mark = this->mark;
@@ -49 +48 @@
         }
         return *this;
+}
+
+bool GC::notrace_mark(const GC_Object* obj) const {
+        if ( obj && obj->mark != this->mark ) {
+                obj->mark = this->mark;
+                return true;
+        }
+        return false;
 }
 

src/Common/GC.h

@@ -38 +38 @@
         /// Traces a traceable object
         const GC& operator<< (const GC_Object*) const;
+
+        /// No-trace mark; returns true if the object exists and was not already marked
+        bool notrace_mark(const GC_Object*) const;
 
         /// Adds a new object to garbage collection

src/Common/PersistentDisjointSet.h

@@ -281 +281 @@
         const Base& rerooted() const {
                 reroot();
+                assertf(mode == BASE, "reroot results in base");
                 return as<Base>();
         }
@@ -332 +333 @@
         }
 
-        /// Adds fresh class including only one item; returns updated map
+        /// Adds fresh class including only one item; returns updated map (or self if no change)
         template<typename E>
         Self* add(E&& i) {
                 reroot();
-                
-                // transfer map to new node
-                Self* ret = new Self{ BASE, take_as<Base>() };
+
+                // add new element to node
+                Base base_map = take_as<Base>();
+                bool added = base_map.emplace( i, Node{ i } ).second;
+
+                // fail early on node already present
+                if ( ! added ) {
+                        as<Base>() = std::move(base_map);
+                        return this;
+                }
+
+                // make new return node and reset self as REM node
+                Self* ret = new Self{ BASE, std::move(base_map) };
                 reset_as_base();
-
-                // set self to REM node
                 init<Add>( ret, i );
                 mode = REM;
-                
-                // add element in returned map
-                Base& base_map = ret->as<Base>();
-                bool added = base_map.emplace( i, Node{ std::forward<E>(i) } ).second;
-                assertf(added, "added element already present in map");
 
                 return ret;
@@ -460 +464 @@
                 const Base& self = rerooted();
 
-                Elm crnt = i;
-                do {
+                // exit early if class not present
+                auto it = self.find( i );
+                if ( it == self.end() ) return;
+
+                // apply f to each member of class
+                f( i );
+                for ( Elm crnt = it->second.next; crnt != i; crnt = it->second.next ) {
                         f( crnt );
-                        auto it = self.find( crnt );
+                        it = self.find( crnt );
                         assertf( it != self.end(), "current node must exist in base" );
-                        crnt = it->second.next;
-                } while ( crnt != i );
+                }
         }
 

src/Common/PersistentMap.h

@@ -141 +141 @@
                                         gc.maybe_trace( entry.first, entry.second );
                                 }
-                                return;
-                        }
+                        } break;
                         case REM: {
                                 const Rem& self = as<Rem>();
                                 gc << self.base;
                                 gc.maybe_trace( self.key );
-                                return;
-                        }
+                        } break;
                         case INS: case UPD: {
                                 const Ins& self = as<Ins>();
                                 gc << self.base;
                                 gc.maybe_trace( self.key, self.val );
-                                return;
-                        }
+                        } break;
                         default: assertf(false, "invalid mode");
                 }
@@ -198 +195 @@
 
                                 base_map.erase( it );
-                                break;
-                        }
+                        } break;
                         case INS: {
                                 Ins& self = mut_this->as<Ins>();
@@ -207 +203 @@
 
                                 base_map.emplace( std::move(self.key), std::move(self.val) );
-                                break;
-                        }
+                        } break;
                         case UPD: {
                                 Ins& self = mut_this->as<Ins>();
@@ -218 +213 @@
 
                                 it->second = std::move(self.val);
-                                break;
-                        }
+                        } break;
                         default: assertf(false, "invalid mode");
                 }