ruby-lzws 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62d885a3a75f291ea4b808da4ef4e47a68574e74dae8fe39aad61d228a62643c
-  data.tar.gz: 90e5fc29ea554392dcf93bb391a38361707c14306099b6654765e399d111ea9d
+  metadata.gz: 46de1059ebc7e81a3c93869a70801e20571e99631a0a9a8acc0cad9b06e9c21f
+  data.tar.gz: c4d1d3859bd374404b496b9ae393f34b08b49bf94655e420862545fd8949cc12
 SHA512:
-  metadata.gz: 66c07c08d7094be0e9f2d802c01796529e0c14bcde067752aa629d7e3337218e0d6a08e7cfe08725659097fb0e3be90e7565a872a3c79dc96813afa6b235e4ab
-  data.tar.gz: a1d74a3408881c23f816818931685ec084bd2a0e9c114be212f8a059e37af8da882e9235f3780524e5e67557b3c9945f33b3ecab8535768e4737e972fc724d87
+  metadata.gz: 88f2f3627fb6f98fffc6c1289301a9362c6ab22edc7de42732a90c85b1065bd2e3ee73547dbab0ee1c40d14c3490053f43d36d7b67abb25aa6ec2e938211e95e
+  data.tar.gz: e6b97fea5d39bd2ee8b4e9ad43d16453f0640536c86dd9e0d425443c3a48a5bb3bf99c5bb452e4065f3c21489572a4bf05a9809b1eccfd7ef39773a1eea0d05d

data/README.md

@@ -1,8 +1,8 @@
 # Ruby bindings for lzws library
 
