Expose pebble options

cmd/geth/main.go

@@ -160,7 +160,9 @@ var (
 		configFileFlag,
 		utils.LogDebugFlag,
 		utils.LogBacktraceAtFlag,
-	}, utils.NetworkFlags, utils.DatabaseFlags)
+	}, utils.NetworkFlags, utils.DatabaseFlags,
+		utils.PebbleFlags,
+	)
 
 	rpcFlags = []cli.Flag{
 		utils.HTTPEnabledFlag,

cmd/utils/flags.go

@@ -1720,6 +1720,9 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
 	setRequiredBlocks(ctx, cfg)
 	setLes(ctx, cfg)
 
+	setPebbleExtraOptions(ctx, cfg)
+	log.Debug("Set pebble extra options", "pebble_extra_options", cfg.PebbleExtraOptions)
+
 	// Cap the cache allowance and tune the garbage collector
 	mem, err := gopsutil.VirtualMemory()
 	if err == nil {
@@ -1947,7 +1950,7 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
 			if rawdb.ReadCanonicalHash(chaindb, 0) != (common.Hash{}) {
 				cfg.Genesis = nil // fallback to db content
 
-				//validate genesis has PoS enabled in block 0
+				// validate genesis has PoS enabled in block 0
 				genesis, err := core.ReadGenesis(chaindb)
 				if err != nil {
 					Fatalf("Could not read genesis from database: %v", err)

cmd/utils/pebble_extra.go

@@ -0,0 +1,176 @@
+package utils
+
+import (
+	"time"
+
+	"github.com/ethereum/go-ethereum/eth/ethconfig"
+	"github.com/ethereum/go-ethereum/ethdb/pebble"
+	"github.com/ethereum/go-ethereum/internal/flags"
+	"github.com/urfave/cli/v2"
+)
+
+var (
+	PebbleBytesPerSyncFlag = &cli.IntFlag{
+		Name:     "pebble.bytes-per-sync",
+		Category: flags.PebbleCategory,
+	}
+	PebbleL0CompactionFileThresholdFlag = &cli.IntFlag{
+		Name:     "pebble.l0-compaction-file-threshold",
+		Category: flags.PebbleCategory,
+	}
+	PebbleL0CompactionThresholdFlag = &cli.IntFlag{
+		Name:     "pebble.l0-compaction-threshold",
+		Category: flags.PebbleCategory,
+	}
+	PebbleL0StopWritesThresholdFlag = &cli.IntFlag{
+		Name:     "pebble.l0-stop-writes-threshold",
+		Category: flags.PebbleCategory,
+	}
+	PebbleLBaseMaxBytesFlag = &cli.Int64Flag{
+		Name:     "pebble.l-base-max-bytes",
+		Category: flags.PebbleCategory,
+	}
+	PebbleMemTableStopWritesThresholdFlag = &cli.IntFlag{
+		Name:     "pebble.mem-table-stop-writes-threshold",
+		Category: flags.PebbleCategory,
+	}
+	PebbleMaxConcurrentCompactionsFlag = &cli.IntFlag{
+		Name:     "pebble.max-concurrent-compactions",
+		Category: flags.PebbleCategory,
+	}
+	PebbleDisableAutomaticCompactionsFlag = &cli.BoolFlag{
+		Name:     "pebble.disable-automatic-compactions",
+		Category: flags.PebbleCategory,
+	}
+	PebbleWALBytesPerSyncFlag = &cli.IntFlag{
+		Name:     "pebble.wal-bytes-per-sync",
+		Category: flags.PebbleCategory,
+	}
+	PebbleWALDirFlag = &cli.StringFlag{
+		Name:     "pebble.wal-dir",
+		Category: flags.PebbleCategory,
+	}
+	PebbleWALMinSyncIntervalFlag = &cli.DurationFlag{
+		Name:     "pebble.wal-min-sync-interval",
+		Category: flags.PebbleCategory,
+	}
+	PebbleTargetByteDeletionRateFlag = &cli.IntFlag{
+		Name:     "pebble.target-byte-deletion-rate",
+		Category: flags.PebbleCategory,
+	}
+
+	// TODO: PebbleLevelOptions
+
+	// Experimental
+
+	PebbleL0CompactionConcurrencyFlag = &cli.IntFlag{
+		Name:     "pebble.l0-compaction-concurrency",
+		Category: flags.PebbleCategory,
+	}
+	PebbleCompactionDebtConcurrencyFlag = &cli.Uint64Flag{
+		Name:     "pebble.compaction-debt-concurrency",
+		Category: flags.PebbleCategory,
+	}
+	PebbleReadCompactionRateFlag = &cli.Int64Flag{
+		Name:     "pebble.read-compaction-rate",
+		Category: flags.PebbleCategory,
+	}
+	PebbleReadSamplingMultiplierFlag = &cli.Int64Flag{
+		Name:     "pebble.read-sampling-multiplier",
+		Category: flags.PebbleCategory,
+	}
+	PebbleMaxWriterConcurrencyFlag = &cli.IntFlag{
+		Name:     "pebble.max-writer-concurrency",
+		Category: flags.PebbleCategory,
+	}
+	PebbleForceWriterParallelismFlag = &cli.BoolFlag{
+		Name:     "pebble.force-writer-parallelism",
+		Category: flags.PebbleCategory,
+	}
+
+	PebbleFlags = []cli.Flag{
+		PebbleBytesPerSyncFlag,
+		PebbleL0CompactionFileThresholdFlag,
+		PebbleL0CompactionThresholdFlag,
+		PebbleL0StopWritesThresholdFlag,
+		PebbleLBaseMaxBytesFlag,
+		PebbleMemTableStopWritesThresholdFlag,
+		PebbleMaxConcurrentCompactionsFlag,
+		PebbleDisableAutomaticCompactionsFlag,
+		PebbleWALBytesPerSyncFlag,
+		PebbleWALDirFlag,
+		PebbleWALMinSyncIntervalFlag,
+		PebbleTargetByteDeletionRateFlag,
+		// Experimental
+		PebbleL0CompactionConcurrencyFlag,
+		PebbleCompactionDebtConcurrencyFlag,
+		PebbleReadCompactionRateFlag,
+		PebbleReadSamplingMultiplierFlag,
+		PebbleMaxWriterConcurrencyFlag,
+		PebbleForceWriterParallelismFlag,
+	}
+)
+
+func setPebbleExtraOptions(ctx *cli.Context, cfg *ethconfig.Config) {
+	peos := new(pebble.ExtraOptions)
+
+	if flag := PebbleBytesPerSyncFlag.Name; ctx.IsSet(flag) {
+		peos.BytesPerSync = ctx.Int(flag)
+	}
+	if flag := PebbleL0CompactionFileThresholdFlag.Name; ctx.IsSet(flag) {
+		peos.L0CompactionFileThreshold = ctx.Int(flag)
+	}
+	if flag := PebbleL0CompactionThresholdFlag.Name; ctx.IsSet(flag) {
+		peos.L0CompactionThreshold = ctx.Int(flag)
+	}
+	if flag := PebbleL0StopWritesThresholdFlag.Name; ctx.IsSet(flag) {
+		peos.L0StopWritesThreshold = ctx.Int(flag)
+	}
+	if flag := PebbleLBaseMaxBytesFlag.Name; ctx.IsSet(flag) {
+		peos.LBaseMaxBytes = ctx.Int64(flag)
+	}
+	if flag := PebbleMemTableStopWritesThresholdFlag.Name; ctx.IsSet(flag) {
+		peos.MemTableStopWritesThreshold = ctx.Int(flag)
+	}
+	if flag := PebbleMaxConcurrentCompactionsFlag.Name; ctx.IsSet(flag) {
+		peos.MaxConcurrentCompactions = func() int { return ctx.Int(flag) }
+	}
+	if flag := PebbleDisableAutomaticCompactionsFlag.Name; ctx.IsSet(flag) {
+		peos.DisableAutomaticCompactions = ctx.Bool(flag)
+	}
+	if flag := PebbleWALBytesPerSyncFlag.Name; ctx.IsSet(flag) {
+		peos.WALBytesPerSync = ctx.Int(flag)
+	}
+	if flag := PebbleWALDirFlag.Name; ctx.IsSet(flag) {
+		peos.WALDir = ctx.String(flag)
+	}
+	if flag := PebbleWALMinSyncIntervalFlag.Name; ctx.IsSet(flag) {
+		peos.WALMinSyncInterval = func() time.Duration { return ctx.Duration(flag) }
+	}
+	if flag := PebbleTargetByteDeletionRateFlag.Name; ctx.IsSet(flag) {
+		peos.TargetByteDeletionRate = ctx.Int(flag)
+	}
+
+	// Experimental
+
+	if flag := PebbleL0CompactionConcurrencyFlag.Name; ctx.IsSet(flag) {
+		peos.Experimental.L0CompactionConcurrency = ctx.Int(flag)
+	}
+	if flag := PebbleCompactionDebtConcurrencyFlag.Name; ctx.IsSet(flag) {
+		peos.Experimental.CompactionDebtConcurrency = ctx.Uint64(flag)
+	}
+	if flag := PebbleReadCompactionRateFlag.Name; ctx.IsSet(flag) {
+		peos.Experimental.ReadCompactionRate = ctx.Int64(flag)
+	}
+	if flag := PebbleReadSamplingMultiplierFlag.Name; ctx.IsSet(flag) {
+		peos.Experimental.ReadSamplingMultiplier = ctx.Int64(flag)
+	}
+	if flag := PebbleMaxWriterConcurrencyFlag.Name; ctx.IsSet(flag) {
+		peos.Experimental.MaxWriterConcurrency = ctx.Int(flag)
+	}
+	if flag := PebbleForceWriterParallelismFlag.Name; ctx.IsSet(flag) {
+		peos.Experimental.ForceWriterParallelism = ctx.Bool(flag)
+	}
+
+	cfg.PebbleExtraOptions = peos
+}

core/rawdb/database.go

@@ -324,8 +324,8 @@ func NewLevelDBDatabase(file string, cache int, handles int, namespace string, r
 
 // NewPebbleDBDatabase creates a persistent key-value database without a freezer
 // moving immutable chain segments into cold storage.
-func NewPebbleDBDatabase(file string, cache int, handles int, namespace string, readonly, ephemeral bool) (ethdb.Database, error) {
-	db, err := pebble.New(file, cache, handles, namespace, readonly, ephemeral)
+func NewPebbleDBDatabase(file string, cache int, handles int, namespace string, readonly, ephemeral bool, extraOptions *pebble.ExtraOptions) (ethdb.Database, error) {
+	db, err := pebble.New(file, cache, handles, namespace, readonly, ephemeral, extraOptions)
 	if err != nil {
 		return nil, err
 	}
@@ -366,6 +366,8 @@ type OpenOptions struct {
 	// Ephemeral means that filesystem sync operations should be avoided: data integrity in the face of
 	// a crash is not important. This option should typically be used in tests.
 	Ephemeral bool
+
+	PebbleExtraOptions *pebble.ExtraOptions
 }
 
 // openKeyValueDatabase opens a disk-based key-value database, e.g. leveldb or pebble.
@@ -387,15 +389,15 @@ func openKeyValueDatabase(o OpenOptions) (ethdb.Database, error) {
 	}
 	if o.Type == dbPebble || existingDb == dbPebble {
 		log.Info("Using pebble as the backing database")
-		return NewPebbleDBDatabase(o.Directory, o.Cache, o.Handles, o.Namespace, o.ReadOnly, o.Ephemeral)
+		return NewPebbleDBDatabase(o.Directory, o.Cache, o.Handles, o.Namespace, o.ReadOnly, o.Ephemeral, o.PebbleExtraOptions)
 	}
 	if o.Type == dbLeveldb || existingDb == dbLeveldb {
 		log.Info("Using leveldb as the backing database")
 		return NewLevelDBDatabase(o.Directory, o.Cache, o.Handles, o.Namespace, o.ReadOnly)
 	}
 	// No pre-existing database, no user-requested one either. Default to Pebble.
 	log.Info("Defaulting to pebble as the backing database")
-	return NewPebbleDBDatabase(o.Directory, o.Cache, o.Handles, o.Namespace, o.ReadOnly, o.Ephemeral)
+	return NewPebbleDBDatabase(o.Directory, o.Cache, o.Handles, o.Namespace, o.ReadOnly, o.Ephemeral, o.PebbleExtraOptions)
 }
 
 // Open opens both a disk-based key-value database such as leveldb or pebble, but also

eth/backend.go

@@ -136,7 +136,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 	log.Info("Allocated trie memory caches", "clean", common.StorageSize(config.TrieCleanCache)*1024*1024, "dirty", common.StorageSize(config.TrieDirtyCache)*1024*1024)
 
 	// Assemble the Ethereum object
-	chainDb, err := stack.OpenDatabaseWithFreezer("chaindata", config.DatabaseCache, config.DatabaseHandles, config.DatabaseFreezer, "eth/db/chaindata/", false)
+	chainDb, err := stack.OpenDatabaseWithFreezerWithExtraOptions("chaindata", config.DatabaseCache, config.DatabaseHandles, config.DatabaseFreezer, "eth/db/chaindata/", false, config.PebbleExtraOptions)
 	if err != nil {
 		return nil, err
 	}

eth/ethconfig/config.go

@@ -32,6 +32,7 @@ import (
 	"github.com/ethereum/go-ethereum/eth/downloader"
 	"github.com/ethereum/go-ethereum/eth/gasprice"
 	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/ethdb/pebble"
 	"github.com/ethereum/go-ethereum/miner"
 	"github.com/ethereum/go-ethereum/params"
 )
@@ -178,6 +179,8 @@ type Config struct {
 	RollupDisableTxPoolGossip               bool
 	RollupDisableTxPoolAdmission            bool
 	RollupHaltOnIncompatibleProtocolVersion string
+
+	PebbleExtraOptions *pebble.ExtraOptions
 }
 
 // CreateConsensusEngine creates a consensus engine for the given chain config.

ethdb/pebble/extraoptions.go

@@ -0,0 +1,35 @@
+package pebble
+
+import "time"
+
+type ExtraOptions struct {
+	BytesPerSync                int
+	L0CompactionFileThreshold   int
+	L0CompactionThreshold       int
+	L0StopWritesThreshold       int
+	LBaseMaxBytes               int64
+	MemTableStopWritesThreshold int
+	MaxConcurrentCompactions    func() int
+	DisableAutomaticCompactions bool
+	WALBytesPerSync             int
+	WALDir                      string
+	WALMinSyncInterval          func() time.Duration
+	TargetByteDeletionRate      int
+	Experimental                ExtraOptionsExperimental
+	Levels                      []ExtraLevelOptions
+}
+
+type ExtraOptionsExperimental struct {
+	L0CompactionConcurrency   int
+	CompactionDebtConcurrency uint64
+	ReadCompactionRate        int64
+	ReadSamplingMultiplier    int64
+	MaxWriterConcurrency      int
+	ForceWriterParallelism    bool
+}
+
+type ExtraLevelOptions struct {
+	BlockSize      int
+	IndexBlockSize int
+	TargetFileSize int64
+}