123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188 |
- // Copyright 2017 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 ethash
- import (
- "encoding/binary"
- "encoding/json"
- "math/big"
- "math/rand"
- "os"
- "path/filepath"
- "testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
- )
- type diffTest struct {
- ParentTimestamp uint64
- ParentDifficulty *big.Int
- CurrentTimestamp uint64
- CurrentBlocknumber *big.Int
- CurrentDifficulty *big.Int
- }
- func (d *diffTest) UnmarshalJSON(b []byte) (err error) {
- var ext struct {
- ParentTimestamp string
- ParentDifficulty string
- CurrentTimestamp string
- CurrentBlocknumber string
- CurrentDifficulty string
- }
- if err := json.Unmarshal(b, &ext); err != nil {
- return err
- }
- d.ParentTimestamp = math.MustParseUint64(ext.ParentTimestamp)
- d.ParentDifficulty = math.MustParseBig256(ext.ParentDifficulty)
- d.CurrentTimestamp = math.MustParseUint64(ext.CurrentTimestamp)
- d.CurrentBlocknumber = math.MustParseBig256(ext.CurrentBlocknumber)
- d.CurrentDifficulty = math.MustParseBig256(ext.CurrentDifficulty)
- return nil
- }
- func TestCalcDifficulty(t *testing.T) {
- file, err := os.Open(filepath.Join("..", "..", "tests", "testdata", "BasicTests", "difficulty.json"))
- if err != nil {
- t.Skip(err)
- }
- defer file.Close()
- tests := make(map[string]diffTest)
- err = json.NewDecoder(file).Decode(&tests)
- if err != nil {
- t.Fatal(err)
- }
- config := ¶ms.ChainConfig{HomesteadBlock: big.NewInt(1150000)}
- for name, test := range tests {
- number := new(big.Int).Sub(test.CurrentBlocknumber, big.NewInt(1))
- diff := CalcDifficulty(config, test.CurrentTimestamp, &types.Header{
- Number: number,
- Time: test.ParentTimestamp,
- Difficulty: test.ParentDifficulty,
- })
- if diff.Cmp(test.CurrentDifficulty) != 0 {
- t.Error(name, "failed. Expected", test.CurrentDifficulty, "and calculated", diff)
- }
- }
- }
- func randSlice(min, max uint32) []byte {
- var b = make([]byte, 4)
- rand.Read(b)
- a := binary.LittleEndian.Uint32(b)
- size := min + a%(max-min)
- out := make([]byte, size)
- rand.Read(out)
- return out
- }
- func TestDifficultyCalculators(t *testing.T) {
- rand.Seed(2)
- for i := 0; i < 5000; i++ {
- // 1 to 300 seconds diff
- var timeDelta = uint64(1 + rand.Uint32()%3000)
- diffBig := big.NewInt(0).SetBytes(randSlice(2, 10))
- if diffBig.Cmp(params.MinimumDifficulty) < 0 {
- diffBig.Set(params.MinimumDifficulty)
- }
- //rand.Read(difficulty)
- header := &types.Header{
- Difficulty: diffBig,
- Number: new(big.Int).SetUint64(rand.Uint64() % 50_000_000),
- Time: rand.Uint64() - timeDelta,
- }
- if rand.Uint32()&1 == 0 {
- header.UncleHash = types.EmptyUncleHash
- }
- bombDelay := new(big.Int).SetUint64(rand.Uint64() % 50_000_000)
- for i, pair := range []struct {
- bigFn func(time uint64, parent *types.Header) *big.Int
- u256Fn func(time uint64, parent *types.Header) *big.Int
- }{
- {FrontierDifficultyCalulator, CalcDifficultyFrontierU256},
- {HomesteadDifficultyCalulator, CalcDifficultyHomesteadU256},
- {DynamicDifficultyCalculator(bombDelay), MakeDifficultyCalculatorU256(bombDelay)},
- } {
- time := header.Time + timeDelta
- want := pair.bigFn(time, header)
- have := pair.u256Fn(time, header)
- if want.BitLen() > 256 {
- continue
- }
- if want.Cmp(have) != 0 {
- t.Fatalf("pair %d: want %x have %x\nparent.Number: %x\np.Time: %x\nc.Time: %x\nBombdelay: %v\n", i, want, have,
- header.Number, header.Time, time, bombDelay)
- }
- }
- }
- }
- func BenchmarkDifficultyCalculator(b *testing.B) {
- x1 := makeDifficultyCalculator(big.NewInt(1000000))
- x2 := MakeDifficultyCalculatorU256(big.NewInt(1000000))
- h := &types.Header{
- ParentHash: common.Hash{},
- UncleHash: types.EmptyUncleHash,
- Difficulty: big.NewInt(0xffffff),
- Number: big.NewInt(500000),
- Time: 1000000,
- }
- b.Run("big-frontier", func(b *testing.B) {
- b.ReportAllocs()
- for i := 0; i < b.N; i++ {
- calcDifficultyFrontier(1000014, h)
- }
- })
- b.Run("u256-frontier", func(b *testing.B) {
- b.ReportAllocs()
- for i := 0; i < b.N; i++ {
- CalcDifficultyFrontierU256(1000014, h)
- }
- })
- b.Run("big-homestead", func(b *testing.B) {
- b.ReportAllocs()
- for i := 0; i < b.N; i++ {
- calcDifficultyHomestead(1000014, h)
- }
- })
- b.Run("u256-homestead", func(b *testing.B) {
- b.ReportAllocs()
- for i := 0; i < b.N; i++ {
- CalcDifficultyHomesteadU256(1000014, h)
- }
- })
- b.Run("big-generic", func(b *testing.B) {
- b.ReportAllocs()
- for i := 0; i < b.N; i++ {
- x1(1000014, h)
- }
- })
- b.Run("u256-generic", func(b *testing.B) {
- b.ReportAllocs()
- for i := 0; i < b.N; i++ {
- x2(1000014, h)
- }
- })
- }
|