In-memory Engine: defining hybrid engine (tikv#16114)

ref tikv#16141

Introduce hybrid engine which implements KvEngine but without detailed implementation.

Signed-off-by: SpadeA-Tang <[email protected]>

Author: SpadeA-Tang

Cargo.lock

@@ -25,7 +25,7 @@ failpoints = ["fail/failpoints", "raftstore/failpoints", "tikv_util/failpoints",
 cloud-aws = ["encryption_export/cloud-aws"]
 cloud-gcp = ["encryption_export/cloud-gcp"]
 cloud-azure = ["encryption_export/cloud-azure"]
-testexport = ["raftstore/testexport", "api_version/testexport", "causal_ts/testexport", "engine_traits/testexport", "engine_rocks/testexport", "engine_panic/testexport"]
+testexport = ["raftstore/testexport", "api_version/testexport", "causal_ts/testexport", "engine_traits/testexport", "engine_rocks/testexport", "engine_panic/testexport", "hybrid_engine/testexport"]
 test-engine-kv-rocksdb = ["engine_test/test-engine-kv-rocksdb"]
 test-engine-raft-raft-engine = ["engine_test/test-engine-raft-raft-engine"]
 test-engines-rocksdb = ["engine_test/test-engines-rocksdb"]
@@ -90,6 +90,7 @@ grpcio = { workspace = true }
 grpcio-health = { workspace = true }
 hex = "0.4"
 http = "0"
+hybrid_engine = { workspace = true }
 hyper = { version = "0.14", features = ["full"] }
 hyper-tls = "0.5"
 into_other = { workspace = true }
@@ -319,6 +320,7 @@ encryption = { path = "components/encryption" }
 encryption_export = { path = "components/encryption/export" }
 engine_panic = { path = "components/engine_panic" }
 engine_rocks = { path = "components/engine_rocks" }
+hybrid_engine = { path = "components/hybrid_engine" }
 engine_rocks_helper = { path = "components/engine_rocks_helper" }
 engine_test = { path = "components/engine_test", default-features = false }
 engine_traits = { path = "components/engine_traits" }

Cargo.toml

@@ -312,6 +312,8 @@ mod table_properties;
 pub use crate::table_properties::*;
 mod checkpoint;
 pub use crate::checkpoint::*;
+mod memory_engine;
+pub use memory_engine::RegionCacheEngine;
 
 // These modules contain more general traits, some of which may be implemented
 // by multiple types.

components/engine_traits/src/lib.rs

@@ -0,0 +1,17 @@
+// Copyright 2023 TiKV Project Authors. Licensed under Apache-2.0.
+
+use std::fmt::Debug;
+
+use crate::{Iterable, Snapshot, WriteBatchExt};
+
+/// RegionCacheEngine works as a region cache caching some regions (in Memory or
+/// NVME for instance) to improve the read performance.
+pub trait RegionCacheEngine:
+    WriteBatchExt + Iterable + Debug + Clone + Unpin + Send + Sync + 'static
+{
+    type Snapshot: Snapshot;
+
+    // If None is returned, the RegionCacheEngine is currently not readable for this
+    // region or read_ts.
+    fn snapshot(&self, region_id: u64, read_ts: u64) -> Option<Self::Snapshot>;
+}

components/engine_traits/src/memory_engine.rs

@@ -0,0 +1,13 @@
+[package]
+name = "hybrid_engine"
+version = "0.0.1"
+edition = "2021"
+publish = false
+
+[features]
+testexport = []
+
+[dependencies]
+engine_traits = { workspace = true }
+txn_types = { workspace = true }
+tikv_util = { workspace = true }

components/hybrid_engine/Cargo.toml

@@ -0,0 +1,15 @@
+// Copyright 2023 TiKV Project Authors. Licensed under Apache-2.0.
+
+use engine_traits::{CfNamesExt, KvEngine, RegionCacheEngine};
+
+use crate::engine::HybridEngine;
+
+impl<EK, EC> CfNamesExt for HybridEngine<EK, EC>
+where
+    EK: KvEngine,
+    EC: RegionCacheEngine,
+{
+    fn cf_names(&self) -> Vec<&str> {
+        self.disk_engine().cf_names()
+    }
+}

components/hybrid_engine/src/cf_names.rs

@@ -0,0 +1,21 @@
+// Copyright 2023 TiKV Project Authors. Licensed under Apache-2.0.
+
+use engine_traits::{CfOptionsExt, KvEngine, RegionCacheEngine, Result};
+
+use crate::engine::HybridEngine;
+
+impl<EK, EC> CfOptionsExt for HybridEngine<EK, EC>
+where
+    EK: KvEngine,
+    EC: RegionCacheEngine,
+{
+    type CfOptions = EK::CfOptions;
+
+    fn get_options_cf(&self, cf: &str) -> Result<Self::CfOptions> {
+        self.disk_engine().get_options_cf(cf)
+    }
+
+    fn set_options_cf(&self, cf: &str, options: &[(&str, &str)]) -> Result<()> {
+        self.disk_engine().set_options_cf(cf, options)
+    }
+}

components/hybrid_engine/src/cf_options.rs

@@ -0,0 +1,22 @@
+// Copyright 2023 TiKV Project Authors. Licensed under Apache-2.0.
+
+use engine_traits::{Checkpointable, KvEngine, RegionCacheEngine, Result};
+
+use crate::engine::HybridEngine;
+
+impl<EK, EC> Checkpointable for HybridEngine<EK, EC>
+where
+    EK: KvEngine,
+    EC: RegionCacheEngine,
+{
+    type Checkpointer = EK::Checkpointer;
+
+    fn new_checkpointer(&self) -> Result<Self::Checkpointer> {
+        self.disk_engine().new_checkpointer()
+    }
+
+    fn merge(&self, dbs: &[&Self]) -> Result<()> {
+        let disk_dbs: Vec<_> = dbs.iter().map(|&db| db.disk_engine()).collect();
+        self.disk_engine().merge(&disk_dbs)
+    }
+}

components/hybrid_engine/src/checkpoint.rs

@@ -0,0 +1,71 @@
+// Copyright 2023 TiKV Project Authors. Licensed under Apache-2.0.
+
+use engine_traits::{CompactExt, KvEngine, RegionCacheEngine, Result};
+
+use crate::engine::HybridEngine;
+
+impl<EK, EC> CompactExt for HybridEngine<EK, EC>
+where
+    EK: KvEngine,
+    EC: RegionCacheEngine,
+{
+    type CompactedEvent = EK::CompactedEvent;
+
+    fn auto_compactions_is_disabled(&self) -> Result<bool> {
+        self.disk_engine().auto_compactions_is_disabled()
+    }
+
+    fn compact_range_cf(
+        &self,
+        cf: &str,
+        start_key: Option<&[u8]>,
+        end_key: Option<&[u8]>,
+        exclusive_manual: bool,
+        max_subcompactions: u32,
+    ) -> Result<()> {
+        self.disk_engine().compact_range_cf(
+            cf,
+            start_key,
+            end_key,
+            exclusive_manual,
+            max_subcompactions,
+        )
+    }
+
+    fn compact_files_in_range_cf(
+        &self,
+        cf: &str,
+        start: Option<&[u8]>,
+        end: Option<&[u8]>,
+        output_level: Option<i32>,
+    ) -> Result<()> {
+        self.disk_engine()
+            .compact_files_in_range_cf(cf, start, end, output_level)
+    }
+
+    fn compact_files_in_range(
+        &self,
+        start: Option<&[u8]>,
+        end: Option<&[u8]>,
+        output_level: Option<i32>,
+    ) -> Result<()> {
+        self.disk_engine()
+            .compact_files_in_range(start, end, output_level)
+    }
+
+    fn compact_files_cf(
+        &self,
+        cf: &str,
+        files: Vec<String>,
+        output_level: Option<i32>,
+        max_subcompactions: u32,
+        exclude_l0: bool,
+    ) -> Result<()> {
+        self.disk_engine()
+            .compact_files_cf(cf, files, output_level, max_subcompactions, exclude_l0)
+    }
+
+    fn check_in_range(&self, start: Option<&[u8]>, end: Option<&[u8]>) -> Result<()> {
+        self.disk_engine().check_in_range(start, end)
+    }
+}

components/hybrid_engine/src/compact.rs

@@ -0,0 +1,21 @@
+// Copyright 2023 TiKV Project Authors. Licensed under Apache-2.0.
+
+use engine_traits::{DbOptionsExt, KvEngine, RegionCacheEngine, Result};
+
+use crate::engine::HybridEngine;
+
+impl<EK, EC> DbOptionsExt for HybridEngine<EK, EC>
+where
+    EK: KvEngine,
+    EC: RegionCacheEngine,
+{
+    type DbOptions = EK::DbOptions;
+
+    fn get_db_options(&self) -> Self::DbOptions {
+        self.disk_engine().get_db_options()
+    }
+
+    fn set_db_options(&self, options: &[(&str, &str)]) -> Result<()> {
+        self.disk_engine().set_db_options(options)
+    }
+}