ruby-zstds 1.2.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd4f85616a45bb4ea60d08e4f6e4dfa0091d5a098458e3f5c5ac81d6c9113aa3
-  data.tar.gz: a7b1afaa038f4339b0de26e91ae86c16a942620f8f450cbc791a7330cec372cb
+  metadata.gz: 1a3bf1ddf3028d59dbfadc868b7dd0049f95213ccede92b223cab2f1af2a847b
+  data.tar.gz: d8dce89cd592e7815aea864900afd336e67a0bc65def9f6b21b30a67b184a7fc
 SHA512:
-  metadata.gz: 0e76817922415c3fa1381aca25636aef90cc1a4bb98c8c8adc998667fc5eb10e24e27f66127f6c93d341af222bbf44229ef37996ea24fa89888b5381f0e8f1fb
-  data.tar.gz: c4aaa1527b723e6c2eec1f185b10657d50fd2e55fb0a9debf4cf993d561931b8cb60216023b0971d4739389eadcdccec011db668b943bfdc49f323e5852f409c
+  metadata.gz: b956bba7a80f4456b736748e2355d9e862f230af855d5b539cb0d7034c183238d8e8b68a65c629fb5baae2ec94757d0e8f822572d0bcc694a2740bb173ab6e7d
+  data.tar.gz: 6222867bf832bf0d8b08e8cc94d25be1eec376e87b6f24e1bc2d8c75f36d06bb12a7a601f8737eccafa02bdd1c1c0a3eee65c7d7f2c77fcb9e0b4068d9afaef1

data/AUTHORS

@@ -1 +1,3 @@
 Andrew Aladjev
+Ivan Takarlikov
+Jenner La Fave

data/README.md

@@ -1,14 +1,23 @@
 # Ruby bindings for zstd library
 