-| Travis | AppVeyor | Circle | Codecov |
-| :---:  | :---:    | :---:  | :---:   |
-| [![Travis test status](https://travis-ci.com/andrew-aladev/ruby-lzws.svg?branch=master)](https://travis-ci.com/andrew-aladev/ruby-lzws) | [![AppVeyor test status](https://ci.appveyor.com/api/projects/status/github/andrew-aladev/ruby-lzws?branch=master&svg=true)](https://ci.appveyor.com/project/andrew-aladev/ruby-lzws/branch/master) | [![Circle test status](https://circleci.com/gh/andrew-aladev/ruby-lzws/tree/master.svg?style=shield)](https://circleci.com/gh/andrew-aladev/ruby-lzws/tree/master) | [![Codecov](https://codecov.io/gh/andrew-aladev/ruby-lzws/branch/master/graph/badge.svg)](https://codecov.io/gh/andrew-aladev/ruby-lzws) |
+| Travis | AppVeyor | Circle | Codecov | Gem   |
+| :---:  | :---:    | :---:  | :---:   | :---: |
+| [![Travis test status](https://travis-ci.com/andrew-aladev/ruby-lzws.svg?branch=master)](https://travis-ci.com/andrew-aladev/ruby-lzws) | [![AppVeyor test status](https://ci.appveyor.com/api/projects/status/github/andrew-aladev/ruby-lzws?branch=master&svg=true)](https://ci.appveyor.com/project/andrew-aladev/ruby-lzws/branch/master) | [![Circle test status](https://circleci.com/gh/andrew-aladev/ruby-lzws/tree/master.svg?style=shield)](https://circleci.com/gh/andrew-aladev/ruby-lzws/tree/master) | [![Codecov](https://codecov.io/gh/andrew-aladev/ruby-lzws/branch/master/graph/badge.svg)](https://codecov.io/gh/andrew-aladev/ruby-lzws) | [![Gem](https://img.shields.io/gem/v/ruby-lzws.svg)](https://rubygems.org/gems/ruby-lzws) |
 
 See [lzws library](https://github.com/andrew-aladev/lzws).
 
@@ -61,8 +61,8 @@ ensure
 end
 ```
 
-You can create and read `tar.Z` archives with `minitar` for example.
-LZWS is compatible with UNIX compress (with default options).
+You can create and read `tar.Z` archives with [minitar](https://github.com/halostatue/minitar) for example.
+LZWS is compatible with [UNIX compress](https://en.wikipedia.org/wiki/Compress) (with default options).
 
 ```ruby
 require "lzws"
@@ -84,12 +84,25 @@ LZWS::Stream::Reader.open "file.tar.Z" do |reader|
 end
 ```
 
+You can also use `Content-Encoding: compress` with [sinatra](http://sinatrarb.com):
+
+```ruby
+require "lzws"
+require "sinatra"
+
+get "/" do
+  headers["Content-Encoding"] = "compress"
+  LZWS::String.compress "TOBEORNOTTOBEORTOBEORNOT"
+end
+```
+
 ## Options
 
 | Option                      | Values     | Default  | Description |
 |-----------------------------|------------|----------|-------------|
 | `source_buffer_length`      | 0, 2 - inf | 0 (auto) | internal buffer length for source data |
 | `destination_buffer_length` | 0, 2 - inf | 0 (auto) | internal buffer length for description data |
+| `gvl`                       | true/false | false    | enables global VM lock where possible |
 | `max_code_bit_length`       | 9 - 16     | 16       | max code bit length |
 | `block_mode`                | true/false | true     | enables block mode |
 | `without_magic_header`      | true/false | false    | disables magic header |
@@ -101,6 +114,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.
+
 You can also read lzws docs for more info about options.
 
 | Option                | Related constants |
@@ -111,6 +128,7 @@ Possible compressor options:
 ```
 :source_buffer_length
 :destination_buffer_length
+:gvl
 :max_code_bit_length
 :block_mode
 :without_magic_header
@@ -123,6 +141,7 @@ Possible decompressor options:
 ```
 :source_buffer_length
 :destination_buffer_length
+:gvl
 :without_magic_header
 :msb
 :unaligned_bit_groups
@@ -138,18 +157,6 @@ data = LZWS::String.compress "TOBEORNOTTOBEORTOBEORNOT", :msb => true
 puts LZWS::String.decompress(data, :msb => true)
 ```
 
-Default options are compatible with UNIX compress (`Content-Encoding: compress`):
-
-```ruby
-require "lzws"
-require "sinatra"
-
-get "/" do
-  headers["Content-Encoding"] = "compress"
-  LZWS::String.compress "TOBEORNOTTOBEORTOBEORNOT"
-end
-```
-
 Please read more about compatibility in lzws docs.
 
 ## String
@@ -323,12 +330,18 @@ See [`IO`](https://ruby-doc.org/core-2.7.0/IO.html) docs.
 
 Typical helpers, see [`Zlib::GzipReader`](https://ruby-doc.org/stdlib-2.7.0/libdoc/zlib/rdoc/Zlib/GzipReader.html) docs.
 
+## 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,8 @@
 
 require "mkmf"
 
+have_func "rb_thread_call_without_gvl", "ruby/thread.h"
+
 def require_header(name, types = [])
   abort "Can't find #{name} header" unless find_header name
 

data/ext/lzws_ext/buffer.c

@@ -12,10 +12,10 @@ VALUE lzws_ext_create_string_buffer(VALUE length)
   return rb_str_new(NULL, NUM2SIZET(length));
 }
 
-VALUE lzws_ext_resize_string_buffer(VALUE args)
+VALUE lzws_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/lzws_ext/buffer.h

@@ -11,12 +11,12 @@ VALUE lzws_ext_create_string_buffer(VALUE length);
 #define LZWS_EXT_CREATE_STRING_BUFFER(buffer, length, exception) \
   VALUE buffer = rb_protect(lzws_ext_create_string_buffer, SIZET2NUM(length), &exception);
 
-VALUE lzws_ext_resize_string_buffer(VALUE args);
+VALUE lzws_ext_resize_string_buffer(VALUE buffer_args);
 
-#define LZWS_EXT_RESIZE_STRING_BUFFER(buffer, length, exception)            \
-  VALUE args = rb_ary_new_from_args(2, buffer, SIZET2NUM(length));          \
-  buffer     = rb_protect(lzws_ext_resize_string_buffer, args, &exception); \
-  RB_GC_GUARD(args);
+#define LZWS_EXT_RESIZE_STRING_BUFFER(buffer, length, exception)                          \
+  VALUE buffer_args = rb_ary_new_from_args(2, buffer, SIZET2NUM(length));                 \
+  buffer            = rb_protect(lzws_ext_resize_string_buffer, buffer_args, &exception); \
+  RB_GC_GUARD(buffer_args);
 
 void lzws_ext_buffer_exports(VALUE root_module);
 

data/ext/lzws_ext/gvl.h

@@ -0,0 +1,24 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(LZWS_EXT_GVL_H)
+#define LZWS_EXT_GVL_H
+
+#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+
+#include "ruby/thread.h"
+
+#define LZWS_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 LZWS_EXT_GVL_WRAP(_gvl, function, data) function((void*) data);
+
+#endif
+
+#endif // LZWS_EXT_GVL_H

data/ext/lzws_ext/io.c

@@ -6,11 +6,14 @@
 #include <lzws/file.h>
 
 #include "lzws_ext/error.h"
+#include "lzws_ext/gvl.h"
 #include "lzws_ext/macro.h"
 #include "lzws_ext/option.h"
 #include "ruby.h"
 #include "ruby/io.h"
 
+// -- utils --
+
 #define GET_FILE(target)                               \
   Check_Type(target, T_FILE);                          \
                                                        \
@@ -47,20 +50,52 @@ static inline lzws_ext_result_t get_file_error(lzws_result_t result)
   }
 }
 
+// -- compress --
+
+typedef struct
+{
+  FILE*                      source_file;
+  size_t                     source_buffer_length;
+  FILE*                      destination_file;
+  size_t                     destination_buffer_length;
+  lzws_compressor_options_t* compressor_options_ptr;
+  lzws_result_t              result;
+} compress_args_t;
+
+static inline void* compress_wrapper(void* data)
+{
+  compress_args_t* args = data;
+
+  args->result = lzws_compress_file(
+    args->source_file,
+    args->source_buffer_length,
+    args->destination_file,
+    args->destination_buffer_length,
+    args->compressor_options_ptr);
+
+  return NULL;
+}
+
 VALUE lzws_ext_compress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE destination, VALUE options)
 {
   GET_FILE(source);
   GET_FILE(destination);
   Check_Type(options, T_HASH);
+  LZWS_EXT_GET_SIZE_OPTION(options, source_buffer_length);
+  LZWS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  LZWS_EXT_GET_BOOL_OPTION(options, gvl);
   LZWS_EXT_GET_COMPRESSOR_OPTIONS(options);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, source_buffer_length);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
-  lzws_result_t result = lzws_compress_file(
-    source_file, source_buffer_length, destination_file, destination_buffer_length, &compressor_options);
+  compress_args_t args = {
+    .source_file               = source_file,
+    .source_buffer_length      = source_buffer_length,
+    .destination_file          = destination_file,
+    .destination_buffer_length = destination_buffer_length,
+    .compressor_options_ptr    = &compressor_options};
 
-  if (result != 0) {
-    lzws_ext_raise_error(get_file_error(result));
+  LZWS_EXT_GVL_WRAP(gvl, compress_wrapper, &args);
+  if (args.result != 0) {
+    lzws_ext_raise_error(get_file_error(args.result));
   }
 
   // Ruby itself won't flush stdio file before closing fd, flush is required.
@@ -69,20 +104,52 @@ VALUE lzws_ext_compress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE dest
   return Qnil;
 }
 
+// -- decompress --
+
+typedef struct
+{
+  FILE*                        source_file;
+  size_t                       source_buffer_length;
+  FILE*                        destination_file;
+  size_t                       destination_buffer_length;
+  lzws_decompressor_options_t* decompressor_options_ptr;
+  lzws_result_t                result;
+} decompress_args_t;
+
+static inline void* decompress_wrapper(void* data)
+{
+  decompress_args_t* args = data;
+
+  args->result = lzws_decompress_file(
+    args->source_file,
+    args->source_buffer_length,
+    args->destination_file,
+    args->destination_buffer_length,
+    args->decompressor_options_ptr);
+
+  return NULL;
+}
+
 VALUE lzws_ext_decompress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE destination, VALUE options)
 {
   GET_FILE(source);
   GET_FILE(destination);
   Check_Type(options, T_HASH);
+  LZWS_EXT_GET_SIZE_OPTION(options, source_buffer_length);
+  LZWS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  LZWS_EXT_GET_BOOL_OPTION(options, gvl);
   LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, source_buffer_length);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
-  lzws_result_t result = lzws_decompress_file(
-    source_file, source_buffer_length, destination_file, destination_buffer_length, &decompressor_options);
+  decompress_args_t args = {
+    .source_file               = source_file,
+    .source_buffer_length      = source_buffer_length,
+    .destination_file          = destination_file,
+    .destination_buffer_length = destination_buffer_length,
+    .decompressor_options_ptr  = &decompressor_options};
 
-  if (result != 0) {
-    lzws_ext_raise_error(get_file_error(result));
+  LZWS_EXT_GVL_WRAP(gvl, decompress_wrapper, &args);
+  if (args.result != 0) {
+    lzws_ext_raise_error(get_file_error(args.result));
   }
 
   // Ruby itself won't flush stdio file before closing fd, flush is required.
@@ -91,6 +158,8 @@ VALUE lzws_ext_decompress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE de
   return Qnil;
 }
 
+// -- exports --
+
 void lzws_ext_io_exports(VALUE root_module)
 {
   rb_define_module_function(root_module, "_native_compress_io", RUBY_METHOD_FUNC(lzws_ext_compress_io), 3);

data/ext/lzws_ext/option.c

@@ -8,47 +8,65 @@
 
 // -- values --
 
-static inline VALUE get_raw_option_value(VALUE options, const char* name)
+static inline VALUE get_raw_value(VALUE options, const char* name)
 {
   return rb_funcall(options, rb_intern("[]"), 1, ID2SYM(rb_intern(name)));
 }
 
-void lzws_ext_get_bool_option(VALUE options, bool* option, const char* name)
+static inline bool get_bool_value(VALUE raw_value)
 {
-  VALUE raw_value = get_raw_option_value(options, name);
-  if (raw_value == Qnil) {
-    return;
-  }
-
   int raw_type = TYPE(raw_value);
   if (raw_type != T_TRUE && raw_type != T_FALSE) {
     lzws_ext_raise_error(LZWS_EXT_ERROR_VALIDATE_FAILED);
   }
 
-  *option = raw_type == T_TRUE;
+  return raw_type == T_TRUE;
 }
 
-void lzws_ext_get_max_code_bit_length_option(VALUE options, lzws_byte_fast_t* option, const char* name)
+static inline unsigned int get_uint_value(VALUE raw_value)
 {
-  VALUE raw_value = get_raw_option_value(options, name);
-  if (raw_value == Qnil) {
-    return;
-  }
-
   Check_Type(raw_value, T_FIXNUM);
 
-  *option = NUM2UINT(raw_value);
+  return NUM2UINT(raw_value);
 }
 
-size_t lzws_ext_get_size_option_value(VALUE options, const char* name)
+static inline size_t get_size_value(VALUE raw_value)
 {
-  VALUE raw_value = get_raw_option_value(options, name);
-
   Check_Type(raw_value, T_FIXNUM);
 
   return NUM2SIZET(raw_value);
 }
 
+void lzws_ext_resolve_bool_option(VALUE options, bool* option, const char* name)
+{
+  VALUE raw_value = get_raw_value(options, name);
+  if (raw_value != Qnil) {
+    *option = get_bool_value(raw_value);
+  }
+}
+
+void lzws_ext_resolve_max_code_bit_length_option(VALUE options, lzws_byte_fast_t* option, const char* name)
+{
+  VALUE raw_value = get_raw_value(options, name);
+  if (raw_value != Qnil) {
+    *option = get_uint_value(raw_value);
+  }
+}
+
+bool lzws_ext_get_bool_option_value(VALUE options, const char* name)
+{
+  VALUE raw_value = get_raw_value(options, name);
+
+  return get_bool_value(raw_value);
+}
+
+size_t lzws_ext_get_size_option_value(VALUE options, const char* name)
+{
+  VALUE raw_value = get_raw_value(options, name);
+
+  return get_size_value(raw_value);
+}
+
 // -- exports --
 
 void lzws_ext_option_exports(VALUE root_module)

data/ext/lzws_ext/option.h

@@ -11,36 +11,38 @@
 
 #include "ruby.h"
 
-void lzws_ext_get_bool_option(VALUE options, bool* option, const char* name);
-void lzws_ext_get_max_code_bit_length_option(VALUE options, lzws_byte_fast_t* option, const char* name);
+void lzws_ext_resolve_bool_option(VALUE options, bool* option, const char* name);
+void lzws_ext_resolve_max_code_bit_length_option(VALUE options, lzws_byte_fast_t* option, const char* name);
 
-#define LZWS_EXT_GET_BOOL_OPTION(options, target_options, name) \
-  lzws_ext_get_bool_option(options, &target_options.name, #name);
+#define LZWS_EXT_RESOLVE_BOOL_OPTION(options, target_options, name) \
+  lzws_ext_resolve_bool_option(options, &target_options.name, #name);
 
-#define LZWS_EXT_GET_MAX_CODE_BIT_LENGTH_OPTION(options, target_options, name) \
-  lzws_ext_get_max_code_bit_length_option(options, &target_options.name, #name);
+#define LZWS_EXT_RESOLVE_MAX_CODE_BIT_LENGTH_OPTION(options, target_options, name) \
+  lzws_ext_resolve_max_code_bit_length_option(options, &target_options.name, #name);
 
-#define LZWS_EXT_GET_COMPRESSOR_OPTIONS(options)                                             \
-  lzws_compressor_options_t compressor_options = LZWS_COMPRESSOR_DEFAULT_OPTIONS;            \
-                                                                                             \
-  LZWS_EXT_GET_BOOL_OPTION(options, compressor_options, without_magic_header);               \
-  LZWS_EXT_GET_MAX_CODE_BIT_LENGTH_OPTION(options, compressor_options, max_code_bit_length); \
-  LZWS_EXT_GET_BOOL_OPTION(options, compressor_options, block_mode);                         \
-  LZWS_EXT_GET_BOOL_OPTION(options, compressor_options, msb);                                \
-  LZWS_EXT_GET_BOOL_OPTION(options, compressor_options, unaligned_bit_groups);               \
-  LZWS_EXT_GET_BOOL_OPTION(options, compressor_options, quiet);
+#define LZWS_EXT_GET_COMPRESSOR_OPTIONS(options)                                                 \
+  lzws_compressor_options_t compressor_options = LZWS_COMPRESSOR_DEFAULT_OPTIONS;                \
+                                                                                                 \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, compressor_options, without_magic_header);               \
+  LZWS_EXT_RESOLVE_MAX_CODE_BIT_LENGTH_OPTION(options, compressor_options, max_code_bit_length); \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, compressor_options, block_mode);                         \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, compressor_options, msb);                                \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, compressor_options, unaligned_bit_groups);               \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, compressor_options, quiet);
 
 #define LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options)                                      \
   lzws_decompressor_options_t decompressor_options = LZWS_DECOMPRESSOR_DEFAULT_OPTIONS; \
                                                                                         \
-  LZWS_EXT_GET_BOOL_OPTION(options, decompressor_options, without_magic_header);        \
-  LZWS_EXT_GET_BOOL_OPTION(options, decompressor_options, msb);                         \
-  LZWS_EXT_GET_BOOL_OPTION(options, decompressor_options, unaligned_bit_groups);        \
-  LZWS_EXT_GET_BOOL_OPTION(options, decompressor_options, quiet);
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, decompressor_options, without_magic_header);    \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, decompressor_options, msb);                     \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, decompressor_options, unaligned_bit_groups);    \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, decompressor_options, quiet);
 
