minor dag config changes

Author: nottug

cmd/gen-lookup/main.go

@@ -21,7 +21,7 @@ func genCacheLookupTable(initBytes, growthBytes uint64, epochs int) []uint64 {
 
 	lookupTable := make([]uint64, epochs)
 	for i := range lookupTable {
-		lookupTable[i] = dag.CacheSize(cfg, uint64(i))
+		lookupTable[i] = cfg.CacheSize(uint64(i))
 	}
 
 	return lookupTable
@@ -35,7 +35,7 @@ func genDatasetLookupTable(initBytes, growthBytes uint64, epochs int) []uint64 {
 
 	lookupTable := make([]uint64, epochs)
 	for i := range lookupTable {
-		lookupTable[i] = dag.DatasetSize(cfg, uint64(i))
+		lookupTable[i] = cfg.DatasetSize(uint64(i))
 	}
 
 	return lookupTable

ethash/client.go

@@ -97,13 +97,13 @@ func NewEthereumClassic() *Ethash {
 }
 
 func (e *Ethash) Compute(height, nonce uint64, hash []byte) ([]byte, []byte) {
-	epoch := dag.CalcEpoch(e.cfg, height)
-	size := dag.DatasetSize(e.cfg, epoch)
+	epoch := e.cfg.CalcEpoch(height)
+	size := e.cfg.DatasetSize(epoch)
 	cache := e.dag.GetCache(epoch)
 
 	keccak512Hasher := crypto.NewKeccak512Hasher()
 	lookup := func(index uint32) []uint32 {
-		return dag.GenerateDatasetItem512(e.cfg, cache.Cache(), index, keccak512Hasher)
+		return e.cfg.GenerateDatasetItem512(cache.Cache(), index, keccak512Hasher)
 	}
 
 	mix, digest := hashimoto(hash, nonce, size, lookup)

firopow/client.go

@@ -55,13 +55,13 @@ func NewFiro() *Firopow {
 }
 
 func (e *Firopow) Compute(height, nonce uint64, hash []byte) ([]byte, []byte) {
-	epoch := dag.CalcEpoch(e.cfg, height)
-	datasetSize := dag.DatasetSize(e.cfg, epoch)
+	epoch := e.cfg.CalcEpoch(height)
+	datasetSize := e.cfg.DatasetSize(epoch)
 	cache := e.dag.GetCache(epoch)
 
 	keccak512Hasher := crypto.NewKeccak512Hasher()
 	lookup := func(index uint32) []uint32 {
-		return dag.GenerateDatasetItem2048(e.cfg, cache.Cache(), index, keccak512Hasher)
+		return e.cfg.GenerateDatasetItem2048(cache.Cache(), index, keccak512Hasher)
 	}
 
 	mix, digest := compute(hash, height, nonce, datasetSize, lookup, cache.L1())

internal/dag/cache.go

@@ -17,24 +17,12 @@
 package dag
 
 import (
-	"fmt"
 	"os"
-	"path/filepath"
 	"runtime"
 	"sync"
 	"time"
 )
 
-func cachePaths(cfg *Config, seed []byte) (string, string) {
-	cacheName := fmt.Sprintf("cache-%s-R%d-%x", cfg.Name, cfg.Revision, seed)
-	l1Name := fmt.Sprintf("l1-%s-R%d-%x", cfg.Name, cfg.Revision, seed)
-
-	cachePath := filepath.Join(cfg.StorageDir, cacheName)
-	l1Path := filepath.Join(cfg.StorageDir, l1Name)
-
-	return cachePath, l1Path
-}
-
 type cache struct {
 	epoch uint64
 	once  sync.Once
@@ -54,23 +42,24 @@ func (c *cache) L1() []uint32 {
 // generate ensures that the cache content is generated before use.
 func (c *cache) generate(cfg *Config) {
 	c.once.Do(func() {
-		size := CacheSize(cfg, c.epoch)
-		seed := SeedHash(cfg, c.epoch*cfg.EpochLength+1)
+		size := cfg.CacheSize(c.epoch)
+		seed := cfg.SeedHash(c.epoch*cfg.EpochLength + 1)
 
 		// If we don't store anything on disk, generate and return.
 		if cfg.StorageDir == "" {
 			c.cache.data = make([]uint32, size/4)
-			generateCache(cfg, c.cache.data, c.epoch, seed)
+			cfg.generateCache(c.cache.data, c.epoch, seed)
 
 			if cfg.L1Enabled {
 				c.l1.data = make([]uint32, cfg.L1CacheNumItems)
-				generateL1Cache(cfg, c.l1.data, c.cache.data)
+				cfg.generateL1Cache(c.l1.data, c.cache.data)
 			}
 
 			return
 		}
 
-		cachePath, l1Path := cachePaths(cfg, seed[:8])
+		cachePath := cfg.cacheStorageLocation(seed[:8])
+		l1Path := cfg.l1StorageLocation(seed[:8])
 
 		// We're about to mmap the file, ensure that the mapping is cleaned up when the
 		// cache becomes unused.
@@ -93,28 +82,31 @@ func (c *cache) generate(cfg *Config) {
 
 		// No usable previous cache available, create a new cache file to fill
 		if needsCache {
-			cacheGenerator := func(buffer []uint32) { generateCache(cfg, buffer, c.epoch, seed) }
+			cacheGenerator := func(buffer []uint32) { cfg.generateCache(buffer, c.epoch, seed) }
 			c.cache, err = memoryMapAndGenerate(cachePath, size, cfg.CachesLockMmap, cacheGenerator)
 			if err != nil {
 				c.cache.data = make([]uint32, size/4)
-				generateCache(cfg, c.cache.data, c.epoch, seed)
+				cfg.generateCache(c.cache.data, c.epoch, seed)
 			}
 		}
 
 		if needsL1 {
-			l1Generator := func(buffer []uint32) { generateL1Cache(cfg, buffer, c.cache.data) }
+			l1Generator := func(buffer []uint32) { cfg.generateL1Cache(buffer, c.cache.data) }
 			c.l1, err = memoryMapAndGenerate(l1Path, cfg.L1CacheSize, cfg.CachesLockMmap, l1Generator)
 			if err != nil {
 				c.l1.data = make([]uint32, cfg.L1CacheNumItems)
-				generateL1Cache(cfg, c.l1.data, c.cache.data)
+				cfg.generateL1Cache(c.l1.data, c.cache.data)
 			}
 		}
 
 		// Iterate over all previous instances and delete old ones
 		for ep := int(c.epoch) - cfg.CachesCount; ep >= 0; ep-- {
-			seed := SeedHash(cfg, uint64(ep)*cfg.EpochLength+1)
-			cachePath, l1Path := cachePaths(cfg, seed[:8])
+			seed := cfg.SeedHash(uint64(ep)*cfg.EpochLength + 1)
+
+			cachePath := cfg.cacheStorageLocation(seed[:8])
 			os.Remove(cachePath)
+
+			l1Path := cfg.l1StorageLocation(seed[:8])
 			os.Remove(l1Path)
 		}
 	})

internal/dag/calculate.go

@@ -16,12 +16,34 @@
 
 package dag
 
+import (
+	"fmt"
+	"math/big"
+	"path/filepath"
+
+	"github.com/sencha-dev/powkit/internal/crypto"
+)
+
 const (
 	mixBytes  = 128 // Width of mix
 	hashBytes = 64  // Hash length in bytes
 	hashWords = 16  // Number of 32 bit ints in a hash
 )
 
+type LookupTable struct {
+	maxEpoch uint64
+	table    []uint64
+}
+
+func NewLookupTable(table []uint64, maxEpoch uint64) *LookupTable {
+	lookupTable := &LookupTable{
+		maxEpoch: maxEpoch,
+		table:    table,
+	}
+
+	return lookupTable
+}
+
 type Config struct {
 	Name       string
 	Revision   int
@@ -53,16 +75,78 @@ type Config struct {
 	L1CacheNumItems uint
 }
 
-type LookupTable struct {
-	maxEpoch uint64
-	table    []uint64
+/* helpers */
+
+func (cfg *Config) cacheStorageLocation(seed []byte) string {
+	name := fmt.Sprintf("cache-%s-R%d-%x", cfg.Name, cfg.Revision, seed)
+	path := filepath.Join(cfg.StorageDir, name)
+
+	return path
 }
 
-func NewLookupTable(table []uint64, maxEpoch uint64) *LookupTable {
-	lookupTable := &LookupTable{
-		maxEpoch: maxEpoch,
-		table:    table,
+func (cfg *Config) l1StorageLocation(seed []byte) string {
+	name := fmt.Sprintf("l1-%s-R%d-%x", cfg.Name, cfg.Revision, seed)
+	path := filepath.Join(cfg.StorageDir, name)
+
+	return path
+}
+
+/* calculations */
+
+func (cfg *Config) CalcEpoch(height uint64) uint64 {
+	epoch := height / cfg.EpochLength
+
+	return epoch
+}
+
+func (cfg *Config) SeedHash(height uint64) []byte {
+	seed := make([]byte, 32)
+	if height < cfg.SeedEpochLength {
+		return seed
 	}
 
-	return lookupTable
+	keccak256Hasher := crypto.NewKeccak256Hasher()
+	for i := 0; i < int(height/cfg.SeedEpochLength); i++ {
+		keccak256Hasher(seed, seed)
+	}
+
+	return seed
+}
+
+func (cfg *Config) CacheSize(epoch uint64) uint64 {
+	if cfg.CacheSizes != nil && epoch < cfg.CacheSizes.maxEpoch {
+		return cfg.CacheSizes.table[epoch]
+	}
+
+	return cfg.calcCacheSize(epoch)
+}
+
+func (cfg *Config) DatasetSize(epoch uint64) uint64 {
+	if cfg.DatasetSizes != nil && epoch < cfg.DatasetSizes.maxEpoch {
+		return cfg.DatasetSizes.table[epoch]
+	}
+
+	return cfg.calcDatasetSize(epoch)
+}
+
+func (cfg *Config) calcCacheSize(epoch uint64) uint64 {
+	size := cfg.CacheInitBytes + cfg.CacheGrowthBytes*epoch - hashBytes
+
+	// Always accurate for n < 2^64
+	for !new(big.Int).SetUint64(size / hashBytes).ProbablyPrime(1) {
+		size -= 2 * hashBytes
+	}
+
+	return size
+}
+
+func (cfg *Config) calcDatasetSize(epoch uint64) uint64 {
+	size := cfg.DatasetInitBytes + cfg.DatasetGrowthBytes*epoch - mixBytes
+
+	// Always accurate for n < 2^64
+	for !new(big.Int).SetUint64(size / mixBytes).ProbablyPrime(1) {
+		size -= 2 * mixBytes
+	}
+
+	return size
 }

internal/dag/config.go

@@ -87,7 +87,7 @@ func TestEpochNumber(t *testing.T) {
 	}
 
 	for i, tt := range tests {
-		epoch := CalcEpoch(cfg, tt.height)
+		epoch := cfg.CalcEpoch(tt.height)
 
 		if epoch != tt.epoch {
 			t.Errorf("failed on %d: epoch mismatch: have %d want %d", i, epoch, tt.epoch)
@@ -153,7 +153,7 @@ func TestSeedHash(t *testing.T) {
 	}
 
 	for i, tt := range tests {
-		seed := SeedHash(cfg, uint64(tt.epoch)*cfg.EpochLength+1)
+		seed := cfg.SeedHash(uint64(tt.epoch)*cfg.EpochLength + 1)
 		if !reflect.DeepEqual(seed, tt.seed) {
 			t.Errorf("failed on %d: seed mismatch: have %x, want %x", i, seed, tt.seed)
 		}
@@ -232,7 +232,7 @@ func TestCalcCacheSize(t *testing.T) {
 	}
 
 	for i, tt := range tests {
-		size := calcCacheSize(cfg, tt.epoch)
+		size := cfg.calcCacheSize(tt.epoch)
 		if size != tt.size {
 			t.Errorf("failed on %d: size mismatch: have %d, want %d", i, size, tt.size)
 		}
@@ -311,7 +311,7 @@ func TestCalcDatasetSize(t *testing.T) {
 	}
 
 	for i, tt := range tests {
-		size := calcDatasetSize(cfg, tt.epoch)
+		size := cfg.calcDatasetSize(tt.epoch)
 		if size != tt.size {
 			t.Errorf("failed on %d: size mismatch: have %d, want %d", i, size, tt.size)
 		}