ruby-zstds 1.0.3 → 1.1.1

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
   ]
@@ -75,7 +80,14 @@ $srcs = %w[
 .map { |name| "src/#{extension_name}/#{name}.c" }
 .freeze
 
-if ENV["CI"] || ENV["COVERAGE"]
+# Removing library duplicates.
+$libs = $libs.split(%r{\s})
+  .reject(&:empty?)
+  .sort
+  .uniq
+  .join " "
+
+if ENV["CI"]
   $CFLAGS << " --coverage"
   $LDFLAGS << " --coverage"
 end

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_error(const char* name, const char* description))
 {
   VALUE module = rb_define_module(ZSTDS_EXT_MODULE_NAME);
   VALUE error  = rb_const_get(module, rb_intern(name));
@@ -51,30 +51,30 @@ void zstds_ext_raise_error(zstds_ext_result_t ext_result)
 {
   switch (ext_result) {
     case ZSTDS_EXT_ERROR_ALLOCATE_FAILED:
-      raise("AllocateError", "allocate error");
+      raise_error("AllocateError", "allocate error");
     case ZSTDS_EXT_ERROR_VALIDATE_FAILED:
-      raise("ValidateError", "validate error");
+      raise_error("ValidateError", "validate error");
 
     case ZSTDS_EXT_ERROR_USED_AFTER_CLOSE:
-      raise("UsedAfterCloseError", "used after closed");
+      raise_error("UsedAfterCloseError", "used after closed");
     case ZSTDS_EXT_ERROR_NOT_ENOUGH_SOURCE_BUFFER:
-      raise("NotEnoughSourceBufferError", "not enough source buffer");
+      raise_error("NotEnoughSourceBufferError", "not enough source buffer");
     case ZSTDS_EXT_ERROR_NOT_ENOUGH_DESTINATION_BUFFER:
-      raise("NotEnoughDestinationBufferError", "not enough destination buffer");
+      raise_error("NotEnoughDestinationBufferError", "not enough destination buffer");
     case ZSTDS_EXT_ERROR_DECOMPRESSOR_CORRUPTED_SOURCE:
-      raise("DecompressorCorruptedSourceError", "decompressor received corrupted source");
+      raise_error("DecompressorCorruptedSourceError", "decompressor received corrupted source");
     case ZSTDS_EXT_ERROR_CORRUPTED_DICTIONARY:
-      raise("CorruptedDictionaryError", "corrupted dictionary");
+      raise_error("CorruptedDictionaryError", "corrupted dictionary");
 
     case ZSTDS_EXT_ERROR_ACCESS_IO:
-      raise("AccessIOError", "failed to access IO");
+      raise_error("AccessIOError", "failed to access IO");
     case ZSTDS_EXT_ERROR_READ_IO:
-      raise("ReadIOError", "failed to read IO");
+      raise_error("ReadIOError", "failed to read IO");
     case ZSTDS_EXT_ERROR_WRITE_IO:
-      raise("WriteIOError", "failed to write IO");
+      raise_error("WriteIOError", "failed to write IO");
 
     default:
       // ZSTDS_EXT_ERROR_UNEXPECTED
-      raise("UnexpectedError", "unexpected error");
+      raise_error("UnexpectedError", "unexpected error");
   }
 }

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);