core/rawdb: inspect database in parallel

Signed-off-by: jsvisa <delweng@gmail.com>

core/rawdb/database.go

@@ -25,6 +25,8 @@ import (
 	"path/filepath"
 	"slices"
 	"strings"
+	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -32,6 +34,7 @@ import (
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/ethdb/memorydb"
 	"github.com/ethereum/go-ethereum/log"
+	"golang.org/x/sync/errgroup"
 )
 
 var ErrDeleteRangeInterrupted = errors.New("safe delete range operation interrupted")
@@ -362,38 +365,40 @@ func (c counter) Percentage(current uint64) string {
 	return fmt.Sprintf("%d", current*100/uint64(c))
 }
 
-// stat stores sizes and count for a parameter
+// stat provides lock-free statistics aggregation using atomic operations
 type stat struct {
-	size  common.StorageSize
+	size  uint64 // stored as uint64 for atomic operations
-	count counter
+	count uint64
 }
 
-// Add size to the stat and increase the counter by 1
 func (s *stat) Add(size common.StorageSize) {
-	s.size += size
+	atomic.AddUint64(&s.size, uint64(size))
-	s.count++
+	atomic.AddUint64(&s.count, 1)
 }
 
 func (s *stat) Size() string {
-	return s.size.String()
+	return common.StorageSize(atomic.LoadUint64(&s.size)).String()
 }
 
 func (s *stat) Count() string {
-	return s.count.String()
+	return counter(atomic.LoadUint64(&s.count)).String()
+}
+
+func (s *stat) GetSize() common.StorageSize {
+	return common.StorageSize(atomic.LoadUint64(&s.size))
+}
+
+func (s *stat) GetCount() counter {
+	return counter(atomic.LoadUint64(&s.count))
 }
 
 // InspectDatabase traverses the entire database and checks the size
 // of all different categories of data.
 func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error {
-	it := db.NewIterator(keyPrefix, keyStart)
-	defer it.Release()
-
 	var (
-		count  int64
 		start = time.Now()
-		logged = time.Now()
 
-		// Key-value store statistics
+		// Key-value store statistics (lock-free with atomic operations)
 		headers            stat
 		bodies             stat
 		receipts           stat
@@ -428,20 +433,26 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error {
 		unaccounted stat
 
 		// Totals
-		total common.StorageSize
+		totalSize  uint64
+		totalCount int64
 
-		// This map tracks example keys for unaccounted data.
-		// For each unique two-byte prefix, the first unaccounted key encountered
-		// by the iterator will be stored.
 		unaccountedKeys = make(map[[2]byte][]byte)
+		unaccountedMu   sync.Mutex
 	)
-	// Inspect key-value database first.
+
+	// Create worker function to process key ranges
+	processRange := func(rangePrefix []byte) error {
+		it := db.NewIterator(slices.Concat(keyPrefix, rangePrefix), keyStart)
+		defer it.Release()
+
 		for it.Next() {
 			var (
 				key  = it.Key()
 				size = common.StorageSize(len(key) + len(it.Value()))
 			)
-		total += size
+			atomic.AddUint64(&totalSize, uint64(size))
+			atomic.AddInt64(&totalCount, 1)
+
 			switch {
 			case bytes.HasPrefix(key, headerPrefix) && len(key) == (len(headerPrefix)+8+common.HashLength):
 				headers.Add(size)
@@ -481,26 +492,18 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error {
 				beaconHeaders.Add(size)
 			case bytes.HasPrefix(key, CliqueSnapshotPrefix) && len(key) == 7+common.HashLength:
 				cliqueSnaps.Add(size)
-
-		// new log index
 			case bytes.HasPrefix(key, filterMapRowPrefix) && len(key) <= len(filterMapRowPrefix)+9:
 				filterMapRows.Add(size)
 			case bytes.HasPrefix(key, filterMapLastBlockPrefix) && len(key) == len(filterMapLastBlockPrefix)+4:
 				filterMapLastBlock.Add(size)
 			case bytes.HasPrefix(key, filterMapBlockLVPrefix) && len(key) == len(filterMapBlockLVPrefix)+8:
 				filterMapBlockLV.Add(size)
-
-		// old log index (deprecated)
 			case bytes.HasPrefix(key, bloomBitsPrefix) && len(key) == (len(bloomBitsPrefix)+10+common.HashLength):
 				bloomBits.Add(size)
 			case bytes.HasPrefix(key, bloomBitsMetaPrefix) && len(key) < len(bloomBitsMetaPrefix)+8:
 				bloomBits.Add(size)
-
-		// Path-based historic state indexes
 			case bytes.HasPrefix(key, StateHistoryIndexPrefix) && len(key) >= len(StateHistoryIndexPrefix)+common.HashLength:
 				stateIndex.Add(size)
-
-		// Verkle trie data is detected, determine the sub-category
 			case bytes.HasPrefix(key, VerklePrefix):
 				remain := key[len(VerklePrefix):]
 				switch {
@@ -517,26 +520,41 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error {
 				default:
 					unaccounted.Add(size)
 				}
-
-		// Metadata keys
 			case slices.ContainsFunc(knownMetadataKeys, func(x []byte) bool { return bytes.Equal(x, key) }):
 				metadata.Add(size)
-
 			default:
 				unaccounted.Add(size)
 				if len(key) >= 2 {
 					prefix := [2]byte(key[:2])
+					unaccountedMu.Lock()
 					if _, ok := unaccountedKeys[prefix]; !ok {
 						unaccountedKeys[prefix] = bytes.Clone(key)
 					}
+					unaccountedMu.Unlock()
 				}
 			}
-		count++
-		if count%1000 == 0 && time.Since(logged) > 8*time.Second {
-			log.Info("Inspecting database", "count", count, "elapsed", common.PrettyDuration(time.Since(start)))
-			logged = time.Now()
 		}
+
+		return it.Error()
 	}
+
+	// Create error group for parallel processing
+	var g errgroup.Group
+
+	// Split key space into 256 ranges (0x00 to 0xFF)
+	log.Info("Starting parallel database inspection", "workers", 256)
+	for i := 0; i < 256; i++ {
+		rangePrefix := []byte{byte(i)}
+		g.Go(func() error {
+			return processRange(rangePrefix)
+		})
+	}
+
+	// Wait for all workers to complete
+	if err := g.Wait(); err != nil {
+		return err
+	}
+
 	// Display the database statistic of key-value store.
 	stats := [][]string{
 		{"Key-Value store", "Headers", headers.Size(), headers.Count()},
@@ -565,11 +583,18 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error {
 		{"Key-Value store", "Clique snapshots", cliqueSnaps.Size(), cliqueSnaps.Count()},
 		{"Key-Value store", "Singleton metadata", metadata.Size(), metadata.Count()},
 	}
+
 	// Inspect all registered append-only file store then.
 	ancients, err := inspectFreezers(db)
 	if err != nil {
+		// If freezer inspection is not supported, continue without ancient data
+		if err.Error() == "this operation is not supported" {
+			log.Warn("Freezer inspection not supported, skipping ancient data")
+			ancients = nil
+		} else {
 			return err
 		}
+	}
 	for _, ancient := range ancients {
 		for _, table := range ancient.sizes {
 			stats = append(stats, []string{
@@ -579,16 +604,19 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error {
 				fmt.Sprintf("%d", ancient.count()),
 			})
 		}
-		total += ancient.size()
+		atomic.AddUint64(&totalSize, uint64(ancient.size()))
 	}
+
 	table := newTableWriter(os.Stdout)
 	table.SetHeader([]string{"Database", "Category", "Size", "Items"})
-	table.SetFooter([]string{"", "Total", total.String(), " "})
+	table.SetFooter([]string{"", "Total", common.StorageSize(atomic.LoadUint64(&totalSize)).String(), fmt.Sprintf("%d", atomic.LoadInt64(&totalCount))})
 	table.AppendBulk(stats)
 	table.Render()
 
-	if unaccounted.size > 0 {
+	log.Info("Parallel database inspection completed", "total_entries", atomic.LoadInt64(&totalCount), "elapsed", common.PrettyDuration(time.Since(start)))
-		log.Error("Database contains unaccounted data", "size", unaccounted.size, "count", unaccounted.count)
+
+	if unaccounted.GetSize() > 0 {
+		log.Error("Database contains unaccounted data", "size", unaccounted.GetSize(), "count", unaccounted.GetCount())
 		for _, e := range slices.SortedFunc(maps.Values(unaccountedKeys), bytes.Compare) {
 			log.Error(fmt.Sprintf("   example key: %x", e))
 		}