multi_compress 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f801c58708b34a23e3348b12d482ce3afbbf12208bdfa7d8454b20d4afbf55f4
-  data.tar.gz: 666eee26931519bf0069d451767053bc87cf91cede44cfe69a87408dc4b08736
+  metadata.gz: 23ab6bacd75b21b5cfbf5b7b3121428c18060bd9e097f815438af6c8bafd8883
+  data.tar.gz: 90321202358a43bb732077aa1f28b8a9e5d756e27067df851671883a21eb1470
 SHA512:
-  metadata.gz: 39c03d5ce59b250947c9c91a61926d5ac2bdad8193cdd0b5d38bdb639e7ad38921a26e439729c0ea55cebe133a3724bd3010e3d83147aa4ce00a66909f34d7e6
-  data.tar.gz: d633ab7a2257c71d741b66c598aef4924ca99ef62dbaa01185aa1efdaaae93e7ffcaaec0205a300bc6291e279d8fafc34560a203e71da3c9ae6825c69819faa6
+  metadata.gz: 431921d63b8757216df9179dfd5d792103777dbf597d52cfafeb2e593ee8ab52ce12f374499826b0eba45a164bfde0f4adaa3aa3ba9ee811c6d9f44ed2ccdb7d
+  data.tar.gz: 2e1d3bf4455fd627696c7ff7a500e6424497df012939487d39896b8e50dad421c8acd8b427f10fc3de6a51b799ca5b1532cda5508485440e4f633a5ac5677a1d

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.3.2]
+
+### Changed
+- Micro-optimization
+
+## [0.3.1]
+
+### Fixed
+- Data race fix
+
 ## [0.3.0]
 
 ### Added

data/README.md

@@ -106,9 +106,9 @@ Performance comparison against Ruby's built-in zlib compression (200 iterations
 │ Medium JSON (~370KB, no GC) │    8.5% │   15.7% │    6.7% │    5.5% │
 │ Medium logs (~168KB, no GC) │    8.6% │   17.2% │    5.4% │    3.2% │
 │ Large JSON (~1.6MB, GC)     │    8.1% │   15.1% │    6.1% │    5.6% │
-│ Large logs (~600KB, GC)     │    7.6% │   16.0% │    2.8% │    2.1% │
+│ Large logs (~600KB, GC)     │    7.6% │   16.0% │    2.9% │    2.0% │
 │ Large JSON (~1.6MB, no GC)  │    8.1% │   15.1% │    6.1% │    5.6% │
-│ Large logs (~600KB, no GC)  │    7.6% │   16.0% │    2.8% │    2.1% │
+│ Large logs (~600KB, no GC)  │    7.6% │   16.0% │    2.9% │    2.0% │
 └─────────────────────────────┴─────────┴─────────┴─────────┴─────────┘
 ```
 
@@ -117,18 +117,18 @@ Performance comparison against Ruby's built-in zlib compression (200 iterations
 ┌─────────────────────────────┬─────────┬─────────┬─────────┬─────────┐
 │ Configuration               │  zlib   │   lz4   │  zstd   │ brotli  │
 ├─────────────────────────────┼─────────┼─────────┼─────────┼─────────┤
-│ Small JSON (~10KB, GC)      │    0.05 │    0.01 │    0.02 │    0.14 │
-│ Small text (~10KB, GC)      │    0.04 │    0.00 │    0.01 │    0.11 │
+│ Small JSON (~10KB, GC)      │    0.05 │    0.01 │    0.02 │    0.12 │
+│ Small text (~10KB, GC)      │    0.03 │    0.00 │    0.01 │    0.09 │
 │ Small JSON (~10KB, no GC)   │    0.06 │    0.01 │    0.02 │    0.13 │
-│ Small text (~10KB, no GC)   │    0.04 │    0.00 │    0.01 │    0.11 │
-│ Medium JSON (~370KB, GC)    │    2.73 │    0.29 │    0.42 │    2.36 │
-│ Medium logs (~168KB, GC)    │    1.23 │    0.14 │    0.18 │    0.92 │
-│ Medium JSON (~370KB, no GC) │    2.72 │    0.28 │    0.41 │    2.41 │
-│ Medium logs (~168KB, no GC) │    1.26 │    0.13 │    0.18 │    0.96 │
-│ Large JSON (~1.6MB, GC)     │   12.44 │    1.38 │    1.96 │   12.44 │
-│ Large logs (~600KB, GC)     │    4.29 │    0.46 │    0.49 │    2.85 │
-│ Large JSON (~1.6MB, no GC)  │   12.22 │    1.28 │    1.86 │   11.83 │
-│ Large logs (~600KB, no GC)  │    4.39 │    0.42 │    0.44 │    2.86 │
+│ Small text (~10KB, no GC)   │    0.03 │    0.00 │    0.01 │    0.11 │
+│ Medium JSON (~370KB, GC)    │    2.62 │    0.28 │    0.39 │    2.31 │
+│ Medium logs (~168KB, GC)    │    1.23 │    0.13 │    0.18 │    0.88 │
+│ Medium JSON (~370KB, no GC) │    2.65 │    0.27 │    0.40 │    2.31 │
+│ Medium logs (~168KB, no GC) │    1.27 │    0.13 │    0.18 │    0.95 │
+│ Large JSON (~1.6MB, GC)     │   11.70 │    1.36 │    1.93 │   11.95 │
+│ Large logs (~600KB, GC)     │    4.10 │    0.45 │    0.45 │    2.62 │
+│ Large JSON (~1.6MB, no GC)  │   11.47 │    1.27 │    1.88 │   11.47 │
+│ Large logs (~600KB, no GC)  │    4.06 │    0.41 │    0.45 │    2.79 │
 └─────────────────────────────┴─────────┴─────────┴─────────┴─────────┘
 ```
 
