ruby-zstds 1.0.6 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 359ef05325e4af260831df1c3d71b70d64d1b4f235631ad3cd0bf10be63be308
-  data.tar.gz: 39b138930c23a914317db548081db091a607b00867300788d3de3c22e7e56616
+  metadata.gz: f860451f1cf45988053d7d5512e26e18a5c5b446f9f75fbf06f3a9ef3103c806
+  data.tar.gz: a224e7b3e16b3f2e1d2785fc024241813e3fb934351e5a851744eb1e2ae82783
 SHA512:
-  metadata.gz: 0c76ce3fe240fb963dab49e55ff167a2cfea690e1bb48b107d164821d5bba1b5090eb81b73ec221a86aa4c94c05f9082d540d6c0423ae99326face5deee199d8
-  data.tar.gz: 00db3a70938e3ca436d253f9c2e715941837c252569bb6d72d1ddb94b1c8c9e85aeeb1bd67e9c85a0ab965c5393f785f273e67a0a3869a1ae770a915ae23ca9e
+  metadata.gz: 76ee0c342ebb71bf4ae6ac0a6139d3a8d7966da4843eece7c819b84e531fab6e501fa7ebafaa1c864f1200771b2b119ef885a827ba50da27b6112803a2858c7a
+  data.tar.gz: 575a15688165bccf52dc6f73a26fa1ac0f3a1ba0bf010384e9e34ecda8183bb904efb369635f75052420f86c84f59b906d7e46a65f301ab19e2c888d9ca96983

data/README.md

@@ -1,8 +1,8 @@
 # Ruby bindings for zstd library
 
