core/state: fix rebase problems

core/state/snapshot/difflayer.go

@@ -18,6 +18,7 @@ package snapshot
 
 import (
 	"encoding/binary"
+	"fmt"
 	"math"
 	"math/rand"
 	"sort"
@@ -119,17 +120,17 @@ type diffLayer struct {
 // accountBloomHash  is s used to convert an account
 // hash into a 64 bit mini hash.
 func accountBloomHash(h common.Hash) uint64 {
-	return binary.BigEndian.Uint64(h[bloomHasherOffset : bloomHasherOffset+8])
+	return binary.BigEndian.Uint64(h[bloomAccountHasherOffset : bloomAccountHasherOffset+8])
 }
 
 // storageBloomHash is used to convert an account + storage hash into a 64 bit mini hash.
 func storageBloomHash(accountHash, storageHash common.Hash) uint64 {
-	return binary.BigEndian.Uint64(accountHash[bloomHasherOffset:bloomHasherOffset+8]) ^
+	return binary.BigEndian.Uint64(accountHash[bloomStorageHasherOffset:bloomStorageHasherOffset+8]) ^
-		binary.BigEndian.Uint64(storageHash[bloomHasherOffset:bloomHasherOffset+8])
+		binary.BigEndian.Uint64(storageHash[bloomStorageHasherOffset:bloomStorageHasherOffset+8])
 }
 
 // destructBloomHash is used to convert a destruct event into a 64 bit mini hash.
-func destructBloomHash(accountHash common.Hash) uint64 {
+func destructBloomHash(h common.Hash) uint64 {
 	return binary.BigEndian.Uint64(h[bloomDestructHasherOffset : bloomDestructHasherOffset+8])
 }
 
@@ -168,7 +169,7 @@ func (dl *diffLayer) initBloom() {
 	}
 	// Iterate over all the accounts and storage slots and index them
 	for hash := range dl.destructSet {
-		dl.diffed.Add(destructBloomHasher(hash))
+		dl.diffed.AddHash(destructBloomHash(hash))
 	}
 	// Also count memory consumption while we're at it
 	dl.memory = 0
@@ -340,7 +341,7 @@ func (dl *diffLayer) Storage(accountHash, storageHash common.Hash) ([]byte, erro
 	dl.lock.RLock()
 	hit := dl.cumulative.ContainsHash(storageBloomHash(accountHash, storageHash))
 	if !hit {
-		hit = dl.cumulative.Contains(destructBloomHash(accountHash))
+		hit = dl.cumulative.ContainsHash(destructBloomHash(accountHash))
 	}
 	dl.lock.RUnlock()
 

core/state/snapshot/difflayer_test.go

@@ -150,7 +150,8 @@ func TestMergeDelete(t *testing.T) {
 		}
 	}
 	// Add some flipAccs-flopping layers on top
-	parent := newDiffLayer(emptyLayer(), common.Hash{}, flipDrops(), flipAccs(), storage)
+	disk := emptyLayer()
+	parent := newDiffLayer(disk, common.Hash{}, flipDrops(), flipAccs(), storage)
 	child := parent.Update(common.Hash{}, flopDrops(), flopAccs(), storage)
 	child = child.Update(common.Hash{}, flipDrops(), flipAccs(), storage)
 	child = child.Update(common.Hash{}, flopDrops(), flopAccs(), storage)
@@ -158,6 +159,8 @@ func TestMergeDelete(t *testing.T) {
 	child = child.Update(common.Hash{}, flopDrops(), flopAccs(), storage)
 	child = child.Update(common.Hash{}, flipDrops(), flipAccs(), storage)
 
+	child.Prepare(disk)
+
 	if data, _ := child.Account(h1); data == nil {
 		t.Errorf("last diff layer: expected %x account to be non-nil", h1)
 	}
@@ -172,7 +175,7 @@ func TestMergeDelete(t *testing.T) {
 	}
 	// And flatten
 	merged := (child.flatten()).(*diffLayer)
-
+	merged.Prepare(disk)
 	if data, _ := merged.Account(h1); data == nil {
 		t.Errorf("merged layer: expected %x account to be non-nil", h1)
 	}
@@ -201,6 +204,7 @@ func TestInsertAndMerge(t *testing.T) {
 		slot   = common.HexToHash("0x02")
 		parent *diffLayer
 		child  *diffLayer
+		disk   = emptyLayer()
 	)
 	{
 		var (
@@ -208,7 +212,7 @@ func TestInsertAndMerge(t *testing.T) {
 			accounts  = make(map[common.Hash][]byte)
 			storage   = make(map[common.Hash]map[common.Hash][]byte)
 		)
-		parent = newDiffLayer(emptyLayer(), common.Hash{}, destructs, accounts, storage)
+		parent = newDiffLayer(disk, common.Hash{}, destructs, accounts, storage)
 	}
 	{
 		var (
@@ -223,6 +227,7 @@ func TestInsertAndMerge(t *testing.T) {
 	}
 	// And flatten
 	merged := (child.flatten()).(*diffLayer)
+	merged.Prepare(disk)
 	{ // Check that slot value is present
 		have, _ := merged.Storage(acc, slot)
 		if want := []byte{0x01}; !bytes.Equal(have, want) {
@@ -413,7 +418,7 @@ func BenchmarkBloom(b *testing.B) {
 		for i := 0; i < 1000; i++ {
 			accounts[randomHash()] = randomAccount()
 		}
-		return newDiffLayer(parent, common.Hash{}, accounts, storage)
+		return newDiffLayer(parent, common.Hash{}, nil, accounts, storage)
 	}
 	var layer snapshot
 	layer = emptyLayer()

core/state/state_object.go

@@ -329,17 +329,12 @@ func (s *stateObject) updateTrie(db Database) Trie {
 			// lazy load storage
 			if storage == nil {
 				// Retrieve the old storage map, if available
-				s.db.snapLock.RLock()
 				storage = s.db.snapStorage[s.addrHash]
-				s.db.snapLock.RUnlock()
 
 				// If no old storage map was available, create a new one
 				if storage == nil {
 					storage = make(map[common.Hash][]byte)
-
-					s.db.snapLock.Lock()
 					s.db.snapStorage[s.addrHash] = storage
-					s.db.snapLock.Unlock()
 				}
 			}
 			storage[crypto.Keccak256Hash(key[:])] = v // v will be nil if value is 0x00

core/state/statedb.go

@@ -862,9 +862,6 @@ func (s *StateDB) Commit(deleteEmptyObjects bool) (common.Hash, error) {
 			if err := s.snaps.Update(root, parent, s.snapDestructs, s.snapAccounts, s.snapStorage); err != nil {
 				log.Warn("Failed to update snapshot tree", "from", parent, "to", root, "err", err)
 			}
-			if err := s.snaps.Cap(root, 127); err != nil { // Persistent layer is 128th, the last available trie
-				log.Warn("Failed to cap snapshot tree", "root", root, "layers", 127, "err", err)
-			}
 		}
 		s.snap, s.snapDestructs, s.snapAccounts, s.snapStorage = nil, nil, nil, nil
 	}