cerc-io/plugeth
18
0
Fork 1
Code Issues 4 Pull Requests Packages Projects Releases Wiki Activity

core: replaced BlockCache with lru.Cache

Browse Source
This commit is contained in:
Jeffrey Wilcke 2015-06-29 22:42:13 +02:00
parent a8ebf756c7
commit 992e4f83cb
2 changed files with 25 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
core/chain_manager.go
View File

@ -109,9 +109,9 @@ type ChainManager struct {
transState *state.StateDB transState *state.StateDB
txState *state.ManagedState txState *state.ManagedState
cache *lru.Cache // cache is the LRU caching cache *lru.Cache // cache is the LRU caching
futureBlocks *BlockCache // future blocks are blocks added for later processing futureBlocks *lru.Cache // future blocks are blocks added for later processing
pendingBlocks *BlockCache // pending blocks contain blocks not yet written to the db pendingBlocks *lru.Cache // pending blocks contain blocks not yet written to the db
quit chan struct{} quit chan struct{}
// procInterrupt must be atomically called // procInterrupt must be atomically called
@ -158,7 +158,7 @@ func NewChainManager(genesis *types.Block, blockDb, stateDb common.Database, pow
// Take ownership of this particular state // Take ownership of this particular state
bc.txState = state.ManageState(bc.State().Copy()) bc.txState = state.ManageState(bc.State().Copy())
bc.futureBlocks = NewBlockCache(maxFutureBlocks) bc.futureBlocks, _ = lru.New(maxFutureBlocks)
bc.makeCache() bc.makeCache()
go bc.update() go bc.update()
@ -390,7 +390,7 @@ func (bc *ChainManager) HasBlock(hash common.Hash) bool {
} }
if bc.pendingBlocks != nil { if bc.pendingBlocks != nil {
if block := bc.pendingBlocks.Get(hash); block != nil { if _, exist := bc.pendingBlocks.Get(hash); exist {
return true return true
} }
} }
@ -426,8 +426,8 @@ func (self *ChainManager) GetBlock(hash common.Hash) *types.Block {
} }
if self.pendingBlocks != nil { if self.pendingBlocks != nil {
if block := self.pendingBlocks.Get(hash); block != nil { if block, _ := self.pendingBlocks.Get(hash); block != nil {
return block return block.(*types.Block)
} }
} }
@ -510,10 +510,11 @@ type queueEvent struct {
} }
func (self *ChainManager) procFutureBlocks() { func (self *ChainManager) procFutureBlocks() {
var blocks []*types.Block blocks := make([]*types.Block, self.futureBlocks.Len())
self.futureBlocks.Each(func(i int, block *types.Block) { for i, hash := range self.futureBlocks.Keys() {
blocks = append(blocks, block) block, _ := self.futureBlocks.Get(hash)
}) blocks[i] = block.(*types.Block)
}
if len(blocks) > 0 { if len(blocks) > 0 {
types.BlockBy(types.Number).Sort(blocks) types.BlockBy(types.Number).Sort(blocks)
self.InsertChain(blocks) self.InsertChain(blocks)
@ -521,13 +522,16 @@ func (self *ChainManager) procFutureBlocks() {
} }
func (self *ChainManager) enqueueForWrite(block *types.Block) { func (self *ChainManager) enqueueForWrite(block *types.Block) {
self.pendingBlocks.Push(block) self.pendingBlocks.Add(block.Hash(), block)
} }
func (self *ChainManager) flushQueuedBlocks() { func (self *ChainManager) flushQueuedBlocks() {
db, batchWrite := self.blockDb.(*ethdb.LDBDatabase) db, batchWrite := self.blockDb.(*ethdb.LDBDatabase)
batch := new(leveldb.Batch) batch := new(leveldb.Batch)
self.pendingBlocks.Each(func(i int, block *types.Block) { for _, key := range self.pendingBlocks.Keys() {
b, _ := self.pendingBlocks.Get(key)
block := b.(*types.Block)
enc, _ := rlp.EncodeToBytes((*types.StorageBlock)(block)) enc, _ := rlp.EncodeToBytes((*types.StorageBlock)(block))
key := append(blockHashPre, block.Hash().Bytes()...) key := append(blockHashPre, block.Hash().Bytes()...)
if batchWrite { if batchWrite {
@ -535,7 +539,8 @@ func (self *ChainManager) flushQueuedBlocks() {
} else { } else {
self.blockDb.Put(key, enc) self.blockDb.Put(key, enc)
} }
}) }
if batchWrite { if batchWrite {
db.LDB().Write(batch, nil) db.LDB().Write(batch, nil)
} }
@ -588,7 +593,7 @@ func (self *ChainManager) WriteBlock(block *types.Block) (status writeStatus, er
self.enqueueForWrite(block) self.enqueueForWrite(block)
self.mu.Unlock() self.mu.Unlock()
// Delete from future blocks // Delete from future blocks
self.futureBlocks.Delete(block.Hash()) self.futureBlocks.Remove(block.Hash())
return return
} }
@ -602,7 +607,7 @@ func (self *ChainManager) InsertChain(chain types.Blocks) (int, error) {
self.chainmu.Lock() self.chainmu.Lock()
defer self.chainmu.Unlock() defer self.chainmu.Unlock()
self.pendingBlocks = NewBlockCache(len(chain)) self.pendingBlocks, _ = lru.New(len(chain))
// A queued approach to delivering events. This is generally // A queued approach to delivering events. This is generally
// faster than direct delivery and requires much less mutex // faster than direct delivery and requires much less mutex
@ -669,13 +674,13 @@ func (self *ChainManager) InsertChain(chain types.Blocks) (int, error) {
return i, fmt.Errorf("%v: BlockFutureErr, %v > %v", BlockFutureErr, block.Time(), max) return i, fmt.Errorf("%v: BlockFutureErr, %v > %v", BlockFutureErr, block.Time(), max)
} }
self.futureBlocks.Push(block) self.futureBlocks.Add(block.Hash(), block)
stats.queued++ stats.queued++
continue continue
} }
if IsParentErr(err) && self.futureBlocks.Has(block.ParentHash()) { if IsParentErr(err) && self.futureBlocks.Contains(block.ParentHash()) {
self.futureBlocks.Push(block) self.futureBlocks.Add(block.Hash(), block)
stats.queued++ stats.queued++
continue continue
} }

2
core/chain_manager_test.go
View File

@ -393,7 +393,7 @@ func chm(genesis *types.Block, db common.Database) *ChainManager {
var eventMux event.TypeMux var eventMux event.TypeMux
bc := &ChainManager{blockDb: db, stateDb: db, genesisBlock: genesis, eventMux: &eventMux, pow: FakePow{}} bc := &ChainManager{blockDb: db, stateDb: db, genesisBlock: genesis, eventMux: &eventMux, pow: FakePow{}}
bc.cache, _ = lru.New(100) bc.cache, _ = lru.New(100)
bc.futureBlocks = NewBlockCache(100) bc.futureBlocks, _ = lru.New(100)
bc.processor = bproc{} bc.processor = bproc{}
bc.ResetWithGenesisBlock(genesis) bc.ResetWithGenesisBlock(genesis)
bc.txState = state.ManageState(bc.State()) bc.txState = state.ManageState(bc.State())