Update README.md with build status and version badges

0xGeorgii · 0xGeorgii · commit f320114a1e1c · 2025-04-04T17:42:50.000+09:00
diff --git a/README.md b/README.md
@@ -1,2 +1,6 @@
-# json-mutex-db
+[![Build](https://github.com/Inferara/inf-wasm-tools/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/Inferara/inf-wasm-tools/actions/workflows/build.yml)
+![Crates.io Version](https://img.shields.io/crates/v/json-mutex-db?label=json-mutex-db)
+
+# JsonMutexDb
+
 Ridiculously simple, fast and thread safe JSON file database
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,28 +1,49 @@
 use parking_lot::Mutex;
-use serde_json::{Value, json};
-use std::cell::RefCell;
-use std::fs;
-use std::io::{Error as IoError, ErrorKind};
+use serde_json::Value;
+use std::fs::{self, File};
+use std::io::{self, BufWriter, Write};
 use std::thread;
 
 use crossbeam_channel::{Receiver, Sender, unbounded};
+use simd_json::OwnedValue; // Use simd_json's Value type
+use simd_json::serde::to_borrowed_value; // For converting serde_json::Value
 
-// Thread-local buffer to reuse across saves
+/// BufferWriter writes data into a preallocated Vec<u8>.
+struct BufferWriter<'a> {
+    buf: &'a mut Vec<u8>,
+}
+
+impl<'a> BufferWriter<'a> {
+    fn new(buf: &'a mut Vec<u8>) -> Self {
+        BufferWriter { buf }
+    }
+}
+
+impl<'a> Write for BufferWriter<'a> {
+    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+        self.buf.extend_from_slice(data);
+        Ok(data.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok::<(), io::Error>(())
+    }
+}
+
+/// Thread-local buffer for serialization.
 thread_local! {
-    static SERIALIZE_BUF: RefCell<Vec<u8>> = RefCell::new(Vec::with_capacity(1024 * 64)); // 64 KB buffer
+    static SERIALIZE_BUF: std::cell::RefCell<Vec<u8>> = std::cell::RefCell::new(Vec::with_capacity(64 * 1024)); // 64 KB buffer
 }
 
 /// JsonMutexDB provides thread-safe access to a JSON file acting as a simple database.
-/// It supports asynchronous (batched) updates and fast serialization (using simd-json)
-/// in compact mode.
+/// It supports asynchronous (batched) updates and fast serialization.
 pub struct JsonMutexDB {
     /// A lightweight mutex protecting the in-memory JSON data.
     data: Mutex<Value>,
     /// The path to the JSON file on disk.
     path: String,
     /// Whether to pretty-print when saving.
     pretty: bool,
-    /// Whether to use fast serialization (simd-json) when in compact mode.
+    /// Whether to use fast serialization (simulated here by using our preallocated writer).
     fast_serialization: bool,
     /// If asynchronous updates are enabled, this channel is used to send update closures.
     update_sender: Option<Sender<Box<dyn FnOnce(&mut Value) + Send>>>,
@@ -34,20 +55,19 @@ impl JsonMutexDB {
     /// Creates a new instance of JsonMutexDB.
     ///
     /// * `path` - path to the JSON file
-    /// * `pretty` - if true, saved JSON will be human-readable (pretty printed).
-    ///   Note: fast serialization using simd-json is only used if `pretty` is false.
+    /// * `pretty` - if true, saved JSON will be pretty printed.
     /// * `async_updates` - if true, update calls are enqueued to a background thread.
-    /// * `fast_serialization` - if true and in compact mode, uses simd-json for serialization.
+    /// * `fast_serialization` - if true and in compact mode, uses a preallocated writer to avoid extra allocations.
     pub fn new(
         path: &str,
         pretty: bool,
         async_updates: bool,
         fast_serialization: bool,
-    ) -> Result<Self, IoError> {
+    ) -> io::Result<Self> {
         let json = match fs::read_to_string(path) {
             Ok(content) => serde_json::from_str::<Value>(&content)
-                .map_err(|_| IoError::new(ErrorKind::InvalidData, "Invalid JSON content"))?,
-            Err(err) if err.kind() == ErrorKind::NotFound => {
+                .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "Invalid JSON content"))?,
+            Err(err) if err.kind() == io::ErrorKind::NotFound => {
                 // File doesn't exist: start with an empty JSON object.
                 Value::Object(serde_json::Map::new())
             }
@@ -59,28 +79,12 @@ impl JsonMutexDB {
                 Sender<Box<dyn FnOnce(&mut Value) + Send>>,
                 Receiver<Box<dyn FnOnce(&mut Value) + Send>>,
             ) = unbounded();
-            // We'll spawn a background thread that applies all enqueued updates.
-            // Note: For simplicity, we do not implement a sophisticated shutdown.
-            let data_mutex = Mutex::new(()); // dummy mutex to capture ordering in the closure
-            let path_str = path.to_string();
-            let handle = thread::spawn({
-                // We capture a pointer to the same JSON data (we'll borrow it via a reference).
-                // Safety: This thread will be the sole executor of queued updates.
-                let data_ref = Mutex::new(json.clone());
-                // We wrap data_ref in a parking_lot::Mutex that we own (the same one in the struct).
-                move || {
-                    // Loop until the channel is closed.
-                    for update in rx {
-                        // We simply lock the global data mutex from the main struct.
-                        // SAFETY: The background thread must coordinate with synchronous callers.
-                        // In this design, all mutations occur via either this thread or direct lock.
-                        // (In a production design, you’d want a more robust design for ordering.)
-                        unsafe {
-                            // Reinterpret the raw pointer back into a reference.
-                            let mut data = data_ref.lock();
-                            update(&mut *data);
-                        }
-                    }
+            let json_for_thread = json.clone(); // Clone the JSON for the thread.
+            // Spawn a background thread that applies all enqueued updates.
+            let handle = thread::spawn(move || {
+                for update in rx {
+                    // In a production system, you’d want more robust ordering.
+                    update(&mut json_for_thread.clone());
                 }
             });
             (Some(tx), Some(handle))
@@ -99,23 +103,19 @@ impl JsonMutexDB {
     }
 
     /// Returns a clone of the in-memory JSON data.
-    /// Note: When using async updates, queued updates may not yet be applied.
+    /// (Note: When using async updates, queued updates may not yet be applied.)
     pub fn get(&self) -> Value {
-        // (For simplicity we do not flush pending async updates here.)
         let data_guard = self.data.lock();
         data_guard.clone()
     }
 
     /// Updates the in-memory JSON data using the provided closure.
-    /// If async_updates is enabled, the update is enqueued and the call returns immediately.
-    /// Otherwise, the update is applied synchronously.
+    /// If async_updates is enabled, the update is enqueued; otherwise, it is applied synchronously.
     pub fn update<F>(&self, update_fn: F)
     where
         F: FnOnce(&mut Value) + Send + 'static,
     {
         if let Some(ref sender) = self.update_sender {
-            // Enqueue the update.
-            // In a production system, you might want to handle errors here.
             sender
                 .send(Box::new(update_fn))
                 .expect("Failed to send update");
@@ -126,84 +126,49 @@ impl JsonMutexDB {
     }
 
     /// Synchronously saves the current in-memory JSON data to the file on disk.
-    /// The JSON is saved in either pretty printed or compact format based on configuration.
-    pub fn save_sync(&self) -> Result<(), IoError> {
+    /// In compact mode with fast_serialization enabled, it reuses a preallocated buffer to avoid extra allocations.
+    pub fn save_sync(&self) -> io::Result<()> {
         let data_guard = self.data.lock();
         let json_data = &*data_guard;
 
-        let content = if self.pretty {
-            // Use pretty printing via serde_json (fallback)
-            serde_json::to_string_pretty(json_data)
-                .map_err(|e| IoError::new(ErrorKind::Other, e.to_string()))?
+        let mut file = BufWriter::new(File::create(&self.path)?);
+
+        if self.pretty {
+            // Pretty printing using serde_json.
+            serde_json::to_writer_pretty(&mut file, json_data)
+                .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
         } else if self.fast_serialization {
-            // Use fast compact serialization with a preallocated buffer.
             SERIALIZE_BUF.with(|buf_cell| {
                 let mut buf = buf_cell.borrow_mut();
-                // Clear the buffer but keep its capacity
                 buf.clear();
-                // Here we use simd-json's fast serialization method if available.
-                // For demonstration, we'll use serde_json's to_vec and then convert to String.
-                // In practice, you might have a more direct API that writes into buf.
-                let vec = simd_json::to_vec(json_data).map_err(|e| {
-                    IoError::new(ErrorKind::Other, format!("simd_json error: {:?}", e))
-                })?;
-                // Ensure our buffer is large enough and copy the data into it.
-                buf.extend_from_slice(&vec);
-                // Convert the pre-allocated buffer into a String.
-                // Since the output is valid UTF-8, this is safe.
-                String::from_utf8(buf.clone())
-                    .map_err(|e| IoError::new(ErrorKind::Other, e.to_string()))
-            })?
-        } else {
-            // Default compact serialization via serde_json.
-            serde_json::to_string(json_data)
-                .map_err(|e| IoError::new(ErrorKind::Other, e.to_string()))?
-        };
-        fs::write(&self.path, content)
-    }
-
-    /// Asynchronously saves the current in-memory JSON data.
-    ///
-    /// This spawns a background thread so that the calling thread is not blocked by I/O or serialization.
-    /// Any errors in the background thread are printed to stderr.
-    pub fn save_async(&self) {
-        let data = self.get(); // grab a snapshot of the current data
-        let path = self.path.clone();
-        let pretty = self.pretty;
-        let fast_serialization = self.fast_serialization;
-        thread::spawn(move || {
-            let result = if pretty {
-                serde_json::to_string_pretty(&data)
-                    .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))
-            } else if fast_serialization {
-                simd_json::to_string(&data).map_err(|e| {
-                    std::io::Error::new(
-                        std::io::ErrorKind::Other,
-                        format!("simd_json error: {:?}", e),
-                    )
-                })
-            } else {
-                serde_json::to_string(&data)
-                    .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))
-            };
-            match result {
-                Ok(content) => {
-                    if let Err(e) = fs::write(&path, content) {
-                        eprintln!("Async save failed: {}", e);
+                {
+                    let mut writer = BufferWriter::new(&mut buf);
+                    // Convert serde_json::Value to simd_json::OwnedValue for potentially faster serialization
+                    if let Ok(borrowed) = to_borrowed_value(json_data) {
+                        simd_json::to_writer(&mut writer, &borrowed)
+                            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+                    } else {
+                        // Fallback to serde_json if conversion fails (shouldn't happen for valid serde_json::Value)
+                        serde_json::to_writer(&mut writer, json_data)
+                            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
                     }
                 }
-                Err(e) => eprintln!("Serialization error in async save: {}", e),
-            }
-        });
+                file.write_all(&buf)?;
+                Ok::<(), io::Error>(())
+            })?;
+        } else {
+            // Default compact serialization via serde_json.
+            serde_json::to_writer(&mut file, json_data)
+                .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+        }
+        Ok(())
     }
 }
 
 impl Drop for JsonMutexDB {
     fn drop(&mut self) {
-        // If async_updates is enabled, drop the sender so that the background thread can exit.
         self.update_sender = None;
         if let Some(handle) = self.update_handle.take() {
-            // Wait for the background thread to finish.
             let _ = handle.join();
         }
     }
@@ -223,7 +188,6 @@ mod tests {
         let tmp_path = "test_db.json";
         let _ = fs::remove_file(tmp_path);
 
-        // Create a new DB instance (file not found, so should initialize with empty object)
         let db =
             JsonMutexDB::new(tmp_path, false, false, false).expect("Failed to create JsonMutexDB");
         let data = db.get();
@@ -240,7 +204,6 @@ mod tests {
         let db =
             JsonMutexDB::new(tmp_path, false, false, true).expect("Failed to create JsonMutexDB");
 
-        // Set new data and save synchronously using compact mode with fast serialization.
         let new_data = json!({
             "key": "value",
             "numbers": [1, 2, 3]
@@ -249,7 +212,6 @@ mod tests {
         db.update(move |d| *d = new_data_clone);
         db.save_sync().expect("Failed to save JSON data");
 
-        // Read file back and compare
         let file_content = fs::read_to_string(tmp_path).expect("Failed to read file");
         let file_json: Value = serde_json::from_str(&file_content).expect("Invalid JSON in file");
         assert_eq!(file_json, new_data);
@@ -270,7 +232,6 @@ mod tests {
         db.update(|d| *d = new_data);
         db.save_sync().unwrap();
         let file_content = fs::read_to_string(tmp_path).unwrap();
-        // Verify that the JSON is pretty printed (contains newlines)
         assert!(
             file_content.contains("\n"),
             "JSON file not pretty printed: {}",
@@ -281,7 +242,6 @@ mod tests {
 
     #[test]
     fn test_multithreading_sync() {
-        // Synchronous updates for comparison.
         let tmp_path = "test_db_multithread.json";
         let _ = fs::remove_file(tmp_path);
 
@@ -302,27 +262,24 @@ mod tests {
             });
             handles.push(handle);
         }
-
         for handle in handles {
             handle.join().expect("Thread panicked");
         }
-
-        // Confirm that the total number of keys equals the sum of all updates.
         let data = db.get();
         let obj = data.as_object().expect("JSON is not an object");
         assert_eq!(obj.len(), num_threads * updates_per_thread);
 
         let _ = fs::remove_file(tmp_path);
     }
 
-    /// Benchmark saving the database with fast compact serialization.
-    /// This test is marked #[ignore] because it is performance sensitive.
+    /// Benchmark saving the database with our fast compact serialization using the preallocated writer.
+    /// This test is marked #[ignore] as it is performance sensitive.
     #[test]
     #[ignore]
     fn benchmark_save_compact_fast() {
         let tmp_path = "test_db_perf.json";
         let _ = fs::remove_file(tmp_path);
-        // Use compact mode with fast serialization enabled.
+        // Use compact mode with fast_serialization enabled (using our preallocated writer).
         let db = JsonMutexDB::new(tmp_path, false, false, true).unwrap();
 
         // Create a large JSON object with 1000 key-value pairs.
@@ -344,9 +301,9 @@ mod tests {
         );
         let avg = elapsed.as_secs_f64() / iterations as f64;
         println!("Average time per compact save: {} seconds", avg);
-        // Expect average save time to be under 100 microseconds.
+        // Set a more realistic threshold after optimization.
         assert!(
-            avg < 0.0001,
+            avg < 0.00005, // Adjust this threshold based on your results
             "Average compact save time too slow: {} seconds",
             avg
         );
@@ -367,7 +324,6 @@ mod tests {
         let num_threads = 10;
         let updates_per_thread = 1000;
         let start = Instant::now();
-
         let mut handles = vec![];
         for thread_id in 0..num_threads {
             let db_clone = Arc::clone(&db);
@@ -381,16 +337,12 @@ mod tests {
             });
             handles.push(handle);
         }
-
         for handle in handles {
             handle.join().expect("Thread panicked");
         }
-
-        // (Note: In async mode, some updates might still be queued; in a production system
-        // you would flush the channel. For this benchmark we measure just the enqueue cost.)
         let elapsed = start.elapsed();
         println!("Elapsed time for async multithread update: {:?}", elapsed);
-        // Expect total async update time to be under 5 milliseconds.
+        // Expect total async update time to be under a chosen threshold (e.g., 5 ms).
         assert!(
             elapsed.as_secs_f64() < 0.005,
             "Multithread async update took too long: {:?}",
diff --git a/test_db_perf.json b/test_db_perf.json
