360 lines
12 KiB
Nim
360 lines
12 KiB
Nim
# nimbus-eth1
|
|
# Copyright (c) 2021 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 -- a Patricia Trie with labeled edges
|
|
## ===============================================
|
|
##
|
|
## These data structures allow to overlay the *Patricia Trie* with *Merkel
|
|
## Trie* hashes. See the `README.md` in the `aristo` folder for documentation.
|
|
##
|
|
## Some semantic explanations;
|
|
##
|
|
## * HashKey, NodeRef etc. refer to the standard/legacy `Merkle Patricia Tree`
|
|
## * VertexID, VertexRef, etc. refer to the `Aristo Trie`
|
|
##
|
|
{.push raises: [].}
|
|
|
|
import
|
|
std/[hashes, sets, tables],
|
|
eth/common,
|
|
results,
|
|
./aristo_constants,
|
|
./aristo_desc/[desc_error, desc_identifiers, desc_structural]
|
|
|
|
from ./aristo_desc/desc_backend
|
|
import BackendRef
|
|
|
|
# Not auto-exporting backend
|
|
export
|
|
aristo_constants, desc_error, desc_identifiers, desc_structural
|
|
|
|
type
|
|
AristoDudes* = HashSet[AristoDbRef]
|
|
## Descriptor peers asharing the same backend
|
|
|
|
AristoTxRef* = ref object
|
|
## Transaction descriptor
|
|
db*: AristoDbRef ## Database descriptor
|
|
parent*: AristoTxRef ## Previous transaction
|
|
txUid*: uint ## Unique ID among transactions
|
|
level*: int ## Stack index for this transaction
|
|
|
|
DudesRef = ref object
|
|
case rwOk: bool
|
|
of true:
|
|
roDudes: AristoDudes ## Read-only peers
|
|
txDudes: AristoDudes ## Other transaction peers
|
|
else:
|
|
rwDb: AristoDbRef ## Link to writable descriptor
|
|
|
|
AristoDbRef* = ref AristoDbObj
|
|
AristoDbObj* = object
|
|
## Three tier database object supporting distributed instances.
|
|
top*: LayerRef ## Database working layer, mutable
|
|
stack*: seq[LayerRef] ## Stashed immutable parent layers
|
|
roFilter*: FilterRef ## Apply read filter (locks writing)
|
|
backend*: BackendRef ## Backend database (may well be `nil`)
|
|
|
|
txRef*: AristoTxRef ## Latest active transaction
|
|
txUidGen*: uint ## Tx-relative unique number generator
|
|
dudes: DudesRef ## Related DB descriptors
|
|
|
|
# Debugging data below, might go away in future
|
|
xMap*: Table[HashLabel,VertexID] ## For pretty printing, extends `pAmk`
|
|
|
|
AristoDbAction* = proc(db: AristoDbRef) {.gcsafe, raises: [].}
|
|
## Generic call back function/closure.
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Public helpers
|
|
# ------------------------------------------------------------------------------
|
|
|
|
func getOrVoid*[W](tab: Table[W,VertexRef]; w: W): VertexRef =
|
|
tab.getOrDefault(w, VertexRef(nil))
|
|
|
|
func getOrVoid*[W](tab: Table[W,HashLabel]; w: W): HashLabel =
|
|
tab.getOrDefault(w, VOID_HASH_LABEL)
|
|
|
|
func getOrVoid*[W](tab: Table[W,HashKey]; w: W): HashKey =
|
|
tab.getOrDefault(w, VOID_HASH_KEY)
|
|
|
|
func getOrVoid*[W](tab: Table[W,VertexID]; w: W): VertexID =
|
|
tab.getOrDefault(w, VertexID(0))
|
|
|
|
# --------
|
|
|
|
func isValid*(vtx: VertexRef): bool =
|
|
vtx != VertexRef(nil)
|
|
|
|
func isValid*(nd: NodeRef): bool =
|
|
nd != NodeRef(nil)
|
|
|
|
func isValid*(pld: PayloadRef): bool =
|
|
pld != PayloadRef(nil)
|
|
|
|
func isValid*(filter: FilterRef): bool =
|
|
filter != FilterRef(nil)
|
|
|
|
func isValid*(key: HashKey): bool =
|
|
key != VOID_HASH_KEY
|
|
|
|
func isValid*(lbl: HashLabel): bool =
|
|
lbl != VOID_HASH_LABEL
|
|
|
|
func isValid*(vid: VertexID): bool =
|
|
vid != VertexID(0)
|
|
|
|
func isValid*(qid: QueueID): bool =
|
|
qid != QueueID(0)
|
|
|
|
func isValid*(fid: FilterID): bool =
|
|
fid != FilterID(0)
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Public functions, miscellaneous
|
|
# ------------------------------------------------------------------------------
|
|
|
|
# Hash set helper
|
|
func hash*(db: AristoDbRef): Hash =
|
|
## Table/KeyedQueue/HashSet mixin
|
|
cast[pointer](db).hash
|
|
|
|
# Note that the below `init()` function cannot go into `desc_identifiers` as
|
|
# this would result in a circular import.
|
|
func init*(key: var HashKey; data: openArray[byte]): bool =
|
|
## Import argument `data` into `key` which must have length either `32`, or
|
|
## `0`. The latter case is equivalent to an all zero byte array of size `32`.
|
|
if data.len == 32:
|
|
(addr key.ByteArray32[0]).copyMem(unsafeAddr data[0], data.len)
|
|
return true
|
|
if data.len == 0:
|
|
key = VOID_HASH_KEY
|
|
return true
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Public functions, `dude` related
|
|
# ------------------------------------------------------------------------------
|
|
|
|
func isCentre*(db: AristoDbRef): bool =
|
|
## This function returns `true` is the argument `db` is the centre (see
|
|
## comments on `reCentre()` for details.)
|
|
##
|
|
db.dudes.isNil or db.dudes.rwOk
|
|
|
|
func getCentre*(db: AristoDbRef): AristoDbRef =
|
|
## Get the centre descriptor among all other descriptors accessing the same
|
|
## backend database (see comments on `reCentre()` for details.)
|
|
##
|
|
if db.dudes.isNil or db.dudes.rwOk:
|
|
db
|
|
else:
|
|
db.dudes.rwDb
|
|
|
|
proc reCentre*(
|
|
db: AristoDbRef;
|
|
force = false;
|
|
): Result[void,AristoError] =
|
|
## Re-focus the `db` argument descriptor so that it becomes the centre.
|
|
## Nothing is done if the `db` descriptor is the centre, already.
|
|
##
|
|
## With several descriptors accessing the same backend database there is a
|
|
## single one that has write permission for the backend (regardless whether
|
|
## there is a backend, at all.) The descriptor entity with write permission
|
|
## is called *the centre*.
|
|
##
|
|
## After invoking `reCentre()`, the argument database `db` can only be
|
|
## destructed by `finish()` which also destructs all other descriptors
|
|
## accessing the same backend database. Descriptors where `isCentre()`
|
|
## returns `false` must be single destructed with `forget()`.
|
|
##
|
|
## If there is an open transaction spanning several descriptors, the `force`
|
|
## flag must be set `true` (unless the argument `db` is centre, already.) The
|
|
## argument `db` must be covered by the transaction span. Then the re-centred
|
|
## descriptor will also be the centre of the transaction span.
|
|
##
|
|
if not db.isCentre:
|
|
let parent = db.dudes.rwDb
|
|
|
|
# Check for multi-transactions
|
|
if 0 < parent.dudes.txDudes.len:
|
|
if not force:
|
|
return err(CentreTxLocked)
|
|
if db notin parent.dudes.txDudes:
|
|
return err(OutsideTxSpan)
|
|
if db.txRef.isNil or parent.txRef.isNil:
|
|
return err(GarbledTxSpan)
|
|
|
|
# Steal dudes list from parent, make the rw-parent a read-only dude
|
|
db.dudes = parent.dudes
|
|
parent.dudes = DudesRef(rwOk: false, rwDb: db)
|
|
|
|
# Exclude self
|
|
db.dudes.roDudes.excl db
|
|
|
|
# Update dudes
|
|
for w in db.dudes.roDudes:
|
|
# Let all other dudes refer to this one
|
|
w.dudes.rwDb = db
|
|
|
|
# Update dudes list (parent was alredy updated)
|
|
db.dudes.roDudes.incl parent
|
|
|
|
# Update transaction span
|
|
if 0 < db.dudes.txDudes.len:
|
|
db.dudes.txDudes.excl db
|
|
db.dudes.txDudes.incl parent
|
|
|
|
ok()
|
|
|
|
|
|
iterator txSpan*(db: AristoDbRef): AristoDbRef =
|
|
## Interate over all descriptors belonging to the transaction span if there
|
|
## is any. Note that the centre descriptor is aways part of the transaction
|
|
## if there is any.
|
|
##
|
|
if not db.dudes.isNil:
|
|
let parent = db.getCentre
|
|
if 0 < parent.dudes.txDudes.len:
|
|
yield parent
|
|
for dude in parent.dudes.txDudes.items:
|
|
yield dude
|
|
|
|
func nTxSpan*(db: AristoDbRef): int =
|
|
## Returns the number of descriptors belonging to the transaction span. This
|
|
## function is a fast version of `db.txSpan.toSeq.len`. Note that the
|
|
## returned numbe is never `1` (either `0` or at least `2`.)
|
|
##
|
|
if not db.dudes.isNil:
|
|
let parent = db.getCentre
|
|
if 0 < parent.dudes.txDudes.len:
|
|
return 1 + db.getCentre.dudes.txDudes.len
|
|
|
|
func inTxSpan*(db: AristoDbRef): bool =
|
|
## Returns `true` if the argument descriptor `db` belongs to the transaction
|
|
## span if there is any. Note that the centre descriptor is aways part of
|
|
## the transaction if there is any.
|
|
##
|
|
if not db.isCentre:
|
|
return db in db.dudes.rwDb.dudes.txDudes
|
|
elif not db.dudes.isNil:
|
|
return 0 < db.dudes.txDudes.len
|
|
false
|
|
|
|
proc txSpanSet*(dudes: openArray[AristoDbRef]) =
|
|
## Define the set of argument descriptors as transaction span.
|
|
##
|
|
if 0 < dudes.len:
|
|
let parent = dudes[0].getCentre
|
|
if not parent.dudes.isNil:
|
|
parent.dudes.txDudes = dudes.toHashSet - [parent].toHashSet
|
|
|
|
proc txSpanClear*(db: AristoDbRef) =
|
|
## Remove all descriptors from the transaction span.
|
|
##
|
|
if not db.isCentre:
|
|
db.dudes.rwDb.dudes.txDudes.clear
|
|
elif not db.dudes.isNil:
|
|
db.dudes.txDudes.clear
|
|
|
|
|
|
proc fork*(
|
|
db: AristoDbRef;
|
|
rawToplayer = false;
|
|
): Result[AristoDbRef,AristoError] =
|
|
## This function creates a new empty descriptor accessing the same backend
|
|
## (if any) database as the argument `db`. This new descriptor joins the
|
|
## list of descriptors accessing the same backend database.
|
|
##
|
|
## After use, any unused non centre descriptor should be destructed via
|
|
## `forget()`. Not doing so will not only hold memory ressources but might
|
|
## also cost computing ressources for maintaining and updating backend
|
|
## filters when writing to the backend database .
|
|
##
|
|
## If the argument `rawToplayer` is set `true` the function will provide an
|
|
## uninitalised and inconsistent (!) top layer. This setting avoids some
|
|
## database lookup for cases where the top layer is redefined anyway.
|
|
##
|
|
let clone = AristoDbRef(
|
|
top: LayerRef(),
|
|
backend: db.backend)
|
|
|
|
if not rawToplayer:
|
|
let rc = clone.backend.getIdgFn()
|
|
if rc.isOk:
|
|
clone.top.vGen = rc.value
|
|
elif rc.error != GetIdgNotFound:
|
|
return err(rc.error)
|
|
|
|
# Update dudes list
|
|
if db.dudes.isNil:
|
|
clone.dudes = DudesRef(rwOk: false, rwDb: db)
|
|
db.dudes = DudesRef(rwOk: true, roDudes: [clone].toHashSet)
|
|
else:
|
|
let parent = if db.dudes.rwOk: db else: db.dudes.rwDb
|
|
clone.dudes = DudesRef(rwOk: false, rwDb: parent)
|
|
parent.dudes.roDudes.incl clone
|
|
|
|
ok clone
|
|
|
|
iterator forked*(db: AristoDbRef): AristoDbRef =
|
|
## Interate over all non centre descriptors (see comments on `reCentre()`
|
|
## for details.)
|
|
if not db.dudes.isNil:
|
|
for dude in db.getCentre.dudes.roDudes.items:
|
|
yield dude
|
|
|
|
func nForked*(db: AristoDbRef): int =
|
|
## Returns the number of non centre descriptors (see comments on `reCentre()`
|
|
## for details.) This function is a fast version of `db.forked.toSeq.len`.
|
|
if not db.dudes.isNil:
|
|
return db.getCentre.dudes.roDudes.len
|
|
|
|
|
|
proc forget*(db: AristoDbRef): Result[void,AristoError] =
|
|
## Destruct the non centre argument `db` descriptor (see comments on
|
|
## `reCentre()` for details.)
|
|
##
|
|
## A non centre descriptor should always be destructed after use (see also
|
|
## comments on `fork()`.)
|
|
##
|
|
if not db.isNil:
|
|
if db.isCentre:
|
|
return err(NotAllowedOnCentre)
|
|
|
|
# Unlink argument `db`
|
|
let parent = db.dudes.rwDb
|
|
if parent.dudes.roDudes.len < 2:
|
|
parent.dudes = DudesRef(nil)
|
|
else:
|
|
parent.dudes.roDudes.excl db
|
|
parent.dudes.txDudes.excl db # might be empty, anyway
|
|
|
|
# Clear descriptor so it would not do harm if used wrongly
|
|
db[] = AristoDbObj(top: LayerRef())
|
|
ok()
|
|
|
|
proc forgetOthers*(db: AristoDbRef): Result[void,AristoError] =
|
|
## For the centre argument `db` descriptor (see comments on `reCentre()`
|
|
## for details), destruct all other descriptors accessing the same backend.
|
|
##
|
|
if not db.isCentre:
|
|
return err(MustBeOnCentre)
|
|
|
|
if not db.dudes.isNil:
|
|
for dude in db.dudes.roDudes.items:
|
|
dude[] = AristoDbObj(top: LayerRef())
|
|
|
|
db.dudes = DudesRef(nil)
|
|
ok()
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# End
|
|
# ------------------------------------------------------------------------------
|