CheckRangeLeftSide struct

ConflictSet.cpp

@@ -950,26 +950,43 @@ downLeftSpine:
 
 // Return true if the max version among all keys that start with key[:prefixLen]
 // that are >= key is <= readVersion
-bool checkRangeLeftSide(Node *n, std::span<const uint8_t> key, int prefixLen,
+struct CheckRangeLeftSide {
-                        int64_t readVersion) {
+  CheckRangeLeftSide(Node *n, std::span<const uint8_t> key, int prefixLen,
+                     int64_t readVersion)
+      : n(n), remaining(key), prefixLen(prefixLen), readVersion(readVersion) {
 #if DEBUG_VERBOSE && !defined(NDEBUG)
     fprintf(stderr, "Check range left side from %s for keys starting with %s\n",
-          printable(key).c_str(), printable(key.subspan(0, prefixLen)).c_str());
+            printable(key).c_str(),
+            printable(key.subspan(0, prefixLen)).c_str());
 #endif
-  auto remaining = key;
+  }
+
+  Node *n;
+  std::span<const uint8_t> remaining;
+  int prefixLen;
+  int64_t readVersion;
   int searchPathLen = 0;
-  for (;;) {
+  bool ok;
+
+  enum Phase { Search, DownLeftSpine } phase = Search;
+
+  bool step() {
+    switch (phase) {
+    case Search: {
       if (n->maxVersion <= readVersion) {
+        ok = true;
         return true;
       }
       if (remaining.size() == 0) {
         assert(searchPathLen >= prefixLen);
-      return n->maxVersion <= readVersion;
+        ok = n->maxVersion <= readVersion;
+        return true;
       }
 
       if (searchPathLen >= prefixLen) {
         if (maxBetweenExclusive(n, remaining[0], 256) > readVersion) {
-        return false;
+          ok = false;
+          return true;
         }
       }
 
@@ -982,16 +999,20 @@ bool checkRangeLeftSide(Node *n, std::span<const uint8_t> key, int prefixLen,
         if (c >= 0) {
           if (searchPathLen < prefixLen) {
             n = getChildExists(n, c);
-          goto downLeftSpine;
+            phase = DownLeftSpine;
-        }
-        if (maxBetweenExclusive(n, c, 256) > readVersion) {
             return false;
           }
+          if (maxBetweenExclusive(n, c, 256) > readVersion) {
+            ok = false;
+            return true;
+          }
           n = getChildExists(n, c);
-        return n->maxVersion <= readVersion;
+          ok = n->maxVersion <= readVersion;
+          return true;
         } else {
           n = nextSibling(n);
-        goto downLeftSpine;
+          phase = DownLeftSpine;
+          return false;
         }
       }
 
@@ -1005,44 +1026,59 @@ bool checkRangeLeftSide(Node *n, std::span<const uint8_t> key, int prefixLen,
           }
           if (c > 0) {
             if (searchPathLen < prefixLen) {
-            goto downLeftSpine;
+              phase = DownLeftSpine;
-          }
-          if (n->entryPresent && n->entry.rangeVersion > readVersion) {
               return false;
             }
-          return n->maxVersion <= readVersion;
+            if (n->entryPresent && n->entry.rangeVersion > readVersion) {
+              ok = false;
+              return true;
+            }
+            ok = n->maxVersion <= readVersion;
+            return true;
           } else {
             n = nextSibling(n);
-          goto downLeftSpine;
+            phase = DownLeftSpine;
+            return false;
           }
         }
         if (commonLen == n->partialKeyLen) {
           // partial key matches
-        remaining = remaining.subspan(commonLen, remaining.size() - commonLen);
+          remaining =
+              remaining.subspan(commonLen, remaining.size() - commonLen);
         } else if (n->partialKeyLen > int(remaining.size())) {
           if (searchPathLen < prefixLen) {
-          goto downLeftSpine;
+            phase = DownLeftSpine;
-        }
-        if (n->entryPresent && n->entry.rangeVersion > readVersion) {
             return false;
           }
-        return n->maxVersion <= readVersion;
+          if (n->entryPresent && n->entry.rangeVersion > readVersion) {
+            ok = false;
+            return true;
+          }
+          ok = n->maxVersion <= readVersion;
+          return true;
         }
       }
+      break;
     }
-downLeftSpine:
+    case DownLeftSpine:
       if (n == nullptr) {
+        ok = true;
         return true;
       }
       for (;;) {
         if (n->entryPresent) {
-      return n->entry.rangeVersion <= readVersion;
+          ok = n->entry.rangeVersion <= readVersion;
+          return true;
         }
         int c = getChildGeq(n, 0);
         assert(c >= 0);
         n = getChildExists(n, c);
       }
-}
+      break;
+    }
+    return false;
+  }
+};
 
 // Return true if the max version among all keys that start with key[:prefixLen]
 // that are < key is <= readVersion
@@ -1190,7 +1226,10 @@ bool checkRangeRead(Node *n, std::span<const uint8_t> begin,
     return true;
   }
 
-  if (!checkRangeLeftSide(n, begin, lcp + 1, readVersion)) {
+  CheckRangeLeftSide checkRangeLeftSide{n, begin, lcp + 1, readVersion};
+  while (!checkRangeLeftSide.step())
+    ;
+  if (!checkRangeLeftSide.ok) {
     return false;
   }