ruby-zstds 1.0.6 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (22) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +32 -19
  3. data/ext/extconf.rb +5 -0
  4. data/ext/zstds_ext/buffer.c +4 -3
  5. data/ext/zstds_ext/buffer.h +5 -5
  6. data/ext/zstds_ext/dictionary.c +104 -42
  7. data/ext/zstds_ext/dictionary.h +1 -1
  8. data/ext/zstds_ext/error.c +1 -1
  9. data/ext/zstds_ext/error.h +2 -1
  10. data/ext/zstds_ext/gvl.h +24 -0
  11. data/ext/zstds_ext/io.c +229 -137
  12. data/ext/zstds_ext/option.c +44 -43
  13. data/ext/zstds_ext/option.h +62 -51
  14. data/ext/zstds_ext/stream/compressor.c +103 -50
  15. data/ext/zstds_ext/stream/compressor.h +4 -1
  16. data/ext/zstds_ext/stream/decompressor.c +46 -22
  17. data/ext/zstds_ext/stream/decompressor.h +4 -1
  18. data/ext/zstds_ext/string.c +93 -62
  19. data/lib/zstds/dictionary.rb +2 -0
  20. data/lib/zstds/option.rb +6 -0
  21. data/lib/zstds/version.rb +1 -1
  22. metadata +23 -8
data/ext/zstds_ext/option.c CHANGED
@@ -11,12 +11,12 @@
11
11
 
12
12
  // -- values --
13
13
 
14
- static inline VALUE get_raw_option_value(VALUE options, const char* name)
14
+ static inline VALUE get_raw_value(VALUE options, const char* name)
15
15
  {
16
16
  return rb_funcall(options, rb_intern("[]"), 1, ID2SYM(rb_intern(name)));
17
17
  }
18
18
 
