cache

package
v4.1.0-alpha.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 7, 2023 License: GPL-3.0 Imports: 31 Imported by: 44

Documentation

Overview

Package cache includes all important caches for the runtime of an Ethereum Beacon Node, ensuring the node does not spend resources computing duplicate operations such as committee calculations for validators during the same epoch, etc.

Index

Constants

This section is empty.

Variables

View Source 
var (
	// CommitteeCacheMiss tracks the number of committee requests that aren't present in the cache.
	CommitteeCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
		Name: "committee_cache_miss",
		Help: "The number of committee requests that aren't present in the cache.",
	})
	// CommitteeCacheHit tracks the number of committee requests that are in the cache.
	CommitteeCacheHit = promauto.NewCounter(prometheus.CounterOpts{
		Name: "committee_cache_hit",
		Help: "The number of committee requests that are present in the cache.",
	})
)
View Source 
var (
	// ErrNilValueProvided for when we try to put a nil value in a cache.
	ErrNilValueProvided = errors.New("nil value provided on Put()")
	// ErrIncorrectType for when the state is of the incorrect type.
	ErrIncorrectType = errors.New("incorrect state type provided")
	// ErrNotFound for cache fetches that return a nil value.
	ErrNotFound = errors.New("not found in cache")
	// ErrNonExistingSyncCommitteeKey when sync committee key (root) does not exist in cache.
	ErrNonExistingSyncCommitteeKey = errors.New("does not exist sync committee key")

	// ErrNotFoundRegistration when validator registration does not exist in cache.
	ErrNotFoundRegistration = errors.Wrap(ErrNotFound, "no validator registered")
)
View Source 
var (

	// ProposerIndicesCacheMiss tracks the number of proposerIndices requests that aren't present in the cache.
	ProposerIndicesCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
		Name: "proposer_indices_cache_miss",
		Help: "The number of proposer indices requests that aren't present in the cache.",
	})
	// ProposerIndicesCacheHit tracks the number of proposerIndices requests that are in the cache.
	ProposerIndicesCacheHit = promauto.NewCounter(prometheus.CounterOpts{
		Name: "proposer_indices_cache_hit",
		Help: "The number of proposer indices requests that are present in the cache.",
	})
)
View Source 
var (

	// SyncCommitteeCacheMiss tracks the number of committee requests that aren't present in the cache.
	SyncCommitteeCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
		Name: "sync_committee_index_cache_miss_total",
		Help: "The number of committee requests that aren't present in the sync committee index cache.",
	})
	// SyncCommitteeCacheHit tracks the number of committee requests that are in the cache.
	SyncCommitteeCacheHit = promauto.NewCounter(prometheus.CounterOpts{
		Name: "sync_committee_index_cache_hit_total",
		Help: "The number of committee requests that are present in the sync committee index cache.",
	})
)
View Source 
var ErrAlreadyInProgress = errors.New("already in progress")

ErrAlreadyInProgress appears when attempting to mark a cache as in progress while it is already in progress. The client should handle this error and wait for the in progress data to resolve via Get.

View Source 
var ErrNotCommittee = errors.New("object is not a committee struct")

ErrNotCommittee will be returned when a cache object is not a pointer to a Committee struct.

View Source 
var ErrNotProposerIndices = errors.New("object is not a proposer indices struct")

ErrNotProposerIndices will be returned when a cache object is not a pointer to a ProposerIndices struct.

View Source 
var SubnetIDs = newSubnetIDs()

SubnetIDs for attester and aggregator.

View Source 
var SyncSubnetIDs = newSyncSubnetIDs()

SyncSubnetIDs for sync committee participant.

Functions

This section is empty.

Types

type AttestationCache 

type AttestationCache struct {
	// contains filtered or unexported fields
}

AttestationCache is used to store the cached results of an AttestationData request.

func NewAttestationCache 

func NewAttestationCache() *AttestationCache

NewAttestationCache initializes the map and underlying cache.

func (*AttestationCache) Get 

func (c *AttestationCache) Get(ctx context.Context, req *ethpb.AttestationDataRequest) (*ethpb.AttestationData, error)

Get waits for any in progress calculation to complete before returning a cached response, if any.

func (*AttestationCache) MarkInProgress 

func (c *AttestationCache) MarkInProgress(req *ethpb.AttestationDataRequest) error

