feat(code): add block cache

Signed-off-by: Alex Chi <iskyzh@gmail.com>

mini-lsm-starter/src/lsm_storage.rs

@@ -9,10 +9,13 @@ use anyhow::Result;
 use arc_swap::ArcSwap;
 use bytes::Bytes;
 
+use crate::block::Block;
 use crate::lsm_iterator::{FusedIterator, LsmIterator};
 use crate::mem_table::MemTable;
 use crate::table::SsTable;
 
+pub type BlockCache = moka::sync::Cache<(usize, usize), Arc<Block>>;
+
 #[derive(Clone)]
 pub struct LsmStorageInner {
     /// MemTables, from oldest to earliest.

mini-lsm-starter/src/table.rs

@@ -13,6 +13,7 @@ use bytes::{Buf, Bytes};
 pub use iterator::SsTableIterator;
 
 use crate::block::Block;
+use crate::lsm_storage::BlockCache;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct BlockMeta {
@@ -50,6 +51,7 @@ impl FileObject {
         self.0.len() as u64
     }
 
+    /// Create a new file object (day 2) and write the file to the disk (day 4).
     pub fn create(path: &Path, data: Vec<u8>) -> Result<Self> {
         unimplemented!()
     }
@@ -66,8 +68,13 @@ pub struct SsTable {
 }
 
 impl SsTable {
+    #[cfg(test)]
+    pub(crate) fn open_for_test(file: FileObject) -> Result<Self> {
+        Self::open(0, None, file)
+    }
+
     /// Open SSTable from a file.
-    pub fn open(file: FileObject) -> Result<Self> {
+    pub fn open(id: usize, block_cache: Option<Arc<BlockCache>>, file: FileObject) -> Result<Self> {
         unimplemented!()
     }
 
@@ -76,6 +83,11 @@ impl SsTable {
         unimplemented!()
     }
 
+    /// Read a block from disk, with block cache. (Day 4)
+    pub fn read_block_cached(&self, block_idx: usize) -> Result<Arc<Block>> {
+        unimplemented!()
+    }
+
     /// Find the block that may contain `key`.
     pub fn find_block_idx(&self, key: &[u8]) -> usize {
         unimplemented!()

mini-lsm-starter/src/table/builder.rs

@@ -2,10 +2,12 @@
 #![allow(dead_code)] // TODO(you): remove this lint after implementing this mod
 
 use std::path::Path;
+use std::sync::Arc;
 
 use anyhow::Result;
 
 use super::{BlockMeta, SsTable};
+use crate::lsm_storage::BlockCache;
 
 /// Builds an SSTable from key-value pairs.
 pub struct SsTableBuilder {
@@ -31,7 +33,17 @@ impl SsTableBuilder {
 
     /// Builds the SSTable and writes it to the given path. No need to actually write to disk until
     /// chapter 4 block cache.
-    pub fn build(self, path: impl AsRef<Path>) -> Result<SsTable> {
+    pub fn build(
+        self,
+        id: usize,
+        block_cache: Option<Arc<BlockCache>>,
+        path: impl AsRef<Path>,
+    ) -> Result<SsTable> {
         unimplemented!()
     }
+
+    #[cfg(test)]
+    pub(crate) fn build_for_test(self, path: impl AsRef<Path>) -> Result<SsTable> {
+        self.build(0, None, path)
+    }
 }