Jacek Sieka f034af422a
Pre-allocate vids for branches (#2882)
Each branch node may have up to 16 sub-items - currently, these are
given VertexID based when they are first needed leading to a
mostly-random order of vertexid for each subitem.

Here, we pre-allocate all 16 vertex ids such that when a branch subitem
is filled, it already has a vertexid waiting for it. This brings several
important benefits:

* subitems are sorted and "close" in their id sequencing - this means
that when rocksdb stores them, they are likely to end up in the same
data block thus improving read efficiency
* because the ids are consequtive, we can store just the starting id and
a bitmap representing which subitems are in use - this reduces disk
space usage for branches allowing more of them fit into a single disk
read, further improving disk read and caching performance - disk usage
at block 18M is down from 84 to 78gb!
* the in-memory footprint of VertexRef reduced allowing more instances
to fit into caches and less memory to be used overall.

Because of the increased locality of reference, it turns out that we no
longer need to iterate over the entire database to efficiently generate
the hash key database because the normal computation is now faster -
this significantly benefits "live" chain processing as well where each
dirtied key must be accompanied by a read of all branch subitems next to
it - most of the performance benefit in this branch comes from this
locality-of-reference improvement.

On a sample resync, there's already ~20% improvement with later blocks
seeing increasing benefit (because the trie is deeper in later blocks
leading to more benefit from branch read perf improvements)

```
blocks: 18729664, baseline: 190h43m49s, contender: 153h59m0s
Time (total): -36h44m48s, -19.27%
```

Note: clients need to be resynced as the PR changes the on-disk format

R.I.P. little bloom filter - your life in the repo was short but
valuable
2024-12-04 11:42:04 +01:00

120 lines
4.2 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 backend data access
## ==============================================
##
{.push raises: [].}
import
results,
"."/[desc_error, desc_identifiers, desc_structural]
type
GetVtxFn* =
proc(rvid: RootedVertexID, flags: set[GetVtxFlag]): Result[VertexRef,AristoError] {.gcsafe, raises: [].}
## Generic backend database retrieval function for a single structural
## `Aristo DB` data record.
GetKeyFn* =
proc(rvid: RootedVertexID, flags: set[GetVtxFlag]): Result[(HashKey, VertexRef),AristoError] {.gcsafe, raises: [].}
## Generic backend database retrieval function for a single
## `Aristo DB` hash lookup value.
GetTuvFn* =
proc(): Result[VertexID,AristoError] {.gcsafe, raises: [].}
## Generic backend database retrieval function for the top used
## vertex ID.
GetLstFn* =
proc(): Result[SavedState,AristoError]
{.gcsafe, raises: [].}
## Generic last recorded state stamp retrieval function
# -------------
PutHdlRef* = ref object of RootRef
## Persistent database transaction frame handle. This handle is used to
## wrap any of `PutVtxFn`, `PutKeyFn`, and `PutIdgFn` into and atomic
## transaction frame. These transaction frames must not be interleaved
## by any library function using the backend.
PutBegFn* =
proc(): Result[PutHdlRef,AristoError] {.gcsafe, raises: [].}
## Generic transaction initialisation function
PutVtxFn* =
proc(hdl: PutHdlRef; rvid: RootedVertexID; vtx: VertexRef, key: HashKey)
{.gcsafe, raises: [].}
## Generic backend database bulk storage function, `VertexRef(nil)`
## values indicate that records should be deleted.
PutTuvFn* =
proc(hdl: PutHdlRef; vs: VertexID)
{.gcsafe, raises: [].}
## Generic backend database ID generator storage function for the
## top used vertex ID.
PutLstFn* =
proc(hdl: PutHdlRef; lst: SavedState)
{.gcsafe, raises: [].}
## Generic last recorded state stamp storage function. This
## function replaces the currentlt saved state.
PutEndFn* =
proc(hdl: PutHdlRef): Result[void,AristoError] {.gcsafe, raises: [].}
## Generic transaction termination function
# -------------
CloseFn* =
proc(eradicate: bool) {.gcsafe, raises: [].}
## Generic destructor for the `Aristo DB` backend. The argument
## `eradicate` indicates that a full database deletion is requested. If
## passed `false` the outcome might differ depending on the type of
## backend (e.g. in-memory backends will always eradicate on close.)
# -------------
BackendRef* = ref BackendObj
BackendObj* = object of RootObj
## Backend interface.
getVtxFn*: GetVtxFn ## Read vertex record
getKeyFn*: GetKeyFn ## Read Merkle hash/key
getTuvFn*: GetTuvFn ## Read top used vertex ID
getLstFn*: GetLstFn ## Read saved state
putBegFn*: PutBegFn ## Start bulk store session
putVtxFn*: PutVtxFn ## Bulk store vertex records
putTuvFn*: PutTuvFn ## Store top used vertex ID
putLstFn*: PutLstFn ## Store saved state
putEndFn*: PutEndFn ## Commit bulk store session
closeFn*: CloseFn ## Generic destructor
proc init*(trg: var BackendObj; src: BackendObj) =
trg.getVtxFn = src.getVtxFn
trg.getKeyFn = src.getKeyFn
trg.getTuvFn = src.getTuvFn
trg.getLstFn = src.getLstFn
trg.putBegFn = src.putBegFn
trg.putVtxFn = src.putVtxFn
trg.putTuvFn = src.putTuvFn
trg.putLstFn = src.putLstFn
trg.putEndFn = src.putEndFn
trg.closeFn = src.closeFn
# ------------------------------------------------------------------------------
# End
# ------------------------------------------------------------------------------