Make get_delta_view() of sharing map independent of tree depth

Author: danpoe

src/util/sharing_map.h

@@ -530,6 +530,11 @@ class sharing_mapt
 
   void gather_all(const innert &n, delta_viewt &delta_view) const;
 
+  bool is_singular(const leaf_listt &ll) const
+  {
+    return !ll.empty() && std::next(ll.begin()) == ll.end();
+  }
+
   std::size_t count_unmarked_nodes(
     bool leafs_only,
     std::set<const void *> &marked,
@@ -787,7 +792,7 @@ ::get_delta_view(
     return;
   }
 
-  typedef std::tuple<unsigned, const baset *, const baset *> stack_itemt;
+  typedef std::pair<const innert *, const innert *> stack_itemt;
   std::stack<stack_itemt> stack;
 
   // We do a DFS "in lockstep" simultaneously on both maps. For
@@ -797,71 +802,106 @@ ::get_delta_view(
   // The stack contains the children of already visited nodes that we
   // still have to visit during the traversal.
 
-  stack.push(stack_itemt(0, &map, &other.map));
+  if(map.shares_with(other.map))
+    return;
+
+  stack.push(stack_itemt(&map, &other.map));
 
   do
   {
     const stack_itemt &si = stack.top();
 
-    const unsigned depth = std::get<0>(si);
-    const baset *bp1 = std::get<1>(si);
-    const baset *bp2 = std::get<2>(si);
+    const innert *ip1 = si.first;
+    const innert *ip2 = si.second;
 
     stack.pop();
 
-    if(depth < steps) // internal
+    SM_ASSERT(!ip1->empty());
+    SM_ASSERT(!ip2->empty());
+
+    if(ip1->is_internal() && ip2->is_container())
     {
-      const innert *ip1 = static_cast<const innert *>(bp1);
-      const innert *ip2 = static_cast<const innert *>(bp2);
+      // The container *ip2 contains one element as only containers at the
+      // bottom of the tree can have more than one element. This happens when
+      // two different keys have the same hash code. It is known here that *ip2
+      // is not at the bottom of the tree, as *ip1 (the corresponding node in
+      // the other map) is an internal node, and internal nodes cannot be at the
+      // bottom of the map.
+      SM_ASSERT(is_singular(ip2->get_container()));
+
+      for(const auto &item : ip1->get_to_map())
+      {
+        const innert &child = item.second;
+        SM_ASSERT(!child.shares_with(*ip2));
+        stack.push(stack_itemt(&child, ip2));
+      }
 
-      const to_mapt &m = ip1->get_to_map();
+      continue;
+    }
 
-      for(const auto &item : m)
+    if(ip1->is_internal())
+    {
+      SM_ASSERT(ip2->is_internal());
+
+      for(const auto &item : ip1->get_to_map())
       {
-        const innert *p;
+        const innert &child = item.second;
 
+        const innert *p;
         p = ip2->find_child(item.first);
-        if(p==nullptr)
+
+        if(p == nullptr)
         {
           if(!only_common)
           {
-            gather_all(item.second, delta_view);
+            gather_all(child, delta_view);
           }
         }
-        else if(!item.second.shares_with(*p))
+        else if(!child.shares_with(*p))
         {
-          stack.push(stack_itemt(depth + 1, &item.second, p));
+          stack.push(stack_itemt(&child, p));
         }
       }
+
+      continue;
     }
-    else // container
-    {
-      SM_ASSERT(depth == steps);
 
-      const innert *cp1 = static_cast<const innert *>(bp1);
-      const innert *cp2 = static_cast<const innert *>(bp2);
+    SM_ASSERT(ip1->is_container());
 
-      const leaf_listt &ll1 = cp1->get_container();
+    if(ip2->is_internal())
+    {
+      SM_ASSERT(is_singular(ip1->get_container()));
 
-      for(const auto &l1 : ll1)
+      for(const auto &item : ip2->get_to_map())
       {
-        const key_type &k1=l1.get_key();
-        const leaft *p;
+        const innert &child = item.second;
+        SM_ASSERT(!ip1->shares_with(child));
+        stack.push(stack_itemt(ip1, &child));
+      }
 
-        p = cp2->find_leaf(k1);
+      continue;
+    }
 
-        if(p != nullptr)
-        {
-          if(!l1.shares_with(*p))
-          {
-            delta_view.push_back({true, k1, l1.get_value(), p->get_value()});
-          }
-        }
-        else if(!only_common)
+    SM_ASSERT(ip2->is_container());
+
+    for(const auto &l1 : ip1->get_container())
+    {
+      const key_type &k1 = l1.get_key();
+      const leaft *p;
+
+      p = ip2->find_leaf(k1);
+
+      if(p != nullptr)
+      {
+        if(!l1.shares_with(*p))
         {
-          delta_view.push_back({false, l1.get_key(), l1.get_value(), dummy});
+          delta_view.push_back({true, k1, l1.get_value(), p->get_value()});
         }
       }
+      else if(!only_common)
+      {
+        delta_view.push_back({false, l1.get_key(), l1.get_value(), dummy});
+      }
     }
   }
   while(!stack.empty());