feat(code): add block cache

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

mini-lsm/src/table/builder.rs

@@ -1,10 +1,12 @@
 use std::path::Path;
+use std::sync::Arc;
 
 use anyhow::Result;
 use bytes::BufMut;
 
 use super::{BlockMeta, FileObject, SsTable};
 use crate::block::BlockBuilder;
+use crate::lsm_storage::BlockCache;
 
 /// Builds an SSTable from key-value pairs.
 pub struct SsTableBuilder {
@@ -61,7 +63,12 @@ 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(mut self, path: impl AsRef<Path>) -> Result<SsTable> {
+    pub fn build(
+        mut self,
+        id: usize,
+        block_cache: Option<Arc<BlockCache>>,
+        path: impl AsRef<Path>,
+    ) -> Result<SsTable> {
         self.finish_block();
         let mut buf = self.data;
         let meta_offset = buf.len();
@@ -69,9 +76,16 @@ impl SsTableBuilder {
         buf.put_u32(meta_offset as u32);
         let file = FileObject::create(path.as_ref(), buf)?;
         Ok(SsTable {
+            id,
             file,
             block_metas: self.meta,
             block_meta_offset: meta_offset,
+            block_cache,
         })
     }
+
+    #[cfg(test)]
+    pub(crate) fn build_for_test(self, path: impl AsRef<Path>) -> Result<SsTable> {
+        self.build(0, None, path)
+    }
 }

mini-lsm/src/table/iterator.rs

@@ -17,7 +17,7 @@ impl SsTableIterator {
     fn seek_to_first_inner(table: &Arc<SsTable>) -> Result<(usize, BlockIterator)> {
         Ok((
             0,
-            BlockIterator::create_and_seek_to_first(table.read_block(0)?),
+            BlockIterator::create_and_seek_to_first(table.read_block_cached(0)?),
         ))
     }
 
@@ -42,11 +42,13 @@ impl SsTableIterator {
 
     fn seek_to_key_inner(table: &Arc<SsTable>, key: &[u8]) -> Result<(usize, BlockIterator)> {
         let mut blk_idx = table.find_block_idx(key);
-        let mut blk_iter = BlockIterator::create_and_seek_to_key(table.read_block(blk_idx)?, key);
+        let mut blk_iter =
+            BlockIterator::create_and_seek_to_key(table.read_block_cached(blk_idx)?, key);
         if !blk_iter.is_valid() {
             blk_idx += 1;
             if blk_idx < table.num_of_blocks() {
-                blk_iter = BlockIterator::create_and_seek_to_first(table.read_block(blk_idx)?);
+                blk_iter =
+                    BlockIterator::create_and_seek_to_first(table.read_block_cached(blk_idx)?);
             }
         }
         Ok((blk_idx, blk_iter))
@@ -90,8 +92,9 @@ impl StorageIterator for SsTableIterator {
         if !self.blk_iter.is_valid() {
             self.blk_idx += 1;
             if self.blk_idx < self.table.num_of_blocks() {
-                self.blk_iter =
-                    BlockIterator::create_and_seek_to_first(self.table.read_block(self.blk_idx)?);
+                self.blk_iter = BlockIterator::create_and_seek_to_first(
+                    self.table.read_block_cached(self.blk_idx)?,
+                );
             }
         }
         Ok(())

mini-lsm/src/table/tests.rs

@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
 use bytes::Bytes;
+use tempfile::{tempdir, TempDir};
 
 use super::*;
 use crate::iterators::impls::StorageIterator;
@@ -10,7 +11,8 @@ use crate::table::SsTableBuilder;
 fn test_sst_build_single_key() {
     let mut builder = SsTableBuilder::new(16);
     builder.add(b"233", b"233333");
-    builder.build("").unwrap();
+    let dir = tempdir().unwrap();
+    builder.build_for_test(dir.path().join("1.sst")).unwrap();
 }
 
 #[test]
@@ -23,7 +25,8 @@ fn test_sst_build_two_blocks() {
     builder.add(b"55", b"11");
     builder.add(b"66", b"22");
     assert!(builder.meta.len() >= 2);
-    builder.build("").unwrap();
+    let dir = tempdir().unwrap();
+    builder.build_for_test(dir.path().join("1.sst")).unwrap();
 }
 
 fn key_of(idx: usize) -> Vec<u8> {
@@ -38,14 +41,16 @@ fn num_of_keys() -> usize {
     100
 }
 
-fn generate_sst() -> SsTable {
+fn generate_sst() -> (TempDir, SsTable) {
     let mut builder = SsTableBuilder::new(128);
     for idx in 0..num_of_keys() {
         let key = key_of(idx);
         let value = value_of(idx);
         builder.add(&key[..], &value[..]);
     }
-    builder.build("").unwrap()
+    let dir = tempdir().unwrap();
+    let path = dir.path().join("1.sst");
+    (dir, builder.build_for_test(path).unwrap())
 }
 
 #[test]
@@ -55,9 +60,9 @@ fn test_sst_build_all() {
 
 #[test]
 fn test_sst_decode() {
-    let sst = generate_sst();
+    let (_dir, sst) = generate_sst();
     let meta = sst.block_metas.clone();
-    let new_sst = SsTable::open(sst.file).unwrap();
+    let new_sst = SsTable::open_for_test(sst.file).unwrap();
     assert_eq!(new_sst.block_metas, meta);
 }
 
@@ -67,7 +72,8 @@ fn as_bytes(x: &[u8]) -> Bytes {
 
 #[test]
 fn test_sst_iterator() {
-    let sst = Arc::new(generate_sst());
+    let (_dir, sst) = generate_sst();
+    let sst = Arc::new(sst);
     let mut iter = SsTableIterator::create_and_seek_to_first(sst).unwrap();
     for _ in 0..5 {
         for i in 0..num_of_keys() {
@@ -95,7 +101,8 @@ fn test_sst_iterator() {
 
 #[test]
 fn test_sst_seek_key() {
-    let sst = Arc::new(generate_sst());
+    let (_dir, sst) = generate_sst();
+    let sst = Arc::new(sst);
     let mut iter = SsTableIterator::create_and_seek_to_key(sst, &key_of(0)).unwrap();
     for offset in 1..=5 {
         for i in 0..num_of_keys() {