Path-based VertexID

VertexID has 64 bits of values but currently, but the chain state
database uses only a tiny fraction of that (~27 bits). Here, we split up
the number space into a fixed portion statically allocated from the MPT
path and a dynamic portion for leaves and storage slots.

The static portion simply allocates a (bread-first) number based on the
first nibbles in the address/path while any "deeper" paths instead get a
dynamic VertexID like before.

Since the VertedID is path-based, we can more or less guess the VertexID
of any node whose path we know based on the "average" depth of the state
trie. When we're lucky, a single lookup is sufficient to find the node
instead of a one-by-one traversal of each level.

Even in the case that a single lookup is not enough and the actual node
is "deeper" than the guess, the starting point helps skip a few levels
at least.

Tree depth is estimated by keeping track of hits and misses and
occasionally making an adjustment in the direction of the most misses.

On average, this shaves 25% of the import speed for the first 15M blocks
where the lookup depth is guessed to be 7 levels - deepening the trie by
one more level (when more accounts eventually are added) would see even
better performance.

Using 8 levels of statically assigned ids results in 2**32 bits left for
dynamic ids / storage slots - this should by far be enough for any
foreseeable lifetime of the application, specially because large parts
of "current" usage of vertexid space is remains used by actual nodes.

The resulting lookup structure can be thought of as a hybrid between
fully path-based lookupts and the current "sparse" id mapping.

made with coffee sponsored by 0x-r4bbit

fix off-by-one

cleanups

Author: arnetheduck

execution_chain/db/aristo/aristo_blobify.nim

@@ -51,7 +51,7 @@ template data*(v: SbeBuf): openArray[byte] =
 func blobify*(rvid: RootedVertexID): RVidBuf =
   # Length-prefixed root encoding creates a unique and common prefix for all
   # verticies sharing the same root
-  # TODO evaluate an encoding that colocates short roots (like VertexID(1)) with
+  # TODO evaluate an encoding that colocates short roots (like STATE_ROOT_VID) with
   #      the length
   let root = rvid.root.blobify()
   result.buf[0] = root.len

execution_chain/db/aristo/aristo_check/check_top.nim

