diff --git a/beacon-chain/blockchain/process_block.go b/beacon-chain/blockchain/process_block.go index 4f7b1ce13b..444c88fe24 100644 --- a/beacon-chain/blockchain/process_block.go +++ b/beacon-chain/blockchain/process_block.go @@ -381,9 +381,6 @@ func (s *Service) updateEpochBoundaryCaches(ctx context.Context, st state.Beacon if err := helpers.UpdateCommitteeCache(slotCtx, st, e+1); err != nil { log.WithError(err).Warn("Could not update committee cache") } - if err := helpers.UpdateUnsafeProposerIndicesInCache(slotCtx, st, e+1); err != nil { - log.WithError(err).Warn("Failed to cache next epoch proposers") - } }() // The latest block header is from the previous epoch r, err := st.LatestBlockHeader().HashTreeRoot() diff --git a/beacon-chain/cache/proposer_indices.go b/beacon-chain/cache/proposer_indices.go index 498f0d982e..6071e1e462 100644 --- a/beacon-chain/cache/proposer_indices.go +++ b/beacon-chain/cache/proposer_indices.go @@ -42,17 +42,15 @@ var ( // root would be for slot 32 if present. type ProposerIndicesCache struct { sync.Mutex - indices map[primitives.Epoch]map[[32]byte][fieldparams.SlotsPerEpoch]primitives.ValidatorIndex - unsafeIndices map[primitives.Epoch]map[[32]byte][fieldparams.SlotsPerEpoch]primitives.ValidatorIndex - rootMap map[forkchoicetypes.Checkpoint][32]byte // A map from checkpoint root to state root + indices map[primitives.Epoch]map[[32]byte][fieldparams.SlotsPerEpoch]primitives.ValidatorIndex + rootMap map[forkchoicetypes.Checkpoint][32]byte // A map from checkpoint root to state root } // NewProposerIndicesCache returns a newly created cache func NewProposerIndicesCache() *ProposerIndicesCache { return &ProposerIndicesCache{ - indices: make(map[primitives.Epoch]map[[32]byte][fieldparams.SlotsPerEpoch]primitives.ValidatorIndex), - unsafeIndices: make(map[primitives.Epoch]map[[32]byte][fieldparams.SlotsPerEpoch]primitives.ValidatorIndex), - rootMap: make(map[forkchoicetypes.Checkpoint][32]byte), + indices: make(map[primitives.Epoch]map[[32]byte][fieldparams.SlotsPerEpoch]primitives.ValidatorIndex), + rootMap: make(map[forkchoicetypes.Checkpoint][32]byte), } } @@ -74,18 +72,6 @@ func (p *ProposerIndicesCache) ProposerIndices(epoch primitives.Epoch, root [32] return indices, exists } -// UnsafeProposerIndices returns the proposer indices (unsafe) for the given root -func (p *ProposerIndicesCache) UnsafeProposerIndices(epoch primitives.Epoch, root [32]byte) ([fieldparams.SlotsPerEpoch]primitives.ValidatorIndex, bool) { - p.Lock() - defer p.Unlock() - inner, ok := p.unsafeIndices[epoch] - if !ok { - return [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex{}, false - } - indices, exists := inner[root] - return indices, exists -} - // Prune resets the ProposerIndicesCache to its initial state func (p *ProposerIndicesCache) Prune(epoch primitives.Epoch) { p.Lock() @@ -95,11 +81,6 @@ func (p *ProposerIndicesCache) Prune(epoch primitives.Epoch) { delete(p.indices, key) } } - for key := range p.unsafeIndices { - if key < epoch { - delete(p.unsafeIndices, key) - } - } for key := range p.rootMap { if key.Epoch+1 < epoch { delete(p.rootMap, key) @@ -120,18 +101,6 @@ func (p *ProposerIndicesCache) Set(epoch primitives.Epoch, root [32]byte, indice inner[root] = indices } -// SetUnsafe sets the unsafe proposer indices for the given root as key -func (p *ProposerIndicesCache) SetUnsafe(epoch primitives.Epoch, root [32]byte, indices [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex) { - p.Lock() - defer p.Unlock() - inner, ok := p.unsafeIndices[epoch] - if !ok { - inner = make(map[[32]byte][fieldparams.SlotsPerEpoch]primitives.ValidatorIndex) - p.unsafeIndices[epoch] = inner - } - inner[root] = indices -} - // SetCheckpoint updates the map from checkpoints to state roots func (p *ProposerIndicesCache) SetCheckpoint(c forkchoicetypes.Checkpoint, root [32]byte) { p.Lock() diff --git a/beacon-chain/cache/proposer_indices_test.go b/beacon-chain/cache/proposer_indices_test.go index 0b3dd3c64a..c3195416e5 100644 --- a/beacon-chain/cache/proposer_indices_test.go +++ b/beacon-chain/cache/proposer_indices_test.go @@ -34,29 +34,6 @@ func TestProposerCache_Set(t *testing.T) { require.Equal(t, emptyIndices, received) } -func TestProposerCache_SetUnsafe(t *testing.T) { - cache := NewProposerIndicesCache() - bRoot := [32]byte{'A'} - indices, ok := cache.UnsafeProposerIndices(0, bRoot) - require.Equal(t, false, ok) - emptyIndices := [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex{} - require.Equal(t, indices, emptyIndices, "Expected committee count not to exist in empty cache") - emptyIndices[0] = 1 - cache.SetUnsafe(0, bRoot, emptyIndices) - - received, ok := cache.UnsafeProposerIndices(0, bRoot) - require.Equal(t, true, ok) - require.Equal(t, received, emptyIndices) - - newRoot := [32]byte{'B'} - copy(emptyIndices[3:], []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6}) - cache.SetUnsafe(0, newRoot, emptyIndices) - - received, ok = cache.UnsafeProposerIndices(0, newRoot) - require.Equal(t, true, ok) - require.Equal(t, emptyIndices, received) -} - func TestProposerCache_CheckpointAndPrune(t *testing.T) { cache := NewProposerIndicesCache() indices := [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex{} @@ -65,7 +42,6 @@ func TestProposerCache_CheckpointAndPrune(t *testing.T) { copy(indices[3:], []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6}) for i := 1; i < 10; i++ { cache.Set(primitives.Epoch(i), root, indices) - cache.SetUnsafe(primitives.Epoch(i), root, indices) cache.SetCheckpoint(forkchoicetypes.Checkpoint{Epoch: primitives.Epoch(i - 1), Root: cpRoot}, root) } received, ok := cache.ProposerIndices(1, root) @@ -80,18 +56,6 @@ func TestProposerCache_CheckpointAndPrune(t *testing.T) { require.Equal(t, true, ok) require.Equal(t, indices, received) - received, ok = cache.UnsafeProposerIndices(1, root) - require.Equal(t, true, ok) - require.Equal(t, indices, received) - - received, ok = cache.UnsafeProposerIndices(4, root) - require.Equal(t, true, ok) - require.Equal(t, indices, received) - - received, ok = cache.UnsafeProposerIndices(9, root) - require.Equal(t, true, ok) - require.Equal(t, indices, received) - received, ok = cache.IndicesFromCheckpoint(forkchoicetypes.Checkpoint{Epoch: 0, Root: cpRoot}) require.Equal(t, true, ok) require.Equal(t, indices, received) @@ -123,18 +87,6 @@ func TestProposerCache_CheckpointAndPrune(t *testing.T) { require.Equal(t, true, ok) require.Equal(t, indices, received) - received, ok = cache.UnsafeProposerIndices(1, root) - require.Equal(t, false, ok) - require.Equal(t, emptyIndices, received) - - received, ok = cache.UnsafeProposerIndices(4, root) - require.Equal(t, false, ok) - require.Equal(t, emptyIndices, received) - - received, ok = cache.UnsafeProposerIndices(9, root) - require.Equal(t, true, ok) - require.Equal(t, indices, received) - received, ok = cache.IndicesFromCheckpoint(forkchoicetypes.Checkpoint{Epoch: 0, Root: cpRoot}) require.Equal(t, false, ok) require.Equal(t, emptyIndices, received) diff --git a/beacon-chain/core/helpers/beacon_committee.go b/beacon-chain/core/helpers/beacon_committee.go index 0ad139c2da..a7e89c4ff9 100644 --- a/beacon-chain/core/helpers/beacon_committee.go +++ b/beacon-chain/core/helpers/beacon_committee.go @@ -391,49 +391,6 @@ func UpdateCachedCheckpointToStateRoot(state state.ReadOnlyBeaconState, cp *fork return nil } -// UpdateUnsafeProposerIndicesInCache updates proposer indices entry of the -// cache one epoch in advance. -// Input state is used to retrieve active validator indices. -// Input root is to use as key in the cache. -// Input epoch is the epoch to retrieve proposer indices for. -func UpdateUnsafeProposerIndicesInCache(ctx context.Context, state state.ReadOnlyBeaconState, epoch primitives.Epoch) error { - // The cache uses the state root at the end of (current epoch - 2) as key. - // (e.g. for epoch 2, the key is root at slot 31) - if epoch <= params.BeaconConfig().GenesisEpoch+2*params.BeaconConfig().MinSeedLookahead { - return nil - } - slot, err := slots.EpochEnd(epoch - 2) - if err != nil { - return err - } - root, err := state.StateRootAtIndex(uint64(slot % params.BeaconConfig().SlotsPerHistoricalRoot)) - if err != nil { - return err - } - // Skip cache update if the key already exists - _, ok := proposerIndicesCache.UnsafeProposerIndices(epoch, [32]byte(root)) - if ok { - return nil - } - indices, err := ActiveValidatorIndices(ctx, state, epoch) - if err != nil { - return err - } - proposerIndices, err := precomputeProposerIndices(state, indices, epoch) - if err != nil { - return err - } - if len(proposerIndices) != int(params.BeaconConfig().SlotsPerEpoch) { - return errors.New("invalid proposer length returned from state") - } - // This is here to deal with tests only - var indicesArray [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex - copy(indicesArray[:], proposerIndices) - proposerIndicesCache.Prune(epoch - 2) - proposerIndicesCache.SetUnsafe(epoch, [32]byte(root), indicesArray) - return nil -} - // ClearCache clears the beacon committee cache and sync committee cache. func ClearCache() { committeeCache.Clear() diff --git a/beacon-chain/core/helpers/validators.go b/beacon-chain/core/helpers/validators.go index 1a2281dbe7..c34d884a64 100644 --- a/beacon-chain/core/helpers/validators.go +++ b/beacon-chain/core/helpers/validators.go @@ -281,39 +281,6 @@ func cachedProposerIndexAtSlot(slot primitives.Slot, root [32]byte) (primitives. return proposerIndices[slot%params.BeaconConfig().SlotsPerEpoch], nil } -// cachedUnsafeProposerIndexAtSlot returns the proposer index at the given slot -// from the unsafe cache computed in the previous epoch -func cachedUnsafeProposerIndexAtSlot(slot primitives.Slot, root [32]byte) (primitives.ValidatorIndex, error) { - proposerIndices, has := proposerIndicesCache.UnsafeProposerIndices(slots.ToEpoch(slot), root) - if !has { - cache.ProposerIndicesCacheMiss.Inc() - return 0, errProposerIndexMiss - } - if len(proposerIndices) != int(params.BeaconConfig().SlotsPerEpoch) { - cache.ProposerIndicesCacheMiss.Inc() - return 0, errProposerIndexMiss - } - return proposerIndices[slot%params.BeaconConfig().SlotsPerEpoch], nil -} - -// UnsafeBeaconProposerIndexAtSlot returns the proposer index at the given slot -// if it has been cached one epoch in advance -func UnsafeBeaconProposerIndexAtSlot(state state.ReadOnlyBeaconState, slot primitives.Slot) (primitives.ValidatorIndex, error) { - e := slots.ToEpoch(slot) - if e < 2 { - return 0, errProposerIndexMiss - } - s, err := slots.EpochEnd(e - 2) - if err != nil { - return 0, err - } - r, err := StateRootAtSlot(state, s) - if err != nil { - return 0, err - } - return cachedUnsafeProposerIndexAtSlot(slot, [32]byte(r)) -} - // BeaconProposerIndexAtSlot returns proposer index at the given slot from the // point of view of the given state as head state func BeaconProposerIndexAtSlot(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot) (primitives.ValidatorIndex, error) { diff --git a/beacon-chain/core/helpers/validators_test.go b/beacon-chain/core/helpers/validators_test.go index 423deb5c1c..b8b6b90b01 100644 --- a/beacon-chain/core/helpers/validators_test.go +++ b/beacon-chain/core/helpers/validators_test.go @@ -16,7 +16,6 @@ import ( ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/v4/testing/assert" "github.com/prysmaticlabs/prysm/v4/testing/require" - "github.com/prysmaticlabs/prysm/v4/time/slots" ) func TestIsActiveValidator_OK(t *testing.T) { @@ -803,26 +802,3 @@ func TestLastActivatedValidatorIndex_OK(t *testing.T) { require.NoError(t, err) require.Equal(t, index, primitives.ValidatorIndex(3)) } - -func TestUnsafeProposerIndexAtSlot(t *testing.T) { - bRoot := [32]byte{'A'} - e := 4 - slot := primitives.Slot(e) * params.BeaconConfig().SlotsPerEpoch - indices, ok := proposerIndicesCache.UnsafeProposerIndices(primitives.Epoch(e), bRoot) - require.Equal(t, false, ok) - - beaconState, err := state_native.InitializeFromProtoPhase0(ðpb.BeaconState{}) - require.NoError(t, err) - roots := make([][]byte, fieldparams.StateRootsLength) - roots[(e-1)*int(params.BeaconConfig().SlotsPerEpoch)-1] = bRoot[:] - id := primitives.ValidatorIndex(17) - indices[0] = id - require.NoError(t, beaconState.SetStateRoots(roots)) - require.NoError(t, beaconState.SetSlot(slot)) - epoch := slots.ToEpoch(slot) - require.Equal(t, primitives.Epoch(e), epoch) - proposerIndicesCache.SetUnsafe(epoch, bRoot, indices) - pid, err := UnsafeBeaconProposerIndexAtSlot(beaconState, slot) - require.NoError(t, err) - require.Equal(t, id, pid) -}