mirror of
https://github.com/status-im/nimbus-eth1.git
synced 2025-01-16 23:31:16 +00:00
01ca415721
Currently, computed hash keys are stored in a separate column family with respect to the MPT data they're generated from - this has several disadvantages: * A lot of space is wasted because the lookup key (`RootedVertexID`) is repeated in both tables - this is 30% of the `AriKey` content! * rocksdb must maintain in-memory bloom filters and LRU caches for said keys, doubling its "minimal efficient cache size" * An extra disk traversal must be made to check for existence of cached hash key * Doubles the amount of files on disk due to each column family being its own set of files Here, the two CFs are joined such that both key and data is stored in `AriVtx`. This means: * we save ~30% disk space on repeated lookup keys * we save ~2gb of memory overhead that can be used to cache data instead of indices * we can skip storing hash keys for MPT leaf nodes - these are trivial to compute and waste a lot of space - previously they had to present in the `AriKey` CF to avoid having to look in two tables on the happy path. * There is a small increase in write amplification because when a hash value is updated for a branch node, we must write both key and branch data - previously we would write only the key * There's a small shift in CPU usage - instead of performing lookups in the database, hashes for leaf nodes are (re)-computed on the fly * We can return to slightly smaller on-disk SST files since there's fewer of them, which should reduce disk traffic a bit Internally, there are also other advantages: * when clearing keys, we no longer have to store a zero hash in memory - instead, we deduce staleness of the cached key from the presence of an updated VertexRef - this saves ~1gb of mem overhead during import * hash key cache becomes dedicated to branch keys since leaf keys are no longer stored in memory, reducing churn * key computation is a lot faster thanks to the skipped second disk traversal - a key computation for mainnet can be completed in 11 hours instead of ~2 days (!) thanks to better cache usage and less read amplification - with additional improvements to the on-disk format, we can probably get rid of the initial full traversal method of seeding the key cache on first start after import All in all, this PR reduces the size of a mainnet database from 160gb to 110gb and the peak memory footprint during import by ~1-2gb.
302 lines
9.1 KiB
Nim
302 lines
9.1 KiB
Nim
# nimbus-eth1
|
|
# Copyright (c) 2023-2024 Status Research & Development GmbH
|
|
# Licensed under either of
|
|
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
|
|
# http://www.apache.org/licenses/LICENSE-2.0)
|
|
# * MIT license ([LICENSE-MIT](LICENSE-MIT) or
|
|
# http://opensource.org/licenses/MIT)
|
|
# at your option. This file may not be copied, modified, or distributed
|
|
# except according to those terms.
|
|
|
|
## Aristo DB -- Patricia Trie delete funcionality
|
|
## ==============================================
|
|
##
|
|
|
|
{.push raises: [].}
|
|
|
|
import
|
|
std/typetraits,
|
|
eth/common,
|
|
results,
|
|
./aristo_delete/delete_subtree,
|
|
"."/[aristo_desc, aristo_fetch, aristo_get, aristo_hike, aristo_layers]
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Private heplers
|
|
# ------------------------------------------------------------------------------
|
|
|
|
proc branchStillNeeded(vtx: VertexRef, removed: int): Result[int,void] =
|
|
## Returns the nibble if there is only one reference left.
|
|
var nibble = -1
|
|
for n in 0 .. 15:
|
|
if n == removed:
|
|
continue
|
|
|
|
if vtx.bVid[n].isValid:
|
|
if 0 <= nibble:
|
|
return ok(-1)
|
|
nibble = n
|
|
if 0 <= nibble:
|
|
return ok(nibble)
|
|
# Oops, degenerated branch node
|
|
err()
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Private functions
|
|
# ------------------------------------------------------------------------------
|
|
|
|
proc deleteImpl(
|
|
db: AristoDbRef; # Database, top layer
|
|
hike: Hike; # Fully expanded path
|
|
): Result[VertexRef,AristoError] =
|
|
## Removes the last node in the hike and returns the updated leaf in case
|
|
## a branch collapsed
|
|
|
|
# Remove leaf entry
|
|
let lf = hike.legs[^1].wp
|
|
if lf.vtx.vType != Leaf:
|
|
return err(DelLeafExpexted)
|
|
|
|
db.layersResVtx((hike.root, lf.vid))
|
|
|
|
if hike.legs.len == 1:
|
|
# This was the last node in the trie, meaning we don't have any branches or
|
|
# leaves to update
|
|
return ok(nil)
|
|
|
|
if hike.legs[^2].wp.vtx.vType != Branch:
|
|
return err(DelBranchExpexted)
|
|
|
|
# Get current `Branch` vertex `br`
|
|
let
|
|
br = hike.legs[^2].wp
|
|
nbl = br.vtx.branchStillNeeded(hike.legs[^2].nibble).valueOr:
|
|
return err(DelBranchWithoutRefs)
|
|
|
|
# Clear all Merkle hash keys up to the root key
|
|
for n in 0 .. hike.legs.len - 2:
|
|
let wp = hike.legs[n].wp
|
|
db.layersResKey((hike.root, wp.vid), wp.vtx)
|
|
|
|
if 0 <= nbl:
|
|
# Branch has only one entry - move that entry to where the branch was and
|
|
# update its path
|
|
|
|
# Get child vertex (there must be one after a `Branch` node)
|
|
let
|
|
vid = br.vtx.bVid[nbl]
|
|
nxt = db.getVtx (hike.root, vid)
|
|
if not nxt.isValid:
|
|
return err(DelVidStaleVtx)
|
|
|
|
db.layersResVtx((hike.root, vid))
|
|
|
|
let vtx =
|
|
case nxt.vType
|
|
of Leaf:
|
|
VertexRef(
|
|
vType: Leaf,
|
|
pfx: br.vtx.pfx & NibblesBuf.nibble(nbl.byte) & nxt.pfx,
|
|
lData: nxt.lData)
|
|
|
|
of Branch:
|
|
VertexRef(
|
|
vType: Branch,
|
|
pfx: br.vtx.pfx & NibblesBuf.nibble(nbl.byte) & nxt.pfx,
|
|
bVid: nxt.bVid)
|
|
|
|
# Put the new vertex at the id of the obsolete branch
|
|
db.layersPutVtx((hike.root, br.vid), vtx)
|
|
|
|
if vtx.vType == Leaf:
|
|
ok(vtx)
|
|
else:
|
|
ok(nil)
|
|
else:
|
|
# Clear the removed leaf from the branch (that still contains other children)
|
|
let brDup = br.vtx.dup
|
|
brDup.bVid[hike.legs[^2].nibble] = VertexID(0)
|
|
db.layersPutVtx((hike.root, br.vid), brDup)
|
|
|
|
ok(nil)
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Public functions
|
|
# ------------------------------------------------------------------------------
|
|
|
|
proc deleteAccountRecord*(
|
|
db: AristoDbRef;
|
|
accPath: Hash32;
|
|
): Result[void,AristoError] =
|
|
## Delete the account leaf entry addressed by the argument `path`. If this
|
|
## leaf entry referres to a storage tree, this one will be deleted as well.
|
|
##
|
|
var accHike: Hike
|
|
db.fetchAccountHike(accPath, accHike).isOkOr:
|
|
if error == FetchAccInaccessible:
|
|
return err(DelPathNotFound)
|
|
return err(error)
|
|
let
|
|
stoID = accHike.legs[^1].wp.vtx.lData.stoID
|
|
|
|
# Delete storage tree if present
|
|
if stoID.isValid:
|
|
? db.delStoTreeImpl((stoID.vid, stoID.vid), accPath)
|
|
|
|
let otherLeaf = ?db.deleteImpl(accHike)
|
|
|
|
db.layersPutAccLeaf(accPath, nil)
|
|
|
|
if otherLeaf.isValid:
|
|
db.layersPutAccLeaf(
|
|
Hash32(getBytes(NibblesBuf.fromBytes(accPath.data).replaceSuffix(otherLeaf.pfx))),
|
|
otherLeaf)
|
|
|
|
ok()
|
|
|
|
proc deleteGenericData*(
|
|
db: AristoDbRef;
|
|
root: VertexID;
|
|
path: openArray[byte];
|
|
): Result[bool,AristoError] =
|
|
## Delete the leaf data entry addressed by the argument `path`. The MPT
|
|
## sub-tree the leaf data entry is subsumed under is passed as argument
|
|
## `root` which must be greater than `VertexID(1)` and smaller than
|
|
## `LEAST_FREE_VID`.
|
|
##
|
|
## The return value is `true` if the argument `path` deleted was the last
|
|
## one and the tree does not exist anymore.
|
|
##
|
|
# Verify that `root` is neither an accounts tree nor a strorage tree.
|
|
if not root.isValid:
|
|
return err(DelRootVidMissing)
|
|
elif root == VertexID(1):
|
|
return err(DelAccRootNotAccepted)
|
|
elif LEAST_FREE_VID <= root.distinctBase:
|
|
return err(DelStoRootNotAccepted)
|
|
|
|
var hike: Hike
|
|
path.hikeUp(root, db, Opt.none(VertexRef), hike).isOkOr:
|
|
if error[1] in HikeAcceptableStopsNotFound:
|
|
return err(DelPathNotFound)
|
|
return err(error[1])
|
|
|
|
discard ?db.deleteImpl(hike)
|
|
|
|
ok(not db.getVtx((root, root)).isValid)
|
|
|
|
proc deleteGenericTree*(
|
|
db: AristoDbRef; # Database, top layer
|
|
root: VertexID; # Root vertex
|
|
): Result[void,AristoError] =
|
|
## Variant of `deleteGenericData()` for purging the whole MPT sub-tree.
|
|
##
|
|
# Verify that `root` is neither an accounts tree nor a strorage tree.
|
|
if not root.isValid:
|
|
return err(DelRootVidMissing)
|
|
elif root == VertexID(1):
|
|
return err(DelAccRootNotAccepted)
|
|
elif LEAST_FREE_VID <= root.distinctBase:
|
|
return err(DelStoRootNotAccepted)
|
|
|
|
db.delSubTreeImpl root
|
|
|
|
proc deleteStorageData*(
|
|
db: AristoDbRef;
|
|
accPath: Hash32; # Implies storage data tree
|
|
stoPath: Hash32;
|
|
): Result[bool,AristoError] =
|
|
## For a given account argument `accPath`, this function deletes the
|
|
## argument `stoPath` from the associated storage tree (if any, at all.) If
|
|
## the if the argument `stoPath` deleted was the last one on the storage tree,
|
|
## account leaf referred to by `accPath` will be updated so that it will
|
|
## not refer to a storage tree anymore. In the latter case only the function
|
|
## will return `true`.
|
|
##
|
|
|
|
let
|
|
mixPath = mixUp(accPath, stoPath)
|
|
stoLeaf = db.cachedStoLeaf(mixPath)
|
|
|
|
if stoLeaf == Opt.some(nil):
|
|
return err(DelPathNotFound)
|
|
|
|
var accHike: Hike
|
|
db.fetchAccountHike(accPath, accHike).isOkOr:
|
|
if error == FetchAccInaccessible:
|
|
return err(DelStoAccMissing)
|
|
return err(error)
|
|
|
|
let
|
|
wpAcc = accHike.legs[^1].wp
|
|
stoID = wpAcc.vtx.lData.stoID
|
|
|
|
if not stoID.isValid:
|
|
return err(DelStoRootMissing)
|
|
|
|
let stoNibbles = NibblesBuf.fromBytes(stoPath.data)
|
|
var stoHike: Hike
|
|
stoNibbles.hikeUp(stoID.vid, db, stoLeaf, stoHike).isOkOr:
|
|
if error[1] in HikeAcceptableStopsNotFound:
|
|
return err(DelPathNotFound)
|
|
return err(error[1])
|
|
|
|
# Mark account path Merkle keys for update
|
|
db.layersResKeys accHike
|
|
|
|
let otherLeaf = ?db.deleteImpl(stoHike)
|
|
db.layersPutStoLeaf(mixPath, nil)
|
|
|
|
if otherLeaf.isValid:
|
|
let leafMixPath = mixUp(
|
|
accPath,
|
|
Hash32(getBytes(stoNibbles.replaceSuffix(otherLeaf.pfx))))
|
|
db.layersPutStoLeaf(leafMixPath, otherLeaf)
|
|
|
|
# If there was only one item (that got deleted), update the account as well
|
|
if stoHike.legs.len > 1:
|
|
return ok(false)
|
|
|
|
# De-register the deleted storage tree from the account record
|
|
let leaf = wpAcc.vtx.dup # Dup on modify
|
|
leaf.lData.stoID.isValid = false
|
|
db.layersPutAccLeaf(accPath, leaf)
|
|
db.layersPutVtx((accHike.root, wpAcc.vid), leaf)
|
|
ok(true)
|
|
|
|
proc deleteStorageTree*(
|
|
db: AristoDbRef; # Database, top layer
|
|
accPath: Hash32; # Implies storage data tree
|
|
): Result[void,AristoError] =
|
|
## Variant of `deleteStorageData()` for purging the whole storage tree
|
|
## associated to the account argument `accPath`.
|
|
##
|
|
var accHike: Hike
|
|
db.fetchAccountHike(accPath, accHike).isOkOr:
|
|
if error == FetchAccInaccessible:
|
|
return err(DelStoAccMissing)
|
|
return err(error)
|
|
|
|
let
|
|
wpAcc = accHike.legs[^1].wp
|
|
stoID = wpAcc.vtx.lData.stoID
|
|
|
|
if not stoID.isValid:
|
|
return err(DelStoRootMissing)
|
|
|
|
# Mark account path Merkle keys for update
|
|
db.layersResKeys accHike
|
|
|
|
? db.delStoTreeImpl((stoID.vid, stoID.vid), accPath)
|
|
|
|
# De-register the deleted storage tree from the accounts record
|
|
let leaf = wpAcc.vtx.dup # Dup on modify
|
|
leaf.lData.stoID.isValid = false
|
|
db.layersPutAccLeaf(accPath, leaf)
|
|
db.layersPutVtx((accHike.root, wpAcc.vid), leaf)
|
|
ok()
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# End
|
|
# ------------------------------------------------------------------------------
|