@@ -137,18 +137,18 @@ Performance comparison against Ruby's built-in zlib compression (200 iterations
 ┌─────────────────────────────┬─────────┬─────────┬─────────┬─────────┐
 │ Configuration               │  zlib   │   lz4   │  zstd   │ brotli  │
 ├─────────────────────────────┼─────────┼─────────┼─────────┼─────────┤
-│ Small JSON (~10KB, GC)      │   1.00x │   5.00x │   2.50x │   0.36x │
-│ Small text (~10KB, GC)      │   1.00x │     N/A │   4.00x │   0.36x │
+│ Small JSON (~10KB, GC)      │   1.00x │   5.00x │   2.50x │   0.42x │
+│ Small text (~10KB, GC)      │   1.00x │     N/A │   3.00x │   0.33x │
 │ Small JSON (~10KB, no GC)   │   1.00x │   6.00x │   3.00x │   0.46x │
-│ Small text (~10KB, no GC)   │   1.00x │     N/A │   4.00x │   0.36x │
-│ Medium JSON (~370KB, GC)    │   1.00x │   9.41x │   6.50x │   1.16x │
-│ Medium logs (~168KB, GC)    │   1.00x │   8.79x │   6.83x │   1.34x │
-│ Medium JSON (~370KB, no GC) │   1.00x │   9.71x │   6.63x │   1.13x │
-│ Medium logs (~168KB, no GC) │   1.00x │   9.69x │   7.00x │   1.31x │
-│ Large JSON (~1.6MB, GC)     │   1.00x │   9.01x │   6.35x │   1.00x │
-│ Large logs (~600KB, GC)     │   1.00x │   9.33x │   8.76x │   1.51x │
-│ Large JSON (~1.6MB, no GC)  │   1.00x │   9.55x │   6.57x │   1.03x │
-│ Large logs (~600KB, no GC)  │   1.00x │  10.45x │   9.98x │   1.53x │
+│ Small text (~10KB, no GC)   │   1.00x │     N/A │   3.00x │   0.27x │
+│ Medium JSON (~370KB, GC)    │   1.00x │   9.36x │   6.72x │   1.13x │
+│ Medium logs (~168KB, GC)    │   1.00x │   9.46x │   6.83x │   1.40x │
+│ Medium JSON (~370KB, no GC) │   1.00x │   9.81x │   6.62x │   1.15x │
+│ Medium logs (~168KB, no GC) │   1.00x │   9.77x │   7.06x │   1.34x │
+│ Large JSON (~1.6MB, GC)     │   1.00x │   8.60x │   6.06x │   0.98x │
+│ Large logs (~600KB, GC)     │   1.00x │   9.11x │   9.11x │   1.56x │
+│ Large JSON (~1.6MB, no GC)  │   1.00x │   9.03x │   6.10x │   1.00x │
+│ Large logs (~600KB, no GC)  │   1.00x │   9.90x │   9.02x │   1.46x │
 └─────────────────────────────┴─────────┴─────────┴─────────┴─────────┘
 ```
 

data/ext/multi_compress/multi_compress.c

@@ -137,12 +137,94 @@ static void init_id_cache(void) {
     sym_cache.max_ratio = ID2SYM(id_cache.max_ratio);
 }
 
-static inline VALUE opt_get(VALUE opts, VALUE sym) {
-    return NIL_P(opts) ? Qnil : rb_hash_aref(opts, sym);
+typedef struct {
+    VALUE algo;
+    VALUE level;
+    VALUE dictionary;
+    VALUE size;
+    VALUE format;
+    VALUE max_output_size;
+    VALUE max_ratio;
+    int saw_algorithm_keyword;
+} mc_opts_t;
+
+static inline void mc_opts_init(mc_opts_t *opts) {
+    opts->algo = Qnil;
+    opts->level = Qnil;
+    opts->dictionary = Qnil;
+    opts->size = Qnil;
+    opts->format = Qnil;
+    opts->max_output_size = Qundef;
+    opts->max_ratio = Qundef;
+    opts->saw_algorithm_keyword = 0;
+}
+
+static int mc_opts_parse_i(VALUE key, VALUE value, VALUE arg) {
+    mc_opts_t *opts = (mc_opts_t *)arg;
+
+    if (!SYMBOL_P(key))
+        return ST_CONTINUE;
+
+    ID id = SYM2ID(key);
+    if (id == id_cache.algo) {
+        opts->algo = value;
+    } else if (id == id_cache.level) {
+        opts->level = value;
+    } else if (id == id_cache.dictionary) {
+        opts->dictionary = value;
+    } else if (id == id_cache.size) {
+        opts->size = value;
+    } else if (id == id_cache.format) {
+        opts->format = value;
+    } else if (id == id_cache.max_output_size) {
+        opts->max_output_size = value;
+    } else if (id == id_cache.max_ratio) {
+        opts->max_ratio = value;
+    } else if (id == id_cache.algorithm) {
+        opts->saw_algorithm_keyword = 1;
+    }
+
+    return ST_CONTINUE;
+}
+
+static inline void mc_parse_opts(VALUE opts_hash, mc_opts_t *opts) {
+    mc_opts_init(opts);
+    if (NIL_P(opts_hash))
+        return;
+    Check_Type(opts_hash, T_HASH);
+    rb_hash_foreach(opts_hash, mc_opts_parse_i, (VALUE)opts);
 }
 
-static inline VALUE opt_lookup2(VALUE opts, VALUE sym, VALUE default_value) {
-    return NIL_P(opts) ? default_value : rb_hash_lookup2(opts, sym, default_value);
+static inline void scan_one_required_keywords(int argc, VALUE *argv, VALUE *arg, VALUE *opts) {
+    if (argc == 1) {
+        *arg = argv[0];
+        *opts = Qnil;
+        return;
+    }
+
+    if (argc == 2 && rb_keyword_given_p()) {
+        *arg = argv[0];
+        *opts = argv[1];
+        Check_Type(*opts, T_HASH);
+        return;
+    }
+
+    rb_error_arity(argc, 1, 1);
+}
+
+static inline void scan_zero_required_keywords(int argc, VALUE *argv, VALUE *opts) {
+    if (argc == 0) {
+        *opts = Qnil;
+        return;
+    }
+
+    if (argc == 1 && rb_keyword_given_p()) {
+        *opts = argv[0];
+        Check_Type(*opts, T_HASH);
+        return;
+    }
+
+    rb_error_arity(argc, 0, 0);
 }
 
 enum { LZ4_FRAME_MAGIC_LEN = 4 };
@@ -152,8 +234,9 @@ static inline int is_lz4_frame_magic(const uint8_t *data, size_t len) {
     return len >= LZ4_FRAME_MAGIC_LEN && memcmp(data, LZ4_FRAME_MAGIC, LZ4_FRAME_MAGIC_LEN) == 0;
 }
 
-static lz4_format_t parse_lz4_format(VALUE opts, compress_algo_t algo, int explicit_algo) {
-    VALUE format_val = opt_lookup2(opts, sym_cache.format, Qundef);
+static lz4_format_t parse_lz4_format(const mc_opts_t *opts, compress_algo_t algo,
+                                     int explicit_algo) {
+    VALUE format_val = opts->format;
     if (format_val == Qundef || NIL_P(format_val))
         return LZ4_FORMAT_BLOCK;
     if (explicit_algo && algo != ALGO_LZ4)
@@ -169,10 +252,8 @@ static lz4_format_t parse_lz4_format(VALUE opts, compress_algo_t algo, int expli
     return LZ4_FORMAT_BLOCK;
 }
 
-static inline void reject_algorithm_keyword(VALUE opts) {
-    if (NIL_P(opts))
-        return;
-    if (rb_hash_lookup2(opts, sym_cache.algorithm, Qundef) != Qundef) {
+static inline void reject_algorithm_keyword(const mc_opts_t *opts) {
+    if (opts->saw_algorithm_keyword) {
         rb_raise(rb_eArgError, "unknown keyword: :algorithm (use :algo)");
     }
 }
@@ -383,11 +464,8 @@ static void limits_config_init(limits_config_t *limits) {
     limits->max_ratio = DEFAULT_MAX_RATIO;
 }
 
-static void limits_config_apply_opts(VALUE opts, limits_config_t *limits) {
-    if (NIL_P(opts))
-        return;
-
-    VALUE val = opt_lookup2(opts, sym_cache.max_output_size, Qundef);
+static void limits_config_apply_parsed(const mc_opts_t *opts, limits_config_t *limits) {
+    VALUE val = opts->max_output_size;
     if (val != Qundef && !NIL_P(val)) {
         size_t max_output_size = NUM2SIZET(val);
         if (max_output_size == 0)
@@ -395,7 +473,7 @@ static void limits_config_apply_opts(VALUE opts, limits_config_t *limits) {
         limits->max_output_size = max_output_size;
     }
 
-    val = opt_lookup2(opts, sym_cache.max_ratio, Qundef);
+    val = opts->max_ratio;
     if (val == Qundef)
         return;
     if (NIL_P(val)) {
@@ -411,9 +489,9 @@ static void limits_config_apply_opts(VALUE opts, limits_config_t *limits) {
     limits->max_ratio = max_ratio;
 }
 
-static void parse_limits_from_opts(VALUE opts, limits_config_t *limits) {
+static void parse_limits_from_parsed_opts(const mc_opts_t *opts, limits_config_t *limits) {
     limits_config_init(limits);
-    limits_config_apply_opts(opts, limits);
+    limits_config_apply_parsed(opts, limits);
 }
 
 static inline size_t checked_add_size(size_t left, size_t right, const char *message) {
@@ -611,7 +689,7 @@ static inline size_t fiber_maybe_yield(size_t bytes_since_yield, size_t just_pro
     return bytes_since_yield;
 }
 
-#define DICT_CDICT_CACHE_SIZE 4
+#define DICT_CDICT_CACHE_SIZE 22
 _Static_assert(DICT_CDICT_CACHE_SIZE > 0, "CDict cache needs at least one slot");
 
 typedef struct {
@@ -623,6 +701,7 @@ struct dictionary_s {
     compress_algo_t algo;
     uint8_t *data;
     size_t size;
+    pthread_mutex_t cache_mutex;
 
     cdict_cache_entry_t cdict_cache[DICT_CDICT_CACHE_SIZE];
     int cdict_cache_count;
@@ -632,12 +711,15 @@ struct dictionary_s {
 
 static void dict_free(void *ptr) {
     dictionary_t *dict = (dictionary_t *)ptr;
+    if (!dict)
+        return;
     for (int i = 0; i < dict->cdict_cache_count; i++) {
         if (dict->cdict_cache[i].cdict)
             ZSTD_freeCDict(dict->cdict_cache[i].cdict);
     }
     if (dict->ddict)
         ZSTD_freeDDict(dict->ddict);
+    pthread_mutex_destroy(&dict->cache_mutex);
     if (dict->data)
         xfree(dict->data);
     xfree(dict);
@@ -666,47 +748,78 @@ static const rb_data_type_t dictionary_type = {
 static VALUE dict_alloc(VALUE klass) {
     dictionary_t *d = ALLOC(dictionary_t);
     memset(d, 0, sizeof(dictionary_t));
+    if (pthread_mutex_init(&d->cache_mutex, NULL) != 0) {
+        xfree(d);
+        rb_raise(eMemError, "failed to initialize dictionary cache mutex");
+    }
     return TypedData_Wrap_Struct(klass, &dictionary_type, d);
 }
 
 static ZSTD_CDict *dict_get_cdict(dictionary_t *dict, int level) {
+    ZSTD_CDict *existing = NULL;
+
+    pthread_mutex_lock(&dict->cache_mutex);
     for (int i = 0; i < dict->cdict_cache_count; i++) {
-        if (dict->cdict_cache[i].level == level)
-            return dict->cdict_cache[i].cdict;
+        if (dict->cdict_cache[i].level == level) {
+            existing = dict->cdict_cache[i].cdict;
+            break;
+        }
     }
+    pthread_mutex_unlock(&dict->cache_mutex);
+
+    if (existing)
+        return existing;
 
     ZSTD_CDict *cdict = ZSTD_createCDict(dict->data, dict->size, level);
     if (!cdict)
         return NULL;
 
+    pthread_mutex_lock(&dict->cache_mutex);
     for (int i = 0; i < dict->cdict_cache_count; i++) {
         if (dict->cdict_cache[i].level == level) {
+            existing = dict->cdict_cache[i].cdict;
+            pthread_mutex_unlock(&dict->cache_mutex);
             ZSTD_freeCDict(cdict);
-            return dict->cdict_cache[i].cdict;
+            return existing;
         }
     }
 
-    if (dict->cdict_cache_count < DICT_CDICT_CACHE_SIZE) {
-        dict->cdict_cache[dict->cdict_cache_count].level = level;
-        dict->cdict_cache[dict->cdict_cache_count].cdict = cdict;
-        dict->cdict_cache_count++;
-    } else {
-        ZSTD_CDict *old_cdict = dict->cdict_cache[0].cdict;
-        memmove(&dict->cdict_cache[0], &dict->cdict_cache[1],
-                sizeof(cdict_cache_entry_t) * (DICT_CDICT_CACHE_SIZE - 1));
-        dict->cdict_cache[DICT_CDICT_CACHE_SIZE - 1].level = level;
-        dict->cdict_cache[DICT_CDICT_CACHE_SIZE - 1].cdict = cdict;
-        if (old_cdict)
-            ZSTD_freeCDict(old_cdict);
+    if (dict->cdict_cache_count >= DICT_CDICT_CACHE_SIZE) {
+        pthread_mutex_unlock(&dict->cache_mutex);
+        ZSTD_freeCDict(cdict);
+        rb_raise(eError, "zstd dictionary cdict cache exhausted");
     }
+
+    dict->cdict_cache[dict->cdict_cache_count].level = level;
+    dict->cdict_cache[dict->cdict_cache_count].cdict = cdict;
+    dict->cdict_cache_count++;
+    pthread_mutex_unlock(&dict->cache_mutex);
     return cdict;
 }
 
 static ZSTD_DDict *dict_get_ddict(dictionary_t *dict) {
+    ZSTD_DDict *existing;
+
+    pthread_mutex_lock(&dict->cache_mutex);
+    existing = dict->ddict;
+    pthread_mutex_unlock(&dict->cache_mutex);
+    if (existing)
+        return existing;
+
+    ZSTD_DDict *created = ZSTD_createDDict(dict->data, dict->size);
+    if (!created)
+        return NULL;
+
+    pthread_mutex_lock(&dict->cache_mutex);
     if (!dict->ddict) {
-        dict->ddict = ZSTD_createDDict(dict->data, dict->size);
+        dict->ddict = created;
+        pthread_mutex_unlock(&dict->cache_mutex);
+        return created;
     }
-    return dict->ddict;
+    existing = dict->ddict;
+    pthread_mutex_unlock(&dict->cache_mutex);
+    ZSTD_freeDDict(created);
+    return existing;
 }
 
 typedef struct {
@@ -1072,20 +1185,20 @@ static void *zstd_fiber_compress_nogvl(void *arg) {
 
 static VALUE compress_compress(int argc, VALUE *argv, VALUE self) {
     VALUE data, opts;
-    rb_scan_args(argc, argv, "1:", &data, &opts);
+    scan_one_required_keywords(argc, argv, &data, &opts);
     StringValue(data);
-    reject_algorithm_keyword(opts);
 
-    VALUE algo_sym = Qnil, level_val = Qnil, dict_val = Qnil;
-    if (!NIL_P(opts)) {
-        algo_sym = opt_get(opts, sym_cache.algo);
-        level_val = opt_get(opts, sym_cache.level);
-        dict_val = opt_get(opts, sym_cache.dictionary);
-    }
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
+
+    VALUE algo_sym = parsed_opts.algo;
+    VALUE level_val = parsed_opts.level;
+    VALUE dict_val = parsed_opts.dictionary;
 
     int explicit_algo = !NIL_P(algo_sym);
     compress_algo_t algo = explicit_algo ? sym_to_algo(algo_sym) : ALGO_ZSTD;
-    lz4_format_t lz4_format = parse_lz4_format(opts, algo, explicit_algo);
+    lz4_format_t lz4_format = parse_lz4_format(&parsed_opts, algo, explicit_algo);
     int level = resolve_level(algo, level_val);
 
     dictionary_t *dict = NULL;
@@ -1371,17 +1484,17 @@ static VALUE compress_compress(int argc, VALUE *argv, VALUE self) {
 
 static VALUE compress_decompress(int argc, VALUE *argv, VALUE self) {
     VALUE data, opts;
-    rb_scan_args(argc, argv, "1:", &data, &opts);
+    scan_one_required_keywords(argc, argv, &data, &opts);
     StringValue(data);
-    reject_algorithm_keyword(opts);
 
-    VALUE algo_sym = Qnil, dict_val = Qnil;
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
+
+    VALUE algo_sym = parsed_opts.algo;
+    VALUE dict_val = parsed_opts.dictionary;
     limits_config_t limits;
-    parse_limits_from_opts(opts, &limits);
-    if (!NIL_P(opts)) {
-        algo_sym = opt_get(opts, sym_cache.algo);
-        dict_val = opt_get(opts, sym_cache.dictionary);
-    }
+    parse_limits_from_parsed_opts(&parsed_opts, &limits);
 
     const uint8_t *src = (const uint8_t *)RSTRING_PTR(data);
     size_t slen = RSTRING_LEN(data);
@@ -1393,7 +1506,7 @@ static VALUE compress_decompress(int argc, VALUE *argv, VALUE self) {
     } else {
         algo = sym_to_algo(algo_sym);
     }
-    lz4_format_t lz4_format = parse_lz4_format(opts, algo, explicit_algo);
+    lz4_format_t lz4_format = parse_lz4_format(&parsed_opts, algo, explicit_algo);
 
     const algo_policy_t *policy = algo_policy(algo);
 
@@ -1974,18 +2087,18 @@ static VALUE deflater_alloc(VALUE klass) {
 
 static VALUE deflater_initialize(int argc, VALUE *argv, VALUE self) {
     VALUE opts;
-    rb_scan_args(argc, argv, "0:", &opts);
-    reject_algorithm_keyword(opts);
+    scan_zero_required_keywords(argc, argv, &opts);
+
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
 
     deflater_t *d;
     TypedData_Get_Struct(self, deflater_t, &deflater_type, d);
 
-    VALUE algo_sym = Qnil, level_val = Qnil, dict_val = Qnil;
-    if (!NIL_P(opts)) {
-        algo_sym = opt_get(opts, sym_cache.algo);
-        level_val = opt_get(opts, sym_cache.level);
-        dict_val = opt_get(opts, sym_cache.dictionary);
-    }
+    VALUE algo_sym = parsed_opts.algo;
+    VALUE level_val = parsed_opts.level;
+    VALUE dict_val = parsed_opts.dictionary;
 
     d->algo = NIL_P(algo_sym) ? ALGO_ZSTD : sym_to_algo(algo_sym);
     d->level = resolve_level(d->algo, level_val);
@@ -2628,19 +2741,19 @@ static VALUE inflater_alloc(VALUE klass) {
 
 static VALUE inflater_initialize(int argc, VALUE *argv, VALUE self) {
     VALUE opts;
-    rb_scan_args(argc, argv, "0:", &opts);
-    reject_algorithm_keyword(opts);
+    scan_zero_required_keywords(argc, argv, &opts);
+
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
 
     inflater_t *inf;
     TypedData_Get_Struct(self, inflater_t, &inflater_type, inf);
 
-    VALUE algo_sym = Qnil, dict_val = Qnil;
+    VALUE algo_sym = parsed_opts.algo;
+    VALUE dict_val = parsed_opts.dictionary;
     limits_config_t limits;
-    parse_limits_from_opts(opts, &limits);
-    if (!NIL_P(opts)) {
-        algo_sym = opt_get(opts, sym_cache.algo);
-        dict_val = opt_get(opts, sym_cache.dictionary);
-    }
+    parse_limits_from_parsed_opts(&parsed_opts, &limits);
 
     inf->algo = NIL_P(algo_sym) ? ALGO_ZSTD : sym_to_algo(algo_sym);
     inf->closed = 0;
@@ -2867,7 +2980,6 @@ static VALUE inflater_write(VALUE self, VALUE chunk) {
     case ALGO_LZ4: {
         size_t data_len = inf->lz4_buf.len - inf->lz4_buf.offset;
         size_t needed = data_len + slen;
-        // TODO(v0.4): optional standard LZ4 frame format support via lz4frame.h
 
         if (inf->lz4_buf.offset > 0 && needed > inf->lz4_buf.cap) {
             if (data_len > 0)
@@ -3054,17 +3166,17 @@ static VALUE inflater_closed_p(VALUE self) {
 
 static VALUE dict_initialize(int argc, VALUE *argv, VALUE self) {
     VALUE raw, opts;
-    rb_scan_args(argc, argv, "1:", &raw, &opts);
+    scan_one_required_keywords(argc, argv, &raw, &opts);
     StringValue(raw);
-    reject_algorithm_keyword(opts);
+
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
 
     dictionary_t *d;
     TypedData_Get_Struct(self, dictionary_t, &dictionary_type, d);
 
-    VALUE algo_sym = Qnil;
-    if (!NIL_P(opts)) {
-        algo_sym = opt_get(opts, sym_cache.algo);
-    }
+    VALUE algo_sym = parsed_opts.algo;
     d->algo = NIL_P(algo_sym) ? ALGO_ZSTD : sym_to_algo(algo_sym);
 
     if (d->algo == ALGO_LZ4)
@@ -3148,39 +3260,35 @@ static VALUE train_dictionary_internal(VALUE samples, VALUE size_val, compress_a
 }
 
 static VALUE zstd_train_dictionary(int argc, VALUE *argv, VALUE self) {
-    // #if defined(__APPLE__) && (defined(__arm64__) || defined(__aarch64__))
-    //     rb_raise(eUnsupportedError,
-    //              "Zstd dictionary training is temporarily disabled on arm64-darwin "
-    //              "because the current vendored trainer path crashes on this platform");
-    // #endif
-
     VALUE samples, opts;
-    rb_scan_args(argc, argv, "1:", &samples, &opts);
-    reject_algorithm_keyword(opts);
-    VALUE size_val = opt_get(opts, sym_cache.size);
-    return train_dictionary_internal(samples, size_val, ALGO_ZSTD);
+    scan_one_required_keywords(argc, argv, &samples, &opts);
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
+    return train_dictionary_internal(samples, parsed_opts.size, ALGO_ZSTD);
 }
 
 static VALUE brotli_train_dictionary(int argc, VALUE *argv, VALUE self) {
     VALUE samples, opts;
-    rb_scan_args(argc, argv, "1:", &samples, &opts);
-    reject_algorithm_keyword(opts);
-    VALUE size_val = opt_get(opts, sym_cache.size);
+    scan_one_required_keywords(argc, argv, &samples, &opts);
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
 
-    return train_dictionary_internal(samples, size_val, ALGO_BROTLI);
+    return train_dictionary_internal(samples, parsed_opts.size, ALGO_BROTLI);
 }
 
 static VALUE dict_load(int argc, VALUE *argv, VALUE self) {
     VALUE path, opts;
-    rb_scan_args(argc, argv, "1:", &path, &opts);
+    scan_one_required_keywords(argc, argv, &path, &opts);
     StringValue(path);
-    reject_algorithm_keyword(opts);
     raise_if_path_has_null_byte(path);
 
-    VALUE algo_sym = Qnil;
-    if (!NIL_P(opts)) {
-        algo_sym = opt_get(opts, sym_cache.algo);
-    }
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
+
+    VALUE algo_sym = parsed_opts.algo;
     compress_algo_t algo = NIL_P(algo_sym) ? ALGO_ZSTD : sym_to_algo(algo_sym);
 
     if (algo == ALGO_LZ4)

data/lib/multi_compress/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MultiCompress
-  VERSION = "0.3.0"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: multi_compress
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Roman Haydarov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-18 00:00:00.000000000 Z
+date: 2026-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler