Swap back to ParticipationCache

Author: paulhauner

beacon_node/beacon_chain/src/block_verification.rs

@@ -1438,21 +1438,22 @@ fn expose_participation_metrics(summaries: &[EpochProcessingSummary]) {
     }
 
     for summary in summaries {
-        metrics::maybe_set_float_gauge(
-            &metrics::PARTICIPATION_PREV_EPOCH_TARGET_ATTESTER,
-            participation_ratio(
-                summary.previous_epoch_target_attesting_balance(),
-                summary.previous_epoch_total_active_balance(),
-            ),
-        );
+        if let Ok(target_balance) = summary.previous_epoch_target_attesting_balance() {
+            metrics::maybe_set_float_gauge(
+                &metrics::PARTICIPATION_PREV_EPOCH_TARGET_ATTESTER,
+                participation_ratio(
+                    target_balance,
+                    summary.previous_epoch_total_active_balance(),
+                ),
+            );
+        }
 
-        metrics::maybe_set_float_gauge(
-            &metrics::PARTICIPATION_PREV_EPOCH_HEAD_ATTESTER,
-            participation_ratio(
-                summary.previous_epoch_head_attesting_balance(),
-                summary.previous_epoch_total_active_balance(),
-            ),
-        );
+        if let Ok(head_balance) = summary.previous_epoch_head_attesting_balance() {
+            metrics::maybe_set_float_gauge(
+                &metrics::PARTICIPATION_PREV_EPOCH_HEAD_ATTESTER,
+                participation_ratio(head_balance, summary.previous_epoch_total_active_balance()),
+            );
+        }
     }
 }
 

consensus/state_processing/src/per_epoch_processing/altair.rs

@@ -3,19 +3,18 @@ use crate::per_epoch_processing::{
     effective_balance_updates::process_effective_balance_updates,
     historical_roots_update::process_historical_roots_update,
     resets::{process_eth1_data_reset, process_randao_mixes_reset, process_slashings_reset},
-    validator_statuses::ValidatorStatuses,
 };
-pub use epoch_cache::EpochCache;
 pub use inactivity_updates::process_inactivity_updates;
 pub use justification_and_finalization::process_justification_and_finalization;
+pub use participation_cache::ParticipationCache;
 pub use participation_flag_updates::process_participation_flag_updates;
 pub use rewards_and_penalties::process_rewards_and_penalties;
 pub use sync_committee_updates::process_sync_committee_updates;
 use types::{BeaconState, ChainSpec, EthSpec, RelativeEpoch};
 
-pub mod epoch_cache;
 pub mod inactivity_updates;
 pub mod justification_and_finalization;
+pub mod participation_cache;
 pub mod participation_flag_updates;
 pub mod rewards_and_penalties;
 pub mod sync_committee_updates;
@@ -29,23 +28,25 @@ pub fn process_epoch<T: EthSpec>(
     state.build_committee_cache(RelativeEpoch::Current, spec)?;
     state.build_committee_cache(RelativeEpoch::Next, spec)?;
 
-    let cache = EpochCache::new(state, spec)?;
+    // Pre-compute participating indices and total balances.
+    let participation_cache = ParticipationCache::new(state, spec)?;
 
     // Justification and finalization.
-    process_justification_and_finalization(state, &cache, spec)?;
+    process_justification_and_finalization(state, &participation_cache)?;
 
-    process_inactivity_updates(state, &cache, spec)?;
+    process_inactivity_updates(state, &participation_cache, spec)?;
 
     // Rewards and Penalties.
-    process_rewards_and_penalties(state, &cache, spec)?;
+    process_rewards_and_penalties(state, &participation_cache, spec)?;
 
     // Registry Updates.
     process_registry_updates(state, spec)?;
 
     // Slashings.
     process_slashings(
         state,
-        cache.total_active_balance,
+        // FIXME(paul): could this be invalidated by rewards/penalties?
+        participation_cache.current_epoch_total_active_balance(),
         spec.proportional_slashing_multiplier_altair,
         spec,
     )?;
@@ -73,14 +74,7 @@ pub fn process_epoch<T: EthSpec>(
     // Rotate the epoch caches to suit the epoch transition.
     state.advance_caches()?;
 
-    // FIXME(altair): this is an incorrect dummy value, we should think harder
-    // about how we want to unify validator statuses between phase0 & altair.
-    // We should benchmark the new state transition and work out whether Altair could
-    // be accelerated by some similar cache.
-    let validator_statuses = ValidatorStatuses::new(state, spec)?;
-
     Ok(EpochProcessingSummary::Altair {
-        total_balances: validator_statuses.total_balances,
-        participation_cache: cache.participation,
+        participation_cache,
     })
 }

consensus/state_processing/src/per_epoch_processing/altair/epoch_cache.rs

@@ -1,4 +1,4 @@
-use super::EpochCache;
+use super::ParticipationCache;
 use crate::EpochProcessingError;
 use core::result::Result;
 use core::result::Result::Ok;
@@ -11,16 +11,15 @@ use types::eth_spec::EthSpec;
 
 pub fn process_inactivity_updates<T: EthSpec>(
     state: &mut BeaconState<T>,
-    cache: &EpochCache,
+    participation_cache: &ParticipationCache,
     spec: &ChainSpec,
 ) -> Result<(), EpochProcessingError> {
     // Score updates based on previous epoch participation, skip genesis epoch
     if state.current_epoch() == T::genesis_epoch() {
         return Ok(());
     }
 
-    let unslashed_indices = cache
-        .participation
+    let unslashed_indices = participation_cache
         .get_unslashed_participating_indices(TIMELY_TARGET_FLAG_INDEX, state.previous_epoch())?;
 
     for index in state.get_eligible_validator_indices()? {

consensus/state_processing/src/per_epoch_processing/altair/inactivity_updates.rs

@@ -1,34 +1,26 @@
-use super::EpochCache;
+use super::ParticipationCache;
 use crate::per_epoch_processing::weigh_justification_and_finalization;
 use crate::per_epoch_processing::Error;
 use safe_arith::SafeArith;
 use types::consts::altair::TIMELY_TARGET_FLAG_INDEX;
-use types::{BeaconState, ChainSpec, EthSpec};
+use types::{BeaconState, EthSpec};
 
 /// Update the justified and finalized checkpoints for matching target attestations.
 pub fn process_justification_and_finalization<T: EthSpec>(
     state: &mut BeaconState<T>,
-    cache: &EpochCache,
-    spec: &ChainSpec,
+    participation_cache: &ParticipationCache,
 ) -> Result<(), Error> {
     if state.current_epoch() <= T::genesis_epoch().safe_add(1)? {
         return Ok(());
     }
 
     let previous_epoch = state.previous_epoch();
     let current_epoch = state.current_epoch();
-    let previous_indices = cache
-        .participation
+    let previous_indices = participation_cache
         .get_unslashed_participating_indices(TIMELY_TARGET_FLAG_INDEX, previous_epoch)?;
-    let current_indices = cache
-        .participation
+    let current_indices = participation_cache
         .get_unslashed_participating_indices(TIMELY_TARGET_FLAG_INDEX, current_epoch)?;
-    let total_active_balance = state.get_total_balance(
-        state
-            .get_active_validator_indices(current_epoch, spec)?
-            .as_slice(),
-        spec,
-    )?;
+    let total_active_balance = participation_cache.current_epoch_total_active_balance();
     let previous_target_balance = previous_indices.total_balance()?;
     let current_target_balance = current_indices.total_balance()?;
     weigh_justification_and_finalization(