+bool   lzws_ext_get_bool_option_value(VALUE options, const char* name);
 size_t lzws_ext_get_size_option_value(VALUE options, const char* name);
 
-#define LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, name) size_t name = lzws_ext_get_size_option_value(options, #name);
+#define LZWS_EXT_GET_BOOL_OPTION(options, name) bool name = lzws_ext_get_bool_option_value(options, #name);
+#define LZWS_EXT_GET_SIZE_OPTION(options, name) size_t name = lzws_ext_get_size_option_value(options, #name);
 
 void lzws_ext_option_exports(VALUE root_module);
 

data/ext/lzws_ext/stream/compressor.c

@@ -8,9 +8,12 @@
 #include <lzws/compressor/state.h>
 
 #include "lzws_ext/error.h"
+#include "lzws_ext/gvl.h"
 #include "lzws_ext/option.h"
 #include "ruby.h"
 
+// -- initialization --
+
 static void free_compressor(lzws_ext_compressor_t* compressor_ptr)
 {
   lzws_compressor_state_t* state_ptr = compressor_ptr->state_ptr;
@@ -36,6 +39,7 @@ VALUE lzws_ext_allocate_compressor(VALUE klass)
   compressor_ptr->destination_buffer_length           = 0;
   compressor_ptr->remaining_destination_buffer        = NULL;
   compressor_ptr->remaining_destination_buffer_length = 0;
+  compressor_ptr->gvl                                 = false;
 
   return self;
 }
