github.com/halybang/go-ethereum@v1.0.5-0.20180325041310-3b262bc1367c/core/bench_test.go (about) 1 // Copyright 2015 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package core 18 19 import ( 20 "crypto/ecdsa" 21 "io/ioutil" 22 "math/big" 23 "os" 24 "testing" 25 26 "github.com/wanchain/go-wanchain/common" 27 "github.com/wanchain/go-wanchain/common/math" 28 "github.com/wanchain/go-wanchain/consensus/ethash" 29 "github.com/wanchain/go-wanchain/core/types" 30 "github.com/wanchain/go-wanchain/core/vm" 31 "github.com/wanchain/go-wanchain/crypto" 32 "github.com/wanchain/go-wanchain/ethdb" 33 "github.com/wanchain/go-wanchain/params" 34 ) 35 36 func BenchmarkInsertChain_empty_memdb(b *testing.B) { 37 benchInsertChain(b, false, nil) 38 } 39 func BenchmarkInsertChain_empty_diskdb(b *testing.B) { 40 benchInsertChain(b, true, nil) 41 } 42 func BenchmarkInsertChain_valueTx_memdb(b *testing.B) { 43 benchInsertChain(b, false, genValueTx(0)) 44 } 45 func BenchmarkInsertChain_valueTx_diskdb(b *testing.B) { 46 benchInsertChain(b, true, genValueTx(0)) 47 } 48 func BenchmarkInsertChain_valueTx_100kB_memdb(b *testing.B) { 49 benchInsertChain(b, false, genValueTx(100*1024)) 50 } 51 func BenchmarkInsertChain_valueTx_100kB_diskdb(b *testing.B) { 52 benchInsertChain(b, true, genValueTx(100*1024)) 53 } 54 func BenchmarkInsertChain_uncles_memdb(b *testing.B) { 55 benchInsertChain(b, false, genUncles) 56 } 57 func BenchmarkInsertChain_uncles_diskdb(b *testing.B) { 58 benchInsertChain(b, true, genUncles) 59 } 60 func BenchmarkInsertChain_ring200_memdb(b *testing.B) { 61 benchInsertChain(b, false, genTxRing(200)) 62 } 63 func BenchmarkInsertChain_ring200_diskdb(b *testing.B) { 64 benchInsertChain(b, true, genTxRing(200)) 65 } 66 func BenchmarkInsertChain_ring1000_memdb(b *testing.B) { 67 benchInsertChain(b, false, genTxRing(1000)) 68 } 69 func BenchmarkInsertChain_ring1000_diskdb(b *testing.B) { 70 benchInsertChain(b, true, genTxRing(1000)) 71 } 72 73 var ( 74 // This is the content of the genesis block used by the benchmarks. 75 benchRootKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") 76 benchRootAddr = crypto.PubkeyToAddress(benchRootKey.PublicKey) 77 benchRootFunds = math.BigPow(2, 100) 78 ) 79 80 // genValueTx returns a block generator that includes a single 81 // value-transfer transaction with n bytes of extra data in each 82 // block. 83 func genValueTx(nbytes int) func(int, *BlockGen) { 84 return func(i int, gen *BlockGen) { 85 toaddr := common.Address{} 86 data := make([]byte, nbytes) 87 gas := IntrinsicGas(data, false, false) 88 tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(benchRootAddr), toaddr, big.NewInt(1), gas, nil, data), types.HomesteadSigner{}, benchRootKey) 89 gen.AddTx(tx) 90 } 91 } 92 93 var ( 94 ringKeys = make([]*ecdsa.PrivateKey, 1000) 95 ringAddrs = make([]common.Address, len(ringKeys)) 96 bigTxGas = new(big.Int).SetUint64(params.TxGas) 97 ) 98 99 func init() { 100 ringKeys[0] = benchRootKey 101 ringAddrs[0] = benchRootAddr 102 for i := 1; i < len(ringKeys); i++ { 103 ringKeys[i], _ = crypto.GenerateKey() 104 ringAddrs[i] = crypto.PubkeyToAddress(ringKeys[i].PublicKey) 105 } 106 } 107 108 // genTxRing returns a block generator that sends ether in a ring 109 // among n accounts. This is creates n entries in the state database 110 // and fills the blocks with many small transactions. 111 func genTxRing(naccounts int) func(int, *BlockGen) { 112 from := 0 113 return func(i int, gen *BlockGen) { 114 gas := CalcGasLimit(gen.PrevBlock(i - 1)) 115 for { 116 gas.Sub(gas, bigTxGas) 117 if gas.Cmp(bigTxGas) < 0 { 118 break 119 } 120 to := (from + 1) % naccounts 121 tx := types.NewTransaction( 122 gen.TxNonce(ringAddrs[from]), 123 ringAddrs[to], 124 benchRootFunds, 125 bigTxGas, 126 nil, 127 nil, 128 ) 129 tx, _ = types.SignTx(tx, types.HomesteadSigner{}, ringKeys[from]) 130 gen.AddTx(tx) 131 from = to 132 } 133 } 134 } 135 136 // genUncles generates blocks with two uncle headers. 137 func genUncles(i int, gen *BlockGen) { 138 if i >= 6 { 139 b2 := gen.PrevBlock(i - 6).Header() 140 b2.Extra = []byte("foo") 141 gen.AddUncle(b2) 142 b3 := gen.PrevBlock(i - 6).Header() 143 b3.Extra = []byte("bar") 144 gen.AddUncle(b3) 145 } 146 } 147 148 func benchInsertChain(b *testing.B, disk bool, gen func(int, *BlockGen)) { 149 // Create the database in memory or in a temporary directory. 150 var db ethdb.Database 151 if !disk { 152 db, _ = ethdb.NewMemDatabase() 153 } else { 154 dir, err := ioutil.TempDir("", "eth-core-bench") 155 if err != nil { 156 b.Fatalf("cannot create temporary directory: %v", err) 157 } 158 defer os.RemoveAll(dir) 159 db, err = ethdb.NewLDBDatabase(dir, 128, 128) 160 if err != nil { 161 b.Fatalf("cannot create temporary database: %v", err) 162 } 163 defer db.Close() 164 } 165 166 // Generate a chain of b.N blocks using the supplied block 167 // generator function. 168 gspec := DefaultPPOWTestingGenesisBlock() 169 gspec.Alloc = GenesisAlloc{benchRootAddr: {Balance: benchRootFunds}} 170 genesis := gspec.MustCommit(db) 171 engine := ethash.NewFaker(db) 172 chainman, _ := NewBlockChain(db, gspec.Config, engine, vm.Config{}) 173 chainEnv := NewChainEnv(params.TestChainConfig, gspec, engine,chainman, db) 174 chain, _ := chainEnv.GenerateChain(genesis, b.N, gen) 175 176 // Time the insertion of the new chain. 177 // State and blocks are stored in the same DB. 178 179 defer chainman.Stop() 180 b.ReportAllocs() 181 b.ResetTimer() 182 if i, err := chainman.InsertChain(chain); err != nil { 183 b.Fatalf("insert error (block %d): %v\n", i, err) 184 } 185 } 186 187 func BenchmarkChainRead_header_10k(b *testing.B) { 188 benchReadChain(b, false, 10000) 189 } 190 func BenchmarkChainRead_full_10k(b *testing.B) { 191 benchReadChain(b, true, 10000) 192 } 193 func BenchmarkChainRead_header_100k(b *testing.B) { 194 benchReadChain(b, false, 100000) 195 } 196 func BenchmarkChainRead_full_100k(b *testing.B) { 197 benchReadChain(b, true, 100000) 198 } 199 func BenchmarkChainRead_header_500k(b *testing.B) { 200 benchReadChain(b, false, 500000) 201 } 202 func BenchmarkChainRead_full_500k(b *testing.B) { 203 benchReadChain(b, true, 500000) 204 } 205 func BenchmarkChainWrite_header_10k(b *testing.B) { 206 benchWriteChain(b, false, 10000) 207 } 208 func BenchmarkChainWrite_full_10k(b *testing.B) { 209 benchWriteChain(b, true, 10000) 210 } 211 func BenchmarkChainWrite_header_100k(b *testing.B) { 212 benchWriteChain(b, false, 100000) 213 } 214 func BenchmarkChainWrite_full_100k(b *testing.B) { 215 benchWriteChain(b, true, 100000) 216 } 217 func BenchmarkChainWrite_header_500k(b *testing.B) { 218 benchWriteChain(b, false, 500000) 219 } 220 func BenchmarkChainWrite_full_500k(b *testing.B) { 221 benchWriteChain(b, true, 500000) 222 } 223 224 // makeChainForBench writes a given number of headers or empty blocks/receipts 225 // into a database. 226 func makeChainForBench(db ethdb.Database, full bool, count uint64) { 227 var hash common.Hash 228 for n := uint64(0); n < count; n++ { 229 header := &types.Header{ 230 Coinbase: common.Address{}, 231 Number: big.NewInt(int64(n)), 232 ParentHash: hash, 233 Difficulty: big.NewInt(1), 234 UncleHash: types.EmptyUncleHash, 235 TxHash: types.EmptyRootHash, 236 ReceiptHash: types.EmptyRootHash, 237 } 238 hash = header.Hash() 239 WriteHeader(db, header) 240 WriteCanonicalHash(db, hash, n) 241 WriteTd(db, hash, n, big.NewInt(int64(n+1))) 242 if full || n == 0 { 243 block := types.NewBlockWithHeader(header) 244 WriteBody(db, hash, n, block.Body()) 245 WriteBlockReceipts(db, hash, n, nil) 246 } 247 } 248 } 249 250 func benchWriteChain(b *testing.B, full bool, count uint64) { 251 for i := 0; i < b.N; i++ { 252 dir, err := ioutil.TempDir("", "eth-chain-bench") 253 if err != nil { 254 b.Fatalf("cannot create temporary directory: %v", err) 255 } 256 db, err := ethdb.NewLDBDatabase(dir, 128, 1024) 257 if err != nil { 258 b.Fatalf("error opening database at %v: %v", dir, err) 259 } 260 makeChainForBench(db, full, count) 261 db.Close() 262 os.RemoveAll(dir) 263 } 264 } 265 266 func benchReadChain(b *testing.B, full bool, count uint64) { 267 dir, err := ioutil.TempDir("", "eth-chain-bench") 268 if err != nil { 269 b.Fatalf("cannot create temporary directory: %v", err) 270 } 271 defer os.RemoveAll(dir) 272 273 db, err := ethdb.NewLDBDatabase(dir, 128, 1024) 274 if err != nil { 275 b.Fatalf("error opening database at %v: %v", dir, err) 276 } 277 makeChainForBench(db, full, count) 278 db.Close() 279 280 b.ReportAllocs() 281 b.ResetTimer() 282 283 for i := 0; i < b.N; i++ { 284 db, err := ethdb.NewLDBDatabase(dir, 128, 1024) 285 if err != nil { 286 b.Fatalf("error opening database at %v: %v", dir, err) 287 } 288 chain, err := NewBlockChain(db, params.TestChainConfig, ethash.NewFaker(db), vm.Config{}) 289 if err != nil { 290 b.Fatalf("error creating chain: %v", err) 291 } 292 293 for n := uint64(0); n < count; n++ { 294 header := chain.GetHeaderByNumber(n) 295 if full { 296 hash := header.Hash() 297 GetBody(db, hash, n) 298 GetBlockReceipts(db, hash, n) 299 } 300 } 301 302 chain.Stop() 303 db.Close() 304 } 305 }