osv 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f22d1d56b0eba1e23ca192db2c70e68689486e2f0032672285017e1f98a530d2
-  data.tar.gz: 6288dce70b95faf312e8aa244ba56a60c3d59b85bdd16a4a951060df78b97e1e
+  metadata.gz: 687f5a3426558ea4d4d342f153dae1f11da93807daddcc6944888d92cda7502b
+  data.tar.gz: e9f766b94e4c7f806e81eec859a0146b6a4758c5a69c759b084f64e01fd7a888
 SHA512:
-  metadata.gz: 5399b43ecd3987c73daf09341d51a1ee8e5d060f1085e9a7aac9b823ab723ccbbc4084c5c0c9abbd36e7e17becfcfa1757af6af3666e01ef3992a27e35b5b983
-  data.tar.gz: 2a6d98b645af40ab08a5a01a2bcf5b67ce9ebff18a993e602f6b00fa2f3f80d65c63605a7f5a715286ac20751db0607c515686e4439156a4039ae24f49e95e10
+  metadata.gz: bb14e59bca79613064a07cbcfa6c2531f08c68eb131e512b9822c7295bcacfd051de8dcd49100d12c8377d90a438d528dc5b20bcf6a1aa7c4e44f8e2aaae7111
+  data.tar.gz: a3a83f9653ef5bc41c908de14c96b756c719fd2750c8739b4a2165ff91ed82d34fdfde184c853185a8ff516e324d01816c65764f05adf58db6b2159ae66b0c74

data/Cargo.lock

@@ -43,6 +43,12 @@ version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
+[[package]]
+name = "bumpalo"
+version = "3.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
+
 [[package]]
 name = "cexpr"
 version = "0.6.0"
