Add empty / miss lru cache

Empties were handled by the leaf cache previously

Author: arnetheduck

execution_chain/db/aristo/aristo_init/rocks_db.nim

@@ -245,7 +245,7 @@ proc rocksDbBackend*(
 
 iterator walkVtx*(
     be: RdbBackendRef;
-    kinds = {Branch, ExtBranch, AccLeaf, StoLeaf};
+    kinds = {VertexType.Branch, VertexType.ExtBranch, AccLeaf, StoLeaf};
       ): tuple[evid: RootedVertexID, vtx: VertexRef] =
   ## Variant of `walk()` iteration over the vertex sub-table.
   for (rvid, vtx) in be.rdb.walkVtx(kinds):

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

@@ -62,6 +62,8 @@ type
     rdBranchLru*: LruCache[VertexID, (VertexID, uint16)]
     rdBranchSize*: int
 
+    rdEmptyLru*: LruCache[VertexID,tuple[]] ## Read cache
+
   AristoCFs* = enum
     ## Column family symbols/handles and names used on the database
     AdmCF = "AriAdm"                   ## Admin column family name
@@ -73,14 +75,20 @@ type
     Account
     World
 
+  RdbVertexType* = enum
+    Empty
+    Leaf
+    Branch
+    ExtBranch
+
 var
   # Hit/miss counters for LRU cache - global so as to integrate easily with
   # nim-metrics and `uint64` to ensure that increasing them is fast - collection
   # happens from a separate thread.
   # TODO maybe turn this into more general framework for LRU reporting since
   #      we have lots of caches of this sort
   rdbBranchLruStats*: array[RdbStateType, RdbLruCounter]
-  rdbVtxLruStats*: array[RdbStateType, array[VertexType, RdbLruCounter]]
+  rdbVtxLruStats*: array[RdbStateType, array[RdbVertexType, RdbLruCounter]]
   rdbKeyLruStats*: array[RdbStateType, RdbLruCounter]
 
 # ------------------------------------------------------------------------------
@@ -93,6 +101,12 @@ template toOpenArray*(xid: AdminTabID): openArray[byte] =
 template to*(v: RootedVertexID, T: type RdbStateType): RdbStateType =
   if v.root == STATE_ROOT_VID: RdbStateType.World else: RdbStateType.Account
 
+template to*(v: VertexType, T: type RdbVertexType): RdbVertexType =
+  case v
+  of VertexType.AccLeaf, VertexType.StoLeaf: RdbVertexType.Leaf
+  of VertexType.Branch: RdbVertexType.Branch
+  of VertexType.ExtBranch: RdbVertexType.ExtBranch
+
 template inc*(v: var RdbLruCounter, hit: bool) =
   discard v[hit].fetchAdd(1, moRelaxed)
 

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

@@ -56,7 +56,7 @@ when defined(metrics):
     # We don't care about synchronization between each type of metric or between
     # the metrics thread and others since small differences like this don't matter
     for state in RdbStateType:
-      for vtype in VertexType:
+      for vtype in RdbVertexType:
         for hit in [false, true]:
           output(
             name = "aristo_rdb_vtx_lru_total",
@@ -191,9 +191,21 @@ proc getVtx*(
         rdb.rdVtxLru.get(rvid.vid)
 
     if rc.isOk:
-      rdbVtxLruStats[rvid.to(RdbStateType)][rc.value().vType].inc(true)
+      rdbVtxLruStats[rvid.to(RdbStateType)][rc.value().vType.to(RdbVertexType)].inc(
+        true
+      )
       return ok(move(rc.value))
 
+  block:
+    var rc =
+      if GetVtxFlag.PeekCache in flags:
+        rdb.rdEmptyLru.peek(rvid.vid)
+      else:
+        rdb.rdEmptyLru.get(rvid.vid)
+    if rc.isOk():
+      rdbVtxLruStats[rvid.to(RdbStateType)][RdbVertexType.Empty].inc(true)
+      return ok(VertexRef(nil))
+
   # Otherwise fetch from backend database
   # A threadvar is used to avoid allocating an environment for onData
   var res {.threadvar.}: Result[VertexRef, AristoError]
@@ -207,8 +219,10 @@ proc getVtx*(
     return err((errSym, error))
 
   if not gotData:
-    # As a hack, we count missing data as leaf nodes
-    rdbVtxLruStats[rvid.to(RdbStateType)][VertexType.StoLeaf].inc(false)
+    rdbVtxLruStats[rvid.to(RdbStateType)][RdbVertexType.Empty].inc(false)
+    if GetVtxFlag.PeekCache notin flags:
+      rdb.rdEmptyLru.put(rvid.vid, default(tuple[])) # TODO LRU void support
+
     return ok(VertexRef(nil))
 
   if res.isErr():
@@ -217,7 +231,9 @@ proc getVtx*(
   if res.value.vType == Branch:
     rdbBranchLruStats[rvid.to(RdbStateType)].inc(false)
   else:
-    rdbVtxLruStats[rvid.to(RdbStateType)][res.value().vType].inc(false)
+    rdbVtxLruStats[rvid.to(RdbStateType)][res.value().vType.to(RdbVertexType)].inc(
+      false
+    )
 
   # Update cache and return - in peek mode, avoid evicting cache items
   if GetVtxFlag.PeekCache notin flags:

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

@@ -27,7 +27,7 @@ proc dumpCacheStats(keySize, vtxSize, branchSize: int) =
     echo "vtxLru(", vtxSize, ")"
     echo "   state    vtype       miss        hit      total hitrate"
     for state in RdbStateType:
-      for vtype in VertexType:
+      for vtype in RdbVertexType:
         let
           (miss, hit) = (
             rdbVtxLruStats[state][vtype].get(false),
@@ -99,6 +99,7 @@ proc init*(rdb: var RdbInst, opts: DbOptions, baseDb: RocksDbInstanceRef) =
   rdb.rdKeyLru = typeof(rdb.rdKeyLru).init(rdb.rdKeySize)
   rdb.rdVtxLru = typeof(rdb.rdVtxLru).init(rdb.rdVtxSize)
   rdb.rdBranchLru = typeof(rdb.rdBranchLru).init(rdb.rdBranchSize)
+  rdb.rdEmptyLru = typeof(rdb.rdEmptyLru).init(rdb.rdVtxSize) # reuse vtx cache size
 
   if opts.rdbPrintStats:
     let

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

@@ -105,6 +105,8 @@ proc putVtx*(
       else:
         discard rdb.rdVtxLru.update(rvid.vid, vtx)
 
+    rdb.rdEmptyLru.del(rvid.vid)
+
     if key.isValid:
       if rdb.rdKeyLru.len < rdb.rdKeyLru.capacity:
         rdb.rdKeyLru.put(rvid.vid, key)
@@ -126,6 +128,9 @@ proc putVtx*(
     rdb.rdVtxLru.del rvid.vid
     rdb.rdKeyLru.del rvid.vid
 
+    if rdb.rdEmptyLru.len < rdb.rdEmptyLru.capacity:
+      rdb.rdEmptyLru.put(rvid.vid, default(tuple[]))
+
   ok()
 
 # ------------------------------------------------------------------------------