@@ -113,13 +113,6 @@ proc checkTopCommon*(
       if rc.value[0].isValid:
         return err((rvid.vid,CheckAnyVtxEmptyKeyExpected))
 
-  if vTop.distinctBase < LEAST_FREE_VID:
-    # Verify that all vids are below `LEAST_FREE_VID`
-    if topVid.distinctBase < LEAST_FREE_VID:
-      for (rvid,key) in db.layersWalkKey:
-        if key.isValid and LEAST_FREE_VID <= rvid.vid.distinctBase:
-          return err((topVid,CheckAnyVTopUnset))
-
   # If present, there are at least as many deleted hashes as there are deleted
   # vertices.
   if kMapNilCount != 0 and kMapNilCount < nNilVtx:

execution_chain/db/aristo/aristo_check/check_twig.nim

@@ -25,7 +25,7 @@ proc checkTwig*(
       ): Result[void,AristoError] =
   let
     proof = ? db.makeAccountProof(accPath)
-    key = ? db.computeKey (VertexID(1),VertexID(1))
+    key = ? db.computeKey (STATE_ROOT_VID,STATE_ROOT_VID)
   discard ? proof[0].verifyProof(key.to(Hash32), accPath)
 
   ok()
@@ -38,7 +38,7 @@ proc checkTwig*(
   let
     proof = ? db.makeStorageProof(accPath, stoPath)
     vid = ? db.fetchStorageID accPath
-    key = ? db.computeKey (VertexID(1),vid)
+    key = ? db.computeKey (STATE_ROOT_VID,vid)
   discard ? proof[0].verifyProof(key.to(Hash32), stoPath)
 
   ok()

execution_chain/db/aristo/aristo_constants.nim

@@ -27,19 +27,25 @@ const
   VOID_HASH_KEY* = HashKey()
     ## Void equivalent for Merkle hash value
 
-  LEAST_FREE_VID* = 100
-    ## Vids smaller are used as known state roots and cannot be recycled. Only
-    ## the `VertexID(1)` state root is used by the `Aristo` methods. The other
-    ## numbers smaller than `LEAST_FREE_VID` may be used by application
-    ## functions with fixed assignments of the type of a state root (e.g. for
-    ## a receipt or a transaction root.)
+  STATE_ROOT_VID* = VertexID(1)
+    ## VertexID of state root entry in the MPT
+
+  STATIC_VID_LEVELS* = 8
+    ## Number of MPT levels in the account trie that get a fixed VertexID based
+    ## on the initial nibbles of the path. We'll consume a little bit more than
+    ## `STATIC_VID_LEVELS*4` bits for the static part of the vid space:
+    ##
+    ## STATE_ROOT_VID + 16^0 + 16^1 + ... + 16^STATIC_VID_LEVELS
+
+  FIRST_DYNAMIC_VID* = ## First VertexID of the sparse/dynamic part of the MPT
+    block:
+      var v = uint64(STATE_ROOT_VID)
+      for i in 0..STATIC_VID_LEVELS:
+        v += 1'u64 shl (i * 4)
+      v
 
   ACC_LRU_SIZE* = 1024 * 1024
     ## LRU cache size for accounts that have storage, see `.accLeaves` and
     ## `.stoLeaves` fields of the main descriptor.
 
-static:
-  # must stay away from `VertexID(1)` and `VertexID(2)`
-  doAssert 2 < LEAST_FREE_VID
-
 # End

execution_chain/db/aristo/aristo_desc.nim

@@ -125,6 +125,10 @@ type
     # Debugging data below, might go away in future
     xMap*: Table[HashKey,RootedVertexID] ## For pretty printing/debugging
 
+    staticLevel*: int
+      ## MPT level where "most" leaves can be found, for static vid lookups
+    lookups*: tuple[lower, hits, higher: int]
+
   Leg* = object
     ## For constructing a `VertexPath`
     wp*: VidVtxPair                ## Vertex ID and data ref
@@ -238,6 +242,23 @@ proc deltaAtLevel*(db: AristoTxRef, level: int): AristoTxRef =
         return frame
     nil
 
+func getStaticLevel*(db: AristoDbRef): int =
+  # Retrieve the level where we can expect to find a leaf, updating it based on
+  # recent lookups
+
+  if db.lookups[0] + db.lookups[1] + db.lookups[2] >= 1024:
+    if db.lookups.lower > db.lookups.hits + db.lookups.higher:
+      db.staticLevel = max(1, db.staticLevel - 1)
+    elif db.lookups.higher > db.lookups.hits + db.lookups.lower:
+      db.staticLevel = min(STATIC_VID_LEVELS, db.staticLevel + 1)
+    reset(db.lookups)
+
+  if db.staticLevel == 0:
+    db.staticLevel = 1
+
+  db.staticLevel
+
+
 # ------------------------------------------------------------------------------
 # End
 # ------------------------------------------------------------------------------

execution_chain/db/aristo/aristo_fetch.nim

@@ -17,7 +17,7 @@ import
   std/typetraits,
   eth/common/[base, hashes],
   results,
-  "."/[aristo_compute, aristo_desc, aristo_get, aristo_layers, aristo_hike]
+  "."/[aristo_compute, aristo_desc, aristo_get, aristo_layers, aristo_hike, aristo_vid]
 
 # ------------------------------------------------------------------------------
 # Private functions
@@ -26,9 +26,10 @@ import
 proc retrieveLeaf(
     db: AristoTxRef;
     root: VertexID;
-    path: Hash32;
+    path: NibblesBuf;
+    next = VertexID(0),
       ): Result[VertexRef,AristoError] =
-  for step in stepUp(NibblesBuf.fromBytes(path.data), root, db):
+  for step in stepUp(path, root, db, next):
     let vtx = step.valueOr:
       if error in HikeAcceptableStopsNotFound:
         return err(FetchPathNotFound)
@@ -53,6 +54,80 @@ proc cachedStoLeaf*(db: AristoTxRef; mixPath: Hash32): Opt[StoLeafRef] =
     db.db.stoLeaves.get(mixPath) or
     Opt.none(StoLeafRef)
 
+proc retrieveAccStatic(
+    db: AristoTxRef;
+    accPath: Hash32;
+      ): Result[(AccLeafRef, NibblesBuf, VertexID),AristoError] =
+  # A static VertexID essentially splits the path into a prefix encoded in the
+  # vid and the rest of the path stored as normal - here, instead of traversing
+  # the trie from the root and selecting a path nibble by nibble we travers the
+  # trie starting at `staticLevel` and search towards the root until either we
+  # hit the node we're looking for or at least a branch from which we can
+  # shorten the lookup.
+  let staticLevel = db.db.getStaticLevel()
+
+  var path = NibblesBuf.fromBytes(accPath.data)
+  var next: VertexID
+
+  for sl in countdown(staticLevel, 0):
+    template countHitOrLower() =
+      if sl == staticLevel:
+        db.db.lookups.hits += 1
+      else:
+        db.db.lookups.lower += 1
+
+    let
+      svid = path.staticVid(sl)
+      vtx = db.getVtxRc((STATE_ROOT_VID, svid)).valueOr:
+        # Either the node doesn't exist or our guess used too many nibbles and
+        # the trie is not yet this deep at the given path - either way, we'll
+        # try a less deep guess which will result either in a branch,
+        # non-matching leaf or more missing verticies.
+        continue
+
+    case vtx[0].vType
+    of Leaves:
+      let vtx = AccLeafRef(vtx[0])
+
+      countHitOrLower()
+      return
+        if vtx.pfx != path.slice(sl): # Same prefix, different path
+          err FetchPathNotFound
+        else:
+          ok (vtx, path, next)
+    of ExtBranch:
+      let vtx = ExtBranchRef(vtx[0])
+
+      if vtx.pfx != path.slice(sl, sl + vtx.pfx.len): # Same prefix, different path
+        countHitOrLower()
+        return err FetchPathNotFound
+
+      let nibble = path[sl + vtx.pfx.len]
+      next = vtx.bVid(nibble)
+
+      if not next.isValid():
+        countHitOrLower()
+        return err FetchPathNotFound
+
+      path = path.slice(sl + vtx.pfx.len + 1)
+
+      break # Continue the search down the branch children, starting at `next`
+    of Branch: # Same as ExtBranch with vtx.pfx.len == 0!
+      let vtx = BranchRef(vtx[0])
+
+      let nibble = path[sl]
+      next = vtx.bVid(nibble)
+
+      if not next.isValid():
+        countHitOrLower()
+        return err FetchPathNotFound
+
+      path = path.slice(sl + 1)
+      break # Continue the search down the branch children, starting at `next`
+
+  # We end up here when we have to continue the search down a branch
+  ok (nil, path, next)
+
 proc retrieveAccLeaf(
     db: AristoTxRef;
     accPath: Hash32;
@@ -62,14 +137,29 @@ proc retrieveAccLeaf(
       return err(FetchPathNotFound)
     return ok leafVtx[]
 
+  let (staticVtx, path, next) = db.retrieveAccStatic(accPath).valueOr:
+    if error == FetchPathNotFound:
+      db.db.accLeaves.put(accPath, nil)
+    return err(error)
+
+  if staticVtx.isValid():
+    db.db.accLeaves.put(accPath, staticVtx)
+    return ok staticVtx
+
   # Updated payloads are stored in the layers so if we didn't find them there,
   # it must have been in the database
   let
-    leafVtx = db.retrieveLeaf(VertexID(1), accPath).valueOr:
+    leafVtx = db.retrieveLeaf(STATE_ROOT_VID, path, next).valueOr:
       if error == FetchPathNotFound:
+        # The branch was the deepest level where a vertex actually existed
+        # meaning that it was a hit - else searches for non-existing paths would
+        # skew the results towards more depth than exists in the MPT
+        db.db.lookups.hits += 1
         db.db.accLeaves.put(accPath, nil)
       return err(error)
 
+  db.db.lookups.higher += 1
+
   db.db.accLeaves.put(accPath, AccLeafRef(leafVtx))
 
   ok AccLeafRef(leafVtx)
@@ -130,7 +220,7 @@ proc fetchAccountHike*(
   if leaf == Opt.some(AccLeafRef(nil)):
     return err(FetchAccInaccessible)
 
-  accPath.hikeUp(VertexID(1), db, leaf, accHike).isOkOr:
+  accPath.hikeUp(STATE_ROOT_VID, db, leaf, accHike).isOkOr:
     return err(FetchAccInaccessible)
 
   # Extract the account payload from the leaf
@@ -163,7 +253,8 @@ proc retrieveStoragePayload(
 
   # Updated payloads are stored in the layers so if we didn't find them there,
   # it must have been in the database
-  let leafVtx = db.retrieveLeaf(? db.fetchStorageIdImpl(accPath), stoPath).valueOr:
+  let leafVtx = db.retrieveLeaf(
+      ? db.fetchStorageIdImpl(accPath), NibblesBuf.fromBytes(stoPath.data)).valueOr:
     if error == FetchPathNotFound:
       db.db.stoLeaves.put(mixPath, nil)
     return err(error)
@@ -214,7 +305,7 @@ proc fetchStateRoot*(
     db: AristoTxRef;
       ): Result[Hash32,AristoError] =
   ## Fetch the Merkle hash of the account root.
-  db.retrieveMerkleHash(VertexID(1))
+  db.retrieveMerkleHash(STATE_ROOT_VID)
 
 proc hasPathAccount*(
     db: AristoTxRef;

execution_chain/db/aristo/aristo_hike.nim

@@ -124,13 +124,14 @@ iterator stepUp*(
     path: NibblesBuf;                            # Partial path
     root: VertexID;                              # Start vertex
     db: AristoTxRef;                             # Database
+    next = VertexID(0)
 ): Result[VertexRef, AristoError] =
   ## For the argument `path`, iterate over the logest possible path in the
   ## argument database `db`.
   var
     path = path
-    next = root
-    vtx: VertexRef
+    next = if next == VertexID(0): root else: next
+    vtx = VertexRef(nil)
   block iter:
     while true:
       (vtx, path, next) = step(path, (root, next), db).valueOr:

execution_chain/db/aristo/aristo_init/rocks_db/rdb_desc.nim

@@ -91,7 +91,7 @@ template toOpenArray*(xid: AdminTabID): openArray[byte] =
   xid.uint64.toBytesBE.toOpenArray(0,7)
 
 template to*(v: RootedVertexID, T: type RdbStateType): RdbStateType =
-  if v.root == VertexID(1): RdbStateType.World else: RdbStateType.Account
+  if v.root == STATE_ROOT_VID: RdbStateType.World else: RdbStateType.Account
 
 template inc*(v: var RdbLruCounter, hit: bool) =
   discard v[hit].fetchAdd(1, moRelaxed)