Adapt methods for finding, erasing, and inserting elements into the sharing map

This adapts the methods for the case where a leafs can directly be attached to
internal nodes.

Author: danpoe

src/util/sharing_map.h

@@ -518,20 +518,8 @@ class sharing_mapt
 protected:
   // helpers
 
-  innert *get_container_node(const key_type &k);
-  const innert *get_container_node(const key_type &k) const;
-
-  const leaft *get_leaf_node(const key_type &k) const
-  {
-    const innert *cp = get_container_node(k);
-    if(cp == nullptr)
-      return nullptr;
-
-    const leaft *lp;
-    lp = cp->find_leaf(k);
-
-    return lp;
-  }
+  leaft *get_leaf_node(const key_type &k);
+  const leaft *get_leaf_node(const key_type &k) const;
 
   /// Move a container node (containing a single leaf) further down the tree
   /// such as to resolve a collision with another key-value pair. This method is
@@ -551,11 +539,14 @@ class sharing_mapt
   ///   container node to move further down the tree
   /// \return pointer to the container to which the element to be newly inserted
   ///   can be added
-  innert *migrate(
+  template <class valueU>
+  void migrate(
     const std::size_t starting_level,
     const std::size_t key_suffix,
     const std::size_t bit_last,
-    innert &inner);
+    innert &inner,
+    const key_type &k,
+    valueU &&m);
 
   void iterate(
     const innert &n,
@@ -1031,7 +1022,7 @@ ::get_delta_view(
   while(!stack.empty());
 }
 
-SHARING_MAPT2(, innert *)::get_container_node(const key_type &k)
+SHARING_MAPT2(, leaft *)::get_leaf_node(const key_type &k)
 {
   SM_ASSERT(has_key(k));
 
@@ -1045,19 +1036,30 @@ SHARING_MAPT2(, innert *)::get_container_node(const key_type &k)
 
     ip = ip->add_child(bit);
     SM_ASSERT(ip != nullptr);
-    SM_ASSERT(!ip->empty());
+    SM_ASSERT(!ip->empty()); // since the key must exist in the map
 
-    if(ip->is_container())
+    if(ip->is_internal())
+    {
+      key >>= chunk;
+      continue;
+    }
+
+    if(ip->is_leaf())
+    {
       return ip;
+    }
 
-    key >>= chunk;
+    if(ip->is_container())
+    {
+      return ip->find_leaf(k);
+    }
   }
 
   UNREACHABLE;
   return nullptr;
 }
 
-SHARING_MAPT2(const, innert *)::get_container_node(const key_type &k) const
+SHARING_MAPT2(const, leaft *)::get_leaf_node(const key_type &k) const
 {
   if(empty())
     return nullptr;
@@ -1077,10 +1079,21 @@ SHARING_MAPT2(const, innert *)::get_container_node(const key_type &k) const
 
     SM_ASSERT(!ip->empty());
 
-    if(ip->is_container())
-      return ip;
+    if(ip->is_internal())
+    {
+      key >>= chunk;
+      continue;
+    }
 
-    key >>= chunk;
+    if(ip->is_leaf())
+    {
+      return equalT()(ip->get_key(), k) ? ip : nullptr;
+    }
+
+    if(ip->is_container())
+    {
+      return ip->find_leaf(k); // returns nullptr if leaf is not found
+    }
   }
 
   UNREACHABLE;
@@ -1111,62 +1124,72 @@ SHARING_MAPT(void)::erase(const key_type &k)
 
     ip = ip->add_child(bit);
 
-    SM_ASSERT(!ip->empty());
+    PRECONDITION(!ip->empty());
+
+    if(ip->is_internal())
+    {
+      key >>= chunk;
+      continue;
+    }
+
+    if(ip->is_leaf())
+    {
+      PRECONDITION(equalT()(ip->get_key(), k));
+      del->remove_child(del_bit);
+
+      num--;
+
+      return;
+    }
 
     if(ip->is_container())
-      break;
+    {
+      PRECONDITION(!ip->empty());
+      const leaf_listt &ll = as_const(ip)->get_container();
+      PRECONDITION(!ll.empty());
 
-    key >>= chunk;
-  }
+      // forward list has one element
+      if(std::next(ll.begin()) == ll.end())
+      {
+        PRECONDITION(equalT()(ll.front().get_key(), k));
+        del->remove_child(del_bit);
+      }
+      else
+      {
+        ip->remove_leaf(k);
+      }
 
-  PRECONDITION(!ip->empty());
-  const leaf_listt &ll = as_const(ip)->get_container();
-  PRECONDITION(!ll.empty());
+      num--;
 
-  // forward list has one element
-  if(std::next(ll.begin()) == ll.end())
-  {
-    PRECONDITION(equalT()(ll.front().get_key(), k));
-    del->remove_child(del_bit);
-  }
-  else
-  {
-    ip->remove_leaf(k);
+      return;
+    }
   }
 
-  num--;
+  UNREACHABLE;
 }
 