-| Travis | AppVeyor | Circle | Codecov |
-| :---:  | :---:    | :---:  | :---:   |
-| [![Travis test status](https://travis-ci.com/andrew-aladev/ruby-zstds.svg?branch=master)](https://travis-ci.com/andrew-aladev/ruby-zstds) | [![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) | [![Codecov](https://codecov.io/gh/andrew-aladev/ruby-zstds/branch/master/graph/badge.svg)](https://codecov.io/gh/andrew-aladev/ruby-zstds) |
+| Travis | AppVeyor | Circle | Codecov | Gem   |
+| :---:  | :---:    | :---:  | :---:   | :---: |
+| [![Travis test status](https://travis-ci.com/andrew-aladev/ruby-zstds.svg?branch=master)](https://travis-ci.com/andrew-aladev/ruby-zstds) | [![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) | [![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).
 
@@ -79,7 +79,7 @@ data = ZSTDS::String.compress "sample string", :dictionary => dictionary
 puts ZSTDS::String.decompress(data, :dictionary => dictionary)
 ```
 
-You can create and read `tar.zst` archives with `minitar` for example.
+You can create and read `tar.zst` archives with [minitar](https://github.com/halostatue/minitar) for example.
 
 ```ruby
 require "zstds"
@@ -101,12 +101,25 @@ ZSTDS::Stream::Reader.open "file.tar.zst" do |reader|
 end
 ```
 
+You can also use `Content-Encoding: zstd` with [sinatra](http://sinatrarb.com):
+
+```ruby
+require "zstds"
+require "sinatra"
+
+get "/" do
+  headers["Content-Encoding"] = "zstd"
+  ZSTDS::String.compress "sample string"
+end
+```
+
 ## Options
 
 | Option                          | Values         | Default    | Description |
 |---------------------------------|----------------|------------|-------------|
 | `source_buffer_length`          | 0 - inf        | 0 (auto)   | internal buffer length for source data |
 | `destination_buffer_length`     | 0 - inf        | 0 (auto)   | internal buffer length for description data |
+| `gvl`                           | true/false     | false      | enables global VM lock where possible |
 | `compression_level`             | -131072 - 22   | 0 (auto)   | compression level |
 | `window_log`                    | 10 - 31        | 0 (auto)   | maximum back-reference distance (power of 2) |
 | `hash_log`                      | 6 - 30         | 0 (auto)   | size of the initial probe table (power of 2) |
@@ -134,6 +147,10 @@ There are internal buffers for compressed and decompressed data.
 For example you want to use 1 KB as `source_buffer_length` for compressor - please use 256 B as `destination_buffer_length`.
 You want to use 256 B as `source_buffer_length` for decompressor - please use 1 KB as `destination_buffer_length`.
 
+`gvl` is disabled by default, this mode allows running multiple compressors/decompressors in different threads simultaneously.
+Please consider enabling `gvl` if you don't want to launch processors in separate threads.
+If `gvl` is enabled ruby won't waste time on acquiring/releasing VM lock.
+
 `String` and `File` will set `:pledged_size` automaticaly.
 
 You can also read zstd docs for more info about options.
@@ -161,6 +178,7 @@ Possible compressor options:
 ```
 :source_buffer_length
 :destination_buffer_length
+:gvl
 :compression_level
 :window_log
 :hash_log
@@ -188,6 +206,7 @@ Possible decompressor options:
 ```
 :source_buffer_length
 :destination_buffer_length
+:gvl
 :window_log_max
 :dictionary
 ```
@@ -201,18 +220,6 @@ data = ZSTDS::String.compress "sample string", :compression_level => 5
 puts ZSTDS::String.decompress(data, :window_log_max => 11)
 ```
 
-HTTP encoding (`Content-Encoding: zstd`) using default options:
-
-```ruby
-require "zstds"
-require "sinatra"
-
-get "/" do
-  headers["Content-Encoding"] = "zstd"
-  ZSTDS::String.compress "sample string"
-end
-```
-
 ## String
 
 String maintains destination buffer only, so it accepts `destination_buffer_length` option only.
@@ -418,12 +425,18 @@ Please use regular constructor to create dictionary from buffer.
 
 Read dictionary id from buffer.
 
+## Thread safety
+
+`:gvl` option is disabled by default, you can use bindings effectively in multiple threads.
+Please be careful: bindings are not thread safe.
+You should lock all shared data between threads.
+
 ## CI
 
-See universal test script [scripts/ci_test.sh](scripts/ci_test.sh) for CI.
 Please visit [scripts/test-images](scripts/test-images).
-You can run this test script using many native and cross images.
+See universal test script [scripts/ci_test.sh](scripts/ci_test.sh) for CI.
+You can run this script using many native and cross images.
 
 ## License
 
-MIT license, see LICENSE and AUTHORS.
+MIT license, see [LICENSE](LICENSE) and [AUTHORS](AUTHORS).

data/ext/extconf.rb

@@ -3,6 +3,10 @@
 
 require "mkmf"
 
+have_func "rb_thread_call_without_gvl", "ruby/thread.h"
+
+# Old zstd versions has bug: underlinking against pthreads.
+# https://bugs.gentoo.org/713940
 $LDFLAGS << " -pthread" # rubocop:disable Style/GlobalVars
 
 def require_header(name, types = [])
@@ -52,6 +56,7 @@ require_library(
     ZSTD_DStreamOutSize
     ZSTD_compressStream2
     ZSTD_decompressStream
+    ZDICT_isError
     ZDICT_getDictID
     ZDICT_trainFromBuffer
   ]

data/ext/zstds_ext/buffer.c

@@ -12,10 +12,11 @@ VALUE zstds_ext_create_string_buffer(VALUE length)
   return rb_str_new(NULL, NUM2SIZET(length));
 }
 
-VALUE zstds_ext_resize_string_buffer(VALUE args)
+VALUE zstds_ext_resize_string_buffer(VALUE buffer_args)
 {
-  VALUE buffer = rb_ary_entry(args, 0);
-  VALUE length = rb_ary_entry(args, 1);
+  VALUE buffer = rb_ary_entry(buffer_args, 0);
+  VALUE length = rb_ary_entry(buffer_args, 1);
+
   return rb_str_resize(buffer, NUM2SIZET(length));
 }
 

data/ext/zstds_ext/buffer.h

@@ -11,12 +11,12 @@ VALUE zstds_ext_create_string_buffer(VALUE length);
 #define ZSTDS_EXT_CREATE_STRING_BUFFER(buffer, length, exception) \
   VALUE buffer = rb_protect(zstds_ext_create_string_buffer, SIZET2NUM(length), &exception);
 
-VALUE zstds_ext_resize_string_buffer(VALUE args);
+VALUE zstds_ext_resize_string_buffer(VALUE buffer_args);
 
-#define ZSTDS_EXT_RESIZE_STRING_BUFFER(buffer, length, exception)            \
-  VALUE args = rb_ary_new_from_args(2, buffer, SIZET2NUM(length));           \
-  buffer     = rb_protect(zstds_ext_resize_string_buffer, args, &exception); \
-  RB_GC_GUARD(args);
+#define ZSTDS_EXT_RESIZE_STRING_BUFFER(buffer, length, exception)                          \
+  VALUE buffer_args = rb_ary_new_from_args(2, buffer, SIZET2NUM(length));                  \
+  buffer            = rb_protect(zstds_ext_resize_string_buffer, buffer_args, &exception); \
+  RB_GC_GUARD(buffer_args);
 
 void zstds_ext_buffer_exports(VALUE root_module);
 

data/ext/zstds_ext/dictionary.c

@@ -9,36 +9,92 @@
 #include "ruby.h"
 #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"
 
-VALUE zstds_ext_get_dictionary_buffer_id(VALUE ZSTDS_EXT_UNUSED(self), VALUE buffer)
+// -- initialization --
+
+typedef struct
 {
-  unsigned int id = ZDICT_getDictID(RSTRING_PTR(buffer), RSTRING_LEN(buffer));
-  if (id == 0) {
-    zstds_ext_raise_error(ZSTDS_EXT_ERROR_VALIDATE_FAILED);
+  const char* data;
+  size_t      size;
+} sample_t;
+
+typedef struct
+{
+  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;
+
+static inline void* train_wrapper(void* data)
+{
+  train_args_t*   args    = data;
+  const sample_t* samples = args->samples;
+  size_t          length  = args->length;
+  size_t          size    = 0;
+
+  for (size_t index = 0; index < length; index++) {
+    size += samples[index].size;
   }
 
-  return UINT2NUM(id);
+  zstds_ext_byte_t* group = malloc(size);
+  if (group == NULL) {
+    args->ext_result = ZSTDS_EXT_ERROR_ALLOCATE_FAILED;
+    return NULL;
+  }
+
+  size_t* sizes = malloc(length * sizeof(size_t));
+  if (sizes == NULL) {
+    free(group);
+    args->ext_result = ZSTDS_EXT_ERROR_ALLOCATE_FAILED;
+    return NULL;
+  }
+
+  size_t offset = 0;
+
+  for (size_t index = 0; index < length; index++) {
+    const sample_t* sample_ptr  = &samples[index];
+    size_t          sample_size = sample_ptr->size;
+
+    memmove(group + offset, sample_ptr->data, sample_size);
+    offset += sample_size;
+
+    sizes[index] = sample_size;
+  }
+
+  args->result = ZDICT_trainFromBuffer((void*) args->buffer, args->capacity, group, sizes, (unsigned int) length);
+
+  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_train_dictionary_buffer(VALUE ZSTDS_EXT_UNUSED(self), VALUE samples, VALUE options)
+VALUE zstds_ext_train_dictionary_buffer(VALUE ZSTDS_EXT_UNUSED(self), VALUE raw_samples, VALUE options)
 {
-  Check_Type(samples, T_ARRAY);
+  Check_Type(raw_samples, T_ARRAY);
 
-  size_t       sample_index;
-  unsigned int samples_length = (unsigned int)RARRAY_LEN(samples);
-  size_t       samples_size   = 0;
+  size_t length = RARRAY_LEN(raw_samples);
 
-  for (sample_index = 0; sample_index < samples_length; sample_index++) {
-    VALUE sample = rb_ary_entry(samples, sample_index);
-    Check_Type(sample, T_STRING);
-
-    samples_size += RSTRING_LEN(sample);
+  for (size_t index = 0; index < length; index++) {
+    Check_Type(rb_ary_entry(raw_samples, index), T_STRING);
   }
 
   Check_Type(options, T_HASH);
-  ZSTDS_EXT_GET_BUFFER_LENGTH_OPTION(options, capacity);
+  ZSTDS_EXT_GET_BOOL_OPTION(options, gvl);
+  ZSTDS_EXT_GET_SIZE_OPTION(options, capacity);
 
   if (capacity == 0) {
     capacity = ZSTDS_EXT_DEFAULT_DICTIONARY_CAPACITY;
@@ -51,42 +107,34 @@ VALUE zstds_ext_train_dictionary_buffer(VALUE ZSTDS_EXT_UNUSED(self), VALUE samp
     zstds_ext_raise_error(ZSTDS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
-  zstds_ext_byte_t* samples_buffer = malloc(samples_size);
-  if (samples_buffer == NULL) {
+  sample_t* samples = malloc(sizeof(sample_t) * length);
+  if (samples == NULL) {
     zstds_ext_raise_error(ZSTDS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
-  size_t* samples_sizes = malloc(samples_length * sizeof(size_t));
-  if (samples_sizes == NULL) {
-    free(samples_buffer);
-    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];
 
-  size_t sample_offset = 0;
-
-  for (sample_index = 0; sample_index < samples_length; sample_index++) {
-    VALUE       sample      = rb_ary_entry(samples, sample_index);
-    const char* sample_data = RSTRING_PTR(sample);
-    size_t      sample_size = RSTRING_LEN(sample);
-
-    memmove(samples_buffer + sample_offset, sample_data, sample_size);
-    sample_offset += sample_size;
-
-    samples_sizes[sample_index] = sample_size;
+    sample->data = RSTRING_PTR(raw_sample);
+    sample->size = RSTRING_LEN(raw_sample);
   }
 
-  zstds_result_t result = ZDICT_trainFromBuffer(
-    RSTRING_PTR(buffer), capacity,
-    samples_buffer, samples_sizes, samples_length);
+  train_args_t args = {
+    .samples  = samples,
+    .length   = length,
+    .buffer   = RSTRING_PTR(buffer),
+    .capacity = capacity,
+  };
 
-  free(samples_buffer);
-  free(samples_sizes);
+  ZSTDS_EXT_GVL_WRAP(gvl, train_wrapper, &args);
+  free(samples);
 
-  if (ZSTD_isError(result)) {
-    zstds_ext_raise_error(zstds_ext_get_error(ZSTD_getErrorCode(result)));
+  if (args.ext_result != 0) {
+    zstds_ext_raise_error(args.ext_result);
   }
 
-  ZSTDS_EXT_RESIZE_STRING_BUFFER(buffer, result, exception);
+  ZSTDS_EXT_RESIZE_STRING_BUFFER(buffer, args.result, exception);
   if (exception != 0) {
     zstds_ext_raise_error(ZSTDS_EXT_ERROR_ALLOCATE_FAILED);
   }
@@ -94,6 +142,20 @@ VALUE zstds_ext_train_dictionary_buffer(VALUE ZSTDS_EXT_UNUSED(self), VALUE samp
   return buffer;
 }
 
+// -- other --
+
+VALUE zstds_ext_get_dictionary_buffer_id(VALUE ZSTDS_EXT_UNUSED(self), VALUE buffer)
+{
+  unsigned int id = ZDICT_getDictID(RSTRING_PTR(buffer), RSTRING_LEN(buffer));
+  if (id == 0) {
+    zstds_ext_raise_error(ZSTDS_EXT_ERROR_VALIDATE_FAILED);
+  }
+
+  return UINT2NUM(id);
+}
+
+// -- exports --
+
 void zstds_ext_dictionary_exports(VALUE root_module)
 {
   VALUE dictionary = rb_define_class_under(root_module, "Dictionary", rb_cObject);

data/ext/zstds_ext/dictionary.h

@@ -8,8 +8,8 @@
 
 #define ZSTDS_EXT_DEFAULT_DICTIONARY_CAPACITY (1 << 17); // 128 KB
 
-VALUE zstds_ext_get_dictionary_buffer_id(VALUE self, VALUE buffer);
 VALUE zstds_ext_train_dictionary_buffer(VALUE self, VALUE samples, VALUE options);
+VALUE zstds_ext_get_dictionary_buffer_id(VALUE self, VALUE buffer);
 
 void zstds_ext_dictionary_exports(VALUE root_module);
 

data/ext/zstds_ext/error.c

@@ -40,7 +40,7 @@ zstds_ext_result_t zstds_ext_get_error(ZSTD_ErrorCode error_code)
   }
 }
 
-static inline NORETURN(void raise(const char *name, const char *description))
+static inline NORETURN(void raise(const char* name, const char* description))
 {
   VALUE module = rb_define_module(ZSTDS_EXT_MODULE_NAME);
   VALUE error  = rb_const_get(module, rb_intern(name));

data/ext/zstds_ext/error.h

@@ -11,7 +11,8 @@
 
 // Results for errors listed in "lib/zstds/error" used in c extension.
 
-enum {
+enum
+{
   ZSTDS_EXT_ERROR_ALLOCATE_FAILED = 1,
   ZSTDS_EXT_ERROR_VALIDATE_FAILED,
 

data/ext/zstds_ext/gvl.h

@@ -0,0 +1,24 @@
+// Ruby bindings for zstd library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(ZSTDS_EXT_GVL_H)
+#define ZSTDS_EXT_GVL_H
+
+#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+
+#include "ruby/thread.h"
+
+#define ZSTDS_EXT_GVL_WRAP(gvl, function, data)                            \
+  if (gvl) {                                                               \
+    function((void*) data);                                                \
+  } else {                                                                 \
+    rb_thread_call_without_gvl(function, (void*) data, RUBY_UBF_IO, NULL); \
+  }
+
+#else
+
+#define ZSTDS_EXT_GVL_WRAP(_gvl, function, data) function((void*) data);
+
+#endif
+
+#endif // ZSTDS_EXT_GVL_H

data/ext/zstds_ext/io.c

@@ -1,26 +1,29 @@
 // Ruby bindings for zstd library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
-#include "ruby/io.h"
+#include "zstds_ext/io.h"
 
 #include <stdio.h>
 #include <string.h>
 #include <zstd.h>
 
 #include "ruby.h"
+#include "ruby/io.h"
 #include "zstds_ext/error.h"
-#include "zstds_ext/io.h"
+#include "zstds_ext/gvl.h"
 #include "zstds_ext/macro.h"
 #include "zstds_ext/option.h"
 
 // Additional possible results:
-enum {
+enum
+{
   ZSTDS_EXT_FILE_READ_FINISHED = 128
 };
 
 // -- file --
 
-static inline zstds_ext_result_t read_file(FILE* source_file, zstds_ext_byte_t* source_buffer, size_t* source_length_ptr, size_t source_buffer_length)
+static inline zstds_ext_result_t
+  read_file(FILE* source_file, zstds_ext_byte_t* source_buffer, size_t* source_length_ptr, size_t source_buffer_length)
 {
   size_t read_length = fread(source_buffer, 1, source_buffer_length, source_file);
   if (read_length == 0 && feof(source_file)) {
@@ -36,7 +39,8 @@ static inline zstds_ext_result_t read_file(FILE* source_file, zstds_ext_byte_t*
   return 0;
 }
 
-static inline zstds_ext_result_t write_file(FILE* destination_file, zstds_ext_byte_t* destination_buffer, size_t destination_length)
+static inline zstds_ext_result_t
+  write_file(FILE* destination_file, zstds_ext_byte_t* destination_buffer, size_t destination_length)
 {
   size_t written_length = fwrite(destination_buffer, 1, destination_length, destination_file);
   if (written_length != destination_length) {
@@ -49,8 +53,10 @@ static inline zstds_ext_result_t write_file(FILE* destination_file, zstds_ext_by
 // -- buffer --
 
 static inline zstds_ext_result_t create_buffers(
-  zstds_ext_byte_t** source_buffer_ptr, size_t source_buffer_length,
-  zstds_ext_byte_t** destination_buffer_ptr, size_t destination_buffer_length)
+  zstds_ext_byte_t** source_buffer_ptr,
+  size_t             source_buffer_length,
+  zstds_ext_byte_t** destination_buffer_ptr,
+  size_t             destination_buffer_length)
 {
   zstds_ext_byte_t* source_buffer = malloc(source_buffer_length);
   if (source_buffer == NULL) {
@@ -77,8 +83,10 @@ static inline zstds_ext_result_t create_buffers(
 
 static inline zstds_ext_result_t read_more_source(
   FILE*                    source_file,
-  const zstds_ext_byte_t** source_ptr, size_t* source_length_ptr,
-  zstds_ext_byte_t* source_buffer, size_t source_buffer_length)
+  const zstds_ext_byte_t** source_ptr,
+  size_t*                  source_length_ptr,
+  zstds_ext_byte_t*        source_buffer,
+  size_t                   source_buffer_length)
 {
   const zstds_ext_byte_t* source        = *source_ptr;
   size_t                  source_length = *source_length_ptr;
@@ -101,7 +109,9 @@ static inline zstds_ext_result_t read_more_source(
   zstds_ext_byte_t* remaining_source_buffer = source_buffer + source_length;
   size_t            new_source_length;
 
-  zstds_ext_result_t ext_result = read_file(source_file, remaining_source_buffer, &new_source_length, remaining_source_buffer_length);
+  zstds_ext_result_t ext_result =
+    read_file(source_file, remaining_source_buffer, &new_source_length, remaining_source_buffer_length);
+
   if (ext_result != 0) {
     return ext_result;
   }
@@ -111,42 +121,37 @@ static inline zstds_ext_result_t read_more_source(
   return 0;
 }
 
-#define BUFFERED_READ_SOURCE(function, ...)                 \
-  do {                                                      \
-    bool is_function_called = false;                        \
-                                                            \
-    while (true) {                                          \
-      ext_result = read_more_source(                        \
-        source_file,                                        \
-        &source, &source_length,                            \
-        source_buffer, source_buffer_length);               \
-                                                            \
-      if (ext_result == ZSTDS_EXT_FILE_READ_FINISHED) {     \
-        if (source_length != 0) {                           \
-          /* ZSTD won't provide any remainder by design. */ \
-          return ZSTDS_EXT_ERROR_READ_IO;                   \
-        }                                                   \
-        break;                                              \
-      }                                                     \
-      else if (ext_result != 0) {                           \
-        return ext_result;                                  \
-      }                                                     \
-                                                            \
-      ext_result = function(__VA_ARGS__);                   \
-      if (ext_result != 0) {                                \
-        return ext_result;                                  \
-      }                                                     \
-                                                            \
-      is_function_called = true;                            \
-    }                                                       \
-                                                            \
-    if (!is_function_called) {                              \
-      /* Function should be called at least once. */        \
-      ext_result = function(__VA_ARGS__);                   \
-      if (ext_result != 0) {                                \
-        return ext_result;                                  \
-      }                                                     \
-    }                                                       \
+#define BUFFERED_READ_SOURCE(function, ...)                                                                     \
+  do {                                                                                                          \
+    bool is_function_called = false;                                                                            \
+                                                                                                                \
+    while (true) {                                                                                              \
+      ext_result = read_more_source(source_file, &source, &source_length, source_buffer, source_buffer_length); \
+      if (ext_result == ZSTDS_EXT_FILE_READ_FINISHED) {                                                         \
+        if (source_length != 0) {                                                                               \
+          /* ZSTD won't provide any remainder by design. */                                                     \
+          return ZSTDS_EXT_ERROR_READ_IO;                                                                       \
+        }                                                                                                       \
+        break;                                                                                                  \
+      } else if (ext_result != 0) {                                                                             \
+        return ext_result;                                                                                      \
+      }                                                                                                         \
+                                                                                                                \
+      ext_result = function(__VA_ARGS__);                                                                       \
+      if (ext_result != 0) {                                                                                    \
+        return ext_result;                                                                                      \
+      }                                                                                                         \
+                                                                                                                \
+      is_function_called = true;                                                                                \
+    }                                                                                                           \
+                                                                                                                \
+    if (!is_function_called) {                                                                                  \
+      /* Function should be called at least once. */                                                            \
+      ext_result = function(__VA_ARGS__);                                                                       \
+      if (ext_result != 0) {                                                                                    \
+        return ext_result;                                                                                      \
+      }                                                                                                         \
+    }                                                                                                           \
   } while (false);
 
 // Algorithm has written data into destination buffer.
@@ -155,7 +160,9 @@ static inline zstds_ext_result_t read_more_source(
 
 static inline zstds_ext_result_t flush_destination_buffer(
   FILE*             destination_file,
-  zstds_ext_byte_t* destination_buffer, size_t* destination_length_ptr, size_t destination_buffer_length)
+  zstds_ext_byte_t* destination_buffer,
+  size_t*           destination_length_ptr,
+  size_t            destination_buffer_length)
 {
   if (*destination_length_ptr == 0) {
     // We want to write more data at once, than buffer has.
@@ -172,7 +179,8 @@ static inline zstds_ext_result_t flush_destination_buffer(
   return 0;
 }
 
-static inline zstds_ext_result_t write_remaining_destination(FILE* destination_file, zstds_ext_byte_t* destination_buffer, size_t destination_length)
+static inline zstds_ext_result_t
+  write_remaining_destination(FILE* destination_file, zstds_ext_byte_t* destination_buffer, size_t destination_length)
 {
   if (destination_length == 0) {
     return 0;
@@ -194,39 +202,57 @@ static inline zstds_ext_result_t write_remaining_destination(FILE* destination_f
     zstds_ext_raise_error(ZSTDS_EXT_ERROR_ACCESS_IO);  \
   }
 
-// -- compress --
+// -- buffered compress --
+
+typedef struct
+{
+  ZSTD_CCtx*      ctx;
+  ZSTD_inBuffer*  in_buffer_ptr;
+  ZSTD_outBuffer* out_buffer_ptr;
+  zstds_result_t  result;
+} compress_args_t;
+
+static inline void* compress_wrapper(void* data)
+{
+  compress_args_t* args = data;
+
+  args->result = ZSTD_compressStream2(args->ctx, args->out_buffer_ptr, args->in_buffer_ptr, ZSTD_e_continue);
+
+  return NULL;
+}
 
 static inline zstds_ext_result_t buffered_compress(
   ZSTD_CCtx*               ctx,
-  const zstds_ext_byte_t** source_ptr, size_t* source_length_ptr,
-  FILE* destination_file, zstds_ext_byte_t* destination_buffer, size_t* destination_length_ptr, size_t destination_buffer_length)
+  const zstds_ext_byte_t** source_ptr,
+  size_t*                  source_length_ptr,
+  FILE*                    destination_file,
+  zstds_ext_byte_t*        destination_buffer,
+  size_t*                  destination_length_ptr,
+  size_t                   destination_buffer_length,
+  bool                     gvl)
 {
-  zstds_result_t     result;
   zstds_ext_result_t ext_result;
-
-  ZSTD_inBuffer in_buffer;
-  in_buffer.src  = *source_ptr;
-  in_buffer.size = *source_length_ptr;
-  in_buffer.pos  = 0;
-
-  ZSTD_outBuffer out_buffer;
+  ZSTD_inBuffer      in_buffer = {.src = *source_ptr, .size = *source_length_ptr, .pos = 0};
+  compress_args_t    args      = {.ctx = ctx, .in_buffer_ptr = &in_buffer};
 
   while (true) {
-    out_buffer.dst  = destination_buffer + *destination_length_ptr;
-    out_buffer.size = destination_buffer_length - *destination_length_ptr;
-    out_buffer.pos  = 0;
+    ZSTD_outBuffer out_buffer = {
+      .dst  = destination_buffer + *destination_length_ptr,
+      .size = destination_buffer_length - *destination_length_ptr,
+      .pos  = 0};
 
-    result = ZSTD_compressStream2(ctx, &out_buffer, &in_buffer, ZSTD_e_continue);
-    if (ZSTD_isError(result)) {
-      return zstds_ext_get_error(ZSTD_getErrorCode(result));
+    args.out_buffer_ptr = &out_buffer;
+
+    ZSTDS_EXT_GVL_WRAP(gvl, compress_wrapper, &args);
+    if (ZSTD_isError(args.result)) {
+      return zstds_ext_get_error(ZSTD_getErrorCode(args.result));
     }
 
     *destination_length_ptr += out_buffer.pos;
 
     if (*destination_length_ptr == destination_buffer_length) {
       ext_result = flush_destination_buffer(
-        destination_file,
-        destination_buffer, destination_length_ptr, destination_buffer_length);
+        destination_file, destination_buffer, destination_length_ptr, destination_buffer_length);
 
       if (ext_result != 0) {
         return ext_result;
@@ -244,36 +270,55 @@ static inline zstds_ext_result_t buffered_compress(
   return 0;
 }
 
-static inline zstds_ext_result_t buffered_compressor_finish(
-  ZSTD_CCtx* ctx,
-  FILE* destination_file, zstds_ext_byte_t* destination_buffer, size_t* destination_length_ptr, size_t destination_buffer_length)
+// -- buffered compressor finish --
+
+typedef struct
 {
-  zstds_result_t     result;
-  zstds_ext_result_t ext_result;
+  ZSTD_CCtx*      ctx;
+  ZSTD_inBuffer*  in_buffer_ptr;
+  ZSTD_outBuffer* out_buffer_ptr;
+  zstds_result_t  result;
+} compressor_finish_args_t;
 
-  ZSTD_inBuffer in_buffer;
-  in_buffer.src  = NULL;
-  in_buffer.size = 0;
-  in_buffer.pos  = 0;
+static inline void* compressor_finish_wrapper(void* data)
+{
+  compressor_finish_args_t* args = data;
 
-  ZSTD_outBuffer out_buffer;
+  args->result = ZSTD_compressStream2(args->ctx, args->out_buffer_ptr, args->in_buffer_ptr, ZSTD_e_end);
+
+  return NULL;
+}
+
+static inline zstds_ext_result_t buffered_compressor_finish(
+  ZSTD_CCtx*        ctx,
+  FILE*             destination_file,
+  zstds_ext_byte_t* destination_buffer,
+  size_t*           destination_length_ptr,
+  size_t            destination_buffer_length,
+  bool              gvl)
+{
+  zstds_ext_result_t       ext_result;
+  ZSTD_inBuffer            in_buffer = {in_buffer.src = NULL, in_buffer.size = 0, in_buffer.pos = 0};
+  compressor_finish_args_t args      = {.ctx = ctx, .in_buffer_ptr = &in_buffer};
 
   while (true) {
-    out_buffer.dst  = destination_buffer + *destination_length_ptr;
-    out_buffer.size = destination_buffer_length - *destination_length_ptr;
-    out_buffer.pos  = 0;
+    ZSTD_outBuffer out_buffer = {
+      out_buffer.dst  = destination_buffer + *destination_length_ptr,
+      out_buffer.size = destination_buffer_length - *destination_length_ptr,
+      out_buffer.pos  = 0};
 
-    result = ZSTD_compressStream2(ctx, &out_buffer, &in_buffer, ZSTD_e_end);
-    if (ZSTD_isError(result)) {
-      return zstds_ext_get_error(ZSTD_getErrorCode(result));
+    args.out_buffer_ptr = &out_buffer;
+
+    ZSTDS_EXT_GVL_WRAP(gvl, compressor_finish_wrapper, &args);
+    if (ZSTD_isError(args.result)) {
+      return zstds_ext_get_error(ZSTD_getErrorCode(args.result));
     }
 
     *destination_length_ptr += out_buffer.pos;
 
-    if (result != 0) {
+    if (args.result != 0) {
       ext_result = flush_destination_buffer(
-        destination_file,
-        destination_buffer, destination_length_ptr, destination_buffer_length);
+        destination_file, destination_buffer, destination_length_ptr, destination_buffer_length);
 
       if (ext_result != 0) {
         return ext_result;
@@ -288,13 +333,19 @@ static inline zstds_ext_result_t buffered_compressor_finish(
   return 0;
 }
 
+// -- compress --
+
 static inline zstds_ext_result_t compress(
-  ZSTD_CCtx* ctx,
-  FILE* source_file, zstds_ext_byte_t* source_buffer, size_t source_buffer_length,
-  FILE* destination_file, zstds_ext_byte_t* destination_buffer, size_t destination_buffer_length)
+  ZSTD_CCtx*        ctx,
+  FILE*             source_file,
+  zstds_ext_byte_t* source_buffer,
+  size_t            source_buffer_length,
+  FILE*             destination_file,
+  zstds_ext_byte_t* destination_buffer,
+  size_t            destination_buffer_length,
+  bool              gvl)
 {
-  zstds_ext_result_t ext_result;
-
+  zstds_ext_result_t      ext_result;
   const zstds_ext_byte_t* source             = source_buffer;
   size_t                  source_length      = 0;
   size_t                  destination_length = 0;
@@ -302,12 +353,16 @@ static inline zstds_ext_result_t compress(
   BUFFERED_READ_SOURCE(
     buffered_compress,
     ctx,
-    &source, &source_length,
-    destination_file, destination_buffer, &destination_length, destination_buffer_length);
+    &source,
+    &source_length,
+    destination_file,
+    destination_buffer,
+    &destination_length,
+    destination_buffer_length,
+    gvl);
 
   ext_result = buffered_compressor_finish(
-    ctx,
-    destination_file, destination_buffer, &destination_length, destination_buffer_length);
+    ctx, destination_file, destination_buffer, &destination_length, destination_buffer_length, gvl);
 
   if (ext_result != 0) {
     return ext_result;
@@ -321,9 +376,10 @@ VALUE zstds_ext_compress_io(VALUE ZSTDS_EXT_UNUSED(self), VALUE source, VALUE de
   GET_FILE(source);
   GET_FILE(destination);
   Check_Type(options, T_HASH);
+  ZSTDS_EXT_GET_SIZE_OPTION(options, source_buffer_length);
+  ZSTDS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  ZSTDS_EXT_GET_BOOL_OPTION(options, gvl);
   ZSTDS_EXT_GET_COMPRESSOR_OPTIONS(options);
-  ZSTDS_EXT_GET_BUFFER_LENGTH_OPTION(options, source_buffer_length);
-  ZSTDS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   ZSTD_CCtx* ctx = ZSTD_createCCtx();
   if (ctx == NULL) {
@@ -346,10 +402,7 @@ VALUE zstds_ext_compress_io(VALUE ZSTDS_EXT_UNUSED(self), VALUE source, VALUE de
   zstds_ext_byte_t* source_buffer;
   zstds_ext_byte_t* destination_buffer;
 
-  ext_result = create_buffers(
-    &source_buffer, source_buffer_length,
-    &destination_buffer, destination_buffer_length);
-
+  ext_result = create_buffers(&source_buffer, source_buffer_length, &destination_buffer, destination_buffer_length);
   if (ext_result != 0) {
     ZSTD_freeCCtx(ctx);
     zstds_ext_raise_error(ext_result);
@@ -357,8 +410,13 @@ VALUE zstds_ext_compress_io(VALUE ZSTDS_EXT_UNUSED(self), VALUE source, VALUE de
 
   ext_result = compress(
     ctx,
-    source_file, source_buffer, source_buffer_length,
-    destination_file, destination_buffer, destination_buffer_length);
+    source_file,
+    source_buffer,
+    source_buffer_length,
+    destination_file,
+    destination_buffer,
+    destination_buffer_length,
+    gvl);
 
   free(source_buffer);
   free(destination_buffer);
@@ -374,39 +432,57 @@ VALUE zstds_ext_compress_io(VALUE ZSTDS_EXT_UNUSED(self), VALUE source, VALUE de
   return Qnil;
 }
 
-// -- decompress --
+// -- buffered decompress --
+
+typedef struct
+{
+  ZSTD_DCtx*      ctx;
+  ZSTD_inBuffer*  in_buffer_ptr;
+  ZSTD_outBuffer* out_buffer_ptr;
+  zstds_result_t  result;
+} decompress_args_t;
+
+static inline void* decompress_wrapper(void* data)
+{
+  decompress_args_t* args = data;
+
+  args->result = ZSTD_decompressStream(args->ctx, args->out_buffer_ptr, args->in_buffer_ptr);
+
+  return NULL;
+}
 
 static inline zstds_ext_result_t buffered_decompress(
   ZSTD_DCtx*               ctx,
-  const zstds_ext_byte_t** source_ptr, size_t* source_length_ptr,
-  FILE* destination_file, zstds_ext_byte_t* destination_buffer, size_t* destination_length_ptr, size_t destination_buffer_length)
+  const zstds_ext_byte_t** source_ptr,
+  size_t*                  source_length_ptr,
+  FILE*                    destination_file,
+  zstds_ext_byte_t*        destination_buffer,
+  size_t*                  destination_length_ptr,
+  size_t                   destination_buffer_length,
+  bool                     gvl)
 {
-  zstds_result_t     result;
   zstds_ext_result_t ext_result;
-
-  ZSTD_inBuffer in_buffer;
-  in_buffer.src  = *source_ptr;
-  in_buffer.size = *source_length_ptr;
-  in_buffer.pos  = 0;
-
-  ZSTD_outBuffer out_buffer;
+  ZSTD_inBuffer      in_buffer = {.src = *source_ptr, .size = *source_length_ptr, .pos = 0};
+  decompress_args_t  args      = {.ctx = ctx, .in_buffer_ptr = &in_buffer};
 
   while (true) {
-    out_buffer.dst  = destination_buffer + *destination_length_ptr;
-    out_buffer.size = destination_buffer_length - *destination_length_ptr;
-    out_buffer.pos  = 0;
+    ZSTD_outBuffer out_buffer = {
+      .dst  = destination_buffer + *destination_length_ptr,
+      .size = destination_buffer_length - *destination_length_ptr,
+      .pos  = 0};
+
+    args.out_buffer_ptr = &out_buffer;
 
-    result = ZSTD_decompressStream(ctx, &out_buffer, &in_buffer);
-    if (ZSTD_isError(result)) {
-      return zstds_ext_get_error(ZSTD_getErrorCode(result));
+    ZSTDS_EXT_GVL_WRAP(gvl, decompress_wrapper, &args);
+    if (ZSTD_isError(args.result)) {
+      return zstds_ext_get_error(ZSTD_getErrorCode(args.result));
     }
 
     *destination_length_ptr += out_buffer.pos;
 
     if (*destination_length_ptr == destination_buffer_length) {
       ext_result = flush_destination_buffer(
-        destination_file,
-        destination_buffer, destination_length_ptr, destination_buffer_length);
+        destination_file, destination_buffer, destination_length_ptr, destination_buffer_length);
 
       if (ext_result != 0) {
         return ext_result;
@@ -424,13 +500,19 @@ static inline zstds_ext_result_t buffered_decompress(
   return 0;
 }
 
+// -- decompress --
+
 static inline zstds_ext_result_t decompress(
-  ZSTD_DCtx* ctx,
-  FILE* source_file, zstds_ext_byte_t* source_buffer, size_t source_buffer_length,
-  FILE* destination_file, zstds_ext_byte_t* destination_buffer, size_t destination_buffer_length)
+  ZSTD_DCtx*        ctx,
+  FILE*             source_file,
+  zstds_ext_byte_t* source_buffer,
+  size_t            source_buffer_length,
+  FILE*             destination_file,
+  zstds_ext_byte_t* destination_buffer,
+  size_t            destination_buffer_length,
+  bool              gvl)
 {
-  zstds_ext_result_t ext_result;
-
+  zstds_ext_result_t      ext_result;
   const zstds_ext_byte_t* source             = source_buffer;
   size_t                  source_length      = 0;
   size_t                  destination_length = 0;
@@ -438,8 +520,13 @@ static inline zstds_ext_result_t decompress(
   BUFFERED_READ_SOURCE(
     buffered_decompress,
     ctx,
-    &source, &source_length,
-    destination_file, destination_buffer, &destination_length, destination_buffer_length);
+    &source,
+    &source_length,
+    destination_file,
+    destination_buffer,
+    &destination_length,
+    destination_buffer_length,
+    gvl);
 
   return write_remaining_destination(destination_file, destination_buffer, destination_length);
 }
@@ -449,9 +536,10 @@ VALUE zstds_ext_decompress_io(VALUE ZSTDS_EXT_UNUSED(self), VALUE source, VALUE
   GET_FILE(source);
   GET_FILE(destination);
   Check_Type(options, T_HASH);
+  ZSTDS_EXT_GET_SIZE_OPTION(options, source_buffer_length);
+  ZSTDS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  ZSTDS_EXT_GET_BOOL_OPTION(options, gvl);
   ZSTDS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
-  ZSTDS_EXT_GET_BUFFER_LENGTH_OPTION(options, source_buffer_length);
-  ZSTDS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   ZSTD_DCtx* ctx = ZSTD_createDCtx();
   if (ctx == NULL) {
@@ -474,10 +562,7 @@ VALUE zstds_ext_decompress_io(VALUE ZSTDS_EXT_UNUSED(self), VALUE source, VALUE
   zstds_ext_byte_t* source_buffer;
   zstds_ext_byte_t* destination_buffer;
 
-  ext_result = create_buffers(
-    &source_buffer, source_buffer_length,
-    &destination_buffer, destination_buffer_length);
-
+  ext_result = create_buffers(&source_buffer, source_buffer_length, &destination_buffer, destination_buffer_length);
   if (ext_result != 0) {
     ZSTD_freeDCtx(ctx);
     zstds_ext_raise_error(ext_result);
@@ -485,8 +570,13 @@ VALUE zstds_ext_decompress_io(VALUE ZSTDS_EXT_UNUSED(self), VALUE source, VALUE
 
   ext_result = decompress(
     ctx,
-    source_file, source_buffer, source_buffer_length,
-    destination_file, destination_buffer, destination_buffer_length);
+    source_file,
+    source_buffer,
+    source_buffer_length,
+    destination_file,
+    destination_buffer,
+    destination_buffer_length,
+    gvl);
 
   free(source_buffer);
   free(destination_buffer);
@@ -502,6 +592,8 @@ VALUE zstds_ext_decompress_io(VALUE ZSTDS_EXT_UNUSED(self), VALUE source, VALUE
   return Qnil;
 }
 
+// -- exports --
+
 void zstds_ext_io_exports(VALUE root_module)
 {
   rb_define_module_function(root_module, "_native_compress_io", RUBY_METHOD_FUNC(zstds_ext_compress_io), 3);