mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2024-12-25 12:57:18 +00:00
7f7866ff2a
* Starting a quick PoC * Rate limit to one epoch worth of blocks in memory * Proof of concept working * Quick comment out * Save previous finalized checkpoint * Test * Minor fixes * More run time fixes * Remove panic * Feature flag * Removed unused methods * Fixed tests * E2e test * comment * Compatible with current initial sync * Starting * New cache * Cache getters and setters * It should be part of state gen * Need to use cache for DB * Don't have to use finalized state * Rm unused file * some changes to memory mgmt when using mempool * More run time fixes * Can sync to head * Feedback * Revert "some changes to memory mgmt when using mempool" This reverts commit f5b3e7ff4714fef9f0397007f519a45fa259ad24. * Fixed sync tests * Fixed existing tests * Test for state summary getter * Gaz * Fix kafka passthrough * Fixed inputs * Gaz * Fixed build * Fixed visibility * Trying without the ignore * Didn't work.. * Fix kafka Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com> Co-authored-by: Preston Van Loon <preston@prysmaticlabs.com>
128 lines
4.3 KiB
Go
128 lines
4.3 KiB
Go
package stategen
|
|
|
|
import (
|
|
"context"
|
|
"encoding/hex"
|
|
|
|
"github.com/pkg/errors"
|
|
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
|
|
"github.com/prysmaticlabs/prysm/beacon-chain/state"
|
|
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
|
|
"github.com/prysmaticlabs/prysm/shared/bytesutil"
|
|
"github.com/sirupsen/logrus"
|
|
"go.opencensus.io/trace"
|
|
)
|
|
|
|
// This saves a post finalized beacon state in the hot section of the DB. On the epoch boundary,
|
|
// it saves a full state. On an intermediate slot, it saves a back pointer to the
|
|
// nearest epoch boundary state.
|
|
func (s *State) saveHotState(ctx context.Context, blockRoot [32]byte, state *state.BeaconState) error {
|
|
ctx, span := trace.StartSpan(ctx, "stateGen.saveHotState")
|
|
defer span.End()
|
|
|
|
// If the hot state is already in cache, one can be sure the state was processed and in the DB.
|
|
if s.hotStateCache.Has(blockRoot) {
|
|
return nil
|
|
}
|
|
|
|
// Only on an epoch boundary slot, saves the whole state.
|
|
if helpers.IsEpochStart(state.Slot()) {
|
|
if err := s.beaconDB.SaveState(ctx, state, blockRoot); err != nil {
|
|
return err
|
|
}
|
|
log.WithFields(logrus.Fields{
|
|
"slot": state.Slot(),
|
|
"blockRoot": hex.EncodeToString(bytesutil.Trunc(blockRoot[:]))}).Info("Saved full state on epoch boundary")
|
|
}
|
|
|
|
// On an intermediate slots, save the hot state summary.
|
|
s.stateSummaryCache.Put(blockRoot, &pb.StateSummary{
|
|
Slot: state.Slot(),
|
|
Root: blockRoot[:],
|
|
})
|
|
|
|
// Store the copied state in the cache.
|
|
s.hotStateCache.Put(blockRoot, state)
|
|
|
|
return nil
|
|
}
|
|
|
|
// This loads a post finalized beacon state from the hot section of the DB. If necessary it will
|
|
// replay blocks starting from the nearest epoch boundary. It returns the beacon state that
|
|
// corresponds to the input block root.
|
|
func (s *State) loadHotStateByRoot(ctx context.Context, blockRoot [32]byte) (*state.BeaconState, error) {
|
|
ctx, span := trace.StartSpan(ctx, "stateGen.loadHotStateByRoot")
|
|
defer span.End()
|
|
|
|
// Load the hot state from cache.
|
|
cachedState := s.hotStateCache.Get(blockRoot)
|
|
if cachedState != nil {
|
|
return cachedState, nil
|
|
}
|
|
|
|
// Load the hot state from DB.
|
|
if s.beaconDB.HasState(ctx, blockRoot) {
|
|
return s.beaconDB.State(ctx, blockRoot)
|
|
}
|
|
|
|
summary, err := s.stateSummary(ctx, blockRoot)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not get state summary")
|
|
}
|
|
|
|
startState, err := s.lastSavedState(ctx, summary.Slot)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if startState == nil {
|
|
return nil, errUnknownBoundaryState
|
|
}
|
|
|
|
// Don't need to replay the blocks if start state is the same state for the block root.
|
|
var hotState *state.BeaconState
|
|
targetSlot := summary.Slot
|
|
if targetSlot == startState.Slot() {
|
|
hotState = startState
|
|
} else {
|
|
blks, err := s.LoadBlocks(ctx, startState.Slot()+1, targetSlot, bytesutil.ToBytes32(summary.Root))
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not load blocks for hot state using root")
|
|
}
|
|
hotState, err = s.ReplayBlocks(ctx, startState, blks, targetSlot)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not replay blocks for hot state using root")
|
|
}
|
|
}
|
|
|
|
// Save the copied state because the reference also returned in the end.
|
|
s.hotStateCache.Put(blockRoot, hotState.Copy())
|
|
|
|
return hotState, nil
|
|
}
|
|
|
|
// This loads a hot state by slot where the slot lies between the epoch boundary points.
|
|
// This is a slower implementation (versus ByRoot) as slot is the only argument. It require fetching
|
|
// all the blocks between the epoch boundary points for playback.
|
|
// Use `loadHotStateByRoot` unless you really don't know the root.
|
|
func (s *State) loadHotStateBySlot(ctx context.Context, slot uint64) (*state.BeaconState, error) {
|
|
ctx, span := trace.StartSpan(ctx, "stateGen.loadHotStateBySlot")
|
|
defer span.End()
|
|
|
|
// Gather last saved state, that is where node starts to replay the blocks.
|
|
startState, err := s.lastSavedState(ctx, slot)
|
|
|
|
// Gather the last saved block root and the slot number.
|
|
lastValidRoot, lastValidSlot, err := s.lastSavedBlock(ctx, slot)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not get last valid block for hot state using slot")
|
|
}
|
|
|
|
// Load and replay blocks to get the intermediate state.
|
|
replayBlks, err := s.LoadBlocks(ctx, startState.Slot()+1, lastValidSlot, lastValidRoot)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return s.ReplayBlocks(ctx, startState, replayBlks, slot)
|
|
}
|