fix(libra): refactor ClientStorage::read_pack_obj, optimize the pack obj parse time.

libra/src/utils/client_storage.rs

@@ -16,17 +16,22 @@ use mercury::internal::pack::Pack;
 use mercury::utils::read_sha1;
 use once_cell::sync::Lazy;
 use regex::Regex;
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::io::prelude::*;
+use std::io::{BufReader, Cursor};
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 use std::{fs, io};
+
 static PACK_OBJ_CACHE: Lazy<Mutex<LruCache<String, CacheObject>>> = Lazy::new(|| {
     // `lazy_static!` may affect IDE's code completion
     Mutex::new(LruCache::new(1024 * 1024 * 200))
 });
 
+static PACK_FILE_CACHE: Lazy<Mutex<HashMap<String, Vec<u8>>>> =
+    Lazy::new(|| Mutex::new(HashMap::new()));
+
 #[derive(Default)]
 pub struct ClientStorage {
     base_path: PathBuf,
@@ -465,19 +470,35 @@ impl ClientStorage {
 
     /// Read object from pack file, with offset
     fn read_pack_obj(pack_file: &Path, offset: u64) -> Result<CacheObject, GitError> {
-        let cache_key = format!("{:?}-{}", pack_file.file_name().unwrap(), offset);
+        let file_name = pack_file.file_name().unwrap().to_str().unwrap().to_owned();
+        let cache_key = format!("{:?}-{}", file_name, offset);
         // read cache
         if let Some(cached) = PACK_OBJ_CACHE.lock().unwrap().get(&cache_key) {
             return Ok(cached.clone());
         }
 
-        let file = fs::File::open(pack_file)?;
-        let mut pack_reader = io::BufReader::new(&file);
-        pack_reader.seek(io::SeekFrom::Start(offset))?;
-        let mut pack = Pack::new(None, None, None, false);
         let obj = {
-            let mut offset = offset as usize;
-            pack.decode_pack_object(&mut pack_reader, &mut offset)? // offset will be updated!
+            let mut cache = PACK_FILE_CACHE.lock().unwrap();
+            let pack_file_buf = match cache.get(&file_name) {
+                None => {
+                    let file = fs::File::open(pack_file)?;
+                    let mut pack_reader = io::BufReader::new(&file);
+
+                    let mut buf: Vec<u8> = Vec::new();
+                    pack_reader.read_to_end(&mut buf)?;
+                    cache.insert(file_name.clone(), buf);
+                    cache.get(&file_name).unwrap()
+                }
+                Some(buf) => buf,
+            };
+
+            let pack_cursor = Cursor::new(pack_file_buf);
+            let mut pack_reader = BufReader::new(pack_cursor);
+            pack_reader.seek(io::SeekFrom::Start(offset))?;
+            {
+                let mut offset = offset as usize;
+                Pack::decode_pack_object(&mut pack_reader, &mut offset)? // offset will be updated!
+            }
         };
         let full_obj = match obj.object_type() {
             ObjectType::OffsetDelta => {

mercury/src/internal/pack/decode.rs

@@ -198,7 +198,6 @@ impl Pack {
     /// * Or a `GitError` in case of a mismatch in expected size or any other reading error.
     ///
     pub fn decompress_data(
-        &mut self,
         pack: &mut (impl BufRead + Send),
         expected_size: usize,
     ) -> Result<(Vec<u8>, usize), GitError> {
@@ -246,7 +245,6 @@ impl Pack {
     /// * Or a `GitError` in case of any reading or decompression error.
     ///
     pub fn decode_pack_object(
-        &mut self,
         pack: &mut (impl BufRead + Send),
         offset: &mut usize,
     ) -> Result<CacheObject, GitError> {
@@ -267,15 +265,15 @@ impl Pack {
 
         match t {
             ObjectType::Commit | ObjectType::Tree | ObjectType::Blob | ObjectType::Tag => {
-                let (data, raw_size) = self.decompress_data(pack, size)?;
+                let (data, raw_size) = Pack::decompress_data(pack, size)?;
                 *offset += raw_size;
                 Ok(CacheObject::new_for_undeltified(t, data, init_offset))
             }
             ObjectType::OffsetDelta | ObjectType::OffsetZstdelta => {
                 let (delta_offset, bytes) = utils::read_offset_encoding(pack).unwrap();
                 *offset += bytes;
 
-                let (data, raw_size) = self.decompress_data(pack, size)?;
+                let (data, raw_size) = Pack::decompress_data(pack, size)?;
                 *offset += raw_size;
 
                 // Count the base object offset: the current offset - delta offset
@@ -311,7 +309,7 @@ impl Pack {
                 // Offset is incremented by 20 bytes
                 *offset += SHA1::SIZE;
 
-                let (data, raw_size) = self.decompress_data(pack, size)?;
+                let (data, raw_size) = Pack::decompress_data(pack, size)?;
                 *offset += raw_size;
 
                 let mut reader = Cursor::new(&data);
@@ -382,7 +380,7 @@ impl Pack {
                 thread::yield_now();
             }
             let r: Result<CacheObject, GitError> =
-                self.decode_pack_object(&mut reader, &mut offset);
+                Pack::decode_pack_object(&mut reader, &mut offset);
             match r {
                 Ok(mut obj) => {
                     obj.set_mem_recorder(self.cache_objs_mem.clone());
@@ -728,8 +726,7 @@ mod tests {
         let expected_size = data.len();
 
         // Decompress the data and assert correctness
-        let mut p = Pack::new(None, None, None, true);
-        let result = p.decompress_data(&mut cursor, expected_size);
+        let result = Pack::decompress_data(&mut cursor, expected_size);
         match result {
             Ok((decompressed_data, bytes_read)) => {
                 assert_eq!(bytes_read, compressed_size);