@@ -48,8 +52,9 @@ VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options)
 {
   GET_COMPRESSOR(self);
   Check_Type(options, T_HASH);
+  LZWS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  LZWS_EXT_GET_BOOL_OPTION(options, gvl);
   LZWS_EXT_GET_COMPRESSOR_OPTIONS(options);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   lzws_compressor_state_t* state_ptr;
 
@@ -80,63 +85,106 @@ VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options)
   compressor_ptr->destination_buffer_length           = destination_buffer_length;
   compressor_ptr->remaining_destination_buffer        = destination_buffer;
   compressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
+  compressor_ptr->gvl                                 = gvl;
 
   return Qnil;
 }
 
+// -- compress --
+
 #define DO_NOT_USE_AFTER_CLOSE(compressor_ptr)                                           \
   if (compressor_ptr->state_ptr == NULL || compressor_ptr->destination_buffer == NULL) { \
     lzws_ext_raise_error(LZWS_EXT_ERROR_USED_AFTER_CLOSE);                               \
   }
 
-#define GET_SOURCE_DATA(source_value)                                   \
-  Check_Type(source_value, T_STRING);                                   \
-                                                                        \
-  const char*      source                  = RSTRING_PTR(source_value); \
-  size_t           source_length           = RSTRING_LEN(source_value); \
-  lzws_ext_byte_t* remaining_source        = (lzws_ext_byte_t*) source; \
-  size_t           remaining_source_length = source_length;
+typedef struct
+{
+  lzws_ext_compressor_t* compressor_ptr;
+  lzws_ext_byte_t*       remaining_source;
+  size_t*                remaining_source_length_ptr;
+  lzws_result_t          result;
+} compress_args_t;
 
