diff --git a/cmd/mist/assets/examples/coin.html b/cmd/mist/assets/examples/coin.html
index 99e0c7643ed8e64c162f9779f364cf94a85b1fdf..ca7a9c0ddab410688b49baf2047c02fbf232a29d 100644
--- a/cmd/mist/assets/examples/coin.html
+++ b/cmd/mist/assets/examples/coin.html
@@ -117,7 +117,6 @@
refresh();
</script>
-
</html>
<!--
diff --git a/cmd/mist/assets/qml/main.qml b/cmd/mist/assets/qml/main.qml
index 2b56b723615ef674b08fe4a5d5e82b2f533141d6..dce279518fc9c43e901d64ab24796848caec0a2e 100644
--- a/cmd/mist/assets/qml/main.qml
+++ b/cmd/mist/assets/qml/main.qml
@@ -289,6 +289,7 @@ ApplicationWindow {
styleColor: "#797979"
}
+ /*
Label {
//y: 6
objectName: "miningLabel"
@@ -307,6 +308,7 @@ ApplicationWindow {
anchors.right: peerGroup.left
anchors.rightMargin: 5
}
+ */
ProgressBar {
visible: false
@@ -1101,4 +1103,4 @@ ApplicationWindow {
addrField.focus = true
}
}
- }
\ No newline at end of file
+ }
diff --git a/cmd/mist/assets/qml/views/miner.qml b/cmd/mist/assets/qml/views/miner.qml
index 193ce37beaf95c62032d15798703cf54de23583b..0938644b9ec9e0dcd917cfdf287239b11e8c2b75 100644
--- a/cmd/mist/assets/qml/views/miner.qml
+++ b/cmd/mist/assets/qml/views/miner.qml
@@ -14,6 +14,30 @@ Rectangle {
color: "#00000000"
+ Label {
+ visible: false
+ id: lastBlockLabel
+ objectName: "lastBlockLabel"
+ text: "---"
+ font.pixelSize: 10
+ anchors.right: peerGroup.left
+ anchors.rightMargin: 5
+ onTextChanged: {
+ //menuItem.secondaryTitle = text
+ }
+ }
+
+ Label {
+ objectName: "miningLabel"
+ visible: false
+ font.pixelSize: 10
+ anchors.right: lastBlockLabel.left
+ anchors.rightMargin: 5
+ onTextChanged: {
+ menuItem.secondaryTitle = text
+ }
+ }
+
ColumnLayout {
spacing: 10
anchors.fill: parent
diff --git a/cmd/mist/gui.go b/cmd/mist/gui.go
index dee99859c17c90403ad9ded9ff26e6d2763b8ad2..6d179eea1027c783c7538f9edf385550f3b7468f 100644
--- a/cmd/mist/gui.go
+++ b/cmd/mist/gui.go
@@ -452,7 +452,7 @@ func (gui *Gui) update() {
case <-generalUpdateTicker.C:
statusText := "#" + gui.eth.ChainManager().CurrentBlock().Number().String()
lastBlockLabel.Set("text", statusText)
- miningLabel.Set("text", "Mining @ "+strconv.FormatInt(gui.uiLib.miner.GetPow().GetHashrate(), 10)+"Khash")
+ miningLabel.Set("text", "Mining @ "+strconv.FormatInt(gui.uiLib.miner.HashRate(), 10)+"/Khash")
/*
blockLength := gui.eth.BlockPool().BlocksProcessed
diff --git a/cmd/mist/ui_lib.go b/cmd/mist/ui_lib.go
index ba3ac3b61ed7c68c9a83bb5093be588eb4ec428d..ab48386f40d7ee4a5a7896b4ea3d9a9695ec48c6 100644
--- a/cmd/mist/ui_lib.go
+++ b/cmd/mist/ui_lib.go
@@ -209,17 +209,20 @@ func (self *UiLib) Call(params map[string]interface{}) (string, error) {
}
func (self *UiLib) AddLocalTransaction(to, data, gas, gasPrice, value string) int {
- return self.miner.AddLocalTx(&miner.LocalTx{
- To: ethutil.Hex2Bytes(to),
- Data: ethutil.Hex2Bytes(data),
- Gas: gas,
- GasPrice: gasPrice,
- Value: value,
- }) - 1
+ return 0
+ /*
+ return self.miner.AddLocalTx(&miner.LocalTx{
+ To: ethutil.Hex2Bytes(to),
+ Data: ethutil.Hex2Bytes(data),
+ Gas: gas,
+ GasPrice: gasPrice,
+ Value: value,
+ }) - 1
+ */
}
func (self *UiLib) RemoveLocalTransaction(id int) {
- self.miner.RemoveLocalTx(id)
+ //self.miner.RemoveLocalTx(id)
}
func (self *UiLib) SetGasPrice(price string) {
diff --git a/core/block_processor.go b/core/block_processor.go
index c360273da8b3442eee41cc4c37425805f4fb7ef1..893c586dd4344b27a0c55383fd2e4b89e20adf6e 100644
--- a/core/block_processor.go
+++ b/core/block_processor.go
@@ -48,8 +48,9 @@ type BlockProcessor struct {
func NewBlockProcessor(db ethutil.Database, txpool *TxPool, chainManager *ChainManager, eventMux *event.TypeMux) *BlockProcessor {
sm := &BlockProcessor{
- db: db,
- mem: make(map[string]*big.Int),
+ db: db,
+ mem: make(map[string]*big.Int),
+ //Pow: ðash.Ethash{},
Pow: ezp.New(),
bc: chainManager,
eventMux: eventMux,
diff --git a/core/chain_manager.go b/core/chain_manager.go
index 0847980ca8da5e5ff4615ec2c4567bacce4226be..308e958fe9d1242047f6460dbba30508f1bb5914 100644
--- a/core/chain_manager.go
+++ b/core/chain_manager.go
@@ -16,6 +16,11 @@ import (
var chainlogger = logger.NewLogger("CHAIN")
+type ChainEvent struct {
+ Block *types.Block
+ Td *big.Int
+}
+
type StateQuery interface {
GetAccount(addr []byte) *state.StateObject
}
@@ -175,6 +180,9 @@ func (bc *ChainManager) NewBlock(coinbase []byte) *types.Block {
ethutil.BigPow(2, 32),
nil,
"")
+ block.SetUncles(nil)
+ block.SetTransactions(nil)
+ block.SetReceipts(nil)
parent := bc.currentBlock
if parent != nil {
@@ -385,8 +393,9 @@ func (self *ChainManager) InsertChain(chain types.Blocks) error {
self.setTotalDifficulty(td)
self.insert(block)
self.transState = state.New(cblock.Root(), self.db) //state.New(cblock.Trie().Copy())
- }
+ self.eventMux.Post(ChainEvent{block, td})
+ }
}
self.mu.Unlock()
diff --git a/miner/agent.go b/miner/agent.go
new file mode 100644
index 0000000000000000000000000000000000000000..ddd8e667561967a4cd2476ee6d8f0e1927785a77
--- /dev/null
+++ b/miner/agent.go
@@ -0,0 +1,73 @@
+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<- Work
+
+ 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<- Work) { self.returnCh = ch }
+
+func (self *CpuMiner) Stop() {
+ close(self.quit)
+ close(self.quitCurrentOp)
+}
+
+func (self *CpuMiner) update() {
+out:
+ for {
+ select {
+ case block := <-self.c:
+ // 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("(re)started agent[%d]. mining...\n", self.index)
+ nonce := self.pow.Search(block, self.quitCurrentOp)
+ if nonce != nil {
+ self.returnCh <- Work{block.Number().Uint64(), nonce}
+ }
+}
diff --git a/miner/miner.go b/miner/miner.go
index 63c8e22a7624ac48d17cdb27fe6196a923c763e4..e3e7bead2629a20d8c1879809b7113d5ef4a8dd2 100644
--- a/miner/miner.go
+++ b/miner/miner.go
@@ -1,263 +1,61 @@
-/*
- 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 <http://www.gnu.org/licenses/>.
-*/
-/**
- * @authors
- * Jeffrey Wilcke <i@jev.io>
- * @date 2014
- *
- */
-
package miner
import (
"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/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/logger"
+ "github.com/ethereum/go-ethereum/pow/ezp"
)
-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
+
+ coinbase []byte
+ mining bool
}
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),
- Coinbase: coinbase,
+ miner := &Miner{
+ coinbase: coinbase,
+ worker: newWorker(coinbase, eth),
}
-}
-
-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)
+ for i := 0; i < 4; i++ {
+ miner.worker.register(NewCpuMiner(i, ezp.New()))
+ }
- return self.localTxId
+ return miner
}
-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)
- }
- self.eth.EventMux().Post(&LocalTx{})
-
- delete(self.localTxs, id)
+func (self *Miner) Mining() bool {
+ return self.mining
}
func (self *Miner) Start() {
- if self.mining {
- return
- }
-
- 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{})
+ self.worker.start()
- go self.update()
- go self.mine()
+ self.worker.commitNewWork()
}
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)
+ self.worker.stop()
}
-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))
-
- // 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})
-
- minerlogger.Infof("🔨 Mined block %x\n", block.Hash())
- minerlogger.Infoln(block)
- }
-
- go self.mine()
+func (self *Miner) HashRate() int64 {
+ var tot int64
+ for _, agent := range self.worker.agents {
+ tot += agent.Pow().GetHashrate()
}
-}
-
-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
- }
-
- // Faster than append
- for _, tx := range self.eth.TxPool().GetTransactions() {
- if tx.GasPrice().Cmp(self.MinAcceptedGasPrice) >= 0 {
- txs[actualSize] = tx
- actualSize++
- }
- }
-
- 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 ea8f2e8b5cf73f87bd369b1a8ac6654f5684f170..cd1c6e28f96cf9beb4a24fc1637dfccefe88ace6 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -41,12 +41,21 @@ func env(block *types.Block, eth *eth.Ethereum) *environment {
return env
}
+type Work struct {
+ Number uint64
+ Nonce []byte
+}
+
type Agent interface {
- Comms() chan<- *types.Block
+ Work() chan<- *types.Block
+ SetNonceCh(chan<- Work)
+ Stop()
+ Pow() pow.PoW
}
type worker struct {
- agents []chan<- *types.Block
+ agents []Agent
+ recv chan Work
mux *event.TypeMux
quit chan struct{}
pow pow.PoW
@@ -57,40 +66,85 @@ 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 Work),
+ chain: eth.ChainManager(),
+ proc: eth.BlockProcessor(),
+ coinbase: coinbase,
+ }
}
-func (self *worker) register(agent chan<- *types.Block) {
+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)
+}
+
+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:
break out
}
}
+
+ events.Unsubscribe()
}
-func (self *worker) commit() {
- self.current.state.Update(ethutil.Big0)
- self.current.block.SetRoot(self.current.state.Root())
+func (self *worker) wait() {
+ for {
+ for work := range self.recv {
+ if self.current.block.Number().Uint64() == work.Number {
+ self.current.block.Header().Nonce = work.Nonce
- for _, agent := range self.agents {
- agent <- self.current.block
+ self.chain.InsertChain(types.Blocks{self.current.block})
+ }
+ break
+ }
+ }
+}
+
+func (self *worker) push() {
+ 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
+ }
}
}
@@ -110,7 +164,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 +175,7 @@ func (self *worker) commitNewWork() {
self.current.coinbase.AddAmount(core.BlockReward)
- self.commit()
+ self.push()
}
var (
diff --git a/pow/block.go b/pow/block.go
index 62df2b5ff593b9f3cc6254fea6c5a228cd92bd37..31e194d8d844df5d83229db28edc2b3b2abdc5af 100644
--- a/pow/block.go
+++ b/pow/block.go
@@ -6,4 +6,5 @@ type Block interface {
Difficulty() *big.Int
HashNoNonce() []byte
N() []byte
+ Number() *big.Int
}
diff --git a/pow/ezp/pow.go b/pow/ezp/pow.go
index e4caa076a86ae196e4d392347ab9292e68d98787..5571e73cdb969db2b7de374bcc22b5cdc9304db9 100644
--- a/pow/ezp/pow.go
+++ b/pow/ezp/pow.go
@@ -21,7 +21,7 @@ type EasyPow struct {
}
func New() *EasyPow {
- return &EasyPow{turbo: false}
+ return &EasyPow{turbo: true}
}
func (pow *EasyPow) GetHashrate() int64 {
@@ -36,26 +36,33 @@ func (pow *EasyPow) Search(block pow.Block, stop <-chan struct{}) []byte {
r := rand.New(rand.NewSource(time.Now().UnixNano()))
hash := block.HashNoNonce()
diff := block.Difficulty()
- i := int64(0)
+ //i := int64(0)
+ // TODO fix offset
+ i := rand.Int63()
+ starti := i
start := time.Now().UnixNano()
- t := time.Now()
+
+ // Make sure stop is empty
+empty:
+ for {
+ select {
+ case <-stop:
+ default:
+ break empty
+ }
+ }
for {
select {
case <-stop:
- powlogger.Infoln("Breaking from mining")
pow.HashRate = 0
return nil
default:
i++
- if time.Since(t) > (1 * time.Second) {
- elapsed := time.Now().UnixNano() - start
- hashes := ((float64(1e9) / float64(elapsed)) * float64(i)) / 1000
- pow.HashRate = int64(hashes)
-
- t = time.Now()
- }
+ elapsed := time.Now().UnixNano() - start
+ hashes := ((float64(1e9) / float64(elapsed)) * float64(i-starti)) / 1000
+ pow.HashRate = int64(hashes)
sha := crypto.Sha3(big.NewInt(r.Int63()).Bytes())
if verify(hash, diff, sha) {
diff --git a/xeth/types.go b/xeth/types.go
index b13317b03e0203513ebec4d3cea1c8ddf4742a45..a903fccbbff893f8b031e9c1fb17b3a064d6705b 100644
--- a/xeth/types.go
+++ b/xeth/types.go
@@ -60,7 +60,6 @@ func (self *Object) Storage() (storage map[string]string) {
rlp.Decode(bytes.NewReader(it.Value), &data)
storage[toHex(it.Key)] = toHex(data)
}
- self.StateObject.Trie().PrintRoot()
return
}