aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--cmd/geth/chaincmd.go35
-rw-r--r--common/format.go40
-rw-r--r--core/blockchain.go41
-rw-r--r--core/headerchain.go9
-rw-r--r--eth/downloader/downloader.go2
-rw-r--r--internal/ethapi/api.go43
-rw-r--r--internal/web3ext/web3ext.go13
-rw-r--r--miner/worker.go2
-rw-r--r--trie/trie.go14
9 files changed, 174 insertions, 25 deletions
diff --git a/cmd/geth/chaincmd.go b/cmd/geth/chaincmd.go
index 553e5367c..d7cdf1064 100644
--- a/cmd/geth/chaincmd.go
+++ b/cmd/geth/chaincmd.go
@@ -31,6 +31,8 @@ import (
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/logger/glog"
+ "github.com/ethereum/go-ethereum/trie"
+ "github.com/syndtr/goleveldb/leveldb/util"
"gopkg.in/urfave/cli.v1"
)
@@ -81,13 +83,38 @@ func importChain(ctx *cli.Context) error {
}
stack := makeFullNode(ctx)
chain, chainDb := utils.MakeChain(ctx, stack)
+ defer chainDb.Close()
+
+ // Import the chain
start := time.Now()
- err := utils.ImportChain(chain, ctx.Args().First())
- chainDb.Close()
- if err != nil {
+ if err := utils.ImportChain(chain, ctx.Args().First()); err != nil {
utils.Fatalf("Import error: %v", err)
}
- fmt.Printf("Import done in %v", time.Since(start))
+ fmt.Printf("Import done in %v.\n", time.Since(start))
+
+ if db, ok := chainDb.(*ethdb.LDBDatabase); ok {
+ // Output pre-compaction stats mostly to see the import trashing
+ stats, err := db.LDB().GetProperty("leveldb.stats")
+ if err != nil {
+ utils.Fatalf("Failed to read database stats: %v", err)
+ }
+ fmt.Println(stats)
+
+ // Compact the entire database to more accurately measure disk io and print the stats
+ start = time.Now()
+ fmt.Println("Compacting entire database...")
+ if err = db.LDB().CompactRange(util.Range{}); err != nil {
+ utils.Fatalf("Compaction failed: %v", err)
+ }
+ fmt.Printf("Compaction done in %v.\n", time.Since(start))
+
+ stats, err = db.LDB().GetProperty("leveldb.stats")
+ if err != nil {
+ utils.Fatalf("Failed to read database stats: %v", err)
+ }
+ fmt.Println(stats)
+ fmt.Println("Trie cache misses:", trie.CacheMisses())
+ }
return nil
}
diff --git a/common/format.go b/common/format.go
new file mode 100644
index 000000000..119637d2e
--- /dev/null
+++ b/common/format.go
@@ -0,0 +1,40 @@
+// 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 common
+
+import (
+ "fmt"
+ "regexp"
+ "strings"
+ "time"
+)
+
+// PrettyDuration is a pretty printed version of a time.Duration value that cuts
+// the unnecessary precision off from the formatted textual representation.
+type PrettyDuration time.Duration
+
+var prettyDurationRe = regexp.MustCompile("\\.[0-9]+")
+
+// String implements the Stringer interface, allowing pretty printing of duration
+// values rounded to three decimals.
+func (d PrettyDuration) String() string {
+ label := fmt.Sprintf("%v", time.Duration(d))
+ if match := prettyDurationRe.FindString(label); len(match) > 4 {
+ label = strings.Replace(label, match, match[:4], 1)
+ }
+ return label
+}
diff --git a/core/blockchain.go b/core/blockchain.go
index 7657fce78..5cf99cd8c 100644
--- a/core/blockchain.go
+++ b/core/blockchain.go
@@ -769,8 +769,12 @@ func (self *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain
// Report some public statistics so the user has a clue what's going on
first, last := blockChain[0], blockChain[len(blockChain)-1]
- glog.V(logger.Info).Infof("imported %d receipt(s) (%d ignored) in %v. #%d [%x… / %x…]", stats.processed, stats.ignored,
- time.Since(start), last.Number(), first.Hash().Bytes()[:4], last.Hash().Bytes()[:4])
+
+ ignored := ""
+ if stats.ignored > 0 {
+ ignored = fmt.Sprintf(" (%d ignored)", stats.ignored)
+ }
+ glog.V(logger.Info).Infof("imported %d receipts%s in %9v. #%d [%x… / %x…]", stats.processed, ignored, common.PrettyDuration(time.Since(start)), last.Number(), first.Hash().Bytes()[:4], last.Hash().Bytes()[:4])
return 0, nil
}
@@ -947,8 +951,9 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
switch status {
case CanonStatTy:
if glog.V(logger.Debug) {
- glog.Infof("[%v] inserted block #%d (%d TXs %v G %d UNCs) (%x...). Took %v\n", time.Now().UnixNano(), block.Number(), len(block.Transactions()), block.GasUsed(), len(block.Uncles()), block.Hash().Bytes()[0:4], time.Since(bstart))
+ glog.Infof("inserted block #%d [%x…] in %9v: %3d txs %7v gas %d uncles.", block.Number(), block.Hash().Bytes()[0:4], common.PrettyDuration(time.Since(bstart)), len(block.Transactions()), block.GasUsed(), len(block.Uncles()))
}
+ blockInsertTimer.UpdateSince(bstart)
events = append(events, ChainEvent{block, block.Hash(), logs})
// This puts transactions in a extra db for rpc
@@ -965,8 +970,9 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
}
case SideStatTy:
if glog.V(logger.Detail) {
- glog.Infof("inserted forked block #%d (TD=%v) (%d TXs %d UNCs) (%x...). Took %v\n", block.Number(), block.Difficulty(), len(block.Transactions()), len(block.Uncles()), block.Hash().Bytes()[0:4], time.Since(bstart))
+ glog.Infof("inserted forked block #%d [%x…] (TD=%v) in %9v: %3d txs %d uncles.", block.Number(), block.Hash().Bytes()[0:4], block.Difficulty(), common.PrettyDuration(time.Since(bstart)), len(block.Transactions()), len(block.Uncles()))
}
+ blockInsertTimer.UpdateSince(bstart)
events = append(events, ChainSideEvent{block, logs})
case SplitStatTy:
@@ -991,24 +997,27 @@ type insertStats struct {
startTime time.Time
}
-const (
- statsReportLimit = 1024
- statsReportTimeLimit = 8 * time.Second
-)
+// statsReportLimit is the time limit during import after which we always print
+// out progress. This avoids the user wondering what's going on.
+const statsReportLimit = 8 * time.Second
// report prints statistics if some number of blocks have been processed
// or more than a few seconds have passed since the last message.
func (st *insertStats) report(chain []*types.Block, index int) {
- limit := statsReportLimit
- if index == len(chain)-1 {
- limit = 0 // Always print a message for the last block.
- }
- now := time.Now()
- duration := now.Sub(st.startTime)
- if duration > statsReportTimeLimit || st.queued > limit || st.processed > limit || st.ignored > limit {
+ var (
+ now = time.Now()
+ elapsed = now.Sub(st.startTime)
+ )
+ if index == len(chain)-1 || elapsed >= statsReportLimit {
start, end := chain[st.lastIndex], chain[index]
txcount := countTransactions(chain[st.lastIndex : index+1])
- glog.Infof("imported %d block(s) (%d queued %d ignored) including %d txs in %v. #%v [%x / %x]\n", st.processed, st.queued, st.ignored, txcount, duration, end.Number(), start.Hash().Bytes()[:4], end.Hash().Bytes()[:4])
+
+ extra := ""
+ if st.queued > 0 || st.ignored > 0 {
+ extra = fmt.Sprintf(" (%d queued %d ignored)", st.queued, st.ignored)
+ }
+ glog.Infof("imported %d blocks%s, %5d txs in %9v. #%v [%x… / %x…]\n", st.processed, extra, txcount, common.PrettyDuration(elapsed), end.Number(), start.Hash().Bytes()[:4], end.Hash().Bytes()[:4])
+
*st = insertStats{startTime: now, lastIndex: index}
}
}
diff --git a/core/headerchain.go b/core/headerchain.go
index 0f9dd7208..8ca06d9b4 100644
--- a/core/headerchain.go
+++ b/core/headerchain.go
@@ -18,6 +18,7 @@ package core
import (
crand "crypto/rand"
+ "fmt"
"math"
"math/big"
mrand "math/rand"
@@ -321,8 +322,12 @@ func (hc *HeaderChain) InsertHeaderChain(chain []*types.Header, checkFreq int, w
}
// Report some public statistics so the user has a clue what's going on
first, last := chain[0], chain[len(chain)-1]
- glog.V(logger.Info).Infof("imported %d header(s) (%d ignored) in %v. #%v [%x… / %x…]", stats.processed, stats.ignored,
- time.Since(start), last.Number, first.Hash().Bytes()[:4], last.Hash().Bytes()[:4])
+
+ ignored := ""
+ if stats.ignored > 0 {
+ ignored = fmt.Sprintf(" (%d ignored)", stats.ignored)
+ }
+ glog.V(logger.Info).Infof("imported %d headers%s in %9v. #%v [%x… / %x…]", stats.processed, ignored, common.PrettyDuration(time.Since(start)), last.Number, first.Hash().Bytes()[:4], last.Hash().Bytes()[:4])
return 0, nil
}
diff --git a/eth/downloader/downloader.go b/eth/downloader/downloader.go
index fb63757aa..526ecbeca 100644
--- a/eth/downloader/downloader.go
+++ b/eth/downloader/downloader.go
@@ -952,7 +952,7 @@ func (d *Downloader) fetchNodeData() error {
// Log a message to the user and return
if delivered > 0 {
- glog.V(logger.Info).Infof("imported %d state entries in %v: processed %d, pending at least %d", delivered, time.Since(start), d.syncStatsStateDone, pending)
+ glog.V(logger.Info).Infof("imported %d state entries in %9v: processed %d, pending at least %d", delivered, common.PrettyDuration(time.Since(start)), d.syncStatsStateDone, pending)
}
})
}
diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go
index 53ea8d186..de88a5d1e 100644
--- a/internal/ethapi/api.go
+++ b/internal/ethapi/api.go
@@ -597,7 +597,7 @@ func (s *PublicBlockChainAPI) rpcOutputBlock(b *types.Block, inclTx bool, fullTx
"gasUsed": rpc.NewHexNumber(head.GasUsed),
"timestamp": rpc.NewHexNumber(head.Time),
"transactionsRoot": head.TxHash,
- "receiptsRoot": head.ReceiptHash,
+ "receiptsRoot": head.ReceiptHash,
}
if inclTx {
@@ -699,6 +699,16 @@ func newRPCTransactionFromBlockIndex(b *types.Block, txIndex int) (*RPCTransacti
return nil, nil
}
+// newRPCRawTransactionFromBlockIndex returns the bytes of a transaction given a block and a transaction index.
+func newRPCRawTransactionFromBlockIndex(b *types.Block, txIndex int) (rpc.HexBytes, error) {
+ if txIndex >= 0 && txIndex < len(b.Transactions()) {
+ tx := b.Transactions()[txIndex]
+ return rlp.EncodeToBytes(tx)
+ }
+
+ return nil, nil
+}
+
// newRPCTransaction returns a transaction that will serialize to the RPC representation.
func newRPCTransaction(b *types.Block, txHash common.Hash) (*RPCTransaction, error) {
for idx, tx := range b.Transactions() {
@@ -770,6 +780,22 @@ func (s *PublicTransactionPoolAPI) GetTransactionByBlockHashAndIndex(ctx context
return nil, nil
}
+// GetRawTransactionByBlockNumberAndIndex returns the bytes of the transaction for the given block number and index.
+func (s *PublicTransactionPoolAPI) GetRawTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index rpc.HexNumber) (rpc.HexBytes, error) {
+ if block, _ := s.b.BlockByNumber(ctx, blockNr); block != nil {
+ return newRPCRawTransactionFromBlockIndex(block, index.Int())
+ }
+ return nil, nil
+}
+
+// GetRawTransactionByBlockHashAndIndex returns the bytes of the transaction for the given block hash and index.
+func (s *PublicTransactionPoolAPI) GetRawTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index rpc.HexNumber) (rpc.HexBytes, error) {
+ if block, _ := s.b.GetBlock(ctx, blockHash); block != nil {
+ return newRPCRawTransactionFromBlockIndex(block, index.Int())
+ }
+ return nil, nil
+}
+
// GetTransactionCount returns the number of transactions the given address has sent for the given block number
func (s *PublicTransactionPoolAPI) GetTransactionCount(ctx context.Context, address common.Address, blockNr rpc.BlockNumber) (*rpc.HexNumber, error) {
state, _, err := s.b.StateAndHeaderByNumber(blockNr)
@@ -835,6 +861,21 @@ func (s *PublicTransactionPoolAPI) GetTransactionByHash(ctx context.Context, txH
return nil, nil
}
+// GetRawTransactionByHash returns the bytes of the transaction for the given hash.
+func (s *PublicTransactionPoolAPI) GetRawTransactionByHash(ctx context.Context, txHash common.Hash) (rpc.HexBytes, error) {
+ var tx *types.Transaction
+ var err error
+
+ if tx, _, err = getTransaction(s.b.ChainDb(), s.b, txHash); err != nil {
+ glog.V(logger.Debug).Infof("%v\n", err)
+ return nil, nil
+ } else if tx == nil {
+ return nil, nil
+ }
+
+ return rlp.EncodeToBytes(tx)
+}
+
// GetTransactionReceipt returns the transaction receipt for the given transaction hash.
func (s *PublicTransactionPoolAPI) GetTransactionReceipt(txHash common.Hash) (map[string]interface{}, error) {
receipt := core.GetReceipt(s.b.ChainDb(), txHash)
diff --git a/internal/web3ext/web3ext.go b/internal/web3ext/web3ext.go
index 04b13e483..cbbab0ece 100644
--- a/internal/web3ext/web3ext.go
+++ b/internal/web3ext/web3ext.go
@@ -468,6 +468,19 @@ web3._extend({
call: 'eth_submitTransaction',
params: 1,
inputFormatter: [web3._extend.formatters.inputTransactionFormatter]
+ }),
+ new web3._extend.Method({
+ name: 'getRawTransaction',
+ call: 'eth_getRawTransactionByHash',
+ params: 1
+ }),
+ new web3._extend.Method({
+ name: 'getRawTransactionFromBlock',
+ call: function(args) {
+ return (web3._extend.utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getRawTransactionByBlockHashAndIndex' : 'eth_getRawTransactionByBlockNumberAndIndex';
+ },
+ params: 2,
+ inputFormatter: [web3._extend.formatters.inputBlockNumberFormatter, web3._extend.utils.toHex]
})
],
properties:
diff --git a/miner/worker.go b/miner/worker.go
index e5348cef4..89064c3b9 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -169,7 +169,7 @@ func (self *worker) pending() (*types.Block, *state.StateDB) {
self.current.txs,
nil,
self.current.receipts,
- ), self.current.state
+ ), self.current.state.Copy()
}
return self.current.Block, self.current.state.Copy()
}
diff --git a/trie/trie.go b/trie/trie.go
index 30f566a8d..914bf20fa 100644
--- a/trie/trie.go
+++ b/trie/trie.go
@@ -20,6 +20,7 @@ package trie
import (
"bytes"
"fmt"
+ "sync/atomic"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/crypto/sha3"
@@ -34,6 +35,17 @@ var (
emptyState common.Hash
)
+// cacheMisses maintains the number of times a trie node was loaded from disk.
+// Always use atomic operations when accessing this global variable.
+var cacheMisses uint64
+
+// CacheMisses retrieves a global counter measuring the number of cache misses
+// the trie did since process startup. This isn't useful for anything apart from
+// trie debugging purposes.
+func CacheMisses() uint64 {
+ return atomic.LoadUint64(&cacheMisses)
+}
+
func init() {
sha3.NewKeccak256().Sum(emptyState[:0])
}
@@ -420,6 +432,8 @@ func (t *Trie) resolve(n node, prefix, suffix []byte) (node, error) {
}
func (t *Trie) resolveHash(n hashNode, prefix, suffix []byte) (node, error) {
+ atomic.AddUint64(&cacheMisses, 1)
+
enc, err := t.db.Get(n)
if err != nil || enc == nil {
return nil, &MissingNodeError{
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-25 15:04:24 +0800