-SHARING_MAPT2(, innert *)::migrate(
+SHARING_MAPT4(valueU, void)
+::migrate(
   const std::size_t starting_level,
   const std::size_t key_suffix,
   const std::size_t bit_last,
-  innert &inner)
+  innert &inner,
+  const key_type &k,
+  valueU &&m)
 {
   SM_ASSERT(starting_level < levels - 1);
   SM_ASSERT(inner.is_defined_internal());
 
-  const innert &child = *inner.find_child(bit_last);
-  SM_ASSERT(child.is_defined_container());
-
-  const leaf_listt &ll = child.get_container();
-
-  // Only containers at the bottom can contain more than two elements
-  SM_ASSERT(is_singular(ll));
+  leaft &leaf = *inner.add_child(bit_last);
+  SM_ASSERT(leaf.is_defined_leaf());
 
-  const leaft &leaf = ll.front();
   std::size_t key_existing = hash()(leaf.get_key());
-
   key_existing >>= chunk * starting_level;
 
-  // Copy the container
-  innert container_copy(child);
-
-  // Delete existing container
-  inner.remove_child(bit_last);
+  leaft leaf_kept;
+  leaf_kept.swap(leaf);
 
-  // Add internal node
-  innert *ip = inner.add_child(bit_last);
+  innert *ip = &leaf;
   SM_ASSERT(ip->empty());
 
   // Find place for both elements
@@ -1181,18 +1204,24 @@ SHARING_MAPT2(, innert *)::migrate(
 
   do
   {
+    SM_ASSERT(ip->empty());
+
     std::size_t bit_existing = key_existing & mask;
     std::size_t bit = key & mask;
 
     if(bit != bit_existing)
     {
       // Place found
 
-      innert *cp2 = ip->add_child(bit_existing);
-      cp2->swap(container_copy);
+      innert *l1 = ip->add_child(bit_existing);
+      SM_ASSERT(l1->empty());
+      l1->swap(leaf_kept);
 
-      innert *cp1 = ip->add_child(bit);
-      return cp1;
+      innert *l2 = ip->add_child(bit);
+      SM_ASSERT(l2->empty());
+      l2->make_leaf(k, std::forward<valueU>(m));
+
+      return;
     }
 
     SM_ASSERT(bit == bit_existing);
@@ -1204,10 +1233,17 @@ SHARING_MAPT2(, innert *)::migrate(
     level++;
   } while(level < levels);
 
-  leaft leaf_copy(as_const(&container_copy)->get_container().front());
-  ip->get_container().push_front(leaf_copy);
+  // Hash collision, create container and add both elements to it
 
-  return ip;
+  PRECONDITION(!equalT()(k, leaf_kept.get_key()));
+
+  SM_ASSERT(ip->empty());
+  // Make container and add existing leaf
+  ip->get_container().push_front(leaf_kept);
+
+  SM_ASSERT(ip->is_defined_container());
+  // Insert new element in same container
+  ip->place_leaf(k, std::forward<valueU>(m));
 }
 
 SHARING_MAPT4(valueU, void)
@@ -1218,7 +1254,7 @@ ::insert(const key_type &k, valueU &&m)
   std::size_t key = hash()(k);
   innert *ip = &map;
 
-  // The root cannot be a container node
+  // The root must be an internal node
   SM_ASSERT(ip->is_internal());
 
   std::size_t level = 0;
@@ -1236,51 +1272,63 @@ ::insert(const key_type &k, valueU &&m)
     // Place is unoccupied
     if(child->empty())
     {
-      // Create container and insert leaf
-      child->place_leaf(k, std::forward<valueU>(m));
+      if(level < levels - 1)
+      {
+        // Create leaf
+        child->make_leaf(k, m);
+      }
+      else
+      {
+        SM_ASSERT(level == levels - 1);
 
-      SM_ASSERT(child->is_defined_container());
+        // Create container and insert leaf
+        child->place_leaf(k, std::forward<valueU>(m));
+
+        SM_ASSERT(child->is_defined_container());
+      }
 
       num++;
 
       return;
     }
 
-    if(child->is_container())
+    if(child->is_internal())
     {
-      if(level < levels - 1)
-      {
-        // Migrate the elements downwards
-        innert *cp = migrate(level, key, bit, *ip);
+      ip = child;
+      key >>= chunk;
+      level++;
 
-        cp->place_leaf(k, std::forward<valueU>(m));
-      }
-      else
-      {
-        // Add to the bottom container
-        child->place_leaf(k, std::forward<valueU>(m));
-      }
+      continue;
+    }
+
+    if(child->is_leaf())
+    {
+      // migrate leaf downwards
+      migrate(level, key, bit, *ip, k, std::forward<valueU>(m));
 
       num++;
 
       return;
     }
 
-    SM_ASSERT(level == levels - 1 || child->is_defined_internal());
+    if(child->is_container())
+    {
+      SM_ASSERT(level == levels - 1);
 
-    ip = child;
-    key >>= chunk;
-    level++;
+      // Add to the container
+      child->place_leaf(k, std::forward<valueU>(m));
+
+      num++;
+
+      return;
+    }
   }
 }
 
 SHARING_MAPT4(valueU, void)
 ::replace(const key_type &k, valueU &&m)
 {
-  innert *cp = get_container_node(k);
-  SM_ASSERT(cp != nullptr);
-
-  leaft *lp = cp->find_leaf(k);
+  leaft *lp = get_leaf_node(k);
   PRECONDITION(lp != nullptr); // key must exist in map
 
   INVARIANT(
@@ -1293,10 +1341,7 @@ ::replace(const key_type &k, valueU &&m)
 SHARING_MAPT(void)
 ::update(const key_type &k, std::function<void(mapped_type &)> mutator)
 {
-  innert *cp = get_container_node(k);
-  SM_ASSERT(cp != nullptr);
-
-  leaft *lp = cp->find_leaf(k);
+  leaft *lp = get_leaf_node(k);
   PRECONDITION(lp != nullptr); // key must exist in map
 
   value_comparatort comparator(as_const(lp)->get_value());