mirror of https://github.com/status-im/op-geth.git
Merge pull request #3430 from karalabe/miner-pending-race
miner: clean up unconfirmed mined block tracking
This commit is contained in:
Péter Szilágyi
GitHub
commit
b792412d31
|
|
@ -0,0 +1,118 @@
|
|||
// Copyright 2016 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package miner
|
||||
|
||||
import (
|
||||
"container/ring"
|
||||
"sync"
|
||||
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
"github.com/ethereum/go-ethereum/core/types"
|
||||
"github.com/ethereum/go-ethereum/logger"
|
||||
"github.com/ethereum/go-ethereum/logger/glog"
|
||||
)
|
||||
|
||||
// headerRetriever is used by the unconfirmed block set to verify whether a previously
|
||||
// mined block is part of the canonical chain or not.
|
||||
type headerRetriever interface {
|
||||
// GetHeaderByNumber retrieves the canonical header associated with a block number.
|
||||
GetHeaderByNumber(number uint64) *types.Header
|
||||
}
|
||||
|
||||
// unconfirmedBlock is a small collection of metadata about a locally mined block
|
||||
// that is placed into a unconfirmed set for canonical chain inclusion tracking.
|
||||
type unconfirmedBlock struct {
|
||||
index uint64
|
||||
hash common.Hash
|
||||
}
|
||||
|
||||
// unconfirmedBlocks implements a data structure to maintain locally mined blocks
|
||||
// have have not yet reached enough maturity to guarantee chain inclusion. It is
|
||||
// used by the miner to provide logs to the user when a previously mined block
|
||||
// has a high enough guarantee to not be reorged out of te canonical chain.
|
||||
type unconfirmedBlocks struct {
|
||||
chain headerRetriever // Blockchain to verify canonical status through
|
||||
depth uint // Depth after which to discard previous blocks
|
||||
blocks *ring.Ring // Block infos to allow canonical chain cross checks
|
||||
lock sync.RWMutex // Protects the fields from concurrent access
|
||||
}
|
||||
|
||||
// newUnconfirmedBlocks returns new data structure to track currently unconfirmed blocks.
|
||||
func newUnconfirmedBlocks(chain headerRetriever, depth uint) *unconfirmedBlocks {
|
||||
return &unconfirmedBlocks{
|
||||
chain: chain,
|
||||
depth: depth,
|
||||
}
|
||||
}
|
||||
|
||||
// Insert adds a new block to the set of unconfirmed ones.
|
||||
func (set *unconfirmedBlocks) Insert(index uint64, hash common.Hash) {
|
||||
// If a new block was mined locally, shift out any old enough blocks
|
||||
set.Shift(index)
|
||||
|
||||
// Create the new item as its own ring
|
||||
item := ring.New(1)
|
||||
item.Value = &unconfirmedBlock{
|
||||
index: index,
|
||||
hash: hash,
|
||||
}
|
||||
// Set as the initial ring or append to the end
|
||||
set.lock.Lock()
|
||||
defer set.lock.Unlock()
|
||||
|
||||
if set.blocks == nil {
|
||||
set.blocks = item
|
||||
} else {
|
||||
set.blocks.Move(-1).Link(item)
|
||||
}
|
||||
// Display a log for the user to notify of a new mined block unconfirmed
|
||||
glog.V(logger.Info).Infof("🔨 mined potential block #%d [%x…], waiting for %d blocks to confirm", index, hash.Bytes()[:4], set.depth)
|
||||
}
|
||||
|
||||
// Shift drops all unconfirmed blocks from the set which exceed the unconfirmed sets depth
|
||||
// allowance, checking them against the canonical chain for inclusion or staleness
|
||||
// report.
|
||||
func (set *unconfirmedBlocks) Shift(height uint64) {
|
||||
set.lock.Lock()
|
||||
defer set.lock.Unlock()
|
||||
|
||||
for set.blocks != nil {
|
||||
// Retrieve the next unconfirmed block and abort if too fresh
|
||||
next := set.blocks.Value.(*unconfirmedBlock)
|
||||
if next.index+uint64(set.depth) > height {
|
||||
break
|
||||
}
|
||||
// Block seems to exceed depth allowance, check for canonical status
|
||||
header := set.chain.GetHeaderByNumber(next.index)
|
||||
switch {
|
||||
case header == nil:
|
||||
glog.V(logger.Warn).Infof("failed to retrieve header of mined block #%d [%x…]", next.index, next.hash.Bytes()[:4])
|
||||
case header.Hash() == next.hash:
|
||||
glog.V(logger.Info).Infof("🔗 mined block #%d [%x…] reached canonical chain", next.index, next.hash.Bytes()[:4])
|
||||
default:
|
||||
glog.V(logger.Info).Infof("⑂ mined block #%d [%x…] became a side fork", next.index, next.hash.Bytes()[:4])
|
||||
}
|
||||
// Drop the block out of the ring
|
||||
if set.blocks.Value == set.blocks.Next().Value {
|
||||
set.blocks = nil
|
||||
} else {
|
||||
set.blocks = set.blocks.Move(-1)
|
||||
set.blocks.Unlink(1)
|
||||
set.blocks = set.blocks.Move(1)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
// Copyright 2016 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package miner
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
"github.com/ethereum/go-ethereum/core/types"
|
||||
)
|
||||
|
||||
// noopHeaderRetriever is an implementation of headerRetriever that always
|
||||
// returns nil for any requested headers.
|
||||
type noopHeaderRetriever struct{}
|
||||
|
||||
func (r *noopHeaderRetriever) GetHeaderByNumber(number uint64) *types.Header {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Tests that inserting blocks into the unconfirmed set accumulates them until
|
||||
// the desired depth is reached, after which they begin to be dropped.
|
||||
func TestUnconfirmedInsertBounds(t *testing.T) {
|
||||
limit := uint(10)
|
||||
|
||||
pool := newUnconfirmedBlocks(new(noopHeaderRetriever), limit)
|
||||
for depth := uint64(0); depth < 2*uint64(limit); depth++ {
|
||||
// Insert multiple blocks for the same level just to stress it
|
||||
for i := 0; i < int(depth); i++ {
|
||||
pool.Insert(depth, common.Hash([32]byte{byte(depth), byte(i)}))
|
||||
}
|
||||
// Validate that no blocks below the depth allowance are left in
|
||||
pool.blocks.Do(func(block interface{}) {
|
||||
if block := block.(*unconfirmedBlock); block.index+uint64(limit) <= depth {
|
||||
t.Errorf("depth %d: block %x not dropped", depth, block.hash)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Tests that shifting blocks out of the unconfirmed set works both for normal
|
||||
// cases as well as for corner cases such as empty sets, empty shifts or full
|
||||
// shifts.
|
||||
func TestUnconfirmedShifts(t *testing.T) {
|
||||
// Create a pool with a few blocks on various depths
|
||||
limit, start := uint(10), uint64(25)
|
||||
|
||||
pool := newUnconfirmedBlocks(new(noopHeaderRetriever), limit)
|
||||
for depth := start; depth < start+uint64(limit); depth++ {
|
||||
pool.Insert(depth, common.Hash([32]byte{byte(depth)}))
|
||||
}
|
||||
// Try to shift below the limit and ensure no blocks are dropped
|
||||
pool.Shift(start + uint64(limit) - 1)
|
||||
if n := pool.blocks.Len(); n != int(limit) {
|
||||
t.Errorf("unconfirmed count mismatch: have %d, want %d", n, limit)
|
||||
}
|
||||
// Try to shift half the blocks out and verify remainder
|
||||
pool.Shift(start + uint64(limit) - 1 + uint64(limit/2))
|
||||
if n := pool.blocks.Len(); n != int(limit)/2 {
|
||||
t.Errorf("unconfirmed count mismatch: have %d, want %d", n, limit/2)
|
||||
}
|
||||
// Try to shift all the remaining blocks out and verify emptyness
|
||||
pool.Shift(start + 2*uint64(limit))
|
||||
if n := pool.blocks.Len(); n != 0 {
|
||||
t.Errorf("unconfirmed count mismatch: have %d, want %d", n, 0)
|
||||
}
|
||||
// Try to shift out from the empty set and make sure it doesn't break
|
||||
pool.Shift(start + 3*uint64(limit))
|
||||
if n := pool.blocks.Len(); n != 0 {
|
||||
t.Errorf("unconfirmed count mismatch: have %d, want %d", n, 0)
|
||||
}
|
||||
}
|
||||
|
|
@ -55,26 +55,20 @@ type Agent interface {
|
|||
GetHashRate() int64
|
||||
}
|
||||
|
||||
type uint64RingBuffer struct {
|
||||
ints []uint64 //array of all integers in buffer
|
||||
next int //where is the next insertion? assert 0 <= next < len(ints)
|
||||
}
|
||||
|
||||
// Work is the workers current environment and holds
|
||||
// all of the current state information
|
||||
type Work struct {
|
||||
config *params.ChainConfig
|
||||
signer types.Signer
|
||||
|
||||
state *state.StateDB // apply state changes here
|
||||
ancestors *set.Set // ancestor set (used for checking uncle parent validity)
|
||||
family *set.Set // family set (used for checking uncle invalidity)
|
||||
uncles *set.Set // uncle set
|
||||
tcount int // tx count in cycle
|
||||
ownedAccounts *set.Set
|
||||
lowGasTxs types.Transactions
|
||||
failedTxs types.Transactions
|
||||
localMinedBlocks *uint64RingBuffer // the most recent block numbers that were mined locally (used to check block inclusion)
|
||||
state *state.StateDB // apply state changes here
|
||||
ancestors *set.Set // ancestor set (used for checking uncle parent validity)
|
||||
family *set.Set // family set (used for checking uncle invalidity)
|
||||
uncles *set.Set // uncle set
|
||||
tcount int // tx count in cycle
|
||||
ownedAccounts *set.Set
|
||||
lowGasTxs types.Transactions
|
||||
failedTxs types.Transactions
|
||||
|
||||
Block *types.Block // the new block
|
||||
|
||||
|
|
@ -123,6 +117,8 @@ type worker struct {
|
|||
txQueueMu sync.Mutex
|
||||
txQueue map[common.Hash]*types.Transaction
|
||||
|
||||
unconfirmed *unconfirmedBlocks // set of locally mined blocks pending canonicalness confirmations
|
||||
|
||||
// atomic status counters
|
||||
mining int32
|
||||
atWork int32
|
||||
|
|
@ -144,6 +140,7 @@ func newWorker(config *params.ChainConfig, coinbase common.Address, eth Backend,
|
|||
coinbase: coinbase,
|
||||
txQueue: make(map[common.Hash]*types.Transaction),
|
||||
agents: make(map[Agent]struct{}),
|
||||
unconfirmed: newUnconfirmedBlocks(eth.BlockChain(), 5),
|
||||
fullValidation: false,
|
||||
}
|
||||
worker.events = worker.mux.Subscribe(core.ChainHeadEvent{}, core.ChainSideEvent{}, core.TxPreEvent{})
|
||||
|
|
@ -269,18 +266,6 @@ func (self *worker) update() {
|
|||
}
|
||||
}
|
||||
|
||||
func newLocalMinedBlock(blockNumber uint64, prevMinedBlocks *uint64RingBuffer) (minedBlocks *uint64RingBuffer) {
|
||||
if prevMinedBlocks == nil {
|
||||
minedBlocks = &uint64RingBuffer{next: 0, ints: make([]uint64, miningLogAtDepth+1)}
|
||||
} else {
|
||||
minedBlocks = prevMinedBlocks
|
||||
}
|
||||
|
||||
minedBlocks.ints[minedBlocks.next] = blockNumber
|
||||
minedBlocks.next = (minedBlocks.next + 1) % len(minedBlocks.ints)
|
||||
return minedBlocks
|
||||
}
|
||||
|
||||
func (self *worker) wait() {
|
||||
for {
|
||||
mustCommitNewWork := true
|
||||
|
|
@ -355,17 +340,8 @@ func (self *worker) wait() {
|
|||
}
|
||||
}(block, work.state.Logs(), work.receipts)
|
||||
}
|
||||
|
||||
// check staleness and display confirmation
|
||||
var stale, confirm string
|
||||
canonBlock := self.chain.GetBlockByNumber(block.NumberU64())
|
||||
if canonBlock != nil && canonBlock.Hash() != block.Hash() {
|
||||
stale = "stale "
|
||||
} else {
|
||||
confirm = "Wait 5 blocks for confirmation"
|
||||
work.localMinedBlocks = newLocalMinedBlock(block.Number().Uint64(), work.localMinedBlocks)
|
||||
}
|
||||
glog.V(logger.Info).Infof("🔨 Mined %sblock (#%v / %x). %s", stale, block.Number(), block.Hash().Bytes()[:4], confirm)
|
||||
// Insert the block into the set of pending ones to wait for confirmations
|
||||
self.unconfirmed.Insert(block.NumberU64(), block.Hash())
|
||||
|
||||
if mustCommitNewWork {
|
||||
self.commitNewWork()
|
||||
|
|
@ -417,9 +393,6 @@ func (self *worker) makeCurrent(parent *types.Block, header *types.Header) error
|
|||
// Keep track of transactions which return errors so they can be removed
|
||||
work.tcount = 0
|
||||
work.ownedAccounts = accountAddressesSet(accounts)
|
||||
if self.current != nil {
|
||||
work.localMinedBlocks = self.current.localMinedBlocks
|
||||
}
|
||||
self.current = work
|
||||
return nil
|
||||
}
|
||||
|
|
@ -435,38 +408,6 @@ func (w *worker) setGasPrice(p *big.Int) {
|
|||
w.mux.Post(core.GasPriceChanged{Price: w.gasPrice})
|
||||
}
|
||||
|
||||
func (self *worker) isBlockLocallyMined(current *Work, deepBlockNum uint64) bool {
|
||||
//Did this instance mine a block at {deepBlockNum} ?
|
||||
var isLocal = false
|
||||
for idx, blockNum := range current.localMinedBlocks.ints {
|
||||
if deepBlockNum == blockNum {
|
||||
isLocal = true
|
||||
current.localMinedBlocks.ints[idx] = 0 //prevent showing duplicate logs
|
||||
break
|
||||
}
|
||||
}
|
||||
//Short-circuit on false, because the previous and following tests must both be true
|
||||
if !isLocal {
|
||||
return false
|
||||
}
|
||||
|
||||
//Does the block at {deepBlockNum} send earnings to my coinbase?
|
||||
var block = self.chain.GetBlockByNumber(deepBlockNum)
|
||||
return block != nil && block.Coinbase() == self.coinbase
|
||||
}
|
||||
|
||||
func (self *worker) logLocalMinedBlocks(current, previous *Work) {
|
||||
if previous != nil && current.localMinedBlocks != nil {
|
||||
nextBlockNum := current.Block.NumberU64()
|
||||
for checkBlockNum := previous.Block.NumberU64(); checkBlockNum < nextBlockNum; checkBlockNum++ {
|
||||
inspectBlockNum := checkBlockNum - miningLogAtDepth
|
||||
if self.isBlockLocallyMined(current, inspectBlockNum) {
|
||||
glog.V(logger.Info).Infof("🔨 🔗 Mined %d blocks back: block #%v", miningLogAtDepth, inspectBlockNum)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (self *worker) commitNewWork() {
|
||||
self.mu.Lock()
|
||||
defer self.mu.Unlock()
|
||||
|
|
@ -513,7 +454,6 @@ func (self *worker) commitNewWork() {
|
|||
}
|
||||
}
|
||||
}
|
||||
previous := self.current
|
||||
// Could potentially happen if starting to mine in an odd state.
|
||||
err := self.makeCurrent(parent, header)
|
||||
if err != nil {
|
||||
|
|
@ -574,7 +514,7 @@ func (self *worker) commitNewWork() {
|
|||
// We only care about logging if we're actually mining.
|
||||
if atomic.LoadInt32(&self.mining) == 1 {
|
||||
glog.V(logger.Info).Infof("commit new work on block %v with %d txs & %d uncles. Took %v\n", work.Block.Number(), work.tcount, len(uncles), time.Since(tstart))
|
||||
self.logLocalMinedBlocks(work, previous)
|
||||
self.unconfirmed.Shift(work.Block.NumberU64() - 1)
|
||||
}
|
||||
self.push(work)
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue