* Remove SSZ Union usage in BlockHeaderWithProof type
Remove SSZ Union in BlockHeaderWithProof type by making the proof
an SSZ encoded ByteList. The right type for the proof can be
selected at the decoding step by first looking into the header
for the timestamp and selecting the right type based on the
hardfork the block is in.
* Add content db migration function to fcli_db tool
* Update test vector repo
* Remove obsolete header cache
why:
Was fall back for the case that the DB table was inaccessible before
`FC` module reorg.
* Add the number of unused connected peers to metric
* Update docu, add Grafana example
why:
Provides useful settings, e.g. for memory debugging
* Re-calibrate blocks queue for import
why:
Old queue setup provided a staging area which was much too large
consuming too much idle memory. Also the command-line re-calibrating
for debugging was much too complicated.
And the naming for the old setup was wrong: There is no max queue
size. Rather there is a HWM where filling the queue stops when reached.
The currently tested size allows for 1.5k blocks on the queue.
* Rename hidden command-line option for debug/re-calibrating blocks queue
* Simplify txFrame protocol, improve persist performance
To prepare forked-layers for further surgery to avoid the nesting tax,
the commit/rollback style of interacting must first be adjusted, since
it does not provide a point in time where the frame is "done" and goes
from being actively written to, to simply waiting to be persisted or
discarded.
A collateral benefit of this change is that the scheme removes some
complexity from the process by moving the "last saved block number" into
txframe along with the actual state changes thus reducing the risk that
they go "out of sync" and removing the "commit" consolidation
responsibility from ForkedChain.
* commit/rollback become checkpoint/dispose - since these are pure
in-memory constructs, there's less error handling and there's no real
"rollback" involved - dispose better implies that the instance cannot be
used and we can more aggressively clear the memory it uses
* simplified block number handling that moves to become part of txFrame
just like the data that the block number references
* avoid reparenting step by replacing the base instead of keeping a
singleton instance
* persist builds the set of changes from the bottom which helps avoid
moving changes in the top layers through each ancestor level of the
frame stack
* when using an in-memory database in tests, allow the instance to be
passed around to enable testing persist and reload logic
* Use unittest2 test runner
Since upgrading to unittest2, the test runner prints the command line to
re-run a failed test - this however relies on actually using the
unittest2 command line runner.
Previously, test files were assigned numbers - with the unittest2
runner, tests are run using suite/category names instead, like so:
```
# run the Genesis suite
build/all_tests "Genesis::``
# run all tests with "blsMapG1" in the name
build/all_tests "blsMapG1*"
# run tests verbosely
build/all_tests -v
```
A reasonable follow-up here would be to review the suite names to make
them easier to run :)
* lint
* easier-to-compare test order
* bump unittest2 (also the repo)
* add custom `hash` for `RootedVertexID`
There's no benefit hashing `root` since `vid` is already unique and the
"default" hash is not free - this trivially brings a small perf boost to
one of the key lookup tables in aristo_layers.
* lint
* Fix fringe case where the final `checkpoint()` must not be applied
why
If there are no `era` or `era1` files that can be imported from,
then the internal state will not be in sync with the DB state. This
would lead to overwriting the saved state block number with something
fancy. As a consequence the database becomes unusable for the next
process which will eventually fail with a state root mismatch.
* Update comment
By introducing the "shared rocksdb instance" concept to the backend, we
can remove the "piggybacking" mode , thus reducing the complexity of
database initialisation and opening the possibility of extending how
write batching works across kvt/aristo.
The change makes explicit the hidden shared state that was previously
hiding in closures and provides the first step towards simplifying the
"commit/persist" interface of coredb, preparing it for optimizations to
reduce the "layering tax" that `forked-layers` introduced.
* Update Nimbus EVM code to use the latest nim-evmc which is now on EVMC v12.1.0
* Fix copyright.
* Fix tests.
* Update to use FkLatest.
* Fix copyright and update test helper.
* renamed nimbus folder to execution_chain
* Renamed "nimbus" references to "execution_chain"
* fixed wrongly changed http reference
* delete snap types file given that it was deleted before this PR merge
* missing 'execution_chain' replacement
---------
Co-authored-by: pmmiranda <pedro.miranda@nimbus.team>
* Update unprocessed blocks bookkeeping avoiding race condition
details:
Instead of keeping track in `borrowed` of the sum of a set of blocks
fetched from the `unprocessed` list, the particular ranges details are
stored. When committing a particular range, the range itself (rather
then its length) is removed from the `borrowed` data.
why:
The function `blocksUnprocAmend()`) may produce a race condition, so it
was re-implemented as `blocksUnprocAppend()` considering range overlaps
with borrowed.
* Clean up/re-org `blocks_unproc` module
why:
The `borrowed` data structure can be fully maintained with the
`blocksUnprocXxx()` functions.
* Update/simplify unprocessed headers bookkeeping (similar as for blocks)
* Removing stashed headers right after successfully assembled blocks
why:
Was previously deleted after importing blocks although it is not needed
anymore after blocks have been assembled using bodies fetched over
the ethXX network.
* Always curb the blocks to the initialised length
why:
Some error exit directives missed some clean up leaving the blocks
list with empty/stale block bodies.
* Enter reorg-mode right away after block import error
why:
There is not much one can do. Typically, this type of error is due
to a switch to a different canonical chain. When this happens, the
block batch is expected to be relatively short as the cause for a
chain switch is an RPC instruction. This in turn is effective if some
of the blocks on the `FC` database are maintained by the `CL`.
* aristo: fork support via layers/txframes
This change reorganises how the database is accessed: instead holding a
"current frame" in the database object, a dag of frames is created based
on the "base frame" held in `AristoDbRef` and all database access
happens through this frame, which can be thought of as a consistent
point-in-time snapshot of the database based on a particular fork of the
chain.
In the code, "frame", "transaction" and "layer" is used to denote more
or less the same thing: a dag of stacked changes backed by the on-disk
database.
Although this is not a requirement, in practice each frame holds the
change set of a single block - as such, the frame and its ancestors
leading up to the on-disk state represents the state of the database
after that block has been applied.
"committing" means merging the changes to its parent frame so that the
difference between them is lost and only the cumulative changes remain -
this facility enables frames to be combined arbitrarily wherever they
are in the dag.
In particular, it becomes possible to consolidate a set of changes near
the base of the dag and commit those to disk without having to re-do the
in-memory frames built on top of them - this is useful for "flattening"
a set of changes during a base update and sending those to storage
without having to perform a block replay on top.
Looking at abstractions, a side effect of this change is that the KVT
and Aristo are brought closer together by considering them to be part of
the "same" atomic transaction set - the way the code gets organised,
applying a block and saving it to the kvt happens in the same "logical"
frame - therefore, discarding the frame discards both the aristo and kvt
changes at the same time - likewise, they are persisted to disk together
- this makes reasoning about the database somewhat easier but has the
downside of increased memory usage, something that perhaps will need
addressing in the future.
Because the code reasons more strictly about frames and the state of the
persisted database, it also makes it more visible where ForkedChain
should be used and where it is still missing - in particular, frames
represent a single branch of history while forkedchain manages multiple
parallel forks - user-facing services such as the RPC should use the
latter, ie until it has been finalized, a getBlock request should
consider all forks and not just the blocks in the canonical head branch.
Another advantage of this approach is that `AristoDbRef` conceptually
becomes more simple - removing its tracking of the "current" transaction
stack simplifies reasoning about what can go wrong since this state now
has to be passed around in the form of `AristoTxRef` - as such, many of
the tests and facilities in the code that were dealing with "stack
inconsistency" are now structurally prevented from happening. The test
suite will need significant refactoring after this change.
Once this change has been merged, there are several follow-ups to do:
* there's no mechanism for keeping frames up to date as they get
committed or rolled back - TODO
* naming is confused - many names for the same thing for legacy reason
* forkedchain support is still missing in lots of code
* clean up redundant logic based on previous designs - in particular the
debug and introspection code no longer makes sense
* the way change sets are stored will probably need revisiting - because
it's a stack of changes where each frame must be interrogated to find an
on-disk value, with a base distance of 128 we'll at minimum have to
perform 128 frame lookups for *every* database interaction - regardless,
the "dag-like" nature will stay
* dispose and commit are poorly defined and perhaps redundant - in
theory, one could simply let the GC collect abandoned frames etc, though
it's likely an explicit mechanism will remain useful, so they stay for
now
More about the changes:
* `AristoDbRef` gains a `txRef` field (todo: rename) that "more or less"
corresponds to the old `balancer` field
* `AristoDbRef.stack` is gone - instead, there's a chain of
`AristoTxRef` objects that hold their respective "layer" which has the
actual changes
* No more reasoning about "top" and "stack" - instead, each
`AristoTxRef` can be a "head" that "more or less" corresponds to the old
single-history `top` notion and its stack
* `level` still represents "distance to base" - it's computed from the
parent chain instead of being stored
* one has to be careful not to use frames where forkedchain was intended
- layers are only for a single branch of history!
* fix layer vtop after rollback
* engine fix
* Fix test_txpool
* Fix test_rpc
* Fix copyright year
* fix simulator
* Fix copyright year
* Fix copyright year
* Fix tracer
* Fix infinite recursion bug
* Remove aristo and kvt empty files
* Fic copyright year
* Fix fc chain_kvt
* ForkedChain refactoring
* Fix merge master conflict
* Fix copyright year
* Reparent txFrame
* Fix test
* Fix txFrame reparent again
* Cleanup and fix test
* UpdateBase bugfix and fix test
* Fixe newPayload bug discovered by hive
* Fix engine api fcu
* Clean up call template, chain_kvt, andn txguid
* Fix copyright year
* work around base block loading issue
* Add test
* Fix updateHead bug
* Fix updateBase bug
* Change func commitBase to proc commitBase
* Touch up and fix debug mode crash
---------
Co-authored-by: jangko <jangko128@gmail.com>
* Bump RPC server buffer size
When large blocks arrive via RPC, we need to be able to read them from
the socket in reasonable time - at 4kb, we might need thousands of reads
before the JSON can be parsed - 256kb ensures that most blocks can be
read in a few loop iterations - the size doesn't greatly matter since we
only have one of these (unlike p2p connections)
* copyright
* Avoid re-compacting historical data
Per rocksdb docs, it will by default re-compact any data not touched for
30 days - this is obviously wasteful since our historical data rarely
changes and _hopefully_ can stay untouched once written (with a bit of
key sorting luck).
* copyright