MarkInProgress a request so that any other similar requests will block on Get until MarkNotInProgress is called.

func (*AttestationCache) MarkNotInProgress 

func (c *AttestationCache) MarkNotInProgress(req *ethpb.AttestationDataRequest) error

MarkNotInProgress will release the lock on a given request. This should be called after put.

func (*AttestationCache) Put 

func (c *AttestationCache) Put(_ context.Context, req *ethpb.AttestationDataRequest, res *ethpb.AttestationData) error

Put the response in the cache.

type BalanceCache 

type BalanceCache struct {
	// contains filtered or unexported fields
}

BalanceCache is a struct with 1 LRU cache for looking up balance by epoch.

func NewEffectiveBalanceCache 

func NewEffectiveBalanceCache() *BalanceCache

NewEffectiveBalanceCache creates a new effective balance cache for storing/accessing total balance by epoch.

func (*BalanceCache) AddTotalEffectiveBalance 

func (c *BalanceCache) AddTotalEffectiveBalance(st state.ReadOnlyBeaconState, balance uint64) error

AddTotalEffectiveBalance adds a new total effective balance entry for current balance for state `st` into the cache.

func (*BalanceCache) Clear added in v4.0.4 

func (c *BalanceCache) Clear()

Clear resets the SyncCommitteeCache to its initial state

func (*BalanceCache) Get 

func (c *BalanceCache) Get(st state.ReadOnlyBeaconState) (uint64, error)

Get returns the current epoch's effective balance for state `st` in cache.

type CheckpointStateCache 

type CheckpointStateCache struct {
	// contains filtered or unexported fields
}

CheckpointStateCache is a struct with 1 queue for looking up state by checkpoint.

func NewCheckpointStateCache 

func NewCheckpointStateCache() *CheckpointStateCache

NewCheckpointStateCache creates a new checkpoint state cache for storing/accessing processed state.

func (*CheckpointStateCache) AddCheckpointState 

func (c *CheckpointStateCache) AddCheckpointState(cp *ethpb.Checkpoint, s state.ReadOnlyBeaconState) error

AddCheckpointState adds CheckpointState object to the cache. This method also trims the least recently added CheckpointState object if the cache size has ready the max cache size limit.

func (*CheckpointStateCache) StateByCheckpoint 

func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (state.BeaconState, error)

StateByCheckpoint fetches state by checkpoint. Returns true with a reference to the CheckpointState info, if exists. Otherwise returns false, nil.

type CommitteeCache 

type CommitteeCache struct {
	CommitteeCache *lru.Cache
	// contains filtered or unexported fields
}

CommitteeCache is a struct with 1 queue for looking up shuffled indices list by seed.

func NewCommitteesCache 

func NewCommitteesCache() *CommitteeCache

NewCommitteesCache creates a new committee cache for storing/accessing shuffled indices of a committee.

func (*CommitteeCache) ActiveIndices 

func (c *CommitteeCache) ActiveIndices(ctx context.Context, seed [32]byte) ([]primitives.ValidatorIndex, error)

ActiveIndices returns the active indices of a given seed stored in cache.

func (*CommitteeCache) ActiveIndicesCount 

func (c *CommitteeCache) ActiveIndicesCount(ctx context.Context, seed [32]byte) (int, error)

ActiveIndicesCount returns the active indices count of a given seed stored in cache.

func (*CommitteeCache) AddCommitteeShuffledList 

func (c *CommitteeCache) AddCommitteeShuffledList(ctx context.Context, committees *Committees) error

AddCommitteeShuffledList adds Committee shuffled list object to the cache. T his method also trims the least recently list if the cache size has ready the max cache size limit.

func (*CommitteeCache) Clear added in v4.0.4 

func (c *CommitteeCache) Clear()

Clear resets the CommitteeCache to its initial state

func (*CommitteeCache) Committee 

func (c *CommitteeCache) Committee(ctx context.Context, slot primitives.Slot, seed [32]byte, index primitives.CommitteeIndex) ([]primitives.ValidatorIndex, error)

Committee fetches the shuffled indices by slot and committee index. Every list of indices represent one committee. Returns true if the list exists with slot and committee index. Otherwise returns false, nil.

func (*CommitteeCache) HasEntry 

