feat: support build tag with rocksdb (#200)

* feat: support build tag with rocksdb

to avoid undefined: config.OpenDB when build with rocksdb

* Apply suggestions from code review

---------

Co-authored-by: Vlad J <vladjdk@gmail.com>
Co-authored-by: Alex | Interchain Labs <alex@interchainlabs.io>

Author: 3 people

server/config/opendb.go

@@ -0,0 +1,30 @@
+//go:build !rocksdb
+// +build !rocksdb
+
+package config
+
+import (
+	"path/filepath"
+
+	dbm "github.com/cosmos/cosmos-db"
+
+	"github.com/cosmos/cosmos-sdk/server/types"
+)
+
+// OpenDB opens a database based on the specified backend type.
+// It takes the home directory where the database data will be stored, along with the backend type.
+// It opens a database named "application" using the specified backend type and the data directory.
+// It returns the opened database and an error (if any). If the database opens successfully, the error will be nil.
+//
+// NOTE: this is included in builds without rocksdb.
+// When building the binary with rocksdb, the code in 'rocksdb.go' will be included
+// instead of this
+func OpenDB(_ types.AppOptions, home string, backendType dbm.BackendType) (dbm.DB, error) {
+	dataDir := filepath.Join(home, "data")
+	return dbm.NewDB("application", backendType, dataDir)
+}
+
+// OpenReadOnlyDB opens rocksdb backend in read-only mode.
+func OpenReadOnlyDB(home string, backendType dbm.BackendType) (dbm.DB, error) {
+	return OpenDB(nil, home, backendType)
+}

server/config/opendb_rocksdb.go

@@ -0,0 +1,138 @@
+//go:build rocksdb
+// +build rocksdb
+
+package config
+
+import (
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	dbm "github.com/cosmos/cosmos-db"
+	"github.com/cosmos/cosmos-sdk/server/types"
+	"github.com/linxGnu/grocksdb"
+)
+
+// 3G block cache
+const BlockCacheSize = 3 << 30
+
+func OpenDB(_ types.AppOptions, home string, backendType dbm.BackendType) (dbm.DB, error) {
+	dataDir := filepath.Join(home, "data")
+	if backendType == dbm.RocksDBBackend {
+		return openRocksdb(filepath.Join(dataDir, "application.db"), false)
+	}
+
+	return dbm.NewDB("application", backendType, dataDir)
+}
+
+// OpenReadOnlyDB opens rocksdb backend in read-only mode.
+func OpenReadOnlyDB(home string, backendType dbm.BackendType) (dbm.DB, error) {
+	dataDir := filepath.Join(home, "data")
+	if backendType == dbm.RocksDBBackend {
+		return openRocksdb(filepath.Join(dataDir, "application.db"), true)
+	}
+
+	return dbm.NewDB("application", backendType, dataDir)
+}
+
+func openRocksdb(dir string, readonly bool) (dbm.DB, error) {
+	opts, err := loadLatestOptions(dir)
+	if err != nil {
+		return nil, err
+	}
+	// customize rocksdb options
+	opts = NewRocksdbOptions(opts, false)
+
+	var db *grocksdb.DB
+	if readonly {
+		db, err = grocksdb.OpenDbForReadOnly(opts, dir, false)
+	} else {
+		db, err = grocksdb.OpenDb(opts, dir)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	ro := grocksdb.NewDefaultReadOptions()
+	wo := grocksdb.NewDefaultWriteOptions()
+	woSync := grocksdb.NewDefaultWriteOptions()
+	woSync.SetSync(true)
+	return dbm.NewRocksDBWithRawDB(db, ro, wo, woSync), nil
+}
+
+// loadLatestOptions try to load options from existing db, returns nil if not exists.
+func loadLatestOptions(dir string) (*grocksdb.Options, error) {
+	opts, err := grocksdb.LoadLatestOptions(dir, grocksdb.NewDefaultEnv(), true, grocksdb.NewLRUCache(BlockCacheSize))
+	if err != nil {
+		// not found is not an error
+		if strings.HasPrefix(err.Error(), "NotFound: ") {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	cfNames := opts.ColumnFamilyNames()
+	cfOpts := opts.ColumnFamilyOpts()
+
+	for i := 0; i < len(cfNames); i++ {
+		if cfNames[i] == "default" {
+			return &cfOpts[i], nil
+		}
+	}
+
+	return opts.Options(), nil
+}
+
+// NewRocksdbOptions build options for `application.db`,
+// it overrides existing options if provided, otherwise create new one assuming it's a new database.
+func NewRocksdbOptions(opts *grocksdb.Options, sstFileWriter bool) *grocksdb.Options {
+	if opts == nil {
+		opts = grocksdb.NewDefaultOptions()
+		// only enable dynamic-level-bytes on new db, don't override for existing db
+		opts.SetLevelCompactionDynamicLevelBytes(true)
+	}
+	opts.SetCreateIfMissing(true)
+	opts.IncreaseParallelism(runtime.NumCPU())
+	opts.OptimizeLevelStyleCompaction(512 * 1024 * 1024)
+	opts.SetTargetFileSizeMultiplier(2)
+
+	// block based table options
+	bbto := grocksdb.NewDefaultBlockBasedTableOptions()
+
+	bbto.SetBlockCache(grocksdb.NewLRUCache(BlockCacheSize))
+
+	// http://rocksdb.org/blog/2021/12/29/ribbon-filter.html
+	bbto.SetFilterPolicy(grocksdb.NewRibbonHybridFilterPolicy(9.9, 1))
+
+	// partition index
+	// http://rocksdb.org/blog/2017/05/12/partitioned-index-filter.html
+	bbto.SetIndexType(grocksdb.KTwoLevelIndexSearchIndexType)
+	bbto.SetPartitionFilters(true)
+	bbto.SetOptimizeFiltersForMemory(true)
+
+	// reduce memory usage
+	bbto.SetCacheIndexAndFilterBlocks(true)
+	bbto.SetPinTopLevelIndexAndFilter(true)
+	bbto.SetPinL0FilterAndIndexBlocksInCache(true)
+
+	// hash index is better for iavl tree which mostly do point lookup.
+	bbto.SetDataBlockIndexType(grocksdb.KDataBlockIndexTypeBinarySearchAndHash)
+
+	opts.SetBlockBasedTableFactory(bbto)
+
+	// in iavl tree, we almost always query existing keys
+	opts.SetOptimizeFiltersForHits(true)
+
+	// heavier compression option at bottommost level,
+	// 110k dict bytes is default in zstd library,
+	// train bytes is recommended to be set at 100x dict bytes.
+	opts.SetBottommostCompression(grocksdb.ZSTDCompression)
+	compressOpts := grocksdb.NewDefaultCompressionOptions()
+	compressOpts.Level = 12
+	if !sstFileWriter {
+		compressOpts.MaxDictBytes = 110 * 1024
+		opts.SetBottommostCompressionOptionsZstdMaxTrainBytes(compressOpts.MaxDictBytes*100, true)
+	}
+	opts.SetBottommostCompressionOptions(compressOpts, true)
+	return opts
+}

server/start.go

@@ -67,7 +67,7 @@ func NewDefaultStartOptions(appCreator types.AppCreator, defaultNodeHome string)
 	return StartOptions{
 		AppCreator:      appCreator,
 		DefaultNodeHome: defaultNodeHome,
-		DBOpener:        openDB,
+		DBOpener:        cosmosevmserverconfig.OpenDB,
 	}
 }
 
@@ -673,16 +673,3 @@ func GenDocProvider(cfg *cmtcfg.Config) func() (*cmttypes.GenesisDoc, error) {
 		return appGenesis.ToGenesisDoc()
 	}
 }
-
-// openDB opens a database based on the specified backend type.
-// It takes the home directory where the database data will be stored, along with the backend type.
-// It opens a database named "application" using the specified backend type and the data directory.
-// It returns the opened database and an error (if any). If the database opens successfully, the error will be nil.
-//
-// NOTE: this is included in builds without rocksdb.
-// When building the binary with rocksdb, the code in 'rocksdb.go' will be included
-// instead of this
-func openDB(_ types.AppOptions, home string, backendType dbm.BackendType) (dbm.DB, error) {
-	dataDir := filepath.Join(home, "data")
-	return dbm.NewDB("application", backendType, dataDir)
-}