@@ -232,6 +238,7 @@ dependencies = [
 name = "osv"
 version = "0.1.0"
 dependencies = [
+ "bumpalo",
  "csv",
  "kanal",
  "magnus 0.7.1",
@@ -260,18 +267,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.103"
+version = "0.9.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91dbe37ab6ac2fba187480fb6544b92445e41e5c6f553bf0c33743f3c450a1df"
+checksum = "e2e26425f064a90404ed5e33fee2137b02a9c6d1c83e19394f4d8a476b9d76a2"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.103"
+version = "0.9.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4d56a49dcb646b70b758789c0d16c055a386a4f2a3346333abb69850fa860ce"
+checksum = "c9802c9003c5648ee0a067e9aa8960d402d5f764f682f93c1ed49eec72f6d7fc"
 dependencies = [
  "bindgen",
  "lazy_static",

data/ext/osv/Cargo.toml

@@ -7,9 +7,10 @@ edition = "2021"
 crate-type = ["cdylib"]
 
 [dependencies]
-csv = "1.3.1"
+csv = "^1.3"
 magnus = { version = "0.7", features = ["rb-sys"] }
-rb-sys = "0.9"
+rb-sys = "^0.9"
 serde = { version = "1.0", features = ["derive"] }
 serde_magnus = "0.8.1"
 kanal = "0.1.0-pre8"
+bumpalo = { version = "3.16.0", features = ["collections"] }

data/ext/osv/src/csv/builder.rs

@@ -1,4 +1,5 @@
 use super::{
+    header_cache::StringCache,
     parser::RecordParser,
     reader::{ReadImpl, RecordReader},
 };
@@ -80,7 +81,6 @@ impl<'a, T: RecordParser + Send + 'static> RecordReaderBuilder<'a, T> {
 
     pub fn build(self) -> Result<RecordReader<T>, Error> {
         let readable = self.get_reader()?;
-
         let mut reader = csv::ReaderBuilder::new()
             .has_headers(self.has_headers)
             .delimiter(self.delimiter)
@@ -88,14 +88,21 @@ impl<'a, T: RecordParser + Send + 'static> RecordReaderBuilder<'a, T> {
             .from_reader(readable);
 
         let headers = RecordReader::<T>::get_headers(self.ruby, &mut reader, self.has_headers)?;
-        let headers_clone = headers.clone();
         let null_string = self.null_string;
 
+        let static_headers = StringCache::intern_many(&headers).map_err(|e| {
+            Error::new(
+                self.ruby.exception_runtime_error(),
+                format!("Failed to intern headers: {e}"),
+            )
+        })?;
+        let headers_for_cleanup = static_headers.clone();
+
         let (sender, receiver) = kanal::bounded(self.buffer);
         let handle = thread::spawn(move || {
             let mut record = csv::StringRecord::new();
             while let Ok(true) = reader.read_record(&mut record) {
-                let row = T::parse(&headers_clone, &record, &null_string);
+                let row = T::parse(&static_headers, &record, &null_string);
                 if sender.send(row).is_err() {
                     break;
                 }
@@ -106,6 +113,7 @@ impl<'a, T: RecordParser + Send + 'static> RecordReaderBuilder<'a, T> {
 
         Ok(RecordReader {
             reader: ReadImpl::MultiThreaded {
+                headers: headers_for_cleanup,
                 receiver,
                 handle: Some(handle),
             },

data/ext/osv/src/csv/header_cache.rs

@@ -0,0 +1,63 @@
+use std::{
+    collections::HashMap,
+    sync::{atomic::AtomicU32, LazyLock, Mutex},
+};
+
+static STRING_CACHE: LazyLock<Mutex<HashMap<&'static str, AtomicU32>>> =
+    LazyLock::new(|| Mutex::new(HashMap::with_capacity(100)));
+
+pub struct StringCache {}
+
+impl StringCache {
+    #[allow(dead_code)]
+    pub fn intern(string: String) -> Result<&'static str, String> {
+        let mut cache = STRING_CACHE.lock().map_err(|e| e.to_string())?;
+
+        if let Some((&existing, count)) = cache.get_key_value(string.as_str()) {
+            count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+            Ok(existing)
+        } else {
+            let leaked = Box::leak(string.into_boxed_str());
+            cache.insert(leaked, AtomicU32::new(1));
+            Ok(leaked)
+        }
+    }
+
+    pub fn intern_many(strings: &[String]) -> Result<Vec<&'static str>, String> {
+        let mut cache = STRING_CACHE.lock().map_err(|e| e.to_string())?;
+        let mut result = Vec::with_capacity(strings.len());
+
+        for string in strings {
+            let static_str: &'static str =
+                if let Some((&existing, count)) = cache.get_key_value(string.as_str()) {
+                    count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                    existing
+                } else {
+                    let leaked = Box::leak(string.clone().into_boxed_str());
+                    cache.insert(leaked, AtomicU32::new(1));
+                    leaked
+                };
+            result.push(static_str);
+        }
+
+        Ok(result)
+    }
+
+    pub fn clear(headers: &[&'static str]) -> Result<(), String> {
+        let cache = STRING_CACHE.lock().map_err(|e| e.to_string())?;
+
+        for header in headers {
+            if let Some(count) = cache.get(header) {
+                let remaining = count.fetch_sub(1, std::sync::atomic::Ordering::Relaxed);
+                if remaining == 0 {
+                    let ptr = *header as *const str as *mut str;
+                    unsafe {
+                        let _ = Box::from_raw(ptr);
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+}

data/ext/osv/src/csv/mod.rs

@@ -1,8 +1,8 @@
 mod builder;
+mod header_cache;
 mod parser;
 mod reader;
 mod record;
 
 pub use builder::RecordReaderBuilder;
 pub use record::CsvRecord;
-

data/ext/osv/src/csv/parser.rs

@@ -2,42 +2,50 @@ use std::collections::HashMap;
 
 pub trait RecordParser {
     type Output;
-
-    fn parse(headers: &[String], record: &csv::StringRecord, null_string: &str) -> Self::Output;
+    fn parse(
+        headers: &[&'static str],
+        record: &csv::StringRecord,
+        null_string: &str,
+    ) -> Self::Output;
 }
 
-impl RecordParser for HashMap<String, Option<String>> {
+impl RecordParser for HashMap<&'static str, Option<String>> {
     type Output = Self;
-
-    fn parse(headers: &[String], record: &csv::StringRecord, null_string: &str) -> Self::Output {
-        headers
-            .iter()
-            .zip(record.iter())
-            .map(|(header, field)| {
-                let value = if field == null_string {
+    fn parse(
+        headers: &[&'static str],
+        record: &csv::StringRecord,
+        null_string: &str,
+    ) -> Self::Output {
+        let mut map = HashMap::with_capacity(headers.len());
+        for (header, field) in headers.iter().zip(record.iter()) {
+            map.insert(
+                *header,
+                if field == null_string {
                     None
                 } else {
                     Some(field.to_string())
-                };
-                (header.clone(), value)
-            })
-            .collect()
+                },
+            );
+        }
+        map
     }
 }
 
 impl RecordParser for Vec<Option<String>> {
     type Output = Self;
-
-    fn parse(_headers: &[String], record: &csv::StringRecord, null_string: &str) -> Self::Output {
-        record
-            .iter()
-            .map(|field| {
-                if field == null_string {
-                    None
-                } else {
-                    Some(field.to_string())
-                }
-            })
-            .collect()
+    fn parse(
+        _headers: &[&'static str],
+        record: &csv::StringRecord,
+        null_string: &str,
+    ) -> Self::Output {
+        let mut vec = Vec::with_capacity(record.len());
+        for field in record.iter() {
+            vec.push(if field == null_string {
+                None
+            } else {
+                Some(field.to_string())
+            });
+        }
+        vec
     }
 }

data/ext/osv/src/csv/reader.rs

@@ -1,4 +1,4 @@
-use super::parser::RecordParser;
+use super::{header_cache::StringCache, parser::RecordParser};
 use magnus::{Error, Ruby};
 use std::{io::Read, thread};
 
@@ -6,14 +6,36 @@ pub struct RecordReader<T: RecordParser> {
     pub(crate) reader: ReadImpl<T>,
 }
 
+impl<T: RecordParser> Drop for RecordReader<T> {
+    fn drop(&mut self) {
+        match &mut self.reader {
+            ReadImpl::MultiThreaded {
+                receiver,
+                handle,
+                headers,
+            } => {
+                receiver.close();
+                if let Some(handle) = handle.take() {
+                    let _ = handle.join();
+                }
+                StringCache::clear(headers).unwrap();
+            }
+            ReadImpl::SingleThreaded { headers, .. } => {
+                StringCache::clear(headers).unwrap();
+            }
+        }
+    }
+}
+
 #[allow(dead_code)]
 pub enum ReadImpl<T: RecordParser> {
     SingleThreaded {
         reader: csv::Reader<Box<dyn Read + Send + 'static>>,
-        headers: Vec<String>,
+        headers: Vec<&'static str>,
         null_string: String,
     },
     MultiThreaded {
+        headers: Vec<&'static str>,
         receiver: kanal::Receiver<T::Output>,
         handle: Option<thread::JoinHandle<()>>,
     },
@@ -48,7 +70,9 @@ impl<T: RecordParser> Iterator for RecordReader<T> {
 
     fn next(&mut self) -> Option<Self::Item> {
         match &mut self.reader {
-            ReadImpl::MultiThreaded { receiver, handle } => match receiver.recv() {
+            ReadImpl::MultiThreaded {
+                receiver, handle, ..
+            } => match receiver.recv() {
                 Ok(record) => Some(record),
                 Err(_) => {
                     if let Some(handle) = handle.take() {

data/ext/osv/src/csv/record.rs

@@ -1,17 +1,23 @@
-use magnus::{IntoValue, Ruby, Value};
+use magnus::{IntoValue, RHash, Ruby, Value};
 use std::collections::HashMap;
 
 #[derive(Debug)]
 pub enum CsvRecord {
     Vec(Vec<Option<String>>),
-    Map(HashMap<String, Option<String>>),
+    Map(HashMap<&'static str, Option<String>>),
 }
 
 impl IntoValue for CsvRecord {
     fn into_value_with(self, handle: &Ruby) -> Value {
         match self {
             CsvRecord::Vec(vec) => vec.into_value_with(handle),
-            CsvRecord::Map(map) => map.into_value_with(handle),
+            CsvRecord::Map(map) => {
+                let hash = RHash::new();
+                for (k, v) in map {
+                    hash.aset(k, v).unwrap();
+                }
+                hash.into_value_with(handle)
+            }
         }
     }
 }

data/ext/osv/src/reader.rs

@@ -1,15 +1,15 @@
-use std::collections::HashMap;
-
 use crate::csv::{CsvRecord, RecordReaderBuilder};
 use crate::utils::*;
 use magnus::value::ReprValue;
 use magnus::{block::Yield, Error, KwArgs, RHash, Ruby, Symbol, Value};
+use std::collections::HashMap;
 
 pub fn parse_csv(
-    ruby: &Ruby,
     rb_self: Value,
     args: &[Value],
 ) -> Result<Yield<Box<dyn Iterator<Item = CsvRecord>>>, Error> {
+    let ruby = unsafe { Ruby::get_unchecked() };
+
     let CsvArgs {
         to_read,
         has_headers,
@@ -18,7 +18,7 @@ pub fn parse_csv(
         null_string,
         buffer_size,
         result_type,
-    } = parse_csv_args(ruby, args)?;
+    } = parse_csv_args(&ruby, args)?;
 
     if !ruby.block_given() {
         return create_enumerator(EnumeratorArgs {
@@ -35,7 +35,7 @@ pub fn parse_csv(
 
     let iter: Box<dyn Iterator<Item = CsvRecord>> = match result_type.as_str() {
         "hash" => Box::new(
-            RecordReaderBuilder::<HashMap<String, Option<String>>>::new(ruby, to_read)
+            RecordReaderBuilder::<HashMap<&'static str, Option<String>>>::new(&ruby, to_read)
                 .has_headers(has_headers)
                 .delimiter(delimiter)
                 .quote_char(quote_char)
@@ -45,7 +45,7 @@ pub fn parse_csv(
                 .map(CsvRecord::Map),
         ),
         "array" => Box::new(
-            RecordReaderBuilder::<Vec<Option<String>>>::new(ruby, to_read)
+            RecordReaderBuilder::<Vec<Option<String>>>::new(&ruby, to_read)
                 .has_headers(has_headers)
                 .delimiter(delimiter)
                 .quote_char(quote_char)

data/lib/osv/version.rb

@@ -1,3 +1,3 @@
 module OSV
-  VERSION = "0.3.0"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: osv
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Nathan Jaremko
@@ -56,6 +56,7 @@ files:
 - ext/osv/Cargo.toml
 - ext/osv/extconf.rb
 - ext/osv/src/csv/builder.rs
+- ext/osv/src/csv/header_cache.rs
 - ext/osv/src/csv/mod.rs
 - ext/osv/src/csv/parser.rs
 - ext/osv/src/csv/reader.rs