func (c *CommitteeCache) HasEntry(seed string) bool

HasEntry returns true if the committee cache has a value.

func (*CommitteeCache) MarkInProgress 

func (c *CommitteeCache) MarkInProgress(seed [32]byte) error

MarkInProgress a request so that any other similar requests will block on Get until MarkNotInProgress is called.

func (*CommitteeCache) MarkNotInProgress 

func (c *CommitteeCache) MarkNotInProgress(seed [32]byte) error

MarkNotInProgress will release the lock on a given request. This should be called after put.

type Committees 

type Committees struct {
	CommitteeCount  uint64
	Seed            [32]byte
	ShuffledIndices []primitives.ValidatorIndex
	SortedIndices   []primitives.ValidatorIndex
}

Committees defines the shuffled committees seed.

type DepositCache added in v4.1.0 

type DepositCache interface {
	DepositFetcher
	DepositInserter
}

DepositCache combines the interfaces for retrieving and inserting deposit information.

type DepositFetcher added in v4.1.0 

type DepositFetcher interface {
	AllDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit
	AllDepositContainers(ctx context.Context) []*ethpb.DepositContainer
	DepositByPubkey(ctx context.Context, pubKey []byte) (*ethpb.Deposit, *big.Int)
	DepositsNumberAndRootAtHeight(ctx context.Context, blockHeight *big.Int) (uint64, [32]byte)
	InsertPendingDeposit(ctx context.Context, d *ethpb.Deposit, blockNum uint64, index int64, depositRoot [32]byte)
	PendingDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit
	PendingContainers(ctx context.Context, untilBlk *big.Int) []*ethpb.DepositContainer
	PrunePendingDeposits(ctx context.Context, merkleTreeIndex int64)
	PruneProofs(ctx context.Context, untilDepositIndex int64) error
	FinalizedFetcher
}

DepositFetcher defines a struct which can retrieve deposit information from a store.

type DepositInserter added in v4.1.0 

type DepositInserter interface {
	InsertDeposit(ctx context.Context, d *ethpb.Deposit, blockNum uint64, index int64, depositRoot [32]byte) error
	InsertDepositContainers(ctx context.Context, ctrs []*ethpb.DepositContainer)
	InsertFinalizedDeposits(ctx context.Context, eth1DepositIndex int64, executionHash common.Hash, executionNumber uint64) error
}

DepositInserter defines a struct which can insert deposit information from a store.

type FinalizedDeposits added in v4.1.0 

type FinalizedDeposits interface {
	Deposits() MerkleTree
	MerkleTrieIndex() int64
}

FinalizedDeposits defines a method to access a merkle tree containing deposits and their indexes.

type FinalizedFetcher added in v4.1.0 

type FinalizedFetcher interface {
	FinalizedDeposits(ctx context.Context) (FinalizedDeposits, error)
	NonFinalizedDeposits(ctx context.Context, lastFinalizedIndex int64, untilBlk *big.Int) []*ethpb.Deposit
}

FinalizedFetcher is a smaller interface defined to be the bare minimum to satisfy “Service”. It extends the "DepositFetcher" interface with additional methods for fetching finalized deposits.

type MerkleTree added in v4.1.0 

type MerkleTree interface {
	HashTreeRoot() ([32]byte, error)
	NumOfItems() int
	Insert(item []byte, index int) error
	MerkleProof(index int) ([][]byte, error)
}

MerkleTree defines methods for constructing and manipulating a merkle tree.

type ProposerIndices 

type ProposerIndices struct {
	BlockRoot       [32]byte
	ProposerIndices []primitives.ValidatorIndex
}

ProposerIndices defines the cached struct for proposer indices.

type ProposerIndicesCache 

type ProposerIndicesCache struct {
	// contains filtered or unexported fields
}

ProposerIndicesCache is a struct with 1 queue for looking up proposer indices by root.

func NewProposerIndicesCache 

func NewProposerIndicesCache() *ProposerIndicesCache

NewProposerIndicesCache creates a new proposer indices cache for storing/accessing proposer index assignments of an epoch.

func (*ProposerIndicesCache) AddProposerIndices 

func (c *ProposerIndicesCache) AddProposerIndices(p *ProposerIndices) error

AddProposerIndices adds ProposerIndices object to the cache. This method also trims the least recently list if the cache size has ready the max cache size limit.

