2019-05-14 01:13:28 +00:00
|
|
|
use super::*;
|
2019-09-03 06:46:10 +00:00
|
|
|
use rayon::prelude::*;
|
2019-05-22 06:15:52 +00:00
|
|
|
use std::fmt::Debug;
|
2019-09-05 00:19:52 +00:00
|
|
|
use std::path::{Path, PathBuf};
|
2021-07-09 06:15:32 +00:00
|
|
|
use types::ForkName;
|
2019-05-14 01:13:28 +00:00
|
|
|
|
2019-05-21 00:32:14 +00:00
|
|
|
mod bls_aggregate_sigs;
|
2020-02-10 23:19:36 +00:00
|
|
|
mod bls_aggregate_verify;
|
2021-09-25 05:58:35 +00:00
|
|
|
mod bls_eth_aggregate_pubkeys;
|
|
|
|
mod bls_eth_fast_aggregate_verify;
|
2020-02-10 23:19:36 +00:00
|
|
|
mod bls_fast_aggregate_verify;
|
2019-05-21 02:46:22 +00:00
|
|
|
mod bls_sign_msg;
|
2020-02-10 23:19:36 +00:00
|
|
|
mod bls_verify_msg;
|
2019-09-04 03:03:44 +00:00
|
|
|
mod common;
|
2019-08-30 03:29:26 +00:00
|
|
|
mod epoch_processing;
|
2021-07-09 06:15:32 +00:00
|
|
|
mod fork;
|
2021-11-08 07:29:04 +00:00
|
|
|
mod fork_choice;
|
2019-07-30 07:02:38 +00:00
|
|
|
mod genesis_initialization;
|
|
|
|
mod genesis_validity;
|
2019-08-30 06:16:38 +00:00
|
|
|
mod operations;
|
2021-07-09 06:15:32 +00:00
|
|
|
mod rewards;
|
2019-06-11 08:05:44 +00:00
|
|
|
mod sanity_blocks;
|
2019-06-04 06:35:33 +00:00
|
|
|
mod sanity_slots;
|
2019-05-23 13:22:54 +00:00
|
|
|
mod shuffling;
|
2019-05-14 01:13:28 +00:00
|
|
|
mod ssz_generic;
|
2019-05-14 05:08:42 +00:00
|
|
|
mod ssz_static;
|
2021-07-09 06:15:32 +00:00
|
|
|
mod transition;
|
2019-05-14 01:13:28 +00:00
|
|
|
|
2021-11-15 00:26:42 +00:00
|
|
|
pub use self::fork_choice::*;
|
2019-05-21 00:32:14 +00:00
|
|
|
pub use bls_aggregate_sigs::*;
|
2020-02-10 23:19:36 +00:00
|
|
|
pub use bls_aggregate_verify::*;
|
2021-09-25 05:58:35 +00:00
|
|
|
pub use bls_eth_aggregate_pubkeys::*;
|
|
|
|
pub use bls_eth_fast_aggregate_verify::*;
|
2020-02-10 23:19:36 +00:00
|
|
|
pub use bls_fast_aggregate_verify::*;
|
2019-05-21 02:46:22 +00:00
|
|
|
pub use bls_sign_msg::*;
|
2020-02-10 23:19:36 +00:00
|
|
|
pub use bls_verify_msg::*;
|
2019-09-04 03:03:44 +00:00
|
|
|
pub use common::SszStaticType;
|
2019-08-30 03:29:26 +00:00
|
|
|
pub use epoch_processing::*;
|
2021-07-09 06:15:32 +00:00
|
|
|
pub use fork::ForkTest;
|
2019-07-30 07:02:38 +00:00
|
|
|
pub use genesis_initialization::*;
|
|
|
|
pub use genesis_validity::*;
|
2019-08-30 06:16:38 +00:00
|
|
|
pub use operations::*;
|
2021-07-09 06:15:32 +00:00
|
|
|
pub use rewards::RewardsTest;
|
2019-06-11 08:05:44 +00:00
|
|
|
pub use sanity_blocks::*;
|
2019-06-04 06:35:33 +00:00
|
|
|
pub use sanity_slots::*;
|
2019-05-23 13:22:54 +00:00
|
|
|
pub use shuffling::*;
|
2019-05-14 01:13:28 +00:00
|
|
|
pub use ssz_generic::*;
|
2019-05-14 05:08:42 +00:00
|
|
|
pub use ssz_static::*;
|
2021-07-09 06:15:32 +00:00
|
|
|
pub use transition::TransitionTest;
|
2019-05-14 01:13:28 +00:00
|
|
|
|
2019-08-28 08:46:16 +00:00
|
|
|
pub trait LoadCase: Sized {
|
|
|
|
/// Load the test case from a test case directory.
|
2021-07-09 06:15:32 +00:00
|
|
|
fn load_from_dir(_path: &Path, _fork_name: ForkName) -> Result<Self, Error>;
|
2019-08-28 08:46:16 +00:00
|
|
|
}
|
|
|
|
|
2019-09-03 06:46:10 +00:00
|
|
|
pub trait Case: Debug + Sync {
|
2019-05-23 06:55:50 +00:00
|
|
|
/// An optional field for implementing a custom description.
|
|
|
|
///
|
|
|
|
/// Defaults to "no description".
|
|
|
|
fn description(&self) -> String {
|
|
|
|
"no description".to_string()
|
|
|
|
}
|
|
|
|
|
2021-07-09 06:15:32 +00:00
|
|
|
/// Whether or not this test exists for the given `fork_name`.
|
|
|
|
///
|
|
|
|
/// Returns `true` by default.
|
|
|
|
fn is_enabled_for_fork(_fork_name: ForkName) -> bool {
|
|
|
|
true
|
|
|
|
}
|
|
|
|
|
2019-05-22 08:13:22 +00:00
|
|
|
/// Execute a test and return the result.
|
|
|
|
///
|
|
|
|
/// `case_index` reports the index of the case in the set of test cases. It is not strictly
|
|
|
|
/// necessary, but it's useful when troubleshooting specific failing tests.
|
2021-07-09 06:15:32 +00:00
|
|
|
fn result(&self, case_index: usize, fork_name: ForkName) -> Result<(), Error>;
|
2019-05-22 06:15:52 +00:00
|
|
|
}
|
|
|
|
|
2019-05-15 01:45:50 +00:00
|
|
|
#[derive(Debug)]
|
2019-05-15 01:17:32 +00:00
|
|
|
pub struct Cases<T> {
|
2019-09-05 00:19:52 +00:00
|
|
|
pub test_cases: Vec<(PathBuf, T)>,
|
2019-05-14 01:13:28 +00:00
|
|
|
}
|
2019-05-14 05:08:42 +00:00
|
|
|
|
2019-09-03 06:46:10 +00:00
|
|
|
impl<T: Case> Cases<T> {
|
Use async code when interacting with EL (#3244)
## Overview
This rather extensive PR achieves two primary goals:
1. Uses the finalized/justified checkpoints of fork choice (FC), rather than that of the head state.
2. Refactors fork choice, block production and block processing to `async` functions.
Additionally, it achieves:
- Concurrent forkchoice updates to the EL and cache pruning after a new head is selected.
- Concurrent "block packing" (attestations, etc) and execution payload retrieval during block production.
- Concurrent per-block-processing and execution payload verification during block processing.
- The `Arc`-ification of `SignedBeaconBlock` during block processing (it's never mutated, so why not?):
- I had to do this to deal with sending blocks into spawned tasks.
- Previously we were cloning the beacon block at least 2 times during each block processing, these clones are either removed or turned into cheaper `Arc` clones.
- We were also `Box`-ing and un-`Box`-ing beacon blocks as they moved throughout the networking crate. This is not a big deal, but it's nice to avoid shifting things between the stack and heap.
- Avoids cloning *all the blocks* in *every chain segment* during sync.
- It also has the potential to clean up our code where we need to pass an *owned* block around so we can send it back in the case of an error (I didn't do much of this, my PR is already big enough :sweat_smile:)
- The `BeaconChain::HeadSafetyStatus` struct was removed. It was an old relic from prior merge specs.
For motivation for this change, see https://github.com/sigp/lighthouse/pull/3244#issuecomment-1160963273
## Changes to `canonical_head` and `fork_choice`
Previously, the `BeaconChain` had two separate fields:
```
canonical_head: RwLock<Snapshot>,
fork_choice: RwLock<BeaconForkChoice>
```
Now, we have grouped these values under a single struct:
```
canonical_head: CanonicalHead {
cached_head: RwLock<Arc<Snapshot>>,
fork_choice: RwLock<BeaconForkChoice>
}
```
Apart from ergonomics, the only *actual* change here is wrapping the canonical head snapshot in an `Arc`. This means that we no longer need to hold the `cached_head` (`canonical_head`, in old terms) lock when we want to pull some values from it. This was done to avoid deadlock risks by preventing functions from acquiring (and holding) the `cached_head` and `fork_choice` locks simultaneously.
## Breaking Changes
### The `state` (root) field in the `finalized_checkpoint` SSE event
Consider the scenario where epoch `n` is just finalized, but `start_slot(n)` is skipped. There are two state roots we might in the `finalized_checkpoint` SSE event:
1. The state root of the finalized block, which is `get_block(finalized_checkpoint.root).state_root`.
4. The state root at slot of `start_slot(n)`, which would be the state from (1), but "skipped forward" through any skip slots.
Previously, Lighthouse would choose (2). However, we can see that when [Teku generates that event](https://github.com/ConsenSys/teku/blob/de2b2801c89ef5abf983d6bf37867c37fc47121f/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/EventSubscriptionManager.java#L171-L182) it uses [`getStateRootFromBlockRoot`](https://github.com/ConsenSys/teku/blob/de2b2801c89ef5abf983d6bf37867c37fc47121f/data/provider/src/main/java/tech/pegasys/teku/api/ChainDataProvider.java#L336-L341) which uses (1).
I have switched Lighthouse from (2) to (1). I think it's a somewhat arbitrary choice between the two, where (1) is easier to compute and is consistent with Teku.
## Notes for Reviewers
I've renamed `BeaconChain::fork_choice` to `BeaconChain::recompute_head`. Doing this helped ensure I broke all previous uses of fork choice and I also find it more descriptive. It describes an action and can't be confused with trying to get a reference to the `ForkChoice` struct.
I've changed the ordering of SSE events when a block is received. It used to be `[block, finalized, head]` and now it's `[block, head, finalized]`. It was easier this way and I don't think we were making any promises about SSE event ordering so it's not "breaking".
I've made it so fork choice will run when it's first constructed. I did this because I wanted to have a cached version of the last call to `get_head`. Ensuring `get_head` has been run *at least once* means that the cached values doesn't need to wrapped in an `Option`. This was fairly simple, it just involved passing a `slot` to the constructor so it knows *when* it's being run. When loading a fork choice from the store and a slot clock isn't handy I've just used the `slot` that was saved in the `fork_choice_store`. That seems like it would be a faithful representation of the slot when we saved it.
I added the `genesis_time: u64` to the `BeaconChain`. It's small, constant and nice to have around.
Since we're using FC for the fin/just checkpoints, we no longer get the `0x00..00` roots at genesis. You can see I had to remove a work-around in `ef-tests` here: b56be3bc2. I can't find any reason why this would be an issue, if anything I think it'll be better since the genesis-alias has caught us out a few times (0x00..00 isn't actually a real root). Edit: I did find a case where the `network` expected the 0x00..00 alias and patched it here: 3f26ac3e2.
You'll notice a lot of changes in tests. Generally, tests should be functionally equivalent. Here are the things creating the most diff-noise in tests:
- Changing tests to be `tokio::async` tests.
- Adding `.await` to fork choice, block processing and block production functions.
- Refactor of the `canonical_head` "API" provided by the `BeaconChain`. E.g., `chain.canonical_head.cached_head()` instead of `chain.canonical_head.read()`.
- Wrapping `SignedBeaconBlock` in an `Arc`.
- In the `beacon_chain/tests/block_verification`, we can't use the `lazy_static` `CHAIN_SEGMENT` variable anymore since it's generated with an async function. We just generate it in each test, not so efficient but hopefully insignificant.
I had to disable `rayon` concurrent tests in the `fork_choice` tests. This is because the use of `rayon` and `block_on` was causing a panic.
Co-authored-by: Mac L <mjladson@pm.me>
2022-07-03 05:36:50 +00:00
|
|
|
pub fn test_results(&self, fork_name: ForkName, use_rayon: bool) -> Vec<CaseResult> {
|
|
|
|
if use_rayon {
|
|
|
|
self.test_cases
|
|
|
|
.into_par_iter()
|
|
|
|
.enumerate()
|
|
|
|
.map(|(i, (ref path, ref tc))| {
|
|
|
|
CaseResult::new(i, path, tc, tc.result(i, fork_name))
|
|
|
|
})
|
|
|
|
.collect()
|
|
|
|
} else {
|
|
|
|
self.test_cases
|
|
|
|
.iter()
|
|
|
|
.enumerate()
|
|
|
|
.map(|(i, (ref path, ref tc))| {
|
|
|
|
CaseResult::new(i, path, tc, tc.result(i, fork_name))
|
|
|
|
})
|
|
|
|
.collect()
|
|
|
|
}
|
2019-05-22 06:15:52 +00:00
|
|
|
}
|
|
|
|
}
|