19
- static inline bool get_bool_option_value(VALUE raw_value)
19
+ static inline bool get_bool_value(VALUE raw_value)
20
20
  {
21
21
  int raw_type = TYPE(raw_value);
22
22
  if (raw_type != T_TRUE && raw_type != T_FALSE) {
@@ -26,67 +26,65 @@ static inline bool get_bool_option_value(VALUE raw_value)
26
26
  return raw_type == T_TRUE;
27
27
  }
28
28
 
29
- static inline unsigned int get_uint_option_value(VALUE raw_value)
29
+ static inline unsigned int get_uint_value(VALUE raw_value)
30
30
  {
31
31
  Check_Type(raw_value, T_FIXNUM);
32
32
 
33
33
  return NUM2UINT(raw_value);
34
34
  }
35
35
 
36
- static inline int get_int_option_value(VALUE raw_value)
36
+ static inline int get_int_value(VALUE raw_value)
37
37
  {
38
38
  Check_Type(raw_value, T_FIXNUM);
39
39
 
40
40
  return NUM2INT(raw_value);
41
41
  }
42
42
 
43
- static inline unsigned long long get_ull_option_value(VALUE raw_value)
43
+ static inline unsigned long long get_ull_value(VALUE raw_value)
44
44
  {
45
45
  Check_Type(raw_value, T_FIXNUM);
46
46
 
47
47
  return NUM2ULL(raw_value);
48
48
  }
49
49
 
50
- static inline ZSTD_strategy get_strategy_option_value(VALUE raw_value)
50
+ static inline size_t get_size_value(VALUE raw_value)
51
+ {
52
+ Check_Type(raw_value, T_FIXNUM);
53
+
54
+ return NUM2SIZET(raw_value);
55
+ }
56
+
57
+ static inline ZSTD_strategy get_strategy_value(VALUE raw_value)
51
58
  {
52
59
  Check_Type(raw_value, T_SYMBOL);
53
60
 
54
61
  ID raw_id = SYM2ID(raw_value);
55
62
  if (raw_id == rb_intern("fast")) {
56
63
  return ZSTD_fast;
57
- }
58
- else if (raw_id == rb_intern("dfast")) {
64
+ } else if (raw_id == rb_intern("dfast")) {
59
65
  return ZSTD_dfast;
60
- }
61
- else if (raw_id == rb_intern("greedy")) {
66
+ } else if (raw_id == rb_intern("greedy")) {
62
67
  return ZSTD_greedy;
63
- }
64
- else if (raw_id == rb_intern("lazy")) {
68
+ } else if (raw_id == rb_intern("lazy")) {
65
69
  return ZSTD_lazy;
66
- }
67
- else if (raw_id == rb_intern("lazy2")) {
70
+ } else if (raw_id == rb_intern("lazy2")) {
68
71
  return ZSTD_lazy2;
69
- }
70
- else if (raw_id == rb_intern("btlazy2")) {
72
+ } else if (raw_id == rb_intern("btlazy2")) {
71
73
  return ZSTD_btlazy2;
72
- }
73
- else if (raw_id == rb_intern("btopt")) {
74
+ } else if (raw_id == rb_intern("btopt")) {
74
75
  return ZSTD_btopt;
75
- }
76
- else if (raw_id == rb_intern("btultra")) {
76
+ } else if (raw_id == rb_intern("btultra")) {
77
77
  return ZSTD_btultra;
78
- }
79
- else if (raw_id == rb_intern("btultra2")) {
78
+ } else if (raw_id == rb_intern("btultra2")) {
80
79
  return ZSTD_btultra2;
81
- }
82
- else {
80
+ } else {
83
81
  zstds_ext_raise_error(ZSTDS_EXT_ERROR_VALIDATE_FAILED);
84
82
  }
85
83
  }
86
84
 
87
- void zstds_ext_get_option(VALUE options, zstds_ext_option_t* option, zstds_ext_option_type_t type, const char* name)
85
+ void zstds_ext_resolve_option(VALUE options, zstds_ext_option_t* option, zstds_ext_option_type_t type, const char* name)
88
86
  {
89
- VALUE raw_value = get_raw_option_value(options, name);
87
+ VALUE raw_value = get_raw_value(options, name);
90
88
 
91
89
  option->has_value = raw_value != Qnil;
92
90
  if (!option->has_value) {
@@ -97,16 +95,16 @@ void zstds_ext_get_option(VALUE options, zstds_ext_option_t* option, zstds_ext_o
97
95
 
98
96
  switch (type) {
99
97
  case ZSTDS_EXT_OPTION_TYPE_BOOL:
100
- value = get_bool_option_value(raw_value) ? 1 : 0;
98
+ value = get_bool_value(raw_value) ? 1 : 0;
101
99
  break;
102
100
  case ZSTDS_EXT_OPTION_TYPE_UINT:
103
- value = (zstds_ext_option_value_t)get_uint_option_value(raw_value);
101
+ value = (zstds_ext_option_value_t) get_uint_value(raw_value);
104
102
  break;
105
103
  case ZSTDS_EXT_OPTION_TYPE_INT:
106
- value = (zstds_ext_option_value_t)get_int_option_value(raw_value);
104
+ value = (zstds_ext_option_value_t) get_int_value(raw_value);
107
105
  break;
108
106
  case ZSTDS_EXT_OPTION_TYPE_STRATEGY:
109
- value = (zstds_ext_option_value_t)get_strategy_option_value(raw_value);
107
+ value = (zstds_ext_option_value_t) get_strategy_value(raw_value);
110
108
  break;
111
109
  default:
112
110
  zstds_ext_raise_error(ZSTDS_EXT_ERROR_UNEXPECTED);
@@ -115,19 +113,19 @@ void zstds_ext_get_option(VALUE options, zstds_ext_option_t* option, zstds_ext_o
115
113
  option->value = value;
116
114
  }
117
115
 
118
- void zstds_ext_get_ull_option(VALUE options, zstds_ext_ull_option_t* option, const char* name)
116
+ void zstds_ext_resolve_ull_option(VALUE options, zstds_ext_ull_option_t* option, const char* name)
119
117
  {
120
- VALUE raw_value = get_raw_option_value(options, name);
118
+ VALUE raw_value = get_raw_value(options, name);
121
119
 
122
120
  option->has_value = raw_value != Qnil;
123
121
  if (option->has_value) {
124
- option->value = (zstds_ext_ull_option_value_t)get_ull_option_value(raw_value);
122
+ option->value = (zstds_ext_ull_option_value_t) get_ull_value(raw_value);
125
123
  }
126
124
  }
127
125
 
128
- void zstds_ext_get_dictionary_option(VALUE options, VALUE* option, const char* name)
126
+ void zstds_ext_resolve_dictionary_option(VALUE options, VALUE* option, const char* name)
129
127
  {
130
- VALUE raw_value = get_raw_option_value(options, name);
128
+ VALUE raw_value = get_raw_value(options, name);
131
129
 
132
130
  if (raw_value != Qnil) {
133
131
  VALUE root_module = rb_define_module(ZSTDS_EXT_MODULE_NAME);
@@ -140,13 +138,18 @@ void zstds_ext_get_dictionary_option(VALUE options, VALUE* option, const char* n
140
138
  *option = raw_value;
141
139
  }
142
140
 
143
- size_t zstds_ext_get_size_option_value(VALUE options, const char* name)
141
+ bool zstds_ext_get_bool_option_value(VALUE options, const char* name)
144
142
  {
145
- VALUE raw_value = get_raw_option_value(options, name);
143
+ VALUE raw_value = get_raw_value(options, name);
146
144
 
147
- Check_Type(raw_value, T_FIXNUM);
145
+ return get_bool_value(raw_value);
146
+ }
148
147
 
149
- return NUM2SIZET(raw_value);
148
+ size_t zstds_ext_get_size_option_value(VALUE options, const char* name)
149
+ {
150
+ VALUE raw_value = get_raw_value(options, name);
151
+
152
+ return get_size_value(raw_value);
150
153
  }
151
154
 
152
155
  // -- set params --
@@ -159,8 +162,7 @@ size_t zstds_ext_get_size_option_value(VALUE options, const char* name)
159
162
  } \
160
163
  }
161
164
 
162
- #define SET_COMPRESSOR_PARAM(ctx, param, option) \
163
- SET_OPTION_VALUE(ZSTD_CCtx_setParameter, ctx, param, option);
165
+ #define SET_COMPRESSOR_PARAM(ctx, param, option) SET_OPTION_VALUE(ZSTD_CCtx_setParameter, ctx, param, option);
164
166
 
165
167
  zstds_ext_result_t zstds_ext_set_compressor_options(ZSTD_CCtx* ctx, zstds_ext_compressor_options_t* options)
166
168
  {
@@ -205,8 +207,7 @@ zstds_ext_result_t zstds_ext_set_compressor_options(ZSTD_CCtx* ctx, zstds_ext_co
205
207
  return 0;
206
208
  }
207
209
 
208
- #define SET_DECOMPRESSOR_PARAM(ctx, param, option) \
209
- SET_OPTION_VALUE(ZSTD_DCtx_setParameter, ctx, param, option);
210
+ #define SET_DECOMPRESSOR_PARAM(ctx, param, option) SET_OPTION_VALUE(ZSTD_DCtx_setParameter, ctx, param, option);
210
211
 
211
212
  zstds_ext_result_t zstds_ext_set_decompressor_options(ZSTD_DCtx* ctx, zstds_ext_decompressor_options_t* options)
212
213
  {
data/ext/zstds_ext/option.h CHANGED
@@ -13,7 +13,8 @@
13
13
  // Default option values depends on zstd library.
14
14
  // We will set only user defined values.
15
15
 
16
- enum {
16
+ enum
17
+ {
17
18
  ZSTDS_EXT_OPTION_TYPE_BOOL = 1,
18
19
  ZSTDS_EXT_OPTION_TYPE_UINT,
19
20
  ZSTDS_EXT_OPTION_TYPE_INT,
@@ -24,17 +25,20 @@ typedef zstds_ext_byte_fast_t zstds_ext_option_type_t;
24
25
  typedef int zstds_ext_option_value_t;
25
26
  typedef unsigned long long zstds_ext_ull_option_value_t;
26
27
 
27
- typedef struct {
28
+ typedef struct
29
+ {
28
30
  bool has_value;
29
31
  zstds_ext_option_value_t value;
30
32
  } zstds_ext_option_t;
31
33
 
32
- typedef struct {
34
+ typedef struct
35
+ {
33
36
  bool has_value;
34
37
  zstds_ext_ull_option_value_t value;
35
38
  } zstds_ext_ull_option_t;
36
39
 
37
- typedef struct {
40
+ typedef struct
41
+ {
38
42
  zstds_ext_option_t compression_level;
39
43
  zstds_ext_option_t window_log;
40
44
  zstds_ext_option_t hash_log;
@@ -58,59 +62,66 @@ typedef struct {
58
62
  VALUE dictionary;
59
63
  } zstds_ext_compressor_options_t;
60
64
 
61
- typedef struct {
65
+ typedef struct
66
+ {
62
67
  zstds_ext_option_t window_log_max;
63
68
  VALUE dictionary;
64
69
  } zstds_ext_decompressor_options_t;
65
70
 
66
- void zstds_ext_get_option(VALUE options, zstds_ext_option_t* option, zstds_ext_option_type_t type, const char* name);
67
- void zstds_ext_get_ull_option(VALUE options, zstds_ext_ull_option_t* option, const char* name);
68
- void zstds_ext_get_dictionary_option(VALUE options, VALUE* option, const char* name);
69
-
70
- #define ZSTDS_EXT_GET_OPTION(options, target_options, type, name) \
71
- zstds_ext_get_option(options, &target_options.name, type, #name);
72
-
73
- #define ZSTDS_EXT_GET_ULL_OPTION(options, target_options, name) \
74
- zstds_ext_get_ull_option(options, &target_options.name, #name);
75
-
76
- #define ZSTDS_EXT_GET_DICTIONARY_OPTION(options, target_options, name) \
77
- zstds_ext_get_dictionary_option(options, &target_options.name, #name);
78
-
79
- #define ZSTDS_EXT_GET_COMPRESSOR_OPTIONS(options) \
80
- zstds_ext_compressor_options_t compressor_options; \
81
- \
82
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_INT, compression_level); \
83
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, window_log); \
84
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, hash_log); \
85
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, chain_log); \
86
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, search_log); \
87
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, min_match); \
88
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, target_length); \
89
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_STRATEGY, strategy); \
90
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_BOOL, enable_long_distance_matching); \
91
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, ldm_hash_log); \
92
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, ldm_min_match); \
93
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, ldm_bucket_size_log); \
94
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, ldm_hash_rate_log); \
95
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_BOOL, content_size_flag); \
96
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_BOOL, checksum_flag); \
97
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_BOOL, dict_id_flag); \
98
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, nb_workers); \
99
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, job_size); \
100
- ZSTDS_EXT_GET_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, overlap_log); \
101
- ZSTDS_EXT_GET_ULL_OPTION(options, compressor_options, pledged_size); \
102
- ZSTDS_EXT_GET_DICTIONARY_OPTION(options, compressor_options, dictionary);
103
-
104
- #define ZSTDS_EXT_GET_DECOMPRESSOR_OPTIONS(options) \
105
- zstds_ext_decompressor_options_t decompressor_options; \
106
- \
107
- ZSTDS_EXT_GET_OPTION(options, decompressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, window_log_max); \
108
- ZSTDS_EXT_GET_DICTIONARY_OPTION(options, decompressor_options, dictionary);
109
-
71
+ void zstds_ext_resolve_option(
72
+ VALUE options,
73
+ zstds_ext_option_t* option,
74
+ zstds_ext_option_type_t type,
75
+ const char* name);
76
+
77
+ void zstds_ext_resolve_ull_option(VALUE options, zstds_ext_ull_option_t* option, const char* name);
78
+ void zstds_ext_resolve_dictionary_option(VALUE options, VALUE* option, const char* name);
79
+
80
+ #define ZSTDS_EXT_RESOLVE_OPTION(options, target_options, type, name) \
81
+ zstds_ext_resolve_option(options, &target_options.name, type, #name);
82
+
83
+ #define ZSTDS_EXT_RESOLVE_ULL_OPTION(options, target_options, name) \
84
+ zstds_ext_resolve_ull_option(options, &target_options.name, #name);
85
+
86
+ #define ZSTDS_EXT_RESOLVE_DICTIONARY_OPTION(options, target_options, name) \
87
+ zstds_ext_resolve_dictionary_option(options, &target_options.name, #name);
88
+
89
+ #define ZSTDS_EXT_GET_COMPRESSOR_OPTIONS(options) \
90
+ zstds_ext_compressor_options_t compressor_options; \
91
+ \
92
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_INT, compression_level); \
93
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, window_log); \
94
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, hash_log); \
95
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, chain_log); \
96
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, search_log); \
97
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, min_match); \
98
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, target_length); \
99
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_STRATEGY, strategy); \
100
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_BOOL, enable_long_distance_matching); \
101
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, ldm_hash_log); \
102
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, ldm_min_match); \
103
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, ldm_bucket_size_log); \
104
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, ldm_hash_rate_log); \
105
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_BOOL, content_size_flag); \
106
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_BOOL, checksum_flag); \
107
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_BOOL, dict_id_flag); \
108
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, nb_workers); \
109
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, job_size); \
110
+ ZSTDS_EXT_RESOLVE_OPTION(options, compressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, overlap_log); \
111
+ ZSTDS_EXT_RESOLVE_ULL_OPTION(options, compressor_options, pledged_size); \
112
+ ZSTDS_EXT_RESOLVE_DICTIONARY_OPTION(options, compressor_options, dictionary);
113
+
114
+ #define ZSTDS_EXT_GET_DECOMPRESSOR_OPTIONS(options) \
115
+ zstds_ext_decompressor_options_t decompressor_options; \
116
+ \
117
+ ZSTDS_EXT_RESOLVE_OPTION(options, decompressor_options, ZSTDS_EXT_OPTION_TYPE_UINT, window_log_max); \
118
+ ZSTDS_EXT_RESOLVE_DICTIONARY_OPTION(options, decompressor_options, dictionary);
119
+
120
+ bool zstds_ext_get_bool_option_value(VALUE options, const char* name);
110
121
  size_t zstds_ext_get_size_option_value(VALUE options, const char* name);