-VALUE lzws_ext_compress(VALUE self, VALUE source_value)
+static inline void* compress_wrapper(void* data)
 {
-  GET_COMPRESSOR(self);
-  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
-  GET_SOURCE_DATA(source_value);
+  compress_args_t*       args           = data;
+  lzws_ext_compressor_t* compressor_ptr = args->compressor_ptr;
 
-  lzws_result_t result = lzws_compress(
+  args->result = lzws_compress(
     compressor_ptr->state_ptr,
-    &remaining_source,
-    &remaining_source_length,
+    &args->remaining_source,
+    args->remaining_source_length_ptr,
     &compressor_ptr->remaining_destination_buffer,
     &compressor_ptr->remaining_destination_buffer_length);
 
-  if (result != 0 && result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
+  return NULL;
+}
+
+VALUE lzws_ext_compress(VALUE self, VALUE source_value)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+  Check_Type(source_value, T_STRING);
+
+  const char*      source                  = RSTRING_PTR(source_value);
+  size_t           source_length           = RSTRING_LEN(source_value);
+  lzws_ext_byte_t* remaining_source        = (lzws_ext_byte_t*) source;
+  size_t           remaining_source_length = source_length;
+
+  compress_args_t args = {
+    .compressor_ptr              = compressor_ptr,
+    .remaining_source            = remaining_source,
+    .remaining_source_length_ptr = &remaining_source_length};
+
+  LZWS_EXT_GVL_WRAP(compressor_ptr->gvl, compress_wrapper, &args);
+  if (args.result != 0 && args.result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
     lzws_ext_raise_error(LZWS_EXT_ERROR_UNEXPECTED);
   }
 
   VALUE bytes_written          = SIZET2NUM(source_length - remaining_source_length);
-  VALUE needs_more_destination = result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
+  VALUE needs_more_destination = args.result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
 
   return rb_ary_new_from_args(2, bytes_written, needs_more_destination);
 }
 
-VALUE lzws_ext_compressor_finish(VALUE self)
+// -- compressor finish --
+
+typedef struct
 {
-  GET_COMPRESSOR(self);
-  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+  lzws_ext_compressor_t* compressor_ptr;
+  lzws_result_t          result;
+} compressor_finish_args_t;
 
-  lzws_result_t result = lzws_compressor_finish(
+static inline void* compressor_finish_wrapper(void* data)
+{
+  compressor_finish_args_t* args           = data;
+  lzws_ext_compressor_t*    compressor_ptr = args->compressor_ptr;
+
+  args->result = lzws_compressor_finish(
     compressor_ptr->state_ptr,
     &compressor_ptr->remaining_destination_buffer,
     &compressor_ptr->remaining_destination_buffer_length);
 
-  if (result != 0 && result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
+  return NULL;
+}
+
+VALUE lzws_ext_compressor_finish(VALUE self)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+
+  compressor_finish_args_t args = {.compressor_ptr = compressor_ptr};
+
+  LZWS_EXT_GVL_WRAP(compressor_ptr->gvl, compressor_finish_wrapper, &args);
+  if (args.result != 0 && args.result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
     lzws_ext_raise_error(LZWS_EXT_ERROR_UNEXPECTED);
   }
 
-  return result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
+  return args.result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
 }
 
+// -- other --
+
 VALUE lzws_ext_compressor_read_result(VALUE self)
 {
   GET_COMPRESSOR(self);
@@ -156,6 +204,8 @@ VALUE lzws_ext_compressor_read_result(VALUE self)
   return result_value;
 }
 
+// -- cleanup --
+
 VALUE lzws_ext_compressor_close(VALUE self)
 {
   GET_COMPRESSOR(self);
@@ -175,12 +225,14 @@ VALUE lzws_ext_compressor_close(VALUE self)
     compressor_ptr->destination_buffer = NULL;
   }
 
-  // It is possible to keep "destination_buffer_length", "remaining_destination_buffer"
-  //   and "remaining_destination_buffer_length" as is.
+  // It is possible to keep "destination_buffer_length", "remaining_destination_buffer",
+  //   "remaining_destination_buffer_length" and "gvl" as is.
 
   return Qnil;
 }
 
+// -- exports --
+
 void lzws_ext_compressor_exports(VALUE root_module)
 {
   VALUE module = rb_define_module_under(root_module, "Stream");

data/ext/lzws_ext/stream/compressor.h

@@ -5,6 +5,7 @@
 #define LZWS_EXT_STREAM_COMPRESSOR_H
 
 #include <lzws/compressor/state.h>
+#include <stdbool.h>
 #include <stdlib.h>
 
 #include "lzws_ext/common.h"
@@ -17,6 +18,7 @@ typedef struct
   size_t                   destination_buffer_length;
   lzws_ext_byte_t*         remaining_destination_buffer;
   size_t                   remaining_destination_buffer_length;
+  bool                     gvl;
 } lzws_ext_compressor_t;
 
 VALUE lzws_ext_allocate_compressor(VALUE klass);

data/ext/lzws_ext/stream/decompressor.c

@@ -8,9 +8,12 @@
 #include <lzws/decompressor/state.h>
 
 #include "lzws_ext/error.h"
+#include "lzws_ext/gvl.h"
 #include "lzws_ext/option.h"
 #include "ruby.h"
 
+// -- initialization --
+
 static void free_decompressor(lzws_ext_decompressor_t* decompressor_ptr)
 {
   lzws_decompressor_state_t* state_ptr = decompressor_ptr->state_ptr;
@@ -48,8 +51,9 @@ VALUE lzws_ext_initialize_decompressor(VALUE self, VALUE options)
 {
   GET_DECOMPRESSOR(self);
   Check_Type(options, T_HASH);
+  LZWS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  LZWS_EXT_GET_BOOL_OPTION(options, gvl);
   LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   lzws_decompressor_state_t* state_ptr;
 
@@ -78,38 +82,60 @@ VALUE lzws_ext_initialize_decompressor(VALUE self, VALUE options)
   decompressor_ptr->destination_buffer_length           = destination_buffer_length;
   decompressor_ptr->remaining_destination_buffer        = destination_buffer;
   decompressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
+  decompressor_ptr->gvl                                 = gvl;
 
   return Qnil;
 }
 
+// -- decompress --
+
 #define DO_NOT_USE_AFTER_CLOSE(decompressor_ptr)                                             \
   if (decompressor_ptr->state_ptr == NULL || decompressor_ptr->destination_buffer == NULL) { \
     lzws_ext_raise_error(LZWS_EXT_ERROR_USED_AFTER_CLOSE);                                   \
   }
 
-#define GET_SOURCE_DATA(source_value)                                   \
-  Check_Type(source_value, T_STRING);                                   \
-                                                                        \
-  const char*      source                  = RSTRING_PTR(source_value); \
-  size_t           source_length           = RSTRING_LEN(source_value); \
-  lzws_ext_byte_t* remaining_source        = (lzws_ext_byte_t*) source; \
-  size_t           remaining_source_length = source_length;
+typedef struct
+{
+  lzws_ext_decompressor_t* decompressor_ptr;
+  lzws_ext_byte_t*         remaining_source;
+  size_t*                  remaining_source_length_ptr;
+  lzws_result_t            result;
+} decompress_args_t;
 
-VALUE lzws_ext_decompress(VALUE self, VALUE source_value)
+static inline void* decompress_wrapper(void* data)
 {
-  GET_DECOMPRESSOR(self);
-  DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
-  GET_SOURCE_DATA(source_value);
+  decompress_args_t*       args             = data;
+  lzws_ext_decompressor_t* decompressor_ptr = args->decompressor_ptr;
 
-  lzws_result_t result = lzws_decompress(
+  args->result = lzws_decompress(
     decompressor_ptr->state_ptr,
-    &remaining_source,
-    &remaining_source_length,
+    &args->remaining_source,
+    args->remaining_source_length_ptr,
     &decompressor_ptr->remaining_destination_buffer,
     &decompressor_ptr->remaining_destination_buffer_length);
 
-  if (result != 0 && result != LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
-    switch (result) {
+  return NULL;
+}
+
+VALUE lzws_ext_decompress(VALUE self, VALUE source_value)
+{
+  GET_DECOMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
+  Check_Type(source_value, T_STRING);
+
+  const char*      source                  = RSTRING_PTR(source_value);
+  size_t           source_length           = RSTRING_LEN(source_value);
+  lzws_ext_byte_t* remaining_source        = (lzws_ext_byte_t*) source;
+  size_t           remaining_source_length = source_length;
+
+  decompress_args_t args = {
+    .decompressor_ptr            = decompressor_ptr,
+    .remaining_source            = remaining_source,
+    .remaining_source_length_ptr = &remaining_source_length};
+
+  LZWS_EXT_GVL_WRAP(decompressor_ptr->gvl, decompress_wrapper, &args);
+  if (args.result != 0 && args.result != LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
+    switch (args.result) {
       case LZWS_DECOMPRESSOR_INVALID_MAGIC_HEADER:
       case LZWS_DECOMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH:
         lzws_ext_raise_error(LZWS_EXT_ERROR_VALIDATE_FAILED);
@@ -121,11 +147,13 @@ VALUE lzws_ext_decompress(VALUE self, VALUE source_value)
   }
 
   VALUE bytes_read             = SIZET2NUM(source_length - remaining_source_length);
-  VALUE needs_more_destination = result == LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
+  VALUE needs_more_destination = args.result == LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
 
   return rb_ary_new_from_args(2, bytes_read, needs_more_destination);
 }
 
+// -- other --
+
 VALUE lzws_ext_decompressor_read_result(VALUE self)
 {
   GET_DECOMPRESSOR(self);
@@ -145,6 +173,8 @@ VALUE lzws_ext_decompressor_read_result(VALUE self)
   return result_value;
 }
 
+// -- cleanup --
+
 VALUE lzws_ext_decompressor_close(VALUE self)
 {
   GET_DECOMPRESSOR(self);
@@ -170,6 +200,8 @@ VALUE lzws_ext_decompressor_close(VALUE self)
   return Qnil;
 }
 
+// -- exports --
+
 void lzws_ext_decompressor_exports(VALUE root_module)
 {
   VALUE module = rb_define_module_under(root_module, "Stream");

data/ext/lzws_ext/stream/decompressor.h

@@ -5,6 +5,7 @@
 #define LZWS_EXT_STREAM_DECOMPRESSOR_H
 
 #include <lzws/decompressor/state.h>
+#include <stdbool.h>
 #include <stdlib.h>
 
 #include "lzws_ext/common.h"
@@ -17,6 +18,7 @@ typedef struct
   size_t                     destination_buffer_length;
   lzws_ext_byte_t*           remaining_destination_buffer;
   size_t                     remaining_destination_buffer_length;
+  bool                       gvl;
 } lzws_ext_decompressor_t;
 
 VALUE lzws_ext_allocate_decompressor(VALUE klass);

data/ext/lzws_ext/string.c

@@ -12,6 +12,7 @@
 
 #include "lzws_ext/buffer.h"
 #include "lzws_ext/error.h"
+#include "lzws_ext/gvl.h"
 #include "lzws_ext/macro.h"
 #include "lzws_ext/option.h"
 #include "ruby.h"
@@ -41,30 +42,67 @@ static inline lzws_ext_result_t increase_destination_buffer(
   return 0;
 }
 
-// -- utils --
+// -- compress --
 
-#define GET_SOURCE_DATA(source_value)                    \
-  Check_Type(source_value, T_STRING);                    \
-                                                         \
-  const char* source        = RSTRING_PTR(source_value); \
-  size_t      source_length = RSTRING_LEN(source_value);
+typedef struct
+{
+  lzws_compressor_state_t* state_ptr;
+  lzws_ext_byte_t**        remaining_source_ptr;
+  size_t*                  remaining_source_length_ptr;
+  lzws_ext_byte_t*         remaining_destination_buffer;
+  size_t*                  remaining_destination_buffer_length_ptr;
+  lzws_result_t            result;
+} compress_args_t;
+
+typedef struct
+{
+  lzws_compressor_state_t* state_ptr;
+  lzws_ext_byte_t*         remaining_destination_buffer;
+  size_t*                  remaining_destination_buffer_length_ptr;
+  lzws_result_t            result;
+} compressor_finish_args_t;
 
-// -- compress --
+static inline void* compress_wrapper(void* data)
+{
+  compress_args_t* args = data;
+
+  args->result = lzws_compress(
+    args->state_ptr,
+    args->remaining_source_ptr,
+    args->remaining_source_length_ptr,
+    &args->remaining_destination_buffer,
+    args->remaining_destination_buffer_length_ptr);
+
+  return NULL;
+}
+
+static inline void* compressor_finish_wrapper(void* data)
+{
+  compressor_finish_args_t* args = data;
+
+  args->result = lzws_compressor_finish(
+    args->state_ptr, &args->remaining_destination_buffer, args->remaining_destination_buffer_length_ptr);
+
+  return NULL;
+}
 
-#define BUFFERED_COMPRESS(function, ...)                                                                         \
+#define BUFFERED_COMPRESS(gvl, wrapper, args)                                                                    \
   while (true) {                                                                                                 \
     lzws_ext_byte_t* remaining_destination_buffer =                                                              \
       (lzws_ext_byte_t*) RSTRING_PTR(destination_value) + destination_length;                                    \
     size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;                       \
                                                                                                                  \
-    result = function(__VA_ARGS__, &remaining_destination_buffer, &remaining_destination_buffer_length);         \
-    if (result != 0 && result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                                       \
+    args.remaining_destination_buffer            = remaining_destination_buffer;                                 \
+    args.remaining_destination_buffer_length_ptr = &remaining_destination_buffer_length;                         \
+                                                                                                                 \
+    LZWS_EXT_GVL_WRAP(gvl, wrapper, &args);                                                                      \
+    if (args.result != 0 && args.result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                             \
       return LZWS_EXT_ERROR_UNEXPECTED;                                                                          \
     }                                                                                                            \
                                                                                                                  \
     destination_length += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;        \
                                                                                                                  \
-    if (result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                                                      \
+    if (args.result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                                                 \
       ext_result = increase_destination_buffer(                                                                  \
         destination_value, destination_length, &remaining_destination_buffer_length, destination_buffer_length); \
                                                                                                                  \
@@ -83,17 +121,24 @@ static inline lzws_ext_result_t compress(
   const char*              source,
   size_t                   source_length,
   VALUE                    destination_value,
-  size_t                   destination_buffer_length)
+  size_t                   destination_buffer_length,
+  bool                     gvl)
 {
-  lzws_result_t     result;
   lzws_ext_result_t ext_result;
   lzws_ext_byte_t*  remaining_source                    = (lzws_ext_byte_t*) source;
   size_t            remaining_source_length             = source_length;
   size_t            destination_length                  = 0;
   size_t            remaining_destination_buffer_length = destination_buffer_length;
 
-  BUFFERED_COMPRESS(lzws_compress, state_ptr, &remaining_source, &remaining_source_length);
-  BUFFERED_COMPRESS(lzws_compressor_finish, state_ptr);
+  compress_args_t args = {
+    .state_ptr                   = state_ptr,
+    .remaining_source_ptr        = &remaining_source,
+    .remaining_source_length_ptr = &remaining_source_length};
+
+  BUFFERED_COMPRESS(gvl, compress_wrapper, args);
+
+  compressor_finish_args_t finish_args = {.state_ptr = state_ptr};
+  BUFFERED_COMPRESS(gvl, compressor_finish_wrapper, finish_args);
 
   int exception;
 
@@ -107,10 +152,11 @@ static inline lzws_ext_result_t compress(
 
 VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value, VALUE options)
 {
-  GET_SOURCE_DATA(source_value);
+  Check_Type(source_value, T_STRING);
   Check_Type(options, T_HASH);
+  LZWS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  LZWS_EXT_GET_BOOL_OPTION(options, gvl);
   LZWS_EXT_GET_COMPRESSOR_OPTIONS(options);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   lzws_compressor_state_t* state_ptr;
 
@@ -138,8 +184,11 @@ VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value,
     lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
+  const char* source        = RSTRING_PTR(source_value);
+  size_t      source_length = RSTRING_LEN(source_value);
+
   lzws_ext_result_t ext_result =
-    compress(state_ptr, source, source_length, destination_value, destination_buffer_length);
+    compress(state_ptr, source, source_length, destination_value, destination_buffer_length, gvl);
 
   lzws_compressor_free_state(state_ptr);
 
@@ -152,34 +201,60 @@ VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value,
 
 // -- decompress --
 
+typedef struct
+{
+  lzws_decompressor_state_t* state_ptr;
+  lzws_ext_byte_t**          remaining_source_ptr;
+  size_t*                    remaining_source_length_ptr;
+  lzws_ext_byte_t*           remaining_destination_buffer;
+  size_t*                    remaining_destination_buffer_length_ptr;
+  lzws_result_t              result;
+} decompress_args_t;
+
+static inline void* decompress_wrapper(void* data)
+{
+  decompress_args_t* args = data;
+
+  args->result = lzws_decompress(
+    args->state_ptr,
+    args->remaining_source_ptr,
+    args->remaining_source_length_ptr,
+    &args->remaining_destination_buffer,
+    args->remaining_destination_buffer_length_ptr);
+
+  return NULL;
+}
+
 static inline lzws_ext_result_t decompress(
   lzws_decompressor_state_t* state_ptr,
   const char*                source,
   size_t                     source_length,
   VALUE                      destination_value,
-  size_t                     destination_buffer_length)
+  size_t                     destination_buffer_length,
+  bool                       gvl)
 {
-  lzws_result_t     result;
   lzws_ext_result_t ext_result;
   lzws_ext_byte_t*  remaining_source                    = (lzws_ext_byte_t*) source;
   size_t            remaining_source_length             = source_length;
   size_t            destination_length                  = 0;
   size_t            remaining_destination_buffer_length = destination_buffer_length;
 
+  decompress_args_t args = {
+    .state_ptr                   = state_ptr,
+    .remaining_source_ptr        = &remaining_source,
+    .remaining_source_length_ptr = &remaining_source_length};
+
   while (true) {
     lzws_ext_byte_t* remaining_destination_buffer =
       (lzws_ext_byte_t*) RSTRING_PTR(destination_value) + destination_length;
     size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
 
-    result = lzws_decompress(
-      state_ptr,
-      &remaining_source,
-      &remaining_source_length,
-      &remaining_destination_buffer,
-      &remaining_destination_buffer_length);
+    args.remaining_destination_buffer            = remaining_destination_buffer;
+    args.remaining_destination_buffer_length_ptr = &remaining_destination_buffer_length;
 
-    if (result != 0 && result != LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
-      switch (result) {
+    LZWS_EXT_GVL_WRAP(gvl, decompress_wrapper, &args);
+    if (args.result != 0 && args.result != LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
+      switch (args.result) {
         case LZWS_DECOMPRESSOR_INVALID_MAGIC_HEADER:
         case LZWS_DECOMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH:
           return LZWS_EXT_ERROR_VALIDATE_FAILED;
@@ -192,7 +267,7 @@ static inline lzws_ext_result_t decompress(
 
     destination_length += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;
 
-    if (result == LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
+    if (args.result == LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
       ext_result = increase_destination_buffer(
         destination_value, destination_length, &remaining_destination_buffer_length, destination_buffer_length);
 
@@ -218,10 +293,11 @@ static inline lzws_ext_result_t decompress(
 
 VALUE lzws_ext_decompress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value, VALUE options)
 {
-  GET_SOURCE_DATA(source_value);
+  Check_Type(source_value, T_STRING);
   Check_Type(options, T_HASH);
+  LZWS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  LZWS_EXT_GET_BOOL_OPTION(options, gvl);
   LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   lzws_decompressor_state_t* state_ptr;
 
@@ -247,8 +323,11 @@ VALUE lzws_ext_decompress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value
     lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
+  const char* source        = RSTRING_PTR(source_value);
+  size_t      source_length = RSTRING_LEN(source_value);
+
   lzws_ext_result_t ext_result =
-    decompress(state_ptr, source, source_length, destination_value, destination_buffer_length);
+    decompress(state_ptr, source, source_length, destination_value, destination_buffer_length, gvl);
 
   lzws_decompressor_free_state(state_ptr);
 
@@ -259,6 +338,8 @@ VALUE lzws_ext_decompress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value
   return destination_value;
 }
 
+// -- exports --
+
 void lzws_ext_string_exports(VALUE root_module)
 {
   rb_define_module_function(root_module, "_native_compress_string", RUBY_METHOD_FUNC(lzws_ext_compress_string), 2);

data/lib/lzws/option.rb

@@ -10,14 +10,36 @@ module LZWS
   module Option
     DEFAULT_BUFFER_LENGTH = 0
 
+    COMPRESSOR_DEFAULTS = {
+      :gvl                  => false,
+      :max_code_bit_length  => nil,
+      :without_magic_header => nil,
+      :block_mode           => nil,
+      :msb                  => nil,
+      :unaligned_bit_groups => nil,
+      :quiet                => nil
+    }
+    .freeze
+
+    DECOMPRESSOR_DEFAULTS = {
+      :gvl                  => false,
+      :without_magic_header => nil,
+      :msb                  => nil,
+      :unaligned_bit_groups => nil,
+      :quiet                => nil
+    }
+    .freeze
+
     def self.get_compressor_options(options, buffer_length_names)
       Validation.validate_hash options
 
       buffer_length_defaults = buffer_length_names.each_with_object({}) { |name, defaults| defaults[name] = DEFAULT_BUFFER_LENGTH }
-      options                = buffer_length_defaults.merge options
+      options                = COMPRESSOR_DEFAULTS.merge(buffer_length_defaults).merge options
 
       buffer_length_names.each { |name| Validation.validate_not_negative_integer options[name] }
 
+      Validation.validate_bool options[:gvl]
+
       max_code_bit_length = options[:max_code_bit_length]
       unless max_code_bit_length.nil?
         Validation.validate_positive_integer max_code_bit_length
@@ -47,10 +69,12 @@ module LZWS
       Validation.validate_hash options
 
       buffer_length_defaults = buffer_length_names.each_with_object({}) { |name, defaults| defaults[name] = DEFAULT_BUFFER_LENGTH }
-      options                = buffer_length_defaults.merge options
+      options                = DECOMPRESSOR_DEFAULTS.merge(buffer_length_defaults).merge options
 
       buffer_length_names.each { |name| Validation.validate_not_negative_integer options[name] }
 
+      Validation.validate_bool options[:gvl]
+
       without_magic_header = options[:without_magic_header]
       Validation.validate_bool without_magic_header unless without_magic_header.nil?
 

data/lib/lzws/version.rb

@@ -2,5 +2,5 @@
 # Copyright (c) 2019 AUTHORS, MIT License.
 
 module LZWS
-  VERSION = "1.2.0".freeze
+  VERSION = "1.3.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lzws
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Andrew Aladjev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-14 00:00:00.000000000 Z
+date: 2020-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codecov
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -152,6 +166,7 @@ files:
 - ext/lzws_ext/common.h
 - ext/lzws_ext/error.c
 - ext/lzws_ext/error.h
+- ext/lzws_ext/gvl.h
 - ext/lzws_ext/io.c
 - ext/lzws_ext/io.h
 - ext/lzws_ext/macro.h
@@ -203,5 +218,5 @@ requirements: []
 rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
-summary: Ruby bindings for lzws library.
+summary: Ruby bindings for lzws library (compatible with UNIX compress).
 test_files: []