From 7ac24d551bf41bca4deec9f47239c4c0d052e721 Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 28 Apr 2015 17:48:46 +0200 Subject: [PATCH] core: seperated proccing mutex and getting mutex --- core/block_processor.go | 2 +- core/chain_manager.go | 94 ++++++++++++++++++++++------------------- 2 files changed, 51 insertions(+), 45 deletions(-) diff --git a/core/block_processor.go b/core/block_processor.go index 9f26ab8b5..af47069ad 100644 --- a/core/block_processor.go +++ b/core/block_processor.go @@ -21,7 +21,7 @@ import ( const ( // must be bumped when consensus algorithm is changed, this forces the upgradedb // command to be run (forces the blocks to be imported again using the new algorithm) - BlockChainVersion = 3 + BlockChainVersion = 2 ) var statelogger = logger.NewLogger("BLOCK") diff --git a/core/chain_manager.go b/core/chain_manager.go index 9bb14b0cd..56895b73e 100644 --- a/core/chain_manager.go +++ b/core/chain_manager.go @@ -74,8 +74,10 @@ type ChainManager struct { eventMux *event.TypeMux genesisBlock *types.Block // Last known total difficulty - mu sync.RWMutex - tsmu sync.RWMutex + mu sync.RWMutex + tsmu sync.RWMutex + insertMu sync.Mutex + td *big.Int currentBlock *types.Block lastBlockHash common.Hash @@ -496,8 +498,8 @@ func (self *ChainManager) procFutureBlocks() { } func (self *ChainManager) InsertChain(chain types.Blocks) error { - self.mu.Lock() - defer self.mu.Unlock() + self.insertMu.Lock() + defer self.insertMu.Unlock() // A queued approach to delivering events. This is generally faster than direct delivery and requires much less mutex acquiring. var ( @@ -546,51 +548,55 @@ func (self *ChainManager) InsertChain(chain types.Blocks) error { block.Td = new(big.Int).Set(CalculateTD(block, self.GetBlock(block.ParentHash()))) - cblock := self.currentBlock - // Write block to database. Eventually we'll have to improve on this and throw away blocks that are - // not in the canonical chain. - self.write(block) - // Compare the TD of the last known block in the canonical chain to make sure it's greater. - // At this point it's possible that a different chain (fork) becomes the new canonical chain. - if block.Td.Cmp(self.td) > 0 { - //if block.Header().Number.Cmp(new(big.Int).Add(cblock.Header().Number, common.Big1)) < 0 { - if block.Number().Cmp(cblock.Number()) <= 0 { - chash := cblock.Hash() - hash := block.Hash() + self.mu.Lock() + { + cblock := self.currentBlock + // Write block to database. Eventually we'll have to improve on this and throw away blocks that are + // not in the canonical chain. + self.write(block) + // Compare the TD of the last known block in the canonical chain to make sure it's greater. + // At this point it's possible that a different chain (fork) becomes the new canonical chain. + if block.Td.Cmp(self.td) > 0 { + //if block.Header().Number.Cmp(new(big.Int).Add(cblock.Header().Number, common.Big1)) < 0 { + if block.Number().Cmp(cblock.Number()) <= 0 { + chash := cblock.Hash() + hash := block.Hash() - if glog.V(logger.Info) { - glog.Infof("Split detected. New head #%v (%x) TD=%v, was #%v (%x) TD=%v\n", block.Header().Number, hash[:4], block.Td, cblock.Header().Number, chash[:4], self.td) + if glog.V(logger.Info) { + glog.Infof("Split detected. New head #%v (%x) TD=%v, was #%v (%x) TD=%v\n", block.Header().Number, hash[:4], block.Td, cblock.Header().Number, chash[:4], self.td) + } + // during split we merge two different chains and create the new canonical chain + self.merge(self.getBlockByNumber(block.NumberU64()), block) + + queue[i] = ChainSplitEvent{block, logs} + queueEvent.splitCount++ } - // during split we merge two different chains and create the new canonical chain - self.merge(self.getBlockByNumber(block.NumberU64()), block) - queue[i] = ChainSplitEvent{block, logs} - queueEvent.splitCount++ + self.setTotalDifficulty(block.Td) + self.insert(block) + + jsonlogger.LogJson(&logger.EthChainNewHead{ + BlockHash: block.Hash().Hex(), + BlockNumber: block.Number(), + ChainHeadHash: cblock.Hash().Hex(), + BlockPrevHash: block.ParentHash().Hex(), + }) + + self.setTransState(state.New(block.Root(), self.stateDb)) + self.txState.SetState(state.New(block.Root(), self.stateDb)) + + queue[i] = ChainEvent{block, logs} + queueEvent.canonicalCount++ + + if glog.V(logger.Debug) { + glog.Infof("inserted block #%d (%d TXs %d UNCs) (%x...)\n", block.Number(), len(block.Transactions()), len(block.Uncles()), block.Hash().Bytes()[0:4]) + } + } else { + queue[i] = ChainSideEvent{block, logs} + queueEvent.sideCount++ } - - self.setTotalDifficulty(block.Td) - self.insert(block) - - jsonlogger.LogJson(&logger.EthChainNewHead{ - BlockHash: block.Hash().Hex(), - BlockNumber: block.Number(), - ChainHeadHash: cblock.Hash().Hex(), - BlockPrevHash: block.ParentHash().Hex(), - }) - - self.setTransState(state.New(block.Root(), self.stateDb)) - self.txState.SetState(state.New(block.Root(), self.stateDb)) - - queue[i] = ChainEvent{block, logs} - queueEvent.canonicalCount++ - - if glog.V(logger.Debug) { - glog.Infof("inserted block #%d (%d TXs %d UNCs) (%x...)\n", block.Number(), len(block.Transactions()), len(block.Uncles()), block.Hash().Bytes()[0:4]) - } - } else { - queue[i] = ChainSideEvent{block, logs} - queueEvent.sideCount++ } + self.mu.Unlock() stats.processed++