-| AppVeyor | Circle | Github actions | Codecov | Gem  |
-| :------: | :----: | :------------: | :-----: | :--: |
-| [![AppVeyor test status](https://ci.appveyor.com/api/projects/status/github/andrew-aladev/ruby-zstds?branch=master&svg=true)](https://ci.appveyor.com/project/andrew-aladev/ruby-zstds/branch/master) | [![Circle test status](https://circleci.com/gh/andrew-aladev/ruby-zstds/tree/master.svg?style=shield)](https://circleci.com/gh/andrew-aladev/ruby-zstds/tree/master) | [![Github Actions test status](https://github.com/andrew-aladev/ruby-zstds/workflows/test/badge.svg?branch=master)](https://github.com/andrew-aladev/ruby-zstds/actions) | [![Codecov](https://codecov.io/gh/andrew-aladev/ruby-zstds/branch/master/graph/badge.svg)](https://codecov.io/gh/andrew-aladev/ruby-zstds) | [![Gem](https://img.shields.io/gem/v/ruby-zstds.svg)](https://rubygems.org/gems/ruby-zstds) |
+| AppVeyor | Jenkins | Github actions | Codecov | Gem  |
+| :------: | :-----: | :------------: | :-----: | :--: |
+| [![AppVeyor test status](https://ci.appveyor.com/api/projects/status/github/andrew-aladev/ruby-zstds?branch=master&svg=true)](https://ci.appveyor.com/project/andrew-aladev/ruby-zstds/branch/master) | [![Jenkins test status](http://37.187.122.190:58182/buildStatus/icon?job=ruby-zstds)](http://37.187.122.190:58182/job/ruby-zstds) | [![Github Actions test status](https://github.com/andrew-aladev/ruby-zstds/workflows/test/badge.svg?branch=master)](https://github.com/andrew-aladev/ruby-zstds/actions) | [![Codecov](https://codecov.io/gh/andrew-aladev/ruby-zstds/branch/master/graph/badge.svg)](https://codecov.io/gh/andrew-aladev/ruby-zstds) | [![Gem](https://img.shields.io/gem/v/ruby-zstds.svg)](https://rubygems.org/gems/ruby-zstds) |
 
 See [zstd library](https://github.com/facebook/zstd).
 
 ## Installation
 
-Please install zstd library first, use latest 1.4.0+ version.
+Operating systems: GNU/Linux, FreeBSD, OSX.
+
+Dependencies: [zstd](https://github.com/facebook/zstd) 1.4.0+ version.
+
+| Popular OS | Dependencies              |
+|------------|---------------------------|
+| Ubuntu     | `libzstd-dev`             |
+| CentOS     | `libzstd-devel`           |
+| ArchLinux  | `zstd`                    |
+| OSX        | `zstd`                    |
 
 ```sh
 gem install ruby-zstds
@@ -23,6 +32,22 @@ gem install pkg/ruby-zstds-*.gem
 
 You can also use [overlay](https://github.com/andrew-aladev/overlay) for gentoo.
 
+### Installation in macOS on Apple Silicon
+
+On M1 Macs, Homebrew installs to /opt/homebrew, so you'll need to specify its
+include and lib paths when building the native extension for zstd.
+
+```sh
+brew install zstd
+gem install ruby-zstds -- --with-opt-include=/opt/homebrew/include --with-opt-lib=/opt/homebrew/lib
+```
+
+You can also configure Bundler to use those options when installing:
+
+```sh
+bundle config set build.ruby-zstds "--with-opt-include=/opt/homebrew/include --with-opt-lib=/opt/homebrew/lib"
+```
+
 ## Usage
 
 There are simple APIs: `String` and `File`. Also you can use generic streaming API: `Stream::Writer` and `Stream::Reader`.
@@ -125,6 +150,10 @@ Parallel.each large_datas do |large_data|
 end
 ```
 
+# Docs
+
+Please review [rdoc generated docs](https://andrew-aladev.github.io/ruby-zstds).
+
 ## Options
 
 | Option                          | Values         | Default    | Description |
@@ -318,14 +347,11 @@ Special asynchronous methods missing in `Zlib::GzipWriter`.
 So it is possible to have asynchronous variants for these synchronous methods.
 Behaviour is the same as `IO#write_nonblock` method.
 
-All nonblock operations for file will raise `EBADF` error on Windows.
-Setting file into nonblocking mode is [not available on Windows](https://github.com/ruby/ruby/blob/master/win32/win32.c#L4388).
-
 ```
 #<<(object)
 #print(*objects)
 #printf(*args)
-#putc(object, encoding: ::Encoding::BINARY)
+#putc(object, :encoding => 'ASCII-8BIT')
 #puts(*objects)
 ```
 
@@ -449,10 +475,6 @@ You should lock all shared data between threads.
 For example: you should not use same compressor/decompressor inside multiple threads.
 Please verify that you are using each processor inside single thread at the same time.
 
-## Operating systems
-
-GNU/Linux, FreeBSD, OSX, Windows (MinGW).
-
 ## CI
 
 Please visit [scripts/test-images](scripts/test-images).

data/ext/extconf.rb

@@ -72,6 +72,7 @@ require_header(
     "ZSTD_strategy"
   ]
 )
+
 require_header(
   "zstd_errors.h",
   :constants => %w[
@@ -106,11 +107,23 @@ def require_library(name, functions)
   end
 end
 
+# rubocop:disable Style/GlobalVars
+if find_library "zstd", "ZDICT_getDictHeaderSize"
+  $defs.push "-DHAVE_ZDICT_HEADER_SIZE"
+end
+
+zdict_has_params   = find_type "ZDICT_params_t", nil, "zdict.h"
+zdict_has_finalize = find_library "zstd", "ZDICT_finalizeDictionary"
+
+if zdict_has_params && zdict_has_finalize
+  $defs.push "-DHAVE_ZDICT_FINALIZE"
+end
+# rubocop:enable Style/GlobalVars
+
 require_library(
   "zstd",
   %w[
     ZDICT_getDictID
-    ZDICT_getDictHeaderSize
     ZDICT_isError
     ZDICT_trainFromBuffer
     ZSTD_CCtx_loadDictionary

data/ext/zstds_ext/dictionary.c

@@ -9,10 +9,9 @@
 #include "zstds_ext/buffer.h"
 #include "zstds_ext/error.h"
 #include "zstds_ext/gvl.h"
-#include "zstds_ext/macro.h"
 #include "zstds_ext/option.h"
 
-// -- initialization --
+// -- common --
 
 typedef struct
 {
@@ -20,43 +19,64 @@ typedef struct
   size_t      size;
 } sample_t;
 
-typedef struct
+static inline void check_raw_samples(VALUE raw_samples)
 {
-  const sample_t*    samples;
-  size_t             length;
-  char*              buffer;
-  size_t             capacity;
-  zstds_result_t     result;
-  zstds_ext_result_t ext_result;
-} train_args_t;
+  Check_Type(raw_samples, T_ARRAY);
 
-static inline void* train_wrapper(void* data)
+  size_t samples_length = RARRAY_LEN(raw_samples);
+
+  for (size_t index = 0; index < samples_length; index++) {
+    Check_Type(rb_ary_entry(raw_samples, index), T_STRING);
+  }
+}
+
+static inline sample_t* prepare_samples(VALUE raw_samples, size_t* samples_length_ptr)
+{
+  size_t    samples_length = RARRAY_LEN(raw_samples);
+  sample_t* samples        = malloc(sizeof(sample_t) * samples_length);
+  if (samples == NULL) {
+    zstds_ext_raise_error(ZSTDS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  for (size_t index = 0; index < samples_length; index++) {
+    VALUE     raw_sample = rb_ary_entry(raw_samples, index);
+    sample_t* sample     = &samples[index];
+
+    sample->data = RSTRING_PTR(raw_sample);
+    sample->size = RSTRING_LEN(raw_sample);
+  }
+
+  *samples_length_ptr = samples_length;
+
+  return samples;
+}
+
+static inline zstds_ext_result_t prepare_samples_group(
+  const sample_t*    samples,
+  size_t             samples_length,
+  zstds_ext_byte_t** group_ptr,
+  size_t**           sizes_ptr)
 {
-  train_args_t*   args    = data;
-  const sample_t* samples = args->samples;
-  size_t          length  = args->length;
-  size_t          size    = 0;
+  size_t size = 0;
 
-  for (size_t index = 0; index < length; index++) {
+  for (size_t index = 0; index < samples_length; index++) {
     size += samples[index].size;
   }
 
   zstds_ext_byte_t* group = malloc(size);
   if (group == NULL) {
-    args->ext_result = ZSTDS_EXT_ERROR_ALLOCATE_FAILED;
-    return NULL;
+    return ZSTDS_EXT_ERROR_ALLOCATE_FAILED;
   }
 
-  size_t* sizes = malloc(length * sizeof(size_t));
+  size_t* sizes = malloc(samples_length * sizeof(size_t));
   if (sizes == NULL) {
     free(group);
-    args->ext_result = ZSTDS_EXT_ERROR_ALLOCATE_FAILED;
-    return NULL;
+    return ZSTDS_EXT_ERROR_ALLOCATE_FAILED;
   }
 
   size_t offset = 0;
 
-  for (size_t index = 0; index < length; index++) {
+  for (size_t index = 0; index < samples_length; index++) {
     const sample_t* sample_ptr  = &samples[index];
     size_t          sample_size = sample_ptr->size;
 
@@ -66,7 +86,38 @@ static inline void* train_wrapper(void* data)
     sizes[index] = sample_size;
   }
 
-  args->result = ZDICT_trainFromBuffer((void*) args->buffer, args->capacity, group, sizes, (unsigned int) length);
+  *group_ptr = group;
+  *sizes_ptr = sizes;
+
+  return 0;
+}
+
+// -- training --
+
+typedef struct
+{
+  const sample_t*    samples;
+  size_t             samples_length;
+  char*              buffer;
+  size_t             capacity;
+  zstds_result_t     result;
+  zstds_ext_result_t ext_result;
+} train_args_t;
+
+static inline void* train_wrapper(void* data)
+{
+  train_args_t* args = data;
+
+  zstds_ext_byte_t*  group;
+  size_t*            sizes;
+  zstds_ext_result_t result = prepare_samples_group(args->samples, args->samples_length, &group, &sizes);
+  if (result != 0) {
+    args->ext_result = result;
+    return NULL;
+  }
+
+  args->result =
+    ZDICT_trainFromBuffer((void*) args->buffer, args->capacity, group, sizes, (unsigned int) args->samples_length);
 
   free(group);
   free(sizes);
@@ -83,17 +134,13 @@ static inline void* train_wrapper(void* data)
 
 VALUE zstds_ext_train_dictionary_buffer(VALUE ZSTDS_EXT_UNUSED(self), VALUE raw_samples, VALUE options)
 {
-  Check_Type(raw_samples, T_ARRAY);
-
-  size_t length = RARRAY_LEN(raw_samples);
-
-  for (size_t index = 0; index < length; index++) {
-    Check_Type(rb_ary_entry(raw_samples, index), T_STRING);
-  }
-
+  check_raw_samples(raw_samples);
   Check_Type(options, T_HASH);
-  ZSTDS_EXT_GET_BOOL_OPTION(options, gvl);
   ZSTDS_EXT_GET_SIZE_OPTION(options, capacity);
+  ZSTDS_EXT_GET_BOOL_OPTION(options, gvl);
+
+  size_t    samples_length;
+  sample_t* samples = prepare_samples(raw_samples, &samples_length);
 
   if (capacity == 0) {
     capacity = ZSTDS_EXT_DEFAULT_DICTIONARY_CAPACITY;
@@ -106,27 +153,147 @@ VALUE zstds_ext_train_dictionary_buffer(VALUE ZSTDS_EXT_UNUSED(self), VALUE raw_
     zstds_ext_raise_error(ZSTDS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
-  sample_t* samples = malloc(sizeof(sample_t) * length);
-  if (samples == NULL) {
+  train_args_t args = {
+    .samples        = samples,
+    .samples_length = samples_length,
+    .buffer         = RSTRING_PTR(buffer),
+    .capacity       = capacity,
+  };
+
+  ZSTDS_EXT_GVL_WRAP(gvl, train_wrapper, &args);
+  free(samples);
+
+  if (args.ext_result != 0) {
+    zstds_ext_raise_error(args.ext_result);
+  }
+
+  ZSTDS_EXT_RESIZE_STRING_BUFFER(buffer, args.result, exception);
+  if (exception != 0) {
     zstds_ext_raise_error(ZSTDS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
-  for (size_t index = 0; index < length; index++) {
-    VALUE     raw_sample = rb_ary_entry(raw_samples, index);
-    sample_t* sample     = &samples[index];
+  return buffer;
+}
 
-    sample->data = RSTRING_PTR(raw_sample);
-    sample->size = RSTRING_LEN(raw_sample);
+// -- finalizing --
+
+#if defined(HAVE_ZDICT_FINALIZE)
+typedef struct
+{
+  const sample_t*                samples;
+  size_t                         samples_length;
+  char*                          buffer;
+  size_t                         max_size;
+  char*                          content;
+  size_t                         content_length;
+  zstds_ext_dictionary_options_t dictionary_options;
+  zstds_result_t                 result;
+  zstds_ext_result_t             ext_result;
+} finalize_args_t;
+
+static inline void* finalize_wrapper(void* data)
+{
+  finalize_args_t* args = data;
+
+  zstds_ext_byte_t*  group;
+  size_t*            sizes;
+  zstds_ext_result_t result = prepare_samples_group(args->samples, args->samples_length, &group, &sizes);
+  if (result != 0) {
+    args->ext_result = result;
+    return NULL;
   }
 
-  train_args_t args = {
-    .samples  = samples,
-    .length   = length,
-    .buffer   = RSTRING_PTR(buffer),
-    .capacity = capacity,
+  zstds_ext_option_t compression_level = args->dictionary_options.compression_level;
+  int                compression_level_value;
+  if (compression_level.has_value) {
+    compression_level_value = compression_level.value;
+  } else {
+    compression_level_value = 0;
+  }
+
+  zstds_ext_option_t notification_level = args->dictionary_options.notification_level;
+  unsigned int       notification_level_value;
+  if (notification_level.has_value) {
+    notification_level_value = notification_level.value;
+  } else {
+    notification_level_value = 0;
+  }
+
+  zstds_ext_option_t dictionary_id = args->dictionary_options.dictionary_id;
+  unsigned int       dictionary_id_value;
+  if (dictionary_id.has_value) {
+    dictionary_id_value = dictionary_id.value;
+  } else {
+    dictionary_id_value = 0;
+  }
+
+  ZDICT_params_t dictionary_params = {
+    .compressionLevel  = compression_level_value,
+    .notificationLevel = notification_level_value,
+    .dictID            = dictionary_id_value,
   };
 
-  ZSTDS_EXT_GVL_WRAP(gvl, train_wrapper, &args);
+  args->result = ZDICT_finalizeDictionary(
+    (void*) args->buffer,
+    args->max_size,
+    (void*) args->content,
+    args->content_length,
+    group,
+    sizes,
+    (unsigned int) args->samples_length,
+    dictionary_params);
+
+  free(group);
+  free(sizes);
+
+  if (ZDICT_isError(args->result)) {
+    args->ext_result = zstds_ext_get_error(ZSTD_getErrorCode(args->result));
+    return NULL;
+  }
+
+  args->ext_result = 0;
+
+  return NULL;
+}
+
+VALUE zstds_ext_finalize_dictionary_buffer(
+  VALUE ZSTDS_EXT_UNUSED(self),
+  VALUE content,
+  VALUE raw_samples,
+  VALUE options)
+{
+  Check_Type(content, T_STRING);
+  check_raw_samples(raw_samples);
+  Check_Type(options, T_HASH);
+  ZSTDS_EXT_GET_SIZE_OPTION(options, max_size);
+  ZSTDS_EXT_GET_BOOL_OPTION(options, gvl);
+  ZSTDS_EXT_GET_DICTIONARY_OPTIONS(options);
+
+  size_t    samples_length;
+  sample_t* samples = prepare_samples(raw_samples, &samples_length);
+
+  if (max_size == 0) {
+    max_size = ZSTDS_EXT_DEFAULT_DICTIONARY_MAX_SIZE;
+  }
+
+  int exception;
+
+  ZSTDS_EXT_CREATE_STRING_BUFFER(buffer, max_size, exception);
+  if (exception != 0) {
+    zstds_ext_raise_error(ZSTDS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  finalize_args_t args = {
+    .samples            = samples,
+    .samples_length     = samples_length,
+    .buffer             = RSTRING_PTR(buffer),
+    .max_size           = max_size,
+    .content            = RSTRING_PTR(content),
+    .content_length     = RSTRING_LEN(content),
+    .dictionary_options = dictionary_options,
+  };
+
+  ZSTDS_EXT_GVL_WRAP(gvl, finalize_wrapper, &args);
   free(samples);
 
   if (args.ext_result != 0) {
@@ -141,6 +308,17 @@ VALUE zstds_ext_train_dictionary_buffer(VALUE ZSTDS_EXT_UNUSED(self), VALUE raw_
   return buffer;
 }
 
+#else
+ZSTDS_EXT_NORETURN VALUE zstds_ext_finalize_dictionary_buffer(
+  VALUE ZSTDS_EXT_UNUSED(self),
+  VALUE ZSTDS_EXT_UNUSED(content),
+  VALUE ZSTDS_EXT_UNUSED(raw_samples),
+  VALUE ZSTDS_EXT_UNUSED(options))
+{
+  zstds_ext_raise_error(ZSTDS_EXT_ERROR_NOT_IMPLEMENTED);
+}
+#endif // HAVE_ZDICT_FINALIZE
+
 // -- other --
 
 VALUE zstds_ext_get_dictionary_buffer_id(VALUE ZSTDS_EXT_UNUSED(self), VALUE buffer)
@@ -153,6 +331,7 @@ VALUE zstds_ext_get_dictionary_buffer_id(VALUE ZSTDS_EXT_UNUSED(self), VALUE buf
   return UINT2NUM(id);
 }
 
+#if defined(HAVE_ZDICT_HEADER_SIZE)
 VALUE zstds_ext_get_dictionary_header_size(VALUE ZSTDS_EXT_UNUSED(self), VALUE buffer)
 {
   zstds_result_t result = ZDICT_getDictHeaderSize(RSTRING_PTR(buffer), RSTRING_LEN(buffer));
@@ -163,12 +342,21 @@ VALUE zstds_ext_get_dictionary_header_size(VALUE ZSTDS_EXT_UNUSED(self), VALUE b
   return SIZET2NUM(result);
 }
 
+#else
+ZSTDS_EXT_NORETURN VALUE
+  zstds_ext_get_dictionary_header_size(VALUE ZSTDS_EXT_UNUSED(self), VALUE ZSTDS_EXT_UNUSED(buffer))
+{
+  zstds_ext_raise_error(ZSTDS_EXT_ERROR_NOT_IMPLEMENTED);
+};
+#endif // HAVE_ZDICT_HEADER_SIZE
+
 // -- exports --
 
 void zstds_ext_dictionary_exports(VALUE root_module)
 {
   VALUE dictionary = rb_define_class_under(root_module, "Dictionary", rb_cObject);
 
+  rb_define_singleton_method(dictionary, "finalize_buffer", zstds_ext_finalize_dictionary_buffer, 3);
   rb_define_singleton_method(dictionary, "get_buffer_id", zstds_ext_get_dictionary_buffer_id, 1);
   rb_define_singleton_method(dictionary, "get_header_size", zstds_ext_get_dictionary_header_size, 1);
   rb_define_singleton_method(dictionary, "train_buffer", zstds_ext_train_dictionary_buffer, 2);

data/ext/zstds_ext/dictionary.h

@@ -6,11 +6,33 @@
 
 #include "ruby.h"
 
+#include "zstds_ext/macro.h"
+
 #define ZSTDS_EXT_DEFAULT_DICTIONARY_CAPACITY (1 << 17); // 128 KB
+#define ZSTDS_EXT_DEFAULT_DICTIONARY_MAX_SIZE ZSTDS_EXT_DEFAULT_DICTIONARY_CAPACITY
+
+// -- training --
 
 VALUE zstds_ext_train_dictionary_buffer(VALUE self, VALUE samples, VALUE options);
+
+// -- finalizing --
+
+#if defined(HAVE_ZDICT_FINALIZE)
+VALUE zstds_ext_finalize_dictionary_buffer(VALUE self, VALUE content, VALUE samples, VALUE options);
+#else
+ZSTDS_EXT_NORETURN VALUE zstds_ext_finalize_dictionary_buffer(VALUE self, VALUE content, VALUE samples, VALUE options);
+#endif // HAVE_ZDICT_FINALIZE
+
+// -- other --
+
 VALUE zstds_ext_get_dictionary_buffer_id(VALUE self, VALUE buffer);
 
+#if defined(HAVE_ZDICT_HEADER_SIZE)
+VALUE zstds_ext_get_dictionary_header_size(VALUE self, VALUE buffer);
+#else
+ZSTDS_EXT_NORETURN VALUE zstds_ext_get_dictionary_header_size(VALUE self, VALUE buffer);
+#endif // HAVE_ZDICT_HEADER_SIZE
+
 void zstds_ext_dictionary_exports(VALUE root_module);
 
 #endif // ZSTDS_EXT_DICTIONARY_H

data/ext/zstds_ext/error.c

@@ -69,6 +69,9 @@ void zstds_ext_raise_error(zstds_ext_result_t ext_result)
     case ZSTDS_EXT_ERROR_WRITE_IO:
       raise_error("WriteIOError", "failed to write IO");
 
+    case ZSTDS_EXT_ERROR_NOT_IMPLEMENTED:
+      raise_error("NotImplementedError", "not implemented error");
+
     default:
       // ZSTDS_EXT_ERROR_UNEXPECTED
       raise_error("UnexpectedError", "unexpected error");

data/ext/zstds_ext/error.h

@@ -26,6 +26,7 @@ enum
   ZSTDS_EXT_ERROR_READ_IO,
   ZSTDS_EXT_ERROR_WRITE_IO,
 
+  ZSTDS_EXT_ERROR_NOT_IMPLEMENTED,
   ZSTDS_EXT_ERROR_UNEXPECTED
 };
 

data/ext/zstds_ext/gvl.h

@@ -4,7 +4,7 @@
 #if !defined(ZSTDS_EXT_GVL_H)
 #define ZSTDS_EXT_GVL_H
 
-#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
 
 #include "ruby/thread.h"
 
@@ -19,6 +19,6 @@
 
 #define ZSTDS_EXT_GVL_WRAP(_gvl, function, data) function((void*) data);
 
-#endif
+#endif // HAVE_RB_THREAD_CALL_WITHOUT_GVL
 
 #endif // ZSTDS_EXT_GVL_H

data/ext/zstds_ext/macro.h

@@ -8,6 +8,12 @@
 #define ZSTDS_EXT_UNUSED(x) x __attribute__((__unused__))
 #else
 #define ZSTDS_EXT_UNUSED(x) x
-#endif
+#endif // __GNUC__
+
+#if defined(__GNUC__)
+#define ZSTDS_EXT_NORETURN __attribute__((__noreturn__))
+#else
+#define ZSTDS_EXT_NORETURN
+#endif // __GNUC__
 
 #endif // ZSTDS_EXT_MACRO_H

data/ext/zstds_ext/option.h

@@ -68,6 +68,13 @@ typedef struct
   VALUE              dictionary;
 } zstds_ext_decompressor_options_t;
 
+typedef struct
+{
+  zstds_ext_option_t compression_level;
+  zstds_ext_option_t notification_level;
+  zstds_ext_option_t dictionary_id;
+} zstds_ext_dictionary_options_t;
+
 void zstds_ext_resolve_option(
   VALUE                   options,
   zstds_ext_option_t*     option,
@@ -117,6 +124,13 @@ void zstds_ext_resolve_dictionary_option(VALUE options, VALUE* option, const cha
   ZSTDS_EXT_RESOLVE_OPTION(options, decompressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, window_log_max); \
   ZSTDS_EXT_RESOLVE_DICTIONARY_OPTION(options, decompressor_options, dictionary);
 
+#define ZSTDS_EXT_GET_DICTIONARY_OPTIONS(options)                                                        \
+  zstds_ext_dictionary_options_t dictionary_options;                                                     \
+                                                                                                         \
+  ZSTDS_EXT_RESOLVE_OPTION(options, dictionary_options, ZSTDS_EXT_OPTION_TYPE_INT, compression_level);   \
+  ZSTDS_EXT_RESOLVE_OPTION(options, dictionary_options, ZSTDS_EXT_OPTION_TYPE_UINT, notification_level); \
+  ZSTDS_EXT_RESOLVE_OPTION(options, dictionary_options, ZSTDS_EXT_OPTION_TYPE_UINT, dictionary_id);
+
 bool   zstds_ext_get_bool_option_value(VALUE options, const char* name);
 size_t zstds_ext_get_size_option_value(VALUE options, const char* name);