Add RocksDB preset system and WAL directory support for HDD optimization

Implements configurable RocksDB presets and WAL directory placement
to optimize archive nodes on HDD storage, addressing Issue #681.

Features:
- Two RocksDB presets: 'default' (SSD/NVMe) and 'archive' (HDD)
- Archive preset optimized for HDD with 256MB write buffer, BlobDB,
  aggressive compression, and 12 MB/s rate limiter
- --rocksdb-preset CLI flag to select preset
- --rocksdb-wal-dir CLI flag for hybrid NVMe+HDD setups
- Auto-generated unique WAL subdirectories per database

Archive preset configuration:
- 256MB write buffer (4x default) for better batching on HDD
- BlobDB with ZSTD compression for large values
- Tiered compression: LZ4 for L0-L4, ZSTD level 22 for L5+
- 12 MB/s rate limiter to prevent I/O spikes
- 2GB LRU block cache with partitioned Bloom filters
- 4MB read-ahead for compactions

Changes:
- database/src/db/rocksdb_preset.rs: New preset system
- database/src/db/conn_builder.rs: Add preset and WAL directory support
- kaspad/src/args.rs: Add CLI flags
- kaspad/src/daemon.rs: Apply preset to all databases
- consensus/src/consensus/factory.rs: Pass preset to consensus DBs
- database/src/db.rs, database/src/lib.rs: Export RocksDbPreset

Related: #681

Author: Zorglub4242

consensus/src/consensus/factory.rs

@@ -9,7 +9,8 @@ use kaspa_consensusmanager::{ConsensusFactory, ConsensusInstance, DynConsensusCt
 use kaspa_core::{debug, time::unix_now, warn};
 use kaspa_database::{
     prelude::{
-        BatchDbWriter, CachePolicy, CachedDbAccess, CachedDbItem, DirectDbWriter, StoreError, StoreResult, StoreResultExtensions, DB,
+        BatchDbWriter, CachePolicy, CachedDbAccess, CachedDbItem, DirectDbWriter, RocksDbPreset, StoreError, StoreResult,
+        StoreResultExtensions, DB,
     },
     registry::DatabaseStorePrefixes,
 };
@@ -255,6 +256,8 @@ pub struct Factory {
     tx_script_cache_counters: Arc<TxScriptCacheCounters>,
     fd_budget: i32,
     mining_rules: Arc<MiningRules>,
+    rocksdb_preset: RocksDbPreset,
+    wal_dir: Option<PathBuf>,
 }
 
 impl Factory {
@@ -268,6 +271,8 @@ impl Factory {
         tx_script_cache_counters: Arc<TxScriptCacheCounters>,
         fd_budget: i32,
         mining_rules: Arc<MiningRules>,
+        rocksdb_preset: RocksDbPreset,
+        wal_dir: Option<PathBuf>,
     ) -> Self {
         assert!(fd_budget > 0, "fd_budget has to be positive");
         let mut config = config.clone();
@@ -286,6 +291,8 @@ impl Factory {
             tx_script_cache_counters,
             fd_budget,
             mining_rules,
+            rocksdb_preset,
+            wal_dir,
         };
         factory.delete_inactive_consensus_entries();
         factory
@@ -316,6 +323,8 @@ impl ConsensusFactory for Factory {
             .with_db_path(dir)
             .with_parallelism(self.db_parallelism)
             .with_files_limit(self.fd_budget / 2) // active and staging consensuses should have equal budgets
+            .with_preset(self.rocksdb_preset)
+            .with_wal_dir(self.wal_dir.clone())
             .build()
             .unwrap();
 
@@ -351,6 +360,8 @@ impl ConsensusFactory for Factory {
             .with_db_path(dir)
             .with_parallelism(self.db_parallelism)
             .with_files_limit(self.fd_budget / 2) // active and staging consensuses should have equal budgets
+            .with_preset(self.rocksdb_preset)
+            .with_wal_dir(self.wal_dir.clone())
             .build()
             .unwrap();
 

database/src/db.rs

@@ -4,8 +4,10 @@ use std::path::PathBuf;
 
 pub use conn_builder::ConnBuilder;
 use kaspa_utils::fd_budget::FDGuard;
+pub use rocksdb_preset::RocksDbPreset;
 
 mod conn_builder;
+mod rocksdb_preset;
 
 /// The DB type used for Kaspad stores
 pub struct DB {

database/src/db/conn_builder.rs

@@ -1,3 +1,4 @@
+use super::rocksdb_preset::RocksDbPreset;
 use crate::db::DB;
 use rocksdb::{DBWithThreadMode, MultiThreaded};
 use std::{path::PathBuf, sync::Arc};
@@ -13,6 +14,8 @@ pub struct ConnBuilder<Path, const STATS_ENABLED: bool, StatsPeriod, FDLimit> {
     files_limit: FDLimit,
     mem_budget: usize,
     stats_period: StatsPeriod,
+    preset: RocksDbPreset,
+    wal_dir: Option<PathBuf>,
 }
 
 impl Default for ConnBuilder<Unspecified, false, Unspecified, Unspecified> {
@@ -24,6 +27,8 @@ impl Default for ConnBuilder<Unspecified, false, Unspecified, Unspecified> {
             mem_budget: 64 * 1024 * 1024,
             stats_period: Unspecified,
             files_limit: Unspecified,
+            preset: RocksDbPreset::Default,
+            wal_dir: None,
         }
     }
 }
@@ -37,6 +42,8 @@ impl<Path, const STATS_ENABLED: bool, StatsPeriod, FDLimit> ConnBuilder<Path, ST
             parallelism: self.parallelism,
             mem_budget: self.mem_budget,
             stats_period: self.stats_period,
+            preset: self.preset,
+            wal_dir: self.wal_dir,
         }
     }
     pub fn with_create_if_missing(self, create_if_missing: bool) -> ConnBuilder<Path, STATS_ENABLED, StatsPeriod, FDLimit> {
@@ -56,8 +63,16 @@ impl<Path, const STATS_ENABLED: bool, StatsPeriod, FDLimit> ConnBuilder<Path, ST
             parallelism: self.parallelism,
             mem_budget: self.mem_budget,
             stats_period: self.stats_period,
+            preset: self.preset,
+            wal_dir: self.wal_dir,
         }
     }
+    pub fn with_preset(self, preset: RocksDbPreset) -> ConnBuilder<Path, STATS_ENABLED, StatsPeriod, FDLimit> {
+        ConnBuilder { preset, ..self }
+    }
+    pub fn with_wal_dir(self, wal_dir: Option<PathBuf>) -> ConnBuilder<Path, STATS_ENABLED, StatsPeriod, FDLimit> {
+        ConnBuilder { wal_dir, ..self }
+    }
 }
 
 impl<Path, FDLimit> ConnBuilder<Path, false, Unspecified, FDLimit> {
@@ -69,6 +84,8 @@ impl<Path, FDLimit> ConnBuilder<Path, false, Unspecified, FDLimit> {
             files_limit: self.files_limit,
             mem_budget: self.mem_budget,
             stats_period: self.stats_period,
+            preset: self.preset,
+            wal_dir: self.wal_dir,
         }
     }
 }
@@ -82,6 +99,8 @@ impl<Path, StatsPeriod, FDLimit> ConnBuilder<Path, true, StatsPeriod, FDLimit> {
             files_limit: self.files_limit,
             mem_budget: self.mem_budget,
             stats_period: Unspecified,
+            preset: self.preset,
+            wal_dir: self.wal_dir,
         }
     }
     pub fn with_stats_period(self, stats_period: impl Into<u32>) -> ConnBuilder<Path, true, u32, FDLimit> {
@@ -92,18 +111,39 @@ impl<Path, StatsPeriod, FDLimit> ConnBuilder<Path, true, StatsPeriod, FDLimit> {
             files_limit: self.files_limit,
             mem_budget: self.mem_budget,
             stats_period: stats_period.into(),
+            preset: self.preset,
+            wal_dir: self.wal_dir,
         }
     }
 }
 
 macro_rules! default_opts {
     ($self: expr) => {{
         let mut opts = rocksdb::Options::default();
-        if $self.parallelism > 1 {
-            opts.increase_parallelism($self.parallelism as i32);
+
+        // Apply the preset configuration (includes parallelism and compaction settings)
+        $self.preset.apply_to_options(&mut opts, $self.parallelism, $self.mem_budget);
+
+        // Configure WAL directory if specified (for RAM cache / tmpfs)
+        // Auto-generate unique subdirectory from database path to avoid conflicts
+        if let Some(ref wal_base) = $self.wal_dir {
+            let db_name = $self
+                .db_path
+                .file_name()
+                .and_then(|n| n.to_str())
+                .expect(&format!("Invalid database path: {}", $self.db_path.display()));
+            let wal_subdir = wal_base.join(db_name);
+
+            // Create subdirectory if needed (each DB gets its own WAL space)
+            std::fs::create_dir_all(&wal_subdir).expect(&format!(
+                "Failed to create WAL subdirectory {}: {}",
+                wal_subdir.display(),
+                "error"
+            ));
+
+            opts.set_wal_dir(&wal_subdir);
         }
 
-        opts.optimize_level_style_compaction($self.mem_budget);
         let guard = kaspa_utils::fd_budget::acquire_guard($self.files_limit)?;
         opts.set_max_open_files($self.files_limit);
         opts.create_if_missing($self.create_if_missing);
@@ -114,17 +154,19 @@ macro_rules! default_opts {
 impl ConnBuilder<PathBuf, false, Unspecified, i32> {
     pub fn build(self) -> Result<Arc<DB>, kaspa_utils::fd_budget::Error> {
         let (opts, guard) = default_opts!(self)?;
-        let db = Arc::new(DB::new(<DBWithThreadMode<MultiThreaded>>::open(&opts, self.db_path.to_str().unwrap()).unwrap(), guard));
-        Ok(db)
+        let db_path_str = self.db_path.to_str().expect(&format!("Invalid UTF-8 in database path: {}", self.db_path.display()));
+        let db = <DBWithThreadMode<MultiThreaded>>::open(&opts, db_path_str).expect("Failed to open database");
+        Ok(Arc::new(DB::new(db, guard)))
     }
 }
 
 impl ConnBuilder<PathBuf, true, Unspecified, i32> {
     pub fn build(self) -> Result<Arc<DB>, kaspa_utils::fd_budget::Error> {
         let (mut opts, guard) = default_opts!(self)?;
         opts.enable_statistics();
-        let db = Arc::new(DB::new(<DBWithThreadMode<MultiThreaded>>::open(&opts, self.db_path.to_str().unwrap()).unwrap(), guard));
-        Ok(db)
+        let db_path_str = self.db_path.to_str().expect(&format!("Invalid UTF-8 in database path: {}", self.db_path.display()));
+        let db = <DBWithThreadMode<MultiThreaded>>::open(&opts, db_path_str).expect("Failed to open database");
+        Ok(Arc::new(DB::new(db, guard)))
     }
 }
 
@@ -134,7 +176,8 @@ impl ConnBuilder<PathBuf, true, u32, i32> {
         opts.enable_statistics();
         opts.set_report_bg_io_stats(true);
         opts.set_stats_dump_period_sec(self.stats_period);
-        let db = Arc::new(DB::new(<DBWithThreadMode<MultiThreaded>>::open(&opts, self.db_path.to_str().unwrap()).unwrap(), guard));
-        Ok(db)
+        let db_path_str = self.db_path.to_str().expect(&format!("Invalid UTF-8 in database path: {}", self.db_path.display()));
+        let db = <DBWithThreadMode<MultiThreaded>>::open(&opts, db_path_str).expect("Failed to open database");
+        Ok(Arc::new(DB::new(db, guard)))
     }
 }