Use key to search in add_item_if_not_shared()

When the method get_delta_view() encounters a leaf node in the first map, it
searches for a leaf with the same key in the corresponding subtree of the second
map. Previously all the nodes in the subtree were visited. This commit changes
the traversal such that the hash code of a key is used to determine the position
of the leaf in the second map.

Author: danpoe

src/util/sharing_map.h

@@ -548,6 +548,7 @@ class sharing_mapt
   void add_item_if_not_shared(
     const innert &container,
     const innert &inner,
+    const std::size_t level,
     delta_viewt &delta_view,
     const bool only_common) const;
 
@@ -564,6 +565,7 @@ class sharing_mapt
     bool mark = true) const;
 
   static const std::string not_found_msg;
+  static const std::size_t dummy_level;
 
   // config
   static const std::size_t bits;
@@ -792,67 +794,61 @@ ::gather_all(const innert &n, delta_viewt &delta_view) const
 SHARING_MAPT(void)::add_item_if_not_shared(
   const innert &container,
   const innert &inner,
+  const std::size_t level,
   delta_viewt &delta_view,
   const bool only_common) const
 {
-  SM_ASSERT(!container.empty());
-  SM_ASSERT(!inner.empty());
+  const leaft &l1 = container.get_container().front();
 
-  std::stack<const innert *> stack;
-  stack.push(&inner);
+  const auto &k = l1.get_key();
+  std::size_t key = hash()(k);
 
-  do
+  key >>= level * chunk;
+
+  const innert *ip = &inner;
+  SM_ASSERT(ip->is_defined_internal());
+
+  while(true)
   {
-    const innert *ip = stack.top();
-    stack.pop();
+    std::size_t bit = key & mask;
 
-    SM_ASSERT(!ip->empty());
+    ip = ip->find_child(bit);
 
-    if(ip->is_internal())
+    // only in first map
+    if(ip == nullptr)
     {
-      const to_mapt &m = ip->get_to_map();
-      SM_ASSERT(!m.empty());
-
-      for(const auto &item : m)
+      if(!only_common)
       {
-        const innert *i = &item.second;
-        stack.push(i);
+        delta_view.push_back({k, l1.get_value()});
       }
-    }
-    else
-    {
-      SM_ASSERT(ip->is_container());
 
-      if(ip->shares_with(container))
-        return;
+      return;
+    }
 
-      const leaft &l1 = container.get_container().front();
+    SM_ASSERT(!ip->empty());
 
-      const leaf_listt &ll = ip->get_container();
-      SM_ASSERT(!ll.empty());
+    // potentially in both maps
+    if(ip->is_container())
+    {
+      if(container.shares_with(*ip))
+        return;
 
-      for(const auto &l : ll)
+      for(const auto &l2 : ip->get_container())
       {
-        if(l1.shares_with(l))
+        if(l1.shares_with(l2))
           return;
 
-        if(l1.get_key() == l.get_key())
+        if(l1.get_key() == l2.get_key())
         {
-          // element is in both maps and not shared
-          delta_view.push_back(
-            {true, l1.get_key(), l1.get_value(), l.get_value()});
+          delta_view.push_back({k, l1.get_value(), l2.get_value()});
           return;
         }
       }
+
+      return;
     }
-  }
-  while(!stack.empty());
 
-  // element is only in first map
-  if(!only_common)
-  {
-    const leaft &l1 = container.get_container().front();
-    delta_view.push_back({false, l1.get_key(), l1.get_value(), dummy});
+    key >>= chunk;
   }
 }
 
@@ -880,6 +876,8 @@ ::get_delta_view(
   typedef std::pair<const innert *, const innert *> stack_itemt;
   std::stack<stack_itemt> stack;
 
+  std::stack<std::size_t> level_stack;
+
   // We do a DFS "in lockstep" simultaneously on both maps. For
   // corresponding nodes we check whether they are shared between the
   // maps, and if not, we recurse into the corresponding subtrees.
@@ -891,6 +889,7 @@ ::get_delta_view(
     return;
 
   stack.push(stack_itemt(&map, &other.map));
+  level_stack.push(0);
 
   do
   {
@@ -901,6 +900,9 @@ ::get_delta_view(
 
     stack.pop();
 
+    const std::size_t level = level_stack.top();
+    level_stack.pop();
+
     SM_ASSERT(!ip1->empty());
     SM_ASSERT(!ip2->empty());
 
@@ -920,6 +922,11 @@ ::get_delta_view(
         if(!child.shares_with(*ip2))
         {
           stack.push(stack_itemt(&child, ip2));
+
+          // The level is not needed when the node of the left map is an
+          // internal node, and the node of the right map is a container node,
+          // hence we just push a dummy element
+          level_stack.push(dummy_level);
         }
       }
 
@@ -947,6 +954,7 @@ ::get_delta_view(
         else if(!child.shares_with(*p))
         {
           stack.push(stack_itemt(&child, p));
+          level_stack.push(level + 1);
         }
       }
 
@@ -958,8 +966,9 @@ ::get_delta_view(
     if(ip2->is_internal())
     {
       SM_ASSERT(is_singular(ip1->get_container()));
+      SM_ASSERT(level != dummy_level);
 
-      add_item_if_not_shared(*ip1, *ip2, delta_view, only_common);
+      add_item_if_not_shared(*ip1, *ip2, level, delta_view, only_common);
 
       continue;
     }
@@ -1283,6 +1292,7 @@ SHARING_MAPT2(optionalt<std::reference_wrapper<const, mapped_type>>)::find(
 // static constants
 
 SHARING_MAPT(const std::string)::not_found_msg="key not found";
+SHARING_MAPT(const std::size_t)::dummy_level = 0xff;
 
 SHARING_MAPT(const std::size_t)::bits = 30;
 SHARING_MAPT(const std::size_t)::chunk = 3;