111
122
 
112
- #define ZSTDS_EXT_GET_BUFFER_LENGTH_OPTION(options, name) \
113
- size_t name = zstds_ext_get_size_option_value(options, #name);
123
+ #define ZSTDS_EXT_GET_BOOL_OPTION(options, name) size_t name = zstds_ext_get_bool_option_value(options, #name);
124
+ #define ZSTDS_EXT_GET_SIZE_OPTION(options, name) size_t name = zstds_ext_get_size_option_value(options, #name);
114
125
 
115
126
  zstds_ext_result_t zstds_ext_set_compressor_options(ZSTD_CCtx* ctx, zstds_ext_compressor_options_t* options);
116
127
  zstds_ext_result_t zstds_ext_set_decompressor_options(ZSTD_DCtx* ctx, zstds_ext_decompressor_options_t* options);
data/ext/zstds_ext/stream/compressor.c CHANGED
@@ -7,8 +7,11 @@
7
7
 
8
8
  #include "ruby.h"
9
9
  #include "zstds_ext/error.h"
10
+ #include "zstds_ext/gvl.h"
10
11
  #include "zstds_ext/option.h"
11
12
 
13
+ // -- initialization --
14
+
12
15
  static void free_compressor(zstds_ext_compressor_t* compressor_ptr)
13
16
  {
14
17
  ZSTD_CCtx* ctx = compressor_ptr->ctx;
@@ -27,14 +30,14 @@ static void free_compressor(zstds_ext_compressor_t* compressor_ptr)
27
30
  VALUE zstds_ext_allocate_compressor(VALUE klass)
28
31
  {
29
32
  zstds_ext_compressor_t* compressor_ptr;
30
-
31
- VALUE self = Data_Make_Struct(klass, zstds_ext_compressor_t, NULL, free_compressor, compressor_ptr);
33
+ VALUE self = Data_Make_Struct(klass, zstds_ext_compressor_t, NULL, free_compressor, compressor_ptr);
32
34
 
33
35
  compressor_ptr->ctx = NULL;
34
36
  compressor_ptr->destination_buffer = NULL;
35
37
  compressor_ptr->destination_buffer_length = 0;
36
38
  compressor_ptr->remaining_destination_buffer = NULL;
37
39
  compressor_ptr->remaining_destination_buffer_length = 0;
40
+ compressor_ptr->gvl = false;
38
41
 
39
42
  return self;
40
43
  }
@@ -47,8 +50,9 @@ VALUE zstds_ext_initialize_compressor(VALUE self, VALUE options)
47
50
  {
48
51
  GET_COMPRESSOR(self);
49
52
  Check_Type(options, T_HASH);
53
+ ZSTDS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
54
+ ZSTDS_EXT_GET_BOOL_OPTION(options, gvl);
50
55
  ZSTDS_EXT_GET_COMPRESSOR_OPTIONS(options);
51
- ZSTDS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
52
56
 
53
57
  ZSTD_CCtx* ctx = ZSTD_createCCtx();
54
58
  if (ctx == NULL) {
@@ -76,40 +80,56 @@ VALUE zstds_ext_initialize_compressor(VALUE self, VALUE options)
76
80
  compressor_ptr->destination_buffer_length = destination_buffer_length;
77
81
  compressor_ptr->remaining_destination_buffer = destination_buffer;
78
82
  compressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
83
+ compressor_ptr->gvl = gvl;
79
84
 
80
85
  return Qnil;
81
86
  }
82
87
 
88
+ // -- compress --
89
+
83
90
  #define DO_NOT_USE_AFTER_CLOSE(compressor_ptr) \
84
91
  if (compressor_ptr->ctx == NULL || compressor_ptr->destination_buffer == NULL) { \
85
92
  zstds_ext_raise_error(ZSTDS_EXT_ERROR_USED_AFTER_CLOSE); \
86
93
  }
87
94
 
88
- #define GET_SOURCE_DATA(source_value) \
89
- Check_Type(source_value, T_STRING); \
90
- \
91
- const char* source = RSTRING_PTR(source_value); \
92
- size_t source_length = RSTRING_LEN(source_value);
95
+ typedef struct
96
+ {
97
+ zstds_ext_compressor_t* compressor_ptr;
98
+ ZSTD_inBuffer* in_buffer_ptr;
99
+ ZSTD_outBuffer* out_buffer_ptr;
100
+ zstds_result_t result;
101
+ } compress_args_t;
102
+
103
+ static inline void* compress_wrapper(void* data)
104
+ {
105
+ compress_args_t* args = data;
106
+
107
+ args->result =
108
+ ZSTD_compressStream2(args->compressor_ptr->ctx, args->out_buffer_ptr, args->in_buffer_ptr, ZSTD_e_continue);
109
+
110
+ return NULL;
111
+ }
93
112
 
94
113
  VALUE zstds_ext_compress(VALUE self, VALUE source_value)
95
114
  {
96
115
  GET_COMPRESSOR(self);
97
116
  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
98
- GET_SOURCE_DATA(source_value);
117
+ Check_Type(source_value, T_STRING);
99
118
 
100
- ZSTD_inBuffer in_buffer;
101
- in_buffer.src = source;
102
- in_buffer.size = source_length;
103
- in_buffer.pos = 0;
119
+ const char* source = RSTRING_PTR(source_value);
120
+ size_t source_length = RSTRING_LEN(source_value);
104
121
 
105
- ZSTD_outBuffer out_buffer;
106
- out_buffer.dst = compressor_ptr->remaining_destination_buffer;
107
- out_buffer.size = compressor_ptr->remaining_destination_buffer_length;
108
- out_buffer.pos = 0;
122
+ ZSTD_inBuffer in_buffer = {.src = source, .size = source_length, .pos = 0};
123
+ ZSTD_outBuffer out_buffer = {
124
+ .dst = compressor_ptr->remaining_destination_buffer,
125
+ .size = compressor_ptr->remaining_destination_buffer_length,
126
+ .pos = 0};
109
127
 
110
- zstds_result_t result = ZSTD_compressStream2(compressor_ptr->ctx, &out_buffer, &in_buffer, ZSTD_e_continue);
111
- if (ZSTD_isError(result)) {
112
- zstds_ext_raise_error(zstds_ext_get_error(ZSTD_getErrorCode(result)));
128
+ compress_args_t args = {.compressor_ptr = compressor_ptr, .in_buffer_ptr = &in_buffer, .out_buffer_ptr = &out_buffer};
129
+
130
+ ZSTDS_EXT_GVL_WRAP(compressor_ptr->gvl, compress_wrapper, &args);
131
+ if (ZSTD_isError(args.result)) {
132
+ zstds_ext_raise_error(zstds_ext_get_error(ZSTD_getErrorCode(args.result)));
113
133
  }
114
134
 
115
135
  compressor_ptr->remaining_destination_buffer += out_buffer.pos;
@@ -121,32 +141,65 @@ VALUE zstds_ext_compress(VALUE self, VALUE source_value)
121
141
  return rb_ary_new_from_args(2, bytes_written, needs_more_destination);
122
142
  }
123
143
 
144
+ // -- compressor flush --
145
+
146
+ typedef struct
147
+ {
148
+ zstds_ext_compressor_t* compressor_ptr;
149
+ ZSTD_outBuffer* out_buffer_ptr;
150
+ zstds_result_t result;
151
+ } compress_flush_args_t;
152
+
153
+ static inline void* compress_flush_wrapper(void* data)
154
+ {
155
+ compress_flush_args_t* args = data;
156
+ ZSTD_inBuffer in_buffer = {.src = NULL, .size = 0, .pos = 0};
157
+
158
+ args->result = ZSTD_compressStream2(args->compressor_ptr->ctx, args->out_buffer_ptr, &in_buffer, ZSTD_e_flush);
159
+
160
+ return NULL;
161
+ }
162
+
124
163
  VALUE zstds_ext_flush_compressor(VALUE self)
125
164
  {
126
165
  GET_COMPRESSOR(self);
127
166
  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
128
167
 
129
- ZSTD_inBuffer in_buffer;
130
- in_buffer.src = NULL;
131
- in_buffer.size = 0;
132
- in_buffer.pos = 0;
168
+ ZSTD_outBuffer out_buffer = {
169
+ .dst = compressor_ptr->remaining_destination_buffer,
170
+ .size = compressor_ptr->remaining_destination_buffer_length,
171
+ .pos = 0};
133
172
 
134
- ZSTD_outBuffer out_buffer;
135
- out_buffer.dst = compressor_ptr->remaining_destination_buffer;
136
- out_buffer.size = compressor_ptr->remaining_destination_buffer_length;
137
- out_buffer.pos = 0;
173
+ compress_flush_args_t args = {.compressor_ptr = compressor_ptr, .out_buffer_ptr = &out_buffer};
138
174
 
139
- zstds_result_t result = ZSTD_compressStream2(compressor_ptr->ctx, &out_buffer, &in_buffer, ZSTD_e_flush);
140
- if (ZSTD_isError(result)) {
141
- zstds_ext_raise_error(zstds_ext_get_error(ZSTD_getErrorCode(result)));
175
+ ZSTDS_EXT_GVL_WRAP(compressor_ptr->gvl, compress_flush_wrapper, &args);
176
+ if (ZSTD_isError(args.result)) {
177
+ zstds_ext_raise_error(zstds_ext_get_error(ZSTD_getErrorCode(args.result)));
142
178
  }
143
179
 
144
180
  compressor_ptr->remaining_destination_buffer += out_buffer.pos;
145
181
  compressor_ptr->remaining_destination_buffer_length -= out_buffer.pos;
146
182
 
147
- VALUE needs_more_destination = result != 0 ? Qtrue : Qfalse;
183
+ return args.result != 0 ? Qtrue : Qfalse;
184
+ }
185
+
186
+ // -- compressor finish --
187
+
188
+ typedef struct
189
+ {
190
+ zstds_ext_compressor_t* compressor_ptr;
191
+ ZSTD_outBuffer* out_buffer_ptr;
192
+ zstds_result_t result;
193
+ } compress_finish_args_t;
148
194
 
149
- return needs_more_destination;
195
+ static inline void* compress_finish_wrapper(void* data)
196
+ {
197
+ compress_finish_args_t* args = data;
198
+ ZSTD_inBuffer in_buffer = {.src = NULL, .size = 0, .pos = 0};
199
+
200
+ args->result = ZSTD_compressStream2(args->compressor_ptr->ctx, args->out_buffer_ptr, &in_buffer, ZSTD_e_end);
201
+
202
+ return NULL;
150
203
  }
151
204
 
152
205
  VALUE zstds_ext_finish_compressor(VALUE self)
@@ -154,29 +207,26 @@ VALUE zstds_ext_finish_compressor(VALUE self)
154
207
  GET_COMPRESSOR(self);
155
208
  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
156
209
 
157
- ZSTD_inBuffer in_buffer;
158
- in_buffer.src = NULL;
159
- in_buffer.size = 0;
160
- in_buffer.pos = 0;
210
+ ZSTD_outBuffer out_buffer = {
211
+ .dst = compressor_ptr->remaining_destination_buffer,
212
+ .size = compressor_ptr->remaining_destination_buffer_length,
213
+ .pos = 0};
161
214
 
162
- ZSTD_outBuffer out_buffer;
163
- out_buffer.dst = compressor_ptr->remaining_destination_buffer;
164
- out_buffer.size = compressor_ptr->remaining_destination_buffer_length;
165
- out_buffer.pos = 0;
215
+ compress_finish_args_t args = {.compressor_ptr = compressor_ptr, .out_buffer_ptr = &out_buffer};
166
216
 
167
- zstds_result_t result = ZSTD_compressStream2(compressor_ptr->ctx, &out_buffer, &in_buffer, ZSTD_e_end);
168
- if (ZSTD_isError(result)) {
169
- zstds_ext_raise_error(zstds_ext_get_error(ZSTD_getErrorCode(result)));
217
+ ZSTDS_EXT_GVL_WRAP(compressor_ptr->gvl, compress_finish_wrapper, &args);
218
+ if (ZSTD_isError(args.result)) {
219
+ zstds_ext_raise_error(zstds_ext_get_error(ZSTD_getErrorCode(args.result)));
170
220
  }
171
221
 
172
222
  compressor_ptr->remaining_destination_buffer += out_buffer.pos;
173
223
  compressor_ptr->remaining_destination_buffer_length -= out_buffer.pos;
174
224
 
175
- VALUE needs_more_destination = result != 0 ? Qtrue : Qfalse;
176
-
177
- return needs_more_destination;
225
+ return args.result != 0 ? Qtrue : Qfalse;
178
226
  }
179
227
 
228
+ // -- other --
229
+
180
230
  VALUE zstds_ext_compressor_read_result(VALUE self)
181
231
  {
182
232
  GET_COMPRESSOR(self);
@@ -186,10 +236,9 @@ VALUE zstds_ext_compressor_read_result(VALUE self)
186
236
  size_t destination_buffer_length = compressor_ptr->destination_buffer_length;
187
237
  size_t remaining_destination_buffer_length = compressor_ptr->remaining_destination_buffer_length;
188
238
 
189
- const char* result = (const char*)destination_buffer;
239
+ const char* result = (const char*) destination_buffer;
190
240
  size_t result_length = destination_buffer_length - remaining_destination_buffer_length;
191
-
192
- VALUE result_value = rb_str_new(result, result_length);
241
+ VALUE result_value = rb_str_new(result, result_length);
193
242
 
194
243
  compressor_ptr->remaining_destination_buffer = destination_buffer;
195
244
  compressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
@@ -197,6 +246,8 @@ VALUE zstds_ext_compressor_read_result(VALUE self)
197
246
  return result_value;
198
247
  }
199
248
 
249
+ // -- cleanup --
250
+
200
251
  VALUE zstds_ext_compressor_close(VALUE self)
201
252
  {
202
253
  GET_COMPRESSOR(self);
@@ -222,6 +273,8 @@ VALUE zstds_ext_compressor_close(VALUE self)
222
273
  return Qnil;
223
274
  }
224
275
 
276
+ // -- exports --
277
+
225
278
  void zstds_ext_compressor_exports(VALUE root_module)
226
279
  {
227
280
  VALUE module = rb_define_module_under(root_module, "Stream");