)
const (
- maxCachedBlockHeaders = 1000
- maxCachedBlockTransactions = 1000
+ maxCachedBlockHeaders = 1024
+ maxCachedBlockTransactions = 1024
maxCachedVoteResults = 144 // int(60 * 60 * 24 * 1000 / consensus.BlockTimeInterval / consensus.RoundVoteBlockNums)
)
type fillBlockTransactionsFn func(hash *bc.Hash) ([]*types.Tx, error)
type fillVoteResultFn func(seq uint64) (*state.VoteResult, error)
-func newBlockCache(fillBlockHeader fillBlockHeaderFn, fillBlockTxs fillBlockTransactionsFn, fillVoteResult fillVoteResultFn) blockCache {
- return blockCache{
+func newCache(fillBlockHeader fillBlockHeaderFn, fillBlockTxs fillBlockTransactionsFn, fillVoteResult fillVoteResultFn) cache {
+ return cache{
lruBlockHeaders: common.NewCache(maxCachedBlockHeaders),
lruBlockTxs: common.NewCache(maxCachedBlockTransactions),
lruVoteResults: common.NewCache(maxCachedVoteResults),
}
}
-type blockCache struct {
+type cache struct {
lruBlockHeaders *common.Cache
lruBlockTxs *common.Cache
lruVoteResults *common.Cache
singleVoteResult singleflight.Group
}
-func (c *blockCache) lookupBlockHeader(hash *bc.Hash, height uint64) (*types.BlockHeader, error) {
+func (c *cache) lookupBlockHeader(hash *bc.Hash, height uint64) (*types.BlockHeader, error) {
if bH, ok := c.getBlockHeader(hash); ok {
return bH, nil
}
return blockHeader.(*types.BlockHeader), nil
}
-func (c *blockCache) lookupBlockTxs(hash *bc.Hash) ([]*types.Tx, error) {
+func (c *cache) lookupBlockTxs(hash *bc.Hash) ([]*types.Tx, error) {
if bTxs, ok := c.getBlockTransactions(hash); ok {
return bTxs, nil
}
return blockTransactions.([]*types.Tx), nil
}
-func (c *blockCache) lookupVoteResult(seq uint64) (*state.VoteResult, error) {
+func (c *cache) lookupVoteResult(seq uint64) (*state.VoteResult, error) {
if vr, ok := c.getVoteResult(seq); ok {
return vr.Fork(), nil
}
return voteResult.(*state.VoteResult).Fork(), nil
}
-func (c *blockCache) getBlockHeader(hash *bc.Hash) (*types.BlockHeader, bool) {
+func (c *cache) getBlockHeader(hash *bc.Hash) (*types.BlockHeader, bool) {
blockHeader, ok := c.lruBlockHeaders.Get(*hash)
if blockHeader == nil {
return nil, ok
return blockHeader.(*types.BlockHeader), ok
}
-func (c *blockCache) getBlockTransactions(hash *bc.Hash) ([]*types.Tx, bool) {
+func (c *cache) getBlockTransactions(hash *bc.Hash) ([]*types.Tx, bool) {
txs, ok := c.lruBlockTxs.Get(*hash)
if txs == nil {
return nil, ok
return txs.([]*types.Tx), ok
}
-func (c *blockCache) getVoteResult(seq uint64) (*state.VoteResult, bool) {
+func (c *cache) getVoteResult(seq uint64) (*state.VoteResult, bool) {
voteResult, ok := c.lruVoteResults.Get(seq)
if voteResult == nil {
return nil, ok
return voteResult.(*state.VoteResult), ok
}
-func (c *blockCache) addBlockHeader(blockHeader *types.BlockHeader) {
+func (c *cache) addBlockHeader(blockHeader *types.BlockHeader) {
c.lruBlockHeaders.Add(blockHeader.Hash(), blockHeader)
}
-func (c *blockCache) addBlockTxs(hash bc.Hash, txs []*types.Tx) {
+func (c *cache) addBlockTxs(hash bc.Hash, txs []*types.Tx) {
c.lruBlockTxs.Add(hash, txs)
}
-func (c *blockCache) addVoteResult(voteResult *state.VoteResult) {
+func (c *cache) addVoteResult(voteResult *state.VoteResult) {
c.lruVoteResults.Add(voteResult.Seq, voteResult)
}