470 lines
16 KiB
Go
470 lines
16 KiB
Go
// 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 pow
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"math"
|
|
"math/big"
|
|
"math/rand"
|
|
"os"
|
|
"path/filepath"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
"github.com/ethereum/go-ethereum/log"
|
|
metrics "github.com/rcrowley/go-metrics"
|
|
)
|
|
|
|
var (
|
|
ErrNonceOutOfRange = errors.New("nonce out of range")
|
|
ErrInvalidDifficulty = errors.New("non-positive difficulty")
|
|
ErrInvalidMixDigest = errors.New("invalid mix digest")
|
|
ErrInvalidPoW = errors.New("pow difficulty invalid")
|
|
)
|
|
|
|
var (
|
|
// maxUint256 is a big integer representing 2^256-1
|
|
maxUint256 = new(big.Int).Exp(big.NewInt(2), big.NewInt(256), big.NewInt(0))
|
|
|
|
// sharedEthash is a full instance that can be shared between multiple users.
|
|
sharedEthash = NewFullEthash("", 3, 0, "", 1, 0)
|
|
|
|
// algorithmRevision is the data structure version used for file naming.
|
|
algorithmRevision = 23
|
|
|
|
// dumpMagic is a dataset dump header to sanity check a data dump.
|
|
dumpMagic = hexutil.MustDecode("0xfee1deadbaddcafe")
|
|
)
|
|
|
|
// cache wraps an ethash cache with some metadata to allow easier concurrent use.
|
|
type cache struct {
|
|
epoch uint64 // Epoch for which this cache is relevant
|
|
cache []uint32 // The actual cache data content
|
|
used time.Time // Timestamp of the last use for smarter eviction
|
|
once sync.Once // Ensures the cache is generated only once
|
|
lock sync.Mutex // Ensures thread safety for updating the usage time
|
|
}
|
|
|
|
// generate ensures that the cache content is generated before use.
|
|
func (c *cache) generate(dir string, limit int, test bool) {
|
|
c.once.Do(func() {
|
|
// If we have a testing cache, generate and return
|
|
if test {
|
|
rawCache := generateCache(1024, seedHash(c.epoch*epochLength+1))
|
|
c.cache = prepare(1024, bytes.NewReader(rawCache))
|
|
return
|
|
}
|
|
// Full cache generation is needed, check cache dir for existing data
|
|
size := cacheSize(c.epoch*epochLength + 1)
|
|
seed := seedHash(c.epoch*epochLength + 1)
|
|
|
|
path := filepath.Join(dir, fmt.Sprintf("cache-R%d-%x", algorithmRevision, seed))
|
|
logger := log.New("seed", hexutil.Bytes(seed))
|
|
|
|
if dir != "" {
|
|
dump, err := os.Open(path)
|
|
if err == nil {
|
|
logger.Info("Loading ethash cache from disk")
|
|
start := time.Now()
|
|
c.cache = prepare(size, bufio.NewReader(dump))
|
|
logger.Info("Loaded ethash cache from disk", "elapsed", common.PrettyDuration(time.Since(start)))
|
|
|
|
dump.Close()
|
|
return
|
|
}
|
|
}
|
|
// No previous disk cache was available, generate on the fly
|
|
rawCache := generateCache(size, seed)
|
|
c.cache = prepare(size, bytes.NewReader(rawCache))
|
|
|
|
// If a cache directory is given, attempt to serialize for next time
|
|
if dir != "" {
|
|
// Store the ethash cache to disk
|
|
start := time.Now()
|
|
if err := os.MkdirAll(filepath.Dir(path), os.ModePerm); err != nil {
|
|
logger.Error("Failed to create ethash cache dir", "err", err)
|
|
} else if err := ioutil.WriteFile(path, rawCache, os.ModePerm); err != nil {
|
|
logger.Error("Failed to write ethash cache to disk", "err", err)
|
|
} else {
|
|
logger.Info("Stored ethash cache to disk", "elapsed", common.PrettyDuration(time.Since(start)))
|
|
}
|
|
// Iterate over all previous instances and delete old ones
|
|
for ep := int(c.epoch) - limit; ep >= 0; ep-- {
|
|
seed := seedHash(uint64(ep)*epochLength + 1)
|
|
path := filepath.Join(dir, fmt.Sprintf("cache-R%d-%x", algorithmRevision, seed))
|
|
os.Remove(path)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
// dataset wraps an ethash dataset with some metadata to allow easier concurrent use.
|
|
type dataset struct {
|
|
epoch uint64 // Epoch for which this cache is relevant
|
|
dataset []uint32 // The actual cache data content
|
|
used time.Time // Timestamp of the last use for smarter eviction
|
|
once sync.Once // Ensures the cache is generated only once
|
|
lock sync.Mutex // Ensures thread safety for updating the usage time
|
|
}
|
|
|
|
// generate ensures that the dataset content is generated before use.
|
|
func (d *dataset) generate(dir string, limit int, test bool, discard bool) {
|
|
d.once.Do(func() {
|
|
// If we have a testing dataset, generate and return
|
|
if test {
|
|
rawCache := generateCache(1024, seedHash(d.epoch*epochLength+1))
|
|
intCache := prepare(1024, bytes.NewReader(rawCache))
|
|
|
|
rawDataset := generateDataset(32*1024, intCache)
|
|
d.dataset = prepare(32*1024, bytes.NewReader(rawDataset))
|
|
|
|
return
|
|
}
|
|
// Full dataset generation is needed, check dataset dir for existing data
|
|
csize := cacheSize(d.epoch*epochLength + 1)
|
|
dsize := datasetSize(d.epoch*epochLength + 1)
|
|
seed := seedHash(d.epoch*epochLength + 1)
|
|
|
|
path := filepath.Join(dir, fmt.Sprintf("full-R%d-%x", algorithmRevision, seed))
|
|
logger := log.New("seed", hexutil.Bytes(seed))
|
|
|
|
if dir != "" {
|
|
dump, err := os.Open(path)
|
|
if err == nil {
|
|
if !discard {
|
|
logger.Info("Loading ethash DAG from disk")
|
|
start := time.Now()
|
|
d.dataset = prepare(dsize, bufio.NewReader(dump))
|
|
logger.Info("Loaded ethash DAG from disk", "elapsed", common.PrettyDuration(time.Since(start)))
|
|
}
|
|
dump.Close()
|
|
return
|
|
}
|
|
}
|
|
// No previous disk dataset was available, generate on the fly
|
|
rawCache := generateCache(csize, seed)
|
|
intCache := prepare(csize, bytes.NewReader(rawCache))
|
|
|
|
rawDataset := generateDataset(dsize, intCache)
|
|
if !discard {
|
|
d.dataset = prepare(dsize, bytes.NewReader(rawDataset))
|
|
}
|
|
// If a dataset directory is given, attempt to serialize for next time
|
|
if dir != "" {
|
|
// Store the ethash dataset to disk
|
|
start := time.Now()
|
|
if err := os.MkdirAll(filepath.Dir(path), os.ModePerm); err != nil {
|
|
logger.Error("Failed to create ethash DAG dir", "err", err)
|
|
} else if err := ioutil.WriteFile(path, rawDataset, os.ModePerm); err != nil {
|
|
logger.Error("Failed to write ethash DAG to disk", "err", err)
|
|
} else {
|
|
logger.Info("Stored ethash DAG to disk", "elapsed", common.PrettyDuration(time.Since(start)))
|
|
}
|
|
// Iterate over all previous instances and delete old ones
|
|
for ep := int(d.epoch) - limit; ep >= 0; ep-- {
|
|
seed := seedHash(uint64(ep)*epochLength + 1)
|
|
path := filepath.Join(dir, fmt.Sprintf("full-R%d-%x", algorithmRevision, seed))
|
|
os.Remove(path)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
// MakeCache generates a new ethash cache and optionally stores it to disk.
|
|
func MakeCache(block uint64, dir string) {
|
|
c := cache{epoch: block/epochLength + 1}
|
|
c.generate(dir, math.MaxInt32, false)
|
|
}
|
|
|
|
// MakeDataset generates a new ethash dataset and optionally stores it to disk.
|
|
func MakeDataset(block uint64, dir string) {
|
|
d := dataset{epoch: block/epochLength + 1}
|
|
d.generate(dir, math.MaxInt32, false, true)
|
|
}
|
|
|
|
// Ethash is a PoW data struture implementing the ethash algorithm.
|
|
type Ethash struct {
|
|
cachedir string // Data directory to store the verification caches
|
|
cachesinmem int // Number of caches to keep in memory
|
|
cachesondisk int // Number of caches to keep on disk
|
|
dagdir string // Data directory to store full mining datasets
|
|
dagsinmem int // Number of mining datasets to keep in memory
|
|
dagsondisk int // Number of mining datasets to keep on disk
|
|
|
|
caches map[uint64]*cache // In memory caches to avoid regenerating too often
|
|
fcache *cache // Pre-generated cache for the estimated future epoch
|
|
datasets map[uint64]*dataset // In memory datasets to avoid regenerating too often
|
|
fdataset *dataset // Pre-generated dataset for the estimated future epoch
|
|
lock sync.Mutex // Ensures thread safety for the in-memory caches
|
|
|
|
hashrate metrics.Meter // Meter tracking the average hashrate
|
|
|
|
tester bool // Flag whether to use a smaller test dataset
|
|
}
|
|
|
|
// NewFullEthash creates a full sized ethash PoW scheme.
|
|
func NewFullEthash(cachedir string, cachesinmem, cachesondisk int, dagdir string, dagsinmem, dagsondisk int) PoW {
|
|
if cachesinmem <= 0 {
|
|
log.Warn("One ethash cache must alwast be in memory", "requested", cachesinmem)
|
|
cachesinmem = 1
|
|
}
|
|
if cachedir != "" && cachesondisk > 0 {
|
|
log.Info("Disk storage enabled for ethash caches", "dir", cachedir, "count", cachesondisk)
|
|
}
|
|
if dagdir != "" && dagsondisk > 0 {
|
|
log.Info("Disk storage enabled for ethash DAGs", "dir", dagdir, "count", dagsondisk)
|
|
}
|
|
return &Ethash{
|
|
cachedir: cachedir,
|
|
cachesinmem: cachesinmem,
|
|
cachesondisk: cachesondisk,
|
|
dagdir: dagdir,
|
|
dagsinmem: dagsinmem,
|
|
dagsondisk: dagsondisk,
|
|
caches: make(map[uint64]*cache),
|
|
datasets: make(map[uint64]*dataset),
|
|
hashrate: metrics.NewMeter(),
|
|
}
|
|
}
|
|
|
|
// NewTestEthash creates a small sized ethash PoW scheme useful only for testing
|
|
// purposes.
|
|
func NewTestEthash() PoW {
|
|
return &Ethash{
|
|
cachesinmem: 1,
|
|
caches: make(map[uint64]*cache),
|
|
datasets: make(map[uint64]*dataset),
|
|
tester: true,
|
|
hashrate: metrics.NewMeter(),
|
|
}
|
|
}
|
|
|
|
// NewSharedEthash creates a full sized ethash PoW shared between all requesters
|
|
// running in the same process.
|
|
func NewSharedEthash() PoW {
|
|
return sharedEthash
|
|
}
|
|
|
|
// Verify implements PoW, checking whether the given block satisfies the PoW
|
|
// difficulty requirements.
|
|
func (ethash *Ethash) Verify(block Block) error {
|
|
// Sanity check that the block number is below the lookup table size (60M blocks)
|
|
number := block.NumberU64()
|
|
if number/epochLength >= uint64(len(cacheSizes)) {
|
|
// Go < 1.7 cannot calculate new cache/dataset sizes (no fast prime check)
|
|
return ErrNonceOutOfRange
|
|
}
|
|
// Ensure that we have a valid difficulty for the block
|
|
difficulty := block.Difficulty()
|
|
if difficulty.Sign() <= 0 {
|
|
return ErrInvalidDifficulty
|
|
}
|
|
// Recompute the digest and PoW value and verify against the block
|
|
cache := ethash.cache(number)
|
|
|
|
size := datasetSize(number)
|
|
if ethash.tester {
|
|
size = 32 * 1024
|
|
}
|
|
digest, result := hashimotoLight(size, cache, block.HashNoNonce().Bytes(), block.Nonce())
|
|
if !bytes.Equal(block.MixDigest().Bytes(), digest) {
|
|
return ErrInvalidMixDigest
|
|
}
|
|
target := new(big.Int).Div(maxUint256, difficulty)
|
|
if new(big.Int).SetBytes(result).Cmp(target) > 0 {
|
|
return ErrInvalidPoW
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// cache tries to retrieve a verification cache for the specified block number
|
|
// by first checking against a list of in-memory caches, then against caches
|
|
// stored on disk, and finally generating one if none can be found.
|
|
func (ethash *Ethash) cache(block uint64) []uint32 {
|
|
epoch := block / epochLength
|
|
|
|
// If we have a PoW for that epoch, use that
|
|
ethash.lock.Lock()
|
|
|
|
current, future := ethash.caches[epoch], (*cache)(nil)
|
|
if current == nil {
|
|
// No in-memory cache, evict the oldest if the cache limit was reached
|
|
for len(ethash.caches) >= ethash.cachesinmem {
|
|
var evict *cache
|
|
for _, cache := range ethash.caches {
|
|
if evict == nil || evict.used.After(cache.used) {
|
|
evict = cache
|
|
}
|
|
}
|
|
delete(ethash.caches, evict.epoch)
|
|
|
|
log.Debug("Evicted ethash cache", "epoch", evict.epoch, "used", evict.used)
|
|
}
|
|
// If we have the new cache pre-generated, use that, otherwise create a new one
|
|
if ethash.fcache != nil && ethash.fcache.epoch == epoch {
|
|
log.Debug("Using pre-generated cache", "epoch", epoch)
|
|
current, ethash.fcache = ethash.fcache, nil
|
|
} else {
|
|
log.Debug("Requiring new ethash cache", "epoch", epoch)
|
|
current = &cache{epoch: epoch}
|
|
}
|
|
ethash.caches[epoch] = current
|
|
|
|
// If we just used up the future cache, or need a refresh, regenerate
|
|
if ethash.fcache == nil || ethash.fcache.epoch <= epoch {
|
|
log.Debug("Requiring new future ethash cache", "epoch", epoch+1)
|
|
future = &cache{epoch: epoch + 1}
|
|
ethash.fcache = future
|
|
}
|
|
}
|
|
current.used = time.Now()
|
|
ethash.lock.Unlock()
|
|
|
|
// Wait for generation finish, bump the timestamp and finalize the cache
|
|
current.generate(ethash.cachedir, ethash.cachesondisk, ethash.tester)
|
|
|
|
current.lock.Lock()
|
|
current.used = time.Now()
|
|
current.lock.Unlock()
|
|
|
|
// If we exhausted the future cache, now's a good time to regenerate it
|
|
if future != nil {
|
|
go future.generate(ethash.cachedir, ethash.cachesondisk, ethash.tester)
|
|
}
|
|
return current.cache
|
|
}
|
|
|
|
// Search implements PoW, attempting to find a nonce that satisfies the block's
|
|
// difficulty requirements.
|
|
func (ethash *Ethash) Search(block Block, stop <-chan struct{}) (uint64, []byte) {
|
|
// Extract some data from the block
|
|
var (
|
|
hash = block.HashNoNonce().Bytes()
|
|
diff = block.Difficulty()
|
|
target = new(big.Int).Div(maxUint256, diff)
|
|
)
|
|
// Retrieve the mining dataset
|
|
dataset, size := ethash.dataset(block.NumberU64()), datasetSize(block.NumberU64())
|
|
|
|
// Start generating random nonces until we abort or find a good one
|
|
var (
|
|
attempts int64
|
|
|
|
rand = rand.New(rand.NewSource(time.Now().UnixNano()))
|
|
nonce = uint64(rand.Int63())
|
|
)
|
|
for {
|
|
select {
|
|
case <-stop:
|
|
// Mining terminated, update stats and abort
|
|
ethash.hashrate.Mark(attempts)
|
|
return 0, nil
|
|
|
|
default:
|
|
// We don't have to update hash rate on every nonce, so update after after 2^X nonces
|
|
attempts++
|
|
if (attempts % (1 << 15)) == 0 {
|
|
ethash.hashrate.Mark(attempts)
|
|
attempts = 0
|
|
}
|
|
// Compute the PoW value of this nonce
|
|
digest, result := hashimotoFull(size, dataset, hash, nonce)
|
|
if new(big.Int).SetBytes(result).Cmp(target) <= 0 {
|
|
return nonce, digest
|
|
}
|
|
nonce++
|
|
}
|
|
}
|
|
}
|
|
|
|
// dataset tries to retrieve a mining dataset for the specified block number
|
|
// by first checking against a list of in-memory datasets, then against DAGs
|
|
// stored on disk, and finally generating one if none can be found.
|
|
func (ethash *Ethash) dataset(block uint64) []uint32 {
|
|
epoch := block / epochLength
|
|
|
|
// If we have a PoW for that epoch, use that
|
|
ethash.lock.Lock()
|
|
|
|
current, future := ethash.datasets[epoch], (*dataset)(nil)
|
|
if current == nil {
|
|
// No in-memory dataset, evict the oldest if the dataset limit was reached
|
|
for len(ethash.datasets) >= ethash.dagsinmem {
|
|
var evict *dataset
|
|
for _, dataset := range ethash.datasets {
|
|
if evict == nil || evict.used.After(dataset.used) {
|
|
evict = dataset
|
|
}
|
|
}
|
|
delete(ethash.datasets, evict.epoch)
|
|
|
|
log.Debug("Evicted ethash dataset", "epoch", evict.epoch, "used", evict.used)
|
|
}
|
|
// If we have the new cache pre-generated, use that, otherwise create a new one
|
|
if ethash.fdataset != nil && ethash.fdataset.epoch == epoch {
|
|
log.Debug("Using pre-generated dataset", "epoch", epoch)
|
|
current = &dataset{epoch: ethash.fdataset.epoch} // Reload from disk
|
|
ethash.fdataset = nil
|
|
} else {
|
|
log.Debug("Requiring new ethash dataset", "epoch", epoch)
|
|
current = &dataset{epoch: epoch}
|
|
}
|
|
ethash.datasets[epoch] = current
|
|
|
|
// If we just used up the future dataset, or need a refresh, regenerate
|
|
if ethash.fdataset == nil || ethash.fdataset.epoch <= epoch {
|
|
log.Debug("Requiring new future ethash dataset", "epoch", epoch+1)
|
|
future = &dataset{epoch: epoch + 1}
|
|
ethash.fdataset = future
|
|
}
|
|
}
|
|
current.used = time.Now()
|
|
ethash.lock.Unlock()
|
|
|
|
// Wait for generation finish, bump the timestamp and finalize the cache
|
|
current.generate(ethash.dagdir, ethash.dagsondisk, ethash.tester, false)
|
|
|
|
current.lock.Lock()
|
|
current.used = time.Now()
|
|
current.lock.Unlock()
|
|
|
|
// If we exhausted the future dataset, now's a good time to regenerate it
|
|
if future != nil {
|
|
go future.generate(ethash.dagdir, ethash.dagsondisk, ethash.tester, true) // Discard results from memorys
|
|
}
|
|
return current.dataset
|
|
}
|
|
|
|
// Hashrate implements PoW, returning the measured rate of the search invocations
|
|
// per second over the last minute.
|
|
func (ethash *Ethash) Hashrate() float64 {
|
|
return ethash.hashrate.Rate1()
|
|
}
|
|
|
|
// EthashSeedHash is the seed to use for generating a vrification cache and the
|
|
// mining dataset.
|
|
func EthashSeedHash(block uint64) []byte {
|
|
return seedHash(block)
|
|
}
|