func (*ProposerIndicesCache) Clear added in v4.0.4 

func (c *ProposerIndicesCache) Clear()

Clear resets the ProposerIndicesCache to its initial state

func (*ProposerIndicesCache) HasProposerIndices 

func (c *ProposerIndicesCache) HasProposerIndices(r [32]byte) (bool, error)

HasProposerIndices returns the proposer indices of a block root seed.

func (*ProposerIndicesCache) Len 

func (c *ProposerIndicesCache) Len() int

Len returns the number of keys in the underlying cache.

func (*ProposerIndicesCache) ProposerIndices 

func (c *ProposerIndicesCache) ProposerIndices(r [32]byte) ([]primitives.ValidatorIndex, error)

ProposerIndices returns the proposer indices of a block root seed.

type ProposerPayloadIDsCache 

type ProposerPayloadIDsCache struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

ProposerPayloadIDsCache is a cache of proposer payload IDs. The key is the concatenation of the slot and the block root. The value is the concatenation of the proposer and payload IDs, 8 bytes each.

func NewProposerPayloadIDsCache 

func NewProposerPayloadIDsCache() *ProposerPayloadIDsCache

NewProposerPayloadIDsCache creates a new proposer payload IDs cache.

func (*ProposerPayloadIDsCache) GetProposerPayloadIDs 

func (f *ProposerPayloadIDsCache) GetProposerPayloadIDs(
	slot primitives.Slot,
	r [fieldparams.RootLength]byte,
) (primitives.ValidatorIndex, [pIdLength]byte, bool)

GetProposerPayloadIDs returns the proposer and payload IDs for the given slot and head root to build the block.

func (*ProposerPayloadIDsCache) PrunePayloadIDs 

func (f *ProposerPayloadIDsCache) PrunePayloadIDs(slot primitives.Slot)

PrunePayloadIDs removes the payload ID entries older than input slot.

func (*ProposerPayloadIDsCache) SetProposerAndPayloadIDs 

func (f *ProposerPayloadIDsCache) SetProposerAndPayloadIDs(
	slot primitives.Slot,
	vId primitives.ValidatorIndex,
	pId [pIdLength]byte,
	r [fieldparams.RootLength]byte,
)

SetProposerAndPayloadIDs sets the proposer and payload IDs for the given slot and head root to build block.

type RegistrationCache added in v4.0.4 

type RegistrationCache struct {
	// contains filtered or unexported fields
}

RegistrationCache is used to store the cached results of an Validator Registration request. beacon api /eth/v1/validator/register_validator

func NewRegistrationCache added in v4.0.4 

func NewRegistrationCache() *RegistrationCache

NewRegistrationCache initializes the map and underlying cache.

func (*RegistrationCache) RegistrationByIndex added in v4.0.4 

func (regCache *RegistrationCache) RegistrationByIndex(id primitives.ValidatorIndex) (*ethpb.ValidatorRegistrationV1, error)

RegistrationByIndex returns the registration by index in the cache and also removes items in the cache if expired.

func (*RegistrationCache) UpdateIndexToRegisteredMap added in v4.0.4 

func (regCache *RegistrationCache) UpdateIndexToRegisteredMap(ctx context.Context, m map[primitives.ValidatorIndex]*ethpb.ValidatorRegistrationV1)

UpdateIndexToRegisteredMap adds or updates values in the cache based on the argument.

type SkipSlotCache 

type SkipSlotCache struct {
	// contains filtered or unexported fields
}

SkipSlotCache is used to store the cached results of processing skip slots in transition.ProcessSlots.

func NewSkipSlotCache 

func NewSkipSlotCache() *SkipSlotCache

NewSkipSlotCache initializes the map and underlying cache.

func (*SkipSlotCache) Disable 

func (c *SkipSlotCache) Disable()

Disable the skip slot cache.

func (*SkipSlotCache) Enable 

func (c *SkipSlotCache) Enable()

Enable the skip slot cache.

func (*SkipSlotCache) Get 

func (c *SkipSlotCache) Get(ctx context.Context, r [32]byte) (state.BeaconState, error)

Get waits for any in progress calculation to complete before returning a cached response, if any.

func (*SkipSlotCache) MarkInProgress 

