forked from mirror/go-ethereum
Péter Szilágyi
3 years ago
parent
5e78fc034b
commit
58d1988349
@ -1,191 +0,0 @@ |
|||||||
// Copyright 2019 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 trie |
|
||||||
|
|
||||||
import ( |
|
||||||
"encoding/binary" |
|
||||||
"fmt" |
|
||||||
"sync" |
|
||||||
"sync/atomic" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/ethereum/go-ethereum/common" |
|
||||||
"github.com/ethereum/go-ethereum/core/rawdb" |
|
||||||
"github.com/ethereum/go-ethereum/ethdb" |
|
||||||
"github.com/ethereum/go-ethereum/log" |
|
||||||
"github.com/ethereum/go-ethereum/metrics" |
|
||||||
bloomfilter "github.com/holiman/bloomfilter/v2" |
|
||||||
) |
|
||||||
|
|
||||||
var ( |
|
||||||
bloomAddMeter = metrics.NewRegisteredMeter("trie/bloom/add", nil) |
|
||||||
bloomLoadMeter = metrics.NewRegisteredMeter("trie/bloom/load", nil) |
|
||||||
bloomTestMeter = metrics.NewRegisteredMeter("trie/bloom/test", nil) |
|
||||||
bloomMissMeter = metrics.NewRegisteredMeter("trie/bloom/miss", nil) |
|
||||||
bloomFaultMeter = metrics.NewRegisteredMeter("trie/bloom/fault", nil) |
|
||||||
bloomErrorGauge = metrics.NewRegisteredGauge("trie/bloom/error", nil) |
|
||||||
) |
|
||||||
|
|
||||||
// SyncBloom is a bloom filter used during fast sync to quickly decide if a trie
|
|
||||||
// node or contract code already exists on disk or not. It self populates from the
|
|
||||||
// provided disk database on creation in a background thread and will only start
|
|
||||||
// returning live results once that's finished.
|
|
||||||
type SyncBloom struct { |
|
||||||
bloom *bloomfilter.Filter |
|
||||||
inited uint32 |
|
||||||
closer sync.Once |
|
||||||
closed uint32 |
|
||||||
pend sync.WaitGroup |
|
||||||
closeCh chan struct{} |
|
||||||
} |
|
||||||
|
|
||||||
// NewSyncBloom creates a new bloom filter of the given size (in megabytes) and
|
|
||||||
// initializes it from the database. The bloom is hard coded to use 3 filters.
|
|
||||||
func NewSyncBloom(memory uint64, database ethdb.Iteratee) *SyncBloom { |
|
||||||
// Create the bloom filter to track known trie nodes
|
|
||||||
bloom, err := bloomfilter.New(memory*1024*1024*8, 4) |
|
||||||
if err != nil { |
|
||||||
panic(fmt.Sprintf("failed to create bloom: %v", err)) |
|
||||||
} |
|
||||||
log.Info("Allocated fast sync bloom", "size", common.StorageSize(memory*1024*1024)) |
|
||||||
|
|
||||||
// Assemble the fast sync bloom and init it from previous sessions
|
|
||||||
b := &SyncBloom{ |
|
||||||
bloom: bloom, |
|
||||||
closeCh: make(chan struct{}), |
|
||||||
} |
|
||||||
b.pend.Add(2) |
|
||||||
go func() { |
|
||||||
defer b.pend.Done() |
|
||||||
b.init(database) |
|
||||||
}() |
|
||||||
go func() { |
|
||||||
defer b.pend.Done() |
|
||||||
b.meter() |
|
||||||
}() |
|
||||||
return b |
|
||||||
} |
|
||||||
|
|
||||||
// init iterates over the database, pushing every trie hash into the bloom filter.
|
|
||||||
func (b *SyncBloom) init(database ethdb.Iteratee) { |
|
||||||
// Iterate over the database, but restart every now and again to avoid holding
|
|
||||||
// a persistent snapshot since fast sync can push a ton of data concurrently,
|
|
||||||
// bloating the disk.
|
|
||||||
//
|
|
||||||
// Note, this is fine, because everything inserted into leveldb by fast sync is
|
|
||||||
// also pushed into the bloom directly, so we're not missing anything when the
|
|
||||||
// iterator is swapped out for a new one.
|
|
||||||
it := database.NewIterator(nil, nil) |
|
||||||
|
|
||||||
var ( |
|
||||||
start = time.Now() |
|
||||||
swap = time.Now() |
|
||||||
) |
|
||||||
for it.Next() && atomic.LoadUint32(&b.closed) == 0 { |
|
||||||
// If the database entry is a trie node, add it to the bloom
|
|
||||||
key := it.Key() |
|
||||||
if len(key) == common.HashLength { |
|
||||||
b.bloom.AddHash(binary.BigEndian.Uint64(key)) |
|
||||||
bloomLoadMeter.Mark(1) |
|
||||||
} else if ok, hash := rawdb.IsCodeKey(key); ok { |
|
||||||
// If the database entry is a contract code, add it to the bloom
|
|
||||||
b.bloom.AddHash(binary.BigEndian.Uint64(hash)) |
|
||||||
bloomLoadMeter.Mark(1) |
|
||||||
} |
|
||||||
// If enough time elapsed since the last iterator swap, restart
|
|
||||||
if time.Since(swap) > 8*time.Second { |
|
||||||
key := common.CopyBytes(it.Key()) |
|
||||||
|
|
||||||
it.Release() |
|
||||||
it = database.NewIterator(nil, key) |
|
||||||
|
|
||||||
log.Info("Initializing state bloom", "items", b.bloom.N(), "errorrate", b.bloom.FalsePosititveProbability(), "elapsed", common.PrettyDuration(time.Since(start))) |
|
||||||
swap = time.Now() |
|
||||||
} |
|
||||||
} |
|
||||||
it.Release() |
|
||||||
|
|
||||||
// Mark the bloom filter inited and return
|
|
||||||
log.Info("Initialized state bloom", "items", b.bloom.N(), "errorrate", b.bloom.FalsePosititveProbability(), "elapsed", common.PrettyDuration(time.Since(start))) |
|
||||||
atomic.StoreUint32(&b.inited, 1) |
|
||||||
} |
|
||||||
|
|
||||||
// meter periodically recalculates the false positive error rate of the bloom
|
|
||||||
// filter and reports it in a metric.
|
|
||||||
func (b *SyncBloom) meter() { |
|
||||||
// check every second
|
|
||||||
tick := time.NewTicker(1 * time.Second) |
|
||||||
defer tick.Stop() |
|
||||||
|
|
||||||
for { |
|
||||||
select { |
|
||||||
case <-tick.C: |
|
||||||
// Report the current error ration. No floats, lame, scale it up.
|
|
||||||
bloomErrorGauge.Update(int64(b.bloom.FalsePosititveProbability() * 100000)) |
|
||||||
case <-b.closeCh: |
|
||||||
return |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Close terminates any background initializer still running and releases all the
|
|
||||||
// memory allocated for the bloom.
|
|
||||||
func (b *SyncBloom) Close() error { |
|
||||||
b.closer.Do(func() { |
|
||||||
// Ensure the initializer is stopped
|
|
||||||
atomic.StoreUint32(&b.closed, 1) |
|
||||||
close(b.closeCh) |
|
||||||
b.pend.Wait() |
|
||||||
|
|
||||||
// Wipe the bloom, but mark it "uninited" just in case someone attempts an access
|
|
||||||
log.Info("Deallocated state bloom", "items", b.bloom.N(), "errorrate", b.bloom.FalsePosititveProbability()) |
|
||||||
|
|
||||||
atomic.StoreUint32(&b.inited, 0) |
|
||||||
b.bloom = nil |
|
||||||
}) |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
// Add inserts a new trie node hash into the bloom filter.
|
|
||||||
func (b *SyncBloom) Add(hash []byte) { |
|
||||||
if atomic.LoadUint32(&b.closed) == 1 { |
|
||||||
return |
|
||||||
} |
|
||||||
b.bloom.AddHash(binary.BigEndian.Uint64(hash)) |
|
||||||
bloomAddMeter.Mark(1) |
|
||||||
} |
|
||||||
|
|
||||||
// Contains tests if the bloom filter contains the given hash:
|
|
||||||
// - false: the bloom definitely does not contain hash
|
|
||||||
// - true: the bloom maybe contains hash
|
|
||||||
//
|
|
||||||
// While the bloom is being initialized, any query will return true.
|
|
||||||
func (b *SyncBloom) Contains(hash []byte) bool { |
|
||||||
bloomTestMeter.Mark(1) |
|
||||||
if atomic.LoadUint32(&b.inited) == 0 { |
|
||||||
// We didn't load all the trie nodes from the previous run of Geth yet. As
|
|
||||||
// such, we can't say for sure if a hash is not present for anything. Until
|
|
||||||
// the init is done, we're faking "possible presence" for everything.
|
|
||||||
return true |
|
||||||
} |
|
||||||
// Bloom initialized, check the real one and report any successful misses
|
|
||||||
maybe := b.bloom.ContainsHash(binary.BigEndian.Uint64(hash)) |
|
||||||
if !maybe { |
|
||||||
bloomMissMeter.Mark(1) |
|
||||||
} |
|
||||||
return maybe |
|
||||||
} |
|
||||||
Loading…
Reference in new issue