From 697c2b5dc16653228c5264d01c08163cebda3aeb Mon Sep 17 00:00:00 2001 From: Gustav Simonsson Date: Tue, 3 Feb 2015 23:09:39 +0100 Subject: Correct block parent timestamp check and typos --- miner/miner.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'miner') diff --git a/miner/miner.go b/miner/miner.go index 52dd5687d..7ebf00d6a 100644 --- a/miner/miner.go +++ b/miner/miner.go @@ -206,7 +206,7 @@ func (self *Miner) mine() { block.SetReceipts(receipts) // Accumulate the rewards included for this block - blockProcessor.AccumelateRewards(state, block, parent) + blockProcessor.AccumulateRewards(state, block, parent) state.Update(ethutil.Big0) block.SetRoot(state.Root()) -- cgit v1.2.3 From b1870631a4829e075eae77064973ef94aa2166b3 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 4 Feb 2015 05:52:59 -0800 Subject: WIP miner --- miner/worker.go | 164 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 164 insertions(+) create mode 100644 miner/worker.go (limited to 'miner') diff --git a/miner/worker.go b/miner/worker.go new file mode 100644 index 000000000..dbb8a5832 --- /dev/null +++ b/miner/worker.go @@ -0,0 +1,164 @@ +package miner + +import ( + "fmt" + "math/big" + "sort" + + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/eth" + "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/event" + "github.com/ethereum/go-ethereum/pow" + "github.com/ethereum/go-ethereum/state" + "gopkg.in/fatih/set.v0" +) + +type environment struct { + totalUsedGas *big.Int + state *state.StateDB + coinbase *state.StateObject + block *types.Block + ancestors *set.Set + uncles *set.Set +} + +func env(block *types.Block, eth *eth.Ethereum) *environment { + state := state.New(block.Root(), eth.Db()) + env := &environment{ + totalUsedGas: new(big.Int), + state: state, + block: block, + ancestors: set.New(), + uncles: set.New(), + coinbase: state.GetOrNewStateObject(block.Coinbase()), + } + for _, ancestor := range eth.ChainManager().GetAncestors(block, 7) { + env.ancestors.Add(string(ancestor.Hash())) + } + + return env +} + +type worker struct { + agents []chan<- *types.Block + mux *event.TypeMux + quit chan struct{} + pow pow.PoW + + eth *eth.Ethereum + chain *core.ChainManager + proc *core.BlockProcessor + coinbase []byte + + current *environment +} + +func (self *worker) register(agent chan<- *types.Block) { + self.agents = append(self.agents, agent) +} + +func (self *worker) update() { + events := self.mux.Subscribe(core.NewBlockEvent{}, core.TxPreEvent{}, &LocalTx{}) + +out: + for { + select { + case event := <-events.Chan(): + switch event := event.(type) { + case core.NewBlockEvent: + block := event.Block + if self.eth.ChainManager().HasBlock(block.Hash()) { + } else if true { + } + case core.TxPreEvent, *LocalTx: + } + case <-self.quit: + break out + } + } +} + +func (self *worker) commit() { + self.current.state.Update(ethutil.Big0) + self.current.block.SetRoot(self.current.state.Root()) + + for _, agent := range self.agents { + agent <- self.current.block + } +} + +func (self *worker) commitNewWork() { + self.current = env(self.chain.NewBlock(self.coinbase), self.eth) + parent := self.chain.GetBlock(self.current.block.ParentHash()) + self.current.coinbase.SetGasPool(core.CalcGasLimit(parent, self.current.block)) + + transactions := self.eth.TxPool().GetTransactions() + sort.Sort(types.TxByNonce{transactions}) + + // Keep track of transactions which return errors so they can be removed + var remove types.Transactions + for _, tx := range transactions { + err := self.commitTransaction(tx) + switch { + case core.IsNonceErr(err): + remove = append(remove, tx) + case core.IsGasLimitErr(err): + // ignore + default: + minerlogger.Infoln(err) + remove = append(remove, tx) + } + } + self.eth.TxPool().RemoveSet(remove) + + self.current.coinbase.AddAmount(core.BlockReward) + + self.commit() +} + +var ( + inclusionReward = new(big.Int).Div(core.BlockReward, big.NewInt(32)) + _uncleReward = new(big.Int).Mul(core.BlockReward, big.NewInt(15)) + uncleReward = new(big.Int).Div(_uncleReward, big.NewInt(16)) +) + +func (self *worker) commitUncle(uncle *types.Header) error { + if self.current.uncles.Has(string(uncle.Hash())) { + // Error not unique + return core.UncleError("Uncle not unique") + } + self.current.uncles.Add(string(uncle.Hash())) + + if !self.current.ancestors.Has(string(uncle.ParentHash)) { + return core.UncleError(fmt.Sprintf("Uncle's parent unknown (%x)", uncle.ParentHash[0:4])) + } + + if !self.pow.Verify(types.NewBlockWithHeader(uncle)) { + return core.ValidationError("Uncle's nonce is invalid (= %v)", ethutil.Bytes2Hex(uncle.Nonce)) + } + + uncleAccount := self.current.state.GetAccount(uncle.Coinbase) + uncleAccount.AddAmount(uncleReward) + + self.current.coinbase.AddBalance(uncleReward) + + return nil +} + +func (self *worker) commitTransaction(tx *types.Transaction) error { + snapshot := self.current.state.Copy() + receipt, txGas, err := self.proc.ApplyTransaction(self.current.coinbase, self.current.state, self.current.block, tx, self.current.totalUsedGas, true) + if err != nil { + self.current.state.Set(snapshot) + + return err + } + + self.current.totalUsedGas.Add(self.current.totalUsedGas, txGas) + self.current.block.AddTransaction(tx) + self.current.block.AddReceipt(receipt) + + return nil +} -- cgit v1.2.3 From 65158d39b0632226c168b9a3415365ca8f072cbf Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 4 Feb 2015 15:05:47 -0800 Subject: Filtering --- miner/worker.go | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) (limited to 'miner') diff --git a/miner/worker.go b/miner/worker.go index dbb8a5832..ea8f2e8b5 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -41,6 +41,10 @@ func env(block *types.Block, eth *eth.Ethereum) *environment { return env } +type Agent interface { + Comms() chan<- *types.Block +} + type worker struct { agents []chan<- *types.Block mux *event.TypeMux @@ -68,11 +72,12 @@ out: case event := <-events.Chan(): switch event := event.(type) { case core.NewBlockEvent: - block := event.Block - if self.eth.ChainManager().HasBlock(block.Hash()) { - } else if true { + if self.eth.ChainManager().HasBlock(event.Block.Hash()) { + } + case core.TxPreEvent: + if err := self.commitTransaction(event.Tx); err != nil { + self.commit() } - case core.TxPreEvent, *LocalTx: } case <-self.quit: break out -- cgit v1.2.3 From a1b4547a53c4c738e435c1968c1e606935912e47 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 4 Feb 2015 18:26:23 -0800 Subject: set uncles regardless of empty uncle list. Fixes invalid blocks being mined --- miner/miner.go | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) (limited to 'miner') diff --git a/miner/miner.go b/miner/miner.go index 52dd5687d..11d09d953 100644 --- a/miner/miner.go +++ b/miner/miner.go @@ -184,9 +184,7 @@ func (self *Miner) mine() { block.Header().Extra = self.Extra // Apply uncles - if len(self.uncles) > 0 { - block.SetUncles(self.uncles) - } + block.SetUncles(self.uncles) parent := chainMan.GetBlock(block.ParentHash()) coinbase := state.GetOrNewStateObject(block.Coinbase()) -- cgit v1.2.3 From 9d2166a964d83c09481dea6ef30889f260249295 Mon Sep 17 00:00:00 2001 From: obscuren Date: Thu, 5 Feb 2015 08:29:41 -0800 Subject: wip --- miner/miner.go | 42 +++++++++++++++++++++++++++++++++++------- 1 file changed, 35 insertions(+), 7 deletions(-) (limited to 'miner') diff --git a/miner/miner.go b/miner/miner.go index 52dd5687d..8044ef073 100644 --- a/miner/miner.go +++ b/miner/miner.go @@ -24,21 +24,43 @@ package miner import ( + "fmt" "math/big" "sort" - "github.com/ethereum/go-ethereum/eth" - "github.com/ethereum/go-ethereum/ethutil" - "github.com/ethereum/go-ethereum/pow" - "github.com/ethereum/go-ethereum/pow/ezp" - "github.com/ethereum/go-ethereum/state" - + "github.com/ethereum/c-ethash/go-ethash" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/eth" + "github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/pow" + "github.com/ethereum/go-ethereum/state" ) +var dx = []byte{0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42} +var dy = []byte{0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43} + +const epochLen = uint64(1000) + +func getSeed(chainMan *core.ChainManager, block *types.Block) (x []byte, y []byte) { + if block.Number().Uint64() == 0 { + return dx, dy + } else if block.Number().Uint64()%epochLen == 0 { + x, y = getSeed(chainMan, chainMan.GetBlock(block.ParentHash())) + if (block.Number().Uint64()/epochLen)%2 > 0 { + y = crypto.Sha3(append(y, block.ParentHash()...)) + } else { + x = crypto.Sha3(append(x, block.ParentHash()...)) + } + return x, y + } else { + return getSeed(chainMan, chainMan.GetBlock(block.ParentHash())) + } +} + type LocalTx struct { To []byte `json:"to"` Data []byte `json:"data"` @@ -77,7 +99,6 @@ func New(coinbase []byte, eth *eth.Ethereum) *Miner { return &Miner{ eth: eth, powQuitCh: make(chan struct{}), - pow: ezp.New(), mining: false, localTxs: make(map[int]*LocalTx), MinAcceptedGasPrice: big.NewInt(10000000000000), @@ -213,6 +234,13 @@ func (self *Miner) mine() { minerlogger.Infof("Mining on block. Includes %v transactions", len(transactions)) + x, y := getSeed(chainMan, block) + self.pow, err = ethash.New(append(x, y...), block) + if err != nil { + fmt.Println("err", err) + return + } + // Find a valid nonce nonce := self.pow.Search(block, self.powQuitCh) if nonce != nil { -- cgit v1.2.3 From da2fae0e437f9467a943acfe0571a8a24e8e76fd Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 9 Feb 2015 16:20:34 +0100 Subject: Basic structure miner --- miner/agent.go | 74 +++++++++++++++ miner/miner.go | 284 ++++++-------------------------------------------------- miner/worker.go | 61 +++++++++--- 3 files changed, 153 insertions(+), 266 deletions(-) create mode 100644 miner/agent.go (limited to 'miner') diff --git a/miner/agent.go b/miner/agent.go new file mode 100644 index 000000000..b12b9da4d --- /dev/null +++ b/miner/agent.go @@ -0,0 +1,74 @@ +package miner + +import ( + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/pow" +) + +type CpuMiner struct { + c chan *types.Block + quit chan struct{} + quitCurrentOp chan struct{} + returnCh chan<- []byte + + index int + pow pow.PoW +} + +func NewCpuMiner(index int, pow pow.PoW) *CpuMiner { + miner := &CpuMiner{ + c: make(chan *types.Block, 1), + quit: make(chan struct{}), + quitCurrentOp: make(chan struct{}, 1), + pow: pow, + index: index, + } + go miner.update() + + return miner +} + +func (self *CpuMiner) Work() chan<- *types.Block { return self.c } +func (self *CpuMiner) Pow() pow.PoW { return self.pow } +func (self *CpuMiner) SetNonceCh(ch chan<- []byte) { self.returnCh = ch } + +func (self *CpuMiner) Stop() { + close(self.quit) + close(self.quitCurrentOp) +} + +func (self *CpuMiner) update() { +out: + for { + select { + case block := <-self.c: + minerlogger.Infof("miner[%d] got block\n", self.index) + // make sure it's open + self.quitCurrentOp <- struct{}{} + + go self.mine(block) + case <-self.quit: + break out + } + } + +done: + // Empty channel + for { + select { + case <-self.c: + default: + close(self.c) + + break done + } + } +} + +func (self *CpuMiner) mine(block *types.Block) { + minerlogger.Infof("started agent[%d]. mining...\n", self.index) + nonce := self.pow.Search(block, self.quitCurrentOp) + if nonce != nil { + self.returnCh <- nonce + } +} diff --git a/miner/miner.go b/miner/miner.go index 1f4fc2170..f184042dc 100644 --- a/miner/miner.go +++ b/miner/miner.go @@ -1,291 +1,67 @@ -/* - This file is part of go-ethereum - - go-ethereum 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. - - go-ethereum 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 General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with go-ethereum. If not, see . -*/ -/** - * @authors - * Jeffrey Wilcke - * @date 2014 - * - */ - package miner import ( - "fmt" "math/big" - "sort" - "github.com/ethereum/c-ethash/go-ethash" - "github.com/ethereum/go-ethereum/core" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/eth" - "github.com/ethereum/go-ethereum/ethutil" - "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/logger" - "github.com/ethereum/go-ethereum/pow" - "github.com/ethereum/go-ethereum/state" + "github.com/ethereum/go-ethereum/pow/ezp" ) -var dx = []byte{0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42} -var dy = []byte{0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43} - -const epochLen = uint64(1000) - -func getSeed(chainMan *core.ChainManager, block *types.Block) (x []byte, y []byte) { - if block.Number().Uint64() == 0 { - return dx, dy - } else if block.Number().Uint64()%epochLen == 0 { - x, y = getSeed(chainMan, chainMan.GetBlock(block.ParentHash())) - if (block.Number().Uint64()/epochLen)%2 > 0 { - y = crypto.Sha3(append(y, block.ParentHash()...)) - } else { - x = crypto.Sha3(append(x, block.ParentHash()...)) - } - return x, y - } else { - return getSeed(chainMan, chainMan.GetBlock(block.ParentHash())) - } -} - -type LocalTx struct { - To []byte `json:"to"` - Data []byte `json:"data"` - Gas string `json:"gas"` - GasPrice string `json:"gasPrice"` - Value string `json:"value"` -} - -func (self *LocalTx) Sign(key []byte) *types.Transaction { - return nil -} - var minerlogger = logger.NewLogger("MINER") type Miner struct { - eth *eth.Ethereum - events event.Subscription - - uncles []*types.Header - localTxs map[int]*LocalTx - localTxId int - - pow pow.PoW - quitCh chan struct{} - powQuitCh chan struct{} - - Coinbase []byte - - mining bool + worker *worker MinAcceptedGasPrice *big.Int Extra string -} - -func New(coinbase []byte, eth *eth.Ethereum) *Miner { - return &Miner{ - eth: eth, - powQuitCh: make(chan struct{}), - mining: false, - localTxs: make(map[int]*LocalTx), - MinAcceptedGasPrice: big.NewInt(10000000000000), - Coinbase: coinbase, - } -} - -func (self *Miner) GetPow() pow.PoW { - return self.pow -} - -func (self *Miner) AddLocalTx(tx *LocalTx) int { - minerlogger.Infof("Added local tx (%x %v / %v)\n", tx.To[0:4], tx.GasPrice, tx.Value) - - self.localTxId++ - self.localTxs[self.localTxId] = tx - self.eth.EventMux().Post(tx) - return self.localTxId + coinbase []byte + mining bool } -func (self *Miner) RemoveLocalTx(id int) { - if tx := self.localTxs[id]; tx != nil { - minerlogger.Infof("Removed local tx (%x %v / %v)\n", tx.To[0:4], tx.GasPrice, tx.Value) +func New(coinbase []byte, eth *eth.Ethereum) *Miner { + miner := &Miner{ + coinbase: coinbase, + worker: newWorker(coinbase, eth), } - self.eth.EventMux().Post(&LocalTx{}) - - delete(self.localTxs, id) -} -func (self *Miner) Start() { - if self.mining { - return + for i := 0; i < 4; i++ { + miner.worker.register(NewCpuMiner(i, ezp.New())) } - minerlogger.Infoln("Starting mining operations") - self.mining = true - self.quitCh = make(chan struct{}) - self.powQuitCh = make(chan struct{}) - - mux := self.eth.EventMux() - self.events = mux.Subscribe(core.NewBlockEvent{}, core.TxPreEvent{}, &LocalTx{}) - - go self.update() - go self.mine() -} - -func (self *Miner) Stop() { - if !self.mining { - return - } - - self.mining = false - - minerlogger.Infoln("Stopping mining operations") - - self.events.Unsubscribe() - - close(self.quitCh) - close(self.powQuitCh) + return miner } func (self *Miner) Mining() bool { return self.mining } -func (self *Miner) update() { -out: - for { - select { - case event := <-self.events.Chan(): - switch event := event.(type) { - case core.NewBlockEvent: - block := event.Block - if self.eth.ChainManager().HasBlock(block.Hash()) { - self.reset() - self.eth.TxPool().RemoveSet(block.Transactions()) - go self.mine() - } else if true { - // do uncle stuff - } - case core.TxPreEvent, *LocalTx: - self.reset() - go self.mine() - } - case <-self.quitCh: - break out - } - } -} - -func (self *Miner) reset() { - close(self.powQuitCh) - self.powQuitCh = make(chan struct{}) -} - -func (self *Miner) mine() { - var ( - blockProcessor = self.eth.BlockProcessor() - chainMan = self.eth.ChainManager() - block = chainMan.NewBlock(self.Coinbase) - state = state.New(block.Root(), self.eth.Db()) - ) - block.Header().Extra = self.Extra - - // Apply uncles - block.SetUncles(self.uncles) - - parent := chainMan.GetBlock(block.ParentHash()) - coinbase := state.GetOrNewStateObject(block.Coinbase()) - coinbase.SetGasPool(core.CalcGasLimit(parent, block)) - - transactions := self.finiliseTxs() - - // Accumulate all valid transactions and apply them to the new state - // Error may be ignored. It's not important during mining - receipts, txs, _, erroneous, err := blockProcessor.ApplyTransactions(coinbase, state, block, transactions, true) - if err != nil { - minerlogger.Debugln(err) - } - self.eth.TxPool().RemoveSet(erroneous) - - block.SetTransactions(txs) - block.SetReceipts(receipts) - - // Accumulate the rewards included for this block - blockProcessor.AccumulateRewards(state, block, parent) - - state.Update(ethutil.Big0) - block.SetRoot(state.Root()) - - minerlogger.Infof("Mining on block. Includes %v transactions", len(transactions)) - - x, _ := getSeed(chainMan, block) - self.pow, err = ethash.New(x, block) - if err != nil { - fmt.Println("miner gave back err", err) - return - } +func (self *Miner) Start() { + self.worker.start() - // Find a valid nonce - nonce := self.pow.Search(block, self.powQuitCh) - if nonce != nil { - block.Header().Nonce = nonce - err := chainMan.InsertChain(types.Blocks{block}) - if err != nil { - minerlogger.Infoln(err) - } else { - self.eth.EventMux().Post(core.NewMinedBlockEvent{block}) + self.worker.commitNewWork() - minerlogger.Infof("🔨 Mined block %x\n", block.Hash()) - minerlogger.Infoln(block) + /* + timer := time.NewTicker(time.Second) + for { + select { + case <-timer.C: + fmt.Printf("%d workers. %d/Khash\n", len(self.worker.agents), self.HashRate()) + } } - - go self.mine() - } + */ } -func (self *Miner) finiliseTxs() types.Transactions { - // Sort the transactions by nonce in case of odd network propagation - actualSize := len(self.localTxs) // See copy below - txs := make(types.Transactions, actualSize+self.eth.TxPool().Size()) - - state := self.eth.ChainManager().TransState() - // XXX This has to change. Coinbase is, for new, same as key. - key := self.eth.KeyManager() - for i, ltx := range self.localTxs { - tx := types.NewTransactionMessage(ltx.To, ethutil.Big(ltx.Value), ethutil.Big(ltx.Gas), ethutil.Big(ltx.GasPrice), ltx.Data) - tx.SetNonce(state.GetNonce(self.Coinbase)) - state.SetNonce(self.Coinbase, tx.Nonce()+1) - - tx.Sign(key.PrivateKey()) - - txs[i] = tx - } +func (self *Miner) Stop() { + self.worker.stop() +} - // Faster than append - for _, tx := range self.eth.TxPool().GetTransactions() { - if tx.GasPrice().Cmp(self.MinAcceptedGasPrice) >= 0 { - txs[actualSize] = tx - actualSize++ - } +func (self *Miner) HashRate() int64 { + var tot int64 + for _, agent := range self.worker.agents { + tot += agent.Pow().GetHashrate() } - newTransactions := make(types.Transactions, actualSize) - copy(newTransactions, txs[:actualSize]) - sort.Sort(types.TxByNonce{newTransactions}) - - return newTransactions + return tot } diff --git a/miner/worker.go b/miner/worker.go index ea8f2e8b5..d0d085861 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -42,11 +42,15 @@ func env(block *types.Block, eth *eth.Ethereum) *environment { } type Agent interface { - Comms() chan<- *types.Block + Work() chan<- *types.Block + SetNonceCh(chan<- []byte) + Stop() + Pow() pow.PoW } type worker struct { - agents []chan<- *types.Block + agents []Agent + recv chan []byte mux *event.TypeMux quit chan struct{} pow pow.PoW @@ -59,24 +63,44 @@ type worker struct { current *environment } -func (self *worker) register(agent chan<- *types.Block) { +func newWorker(coinbase []byte, eth *eth.Ethereum) *worker { + return &worker{ + eth: eth, + mux: eth.EventMux(), + recv: make(chan []byte), + chain: eth.ChainManager(), + proc: eth.BlockProcessor(), + coinbase: coinbase, + } +} + +func (self *worker) start() { + go self.update() + go self.wait() +} + +func (self *worker) stop() { + close(self.quit) +} + +func (self *worker) register(agent Agent) { self.agents = append(self.agents, agent) + agent.SetNonceCh(self.recv) } func (self *worker) update() { - events := self.mux.Subscribe(core.NewBlockEvent{}, core.TxPreEvent{}, &LocalTx{}) + events := self.mux.Subscribe(core.ChainEvent{}, core.TxPreEvent{}) out: for { select { case event := <-events.Chan(): switch event := event.(type) { - case core.NewBlockEvent: - if self.eth.ChainManager().HasBlock(event.Block.Hash()) { - } + case core.ChainEvent: + self.commitNewWork() case core.TxPreEvent: if err := self.commitTransaction(event.Tx); err != nil { - self.commit() + self.push() } } case <-self.quit: @@ -85,12 +109,24 @@ out: } } -func (self *worker) commit() { +func (self *worker) wait() { + for { + for nonce := range self.recv { + self.current.block.Header().Nonce = nonce + fmt.Println(self.current.block) + + self.chain.InsertChain(types.Blocks{self.current.block}) + break + } + } +} + +func (self *worker) push() { self.current.state.Update(ethutil.Big0) self.current.block.SetRoot(self.current.state.Root()) for _, agent := range self.agents { - agent <- self.current.block + agent.Work() <- self.current.block } } @@ -110,7 +146,8 @@ func (self *worker) commitNewWork() { case core.IsNonceErr(err): remove = append(remove, tx) case core.IsGasLimitErr(err): - // ignore + // Break on gas limit + break default: minerlogger.Infoln(err) remove = append(remove, tx) @@ -120,7 +157,7 @@ func (self *worker) commitNewWork() { self.current.coinbase.AddAmount(core.BlockReward) - self.commit() + self.push() } var ( -- cgit v1.2.3 From 8a0f23915e4feb9aabe21bd075416bc0f32bbc43 Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 13 Feb 2015 17:23:09 +0100 Subject: Fixed a few issues in the miner and updated hash rate title * Sometimes old nonces were set by "old" agents * Added the hash rate to the miner --- miner/agent.go | 13 ++++++------- miner/miner.go | 14 ++++---------- miner/worker.go | 40 +++++++++++++++++++++++++++++----------- 3 files changed, 39 insertions(+), 28 deletions(-) (limited to 'miner') diff --git a/miner/agent.go b/miner/agent.go index b12b9da4d..ddd8e6675 100644 --- a/miner/agent.go +++ b/miner/agent.go @@ -9,7 +9,7 @@ type CpuMiner struct { c chan *types.Block quit chan struct{} quitCurrentOp chan struct{} - returnCh chan<- []byte + returnCh chan<- Work index int pow pow.PoW @@ -28,9 +28,9 @@ func NewCpuMiner(index int, pow pow.PoW) *CpuMiner { return miner } -func (self *CpuMiner) Work() chan<- *types.Block { return self.c } -func (self *CpuMiner) Pow() pow.PoW { return self.pow } -func (self *CpuMiner) SetNonceCh(ch chan<- []byte) { self.returnCh = ch } +func (self *CpuMiner) Work() chan<- *types.Block { return self.c } +func (self *CpuMiner) Pow() pow.PoW { return self.pow } +func (self *CpuMiner) SetNonceCh(ch chan<- Work) { self.returnCh = ch } func (self *CpuMiner) Stop() { close(self.quit) @@ -42,7 +42,6 @@ out: for { select { case block := <-self.c: - minerlogger.Infof("miner[%d] got block\n", self.index) // make sure it's open self.quitCurrentOp <- struct{}{} @@ -66,9 +65,9 @@ done: } func (self *CpuMiner) mine(block *types.Block) { - minerlogger.Infof("started agent[%d]. mining...\n", self.index) + minerlogger.Infof("(re)started agent[%d]. mining...\n", self.index) nonce := self.pow.Search(block, self.quitCurrentOp) if nonce != nil { - self.returnCh <- nonce + self.returnCh <- Work{block.Number().Uint64(), nonce} } } diff --git a/miner/miner.go b/miner/miner.go index f184042dc..e3e7bead2 100644 --- a/miner/miner.go +++ b/miner/miner.go @@ -38,22 +38,16 @@ func (self *Miner) Mining() bool { } func (self *Miner) Start() { + self.mining = true + self.worker.start() self.worker.commitNewWork() - - /* - timer := time.NewTicker(time.Second) - for { - select { - case <-timer.C: - fmt.Printf("%d workers. %d/Khash\n", len(self.worker.agents), self.HashRate()) - } - } - */ } func (self *Miner) Stop() { + self.mining = false + self.worker.stop() } diff --git a/miner/worker.go b/miner/worker.go index d0d085861..cd1c6e28f 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -41,16 +41,21 @@ func env(block *types.Block, eth *eth.Ethereum) *environment { return env } +type Work struct { + Number uint64 + Nonce []byte +} + type Agent interface { Work() chan<- *types.Block - SetNonceCh(chan<- []byte) + SetNonceCh(chan<- Work) Stop() Pow() pow.PoW } type worker struct { agents []Agent - recv chan []byte + recv chan Work mux *event.TypeMux quit chan struct{} pow pow.PoW @@ -61,13 +66,15 @@ type worker struct { coinbase []byte current *environment + + mining bool } func newWorker(coinbase []byte, eth *eth.Ethereum) *worker { return &worker{ eth: eth, mux: eth.EventMux(), - recv: make(chan []byte), + recv: make(chan Work), chain: eth.ChainManager(), proc: eth.BlockProcessor(), coinbase: coinbase, @@ -75,11 +82,17 @@ func newWorker(coinbase []byte, eth *eth.Ethereum) *worker { } func (self *worker) start() { + self.mining = true + + self.quit = make(chan struct{}) + go self.update() go self.wait() } func (self *worker) stop() { + self.mining = false + close(self.quit) } @@ -107,26 +120,31 @@ out: break out } } + + events.Unsubscribe() } func (self *worker) wait() { for { - for nonce := range self.recv { - self.current.block.Header().Nonce = nonce - fmt.Println(self.current.block) + for work := range self.recv { + if self.current.block.Number().Uint64() == work.Number { + self.current.block.Header().Nonce = work.Nonce - self.chain.InsertChain(types.Blocks{self.current.block}) + self.chain.InsertChain(types.Blocks{self.current.block}) + } break } } } func (self *worker) push() { - self.current.state.Update(ethutil.Big0) - self.current.block.SetRoot(self.current.state.Root()) + if self.mining { + self.current.state.Update(ethutil.Big0) + self.current.block.SetRoot(self.current.state.Root()) - for _, agent := range self.agents { - agent.Work() <- self.current.block + for _, agent := range self.agents { + agent.Work() <- self.current.block + } } } -- cgit v1.2.3 From 0f3c25b26589f5667b618d6a91b73392d02ccd1e Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 13 Feb 2015 18:03:16 +0100 Subject: Propagate blocks --- miner/worker.go | 1 + 1 file changed, 1 insertion(+) (limited to 'miner') diff --git a/miner/worker.go b/miner/worker.go index cd1c6e28f..9cb4ab76b 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -131,6 +131,7 @@ func (self *worker) wait() { self.current.block.Header().Nonce = work.Nonce self.chain.InsertChain(types.Blocks{self.current.block}) + self.mux.Post(core.NewMinedBlockEvent{self.current.block}) } break } -- cgit v1.2.3 From ce239333d529898edd8333637fd75c565e80a9ff Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 13 Feb 2015 18:15:23 +0100 Subject: Update balance label when mining --- miner/worker.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'miner') diff --git a/miner/worker.go b/miner/worker.go index 9cb4ab76b..9244e06b9 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -127,7 +127,8 @@ out: func (self *worker) wait() { for { for work := range self.recv { - if self.current.block.Number().Uint64() == work.Number { + block := self.current.block + if block.Number().Uint64() == work.Number && block.Nonce() == nil { self.current.block.Header().Nonce = work.Nonce self.chain.InsertChain(types.Blocks{self.current.block}) -- cgit v1.2.3 From 32c7ebc51dcb31f21efe1b9c75f2b86cd216f510 Mon Sep 17 00:00:00 2001 From: obscuren Date: Sat, 14 Feb 2015 16:52:14 +0100 Subject: Fixed mining & limited hash power --- miner/agent.go | 19 +++++++++++-------- miner/worker.go | 40 +++++++++++++++++++++++++++++----------- 2 files changed, 40 insertions(+), 19 deletions(-) (limited to 'miner') diff --git a/miner/agent.go b/miner/agent.go index ddd8e6675..9046f5d5a 100644 --- a/miner/agent.go +++ b/miner/agent.go @@ -17,32 +17,35 @@ type CpuMiner struct { func NewCpuMiner(index int, pow pow.PoW) *CpuMiner { miner := &CpuMiner{ - c: make(chan *types.Block, 1), - quit: make(chan struct{}), - quitCurrentOp: make(chan struct{}, 1), - pow: pow, - index: index, + pow: pow, + index: index, } - go miner.update() return miner } func (self *CpuMiner) Work() chan<- *types.Block { return self.c } func (self *CpuMiner) Pow() pow.PoW { return self.pow } -func (self *CpuMiner) SetNonceCh(ch chan<- Work) { self.returnCh = ch } +func (self *CpuMiner) SetWorkCh(ch chan<- Work) { self.returnCh = ch } func (self *CpuMiner) Stop() { close(self.quit) close(self.quitCurrentOp) } +func (self *CpuMiner) Start() { + self.quit = make(chan struct{}) + self.quitCurrentOp = make(chan struct{}, 1) + self.c = make(chan *types.Block, 1) + + go self.update() +} + func (self *CpuMiner) update() { out: for { select { case block := <-self.c: - // make sure it's open self.quitCurrentOp <- struct{}{} go self.mine(block) diff --git a/miner/worker.go b/miner/worker.go index 9244e06b9..96c8bdd39 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -48,8 +48,9 @@ type Work struct { type Agent interface { Work() chan<- *types.Block - SetNonceCh(chan<- Work) + SetWorkCh(chan<- Work) Stop() + Start() Pow() pow.PoW } @@ -86,6 +87,11 @@ func (self *worker) start() { self.quit = make(chan struct{}) + // spin up agents + for _, agent := range self.agents { + agent.Start() + } + go self.update() go self.wait() } @@ -98,7 +104,7 @@ func (self *worker) stop() { func (self *worker) register(agent Agent) { self.agents = append(self.agents, agent) - agent.SetNonceCh(self.recv) + agent.SetWorkCh(self.recv) } func (self *worker) update() { @@ -108,15 +114,17 @@ out: for { select { case event := <-events.Chan(): - switch event := event.(type) { + switch event.(type) { case core.ChainEvent: self.commitNewWork() case core.TxPreEvent: - if err := self.commitTransaction(event.Tx); err != nil { - self.push() - } + self.commitNewWork() } case <-self.quit: + // stop all agents + for _, agent := range self.agents { + agent.Stop() + } break out } } @@ -131,8 +139,11 @@ func (self *worker) wait() { if block.Number().Uint64() == work.Number && block.Nonce() == nil { self.current.block.Header().Nonce = work.Nonce - self.chain.InsertChain(types.Blocks{self.current.block}) - self.mux.Post(core.NewMinedBlockEvent{self.current.block}) + if err := self.chain.InsertChain(types.Blocks{self.current.block}); err == nil { + self.mux.Post(core.NewMinedBlockEvent{self.current.block}) + } else { + self.commitNewWork() + } } break } @@ -141,9 +152,10 @@ func (self *worker) wait() { func (self *worker) push() { if self.mining { - self.current.state.Update(ethutil.Big0) + self.current.block.Header().GasUsed = self.current.totalUsedGas self.current.block.SetRoot(self.current.state.Root()) + // push new work to agents for _, agent := range self.agents { agent.Work() <- self.current.block } @@ -169,14 +181,18 @@ func (self *worker) commitNewWork() { // Break on gas limit break default: - minerlogger.Infoln(err) remove = append(remove, tx) } + + if err != nil { + minerlogger.Infoln(err) + } } self.eth.TxPool().RemoveSet(remove) self.current.coinbase.AddAmount(core.BlockReward) + self.current.state.Update(ethutil.Big0) self.push() } @@ -213,7 +229,9 @@ func (self *worker) commitTransaction(tx *types.Transaction) error { snapshot := self.current.state.Copy() receipt, txGas, err := self.proc.ApplyTransaction(self.current.coinbase, self.current.state, self.current.block, tx, self.current.totalUsedGas, true) if err != nil { - self.current.state.Set(snapshot) + if core.IsNonceErr(err) || core.IsGasLimitErr(err) { + self.current.state.Set(snapshot) + } return err } -- cgit v1.2.3 From 2c3a014f03390628d329167109f90a30e3c4e4c3 Mon Sep 17 00:00:00 2001 From: obscuren Date: Sun, 15 Feb 2015 16:16:27 +0100 Subject: Resolved some bugs in the miner * TODO nonce error sometimes persists * Fixed mining on wrong blocks * Fixed state error & receipt fail --- miner/worker.go | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) (limited to 'miner') diff --git a/miner/worker.go b/miner/worker.go index 96c8bdd39..2b64f3210 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -4,6 +4,7 @@ import ( "fmt" "math/big" "sort" + "sync" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" @@ -55,6 +56,7 @@ type Agent interface { } type worker struct { + mu sync.Mutex agents []Agent recv chan Work mux *event.TypeMux @@ -115,9 +117,7 @@ out: select { case event := <-events.Chan(): switch event.(type) { - case core.ChainEvent: - self.commitNewWork() - case core.TxPreEvent: + case core.ChainEvent, core.TxPreEvent: self.commitNewWork() } case <-self.quit: @@ -163,6 +163,9 @@ func (self *worker) push() { } func (self *worker) commitNewWork() { + self.mu.Lock() + defer self.mu.Unlock() + self.current = env(self.chain.NewBlock(self.coinbase), self.eth) parent := self.chain.GetBlock(self.current.block.ParentHash()) self.current.coinbase.SetGasPool(core.CalcGasLimit(parent, self.current.block)) @@ -176,12 +179,11 @@ func (self *worker) commitNewWork() { err := self.commitTransaction(tx) switch { case core.IsNonceErr(err): + // Remove invalid transactions remove = append(remove, tx) case core.IsGasLimitErr(err): // Break on gas limit break - default: - remove = append(remove, tx) } if err != nil { @@ -227,16 +229,13 @@ func (self *worker) commitUncle(uncle *types.Header) error { func (self *worker) commitTransaction(tx *types.Transaction) error { snapshot := self.current.state.Copy() - receipt, txGas, err := self.proc.ApplyTransaction(self.current.coinbase, self.current.state, self.current.block, tx, self.current.totalUsedGas, true) - if err != nil { - if core.IsNonceErr(err) || core.IsGasLimitErr(err) { - self.current.state.Set(snapshot) - } + receipt, _, err := self.proc.ApplyTransaction(self.current.coinbase, self.current.state, self.current.block, tx, self.current.totalUsedGas, true) + if err != nil && (core.IsNonceErr(err) || core.IsGasLimitErr(err)) { + self.current.state.Set(snapshot) return err } - self.current.totalUsedGas.Add(self.current.totalUsedGas, txGas) self.current.block.AddTransaction(tx) self.current.block.AddReceipt(receipt) -- cgit v1.2.3 From 8135752a32837748e6d4a986912131736b1a0aa0 Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 17 Feb 2015 12:24:51 +0100 Subject: "centralised" mining to backend. Closes #323 --- miner/miner.go | 8 ++++---- miner/worker.go | 7 +++---- 2 files changed, 7 insertions(+), 8 deletions(-) (limited to 'miner') diff --git a/miner/miner.go b/miner/miner.go index e3e7bead2..27afcf684 100644 --- a/miner/miner.go +++ b/miner/miner.go @@ -3,7 +3,7 @@ package miner import ( "math/big" - "github.com/ethereum/go-ethereum/eth" + "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/pow/ezp" ) @@ -16,13 +16,13 @@ type Miner struct { MinAcceptedGasPrice *big.Int Extra string - coinbase []byte + Coinbase []byte mining bool } -func New(coinbase []byte, eth *eth.Ethereum) *Miner { +func New(coinbase []byte, eth core.Backend) *Miner { miner := &Miner{ - coinbase: coinbase, + Coinbase: coinbase, worker: newWorker(coinbase, eth), } diff --git a/miner/worker.go b/miner/worker.go index 2b64f3210..47b462e53 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -8,7 +8,6 @@ import ( "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/pow" @@ -25,7 +24,7 @@ type environment struct { uncles *set.Set } -func env(block *types.Block, eth *eth.Ethereum) *environment { +func env(block *types.Block, eth core.Backend) *environment { state := state.New(block.Root(), eth.Db()) env := &environment{ totalUsedGas: new(big.Int), @@ -63,7 +62,7 @@ type worker struct { quit chan struct{} pow pow.PoW - eth *eth.Ethereum + eth core.Backend chain *core.ChainManager proc *core.BlockProcessor coinbase []byte @@ -73,7 +72,7 @@ type worker struct { mining bool } -func newWorker(coinbase []byte, eth *eth.Ethereum) *worker { +func newWorker(coinbase []byte, eth core.Backend) *worker { return &worker{ eth: eth, mux: eth.EventMux(), -- cgit v1.2.3