func (c *SkipSlotCache) MarkInProgress(r [32]byte) error

MarkInProgress a request so that any other similar requests will block on Get until MarkNotInProgress is called.

func (*SkipSlotCache) MarkNotInProgress 

func (c *SkipSlotCache) MarkNotInProgress(r [32]byte)

MarkNotInProgress will release the lock on a given request. This should be called after put.

func (*SkipSlotCache) Put 

func (c *SkipSlotCache) Put(_ context.Context, r [32]byte, state state.BeaconState)

Put the response in the cache.

type SyncCommitteeCache 

type SyncCommitteeCache struct {
	// contains filtered or unexported fields
}

SyncCommitteeCache utilizes a FIFO cache to sufficiently cache validator position within sync committee. It is thread safe with concurrent read write.

func NewSyncCommittee 

func NewSyncCommittee() *SyncCommitteeCache

NewSyncCommittee initializes and returns a new SyncCommitteeCache.

func (*SyncCommitteeCache) Clear added in v4.0.4 

func (s *SyncCommitteeCache) Clear()

Clear resets the SyncCommitteeCache to its initial state

func (*SyncCommitteeCache) CurrentPeriodIndexPosition 

func (s *SyncCommitteeCache) CurrentPeriodIndexPosition(root [32]byte, valIdx primitives.ValidatorIndex) ([]primitives.CommitteeIndex, error)

CurrentPeriodIndexPosition returns current period index position of a validator index with respect with sync committee. If the input validator index has no assignment, an empty list will be returned. If the input root does not exist in cache, `ErrNonExistingSyncCommitteeKey` is returned. Manual checking of state for index position in state is recommended when `ErrNonExistingSyncCommitteeKey` is returned.

func (*SyncCommitteeCache) NextPeriodIndexPosition 

func (s *SyncCommitteeCache) NextPeriodIndexPosition(root [32]byte, valIdx primitives.ValidatorIndex) ([]primitives.CommitteeIndex, error)

NextPeriodIndexPosition returns next period index position of a validator index in respect with sync committee. If the input validator index has no assignment, an empty list will be returned. If the input root does not exist in cache, `ErrNonExistingSyncCommitteeKey` is returned. Manual checking of state for index position in state is recommended when `ErrNonExistingSyncCommitteeKey` is returned.

func (*SyncCommitteeCache) UpdatePositionsInCommittee 

func (s *SyncCommitteeCache) UpdatePositionsInCommittee(syncCommitteeBoundaryRoot [32]byte, st state.BeaconState) error

UpdatePositionsInCommittee updates caching of validators position in sync committee in respect to current epoch and next epoch. This should be called when `current_sync_committee` and `next_sync_committee` change and that happens every `EPOCHS_PER_SYNC_COMMITTEE_PERIOD`.

type SyncCommitteeHeadStateCache 

type SyncCommitteeHeadStateCache struct {
	// contains filtered or unexported fields
}

SyncCommitteeHeadStateCache for the latest head state requested by a sync committee participant.

func NewSyncCommitteeHeadState 

func NewSyncCommitteeHeadState() *SyncCommitteeHeadStateCache

NewSyncCommitteeHeadState initializes a LRU cache for `SyncCommitteeHeadState` with size of 1.

func (*SyncCommitteeHeadStateCache) Get 

func (c *SyncCommitteeHeadStateCache) Get(slot primitives.Slot) (state.BeaconState, error)

Get `state` using `slot` as key. Return nil if nothing is found.

func (*SyncCommitteeHeadStateCache) Put 

func (c *SyncCommitteeHeadStateCache) Put(slot primitives.Slot, st state.BeaconState) error

Put `slot` as key and `state` as value onto the cache.

Source Files

View all Source files

Directories

Path Synopsis
Package depositcache is the source of validator deposits maintained in-memory by the beacon node – deposits processed from the eth1 powchain are then stored in this cache to be accessed by any other service during a beacon node's runtime.
 Package depositcache is the source of validator deposits maintained in-memory by the beacon node – deposits processed from the eth1 powchain are then stored in this cache to be accessed by any other service during a beacon node's runtime.
Package depositsnapshot implements the EIP-4881 standard for minimal sparse Merkle tree.
 Package depositsnapshot implements the EIP-4881 standard for minimal sparse Merkle tree.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.