zstd-ruby 1.5.2.3 → 1.5.4.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (71) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +3 -3
  3. data/ext/zstdruby/libzstd/common/bits.h +175 -0
  4. data/ext/zstdruby/libzstd/common/bitstream.h +18 -59
  5. data/ext/zstdruby/libzstd/common/compiler.h +22 -3
  6. data/ext/zstdruby/libzstd/common/cpu.h +1 -1
  7. data/ext/zstdruby/libzstd/common/debug.c +1 -1
  8. data/ext/zstdruby/libzstd/common/debug.h +1 -1
  9. data/ext/zstdruby/libzstd/common/entropy_common.c +12 -40
  10. data/ext/zstdruby/libzstd/common/error_private.c +9 -2
  11. data/ext/zstdruby/libzstd/common/error_private.h +1 -1
  12. data/ext/zstdruby/libzstd/common/fse.h +5 -83
  13. data/ext/zstdruby/libzstd/common/fse_decompress.c +7 -99
  14. data/ext/zstdruby/libzstd/common/huf.h +65 -156
  15. data/ext/zstdruby/libzstd/common/mem.h +39 -46
  16. data/ext/zstdruby/libzstd/common/pool.c +26 -10
  17. data/ext/zstdruby/libzstd/common/pool.h +7 -1
  18. data/ext/zstdruby/libzstd/common/portability_macros.h +22 -3
  19. data/ext/zstdruby/libzstd/common/threading.c +68 -14
  20. data/ext/zstdruby/libzstd/common/threading.h +5 -10
  21. data/ext/zstdruby/libzstd/common/xxhash.c +2 -2
  22. data/ext/zstdruby/libzstd/common/xxhash.h +8 -8
  23. data/ext/zstdruby/libzstd/common/zstd_common.c +1 -1
  24. data/ext/zstdruby/libzstd/common/zstd_deps.h +1 -1
  25. data/ext/zstdruby/libzstd/common/zstd_internal.h +17 -113
  26. data/ext/zstdruby/libzstd/common/zstd_trace.h +3 -3
  27. data/ext/zstdruby/libzstd/compress/clevels.h +1 -1
  28. data/ext/zstdruby/libzstd/compress/fse_compress.c +7 -124
  29. data/ext/zstdruby/libzstd/compress/hist.c +1 -1
  30. data/ext/zstdruby/libzstd/compress/hist.h +1 -1
  31. data/ext/zstdruby/libzstd/compress/huf_compress.c +234 -169
  32. data/ext/zstdruby/libzstd/compress/zstd_compress.c +1055 -455
  33. data/ext/zstdruby/libzstd/compress/zstd_compress_internal.h +165 -145
  34. data/ext/zstdruby/libzstd/compress/zstd_compress_literals.c +115 -39
  35. data/ext/zstdruby/libzstd/compress/zstd_compress_literals.h +16 -8
  36. data/ext/zstdruby/libzstd/compress/zstd_compress_sequences.c +3 -3
  37. data/ext/zstdruby/libzstd/compress/zstd_compress_sequences.h +1 -1
  38. data/ext/zstdruby/libzstd/compress/zstd_compress_superblock.c +25 -21
  39. data/ext/zstdruby/libzstd/compress/zstd_compress_superblock.h +1 -1
  40. data/ext/zstdruby/libzstd/compress/zstd_cwksp.h +5 -3
  41. data/ext/zstdruby/libzstd/compress/zstd_double_fast.c +95 -33
  42. data/ext/zstdruby/libzstd/compress/zstd_double_fast.h +3 -2
  43. data/ext/zstdruby/libzstd/compress/zstd_fast.c +433 -148
  44. data/ext/zstdruby/libzstd/compress/zstd_fast.h +3 -2
  45. data/ext/zstdruby/libzstd/compress/zstd_lazy.c +306 -283
  46. data/ext/zstdruby/libzstd/compress/zstd_lazy.h +4 -2
  47. data/ext/zstdruby/libzstd/compress/zstd_ldm.c +5 -5
  48. data/ext/zstdruby/libzstd/compress/zstd_ldm.h +1 -1
  49. data/ext/zstdruby/libzstd/compress/zstd_ldm_geartab.h +1 -1
  50. data/ext/zstdruby/libzstd/compress/zstd_opt.c +104 -80
  51. data/ext/zstdruby/libzstd/compress/zstd_opt.h +1 -1
  52. data/ext/zstdruby/libzstd/compress/zstdmt_compress.c +12 -5
  53. data/ext/zstdruby/libzstd/compress/zstdmt_compress.h +1 -1
  54. data/ext/zstdruby/libzstd/decompress/huf_decompress.c +434 -441
  55. data/ext/zstdruby/libzstd/decompress/huf_decompress_amd64.S +30 -39
  56. data/ext/zstdruby/libzstd/decompress/zstd_ddict.c +3 -4
  57. data/ext/zstdruby/libzstd/decompress/zstd_ddict.h +1 -1
  58. data/ext/zstdruby/libzstd/decompress/zstd_decompress.c +164 -42
  59. data/ext/zstdruby/libzstd/decompress/zstd_decompress_block.c +186 -65
  60. data/ext/zstdruby/libzstd/decompress/zstd_decompress_block.h +1 -1
  61. data/ext/zstdruby/libzstd/decompress/zstd_decompress_internal.h +4 -2
  62. data/ext/zstdruby/libzstd/dictBuilder/cover.c +19 -15
  63. data/ext/zstdruby/libzstd/dictBuilder/cover.h +1 -1
  64. data/ext/zstdruby/libzstd/dictBuilder/fastcover.c +2 -2
  65. data/ext/zstdruby/libzstd/dictBuilder/zdict.c +9 -87
  66. data/ext/zstdruby/libzstd/zdict.h +53 -31
  67. data/ext/zstdruby/libzstd/zstd.h +489 -90
  68. data/ext/zstdruby/libzstd/zstd_errors.h +27 -8
  69. data/ext/zstdruby/main.c +4 -0
  70. data/lib/zstd-ruby/version.rb +1 -1
  71. metadata +7 -6
@@ -1,5 +1,5 @@
1
1
  /*
2
- * Copyright (c) Yann Collet, Facebook, Inc.
2
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
3
3
  * All rights reserved.
4
4
  *
5
5
  * This source code is licensed under both the BSD-style license (found in the
@@ -133,21 +133,15 @@ MEM_STATIC size_t MEM_swapST(size_t in);
133
133
  /*-**************************************************************
134
134
  * Memory I/O Implementation
135
135
  *****************************************************************/
136
- /* MEM_FORCE_MEMORY_ACCESS :
137
- * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
138
- * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
139
- * The below switch allow to select different access method for improved performance.
140
- * Method 0 (default) : use `memcpy()`. Safe and portable.
141
- * Method 1 : `__packed` statement. It depends on compiler extension (i.e., not portable).
142
- * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
136
+ /* MEM_FORCE_MEMORY_ACCESS : For accessing unaligned memory:
137
+ * Method 0 : always use `memcpy()`. Safe and portable.
138
+ * Method 1 : Use compiler extension to set unaligned access.
143
139
  * Method 2 : direct access. This method is portable but violate C standard.
144
140
  * It can generate buggy code on targets depending on alignment.
145
- * In some circumstances, it's the only known way to get the most performance (i.e. GCC + ARMv6)
146
- * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
147
- * Prefer these methods in priority order (0 > 1 > 2)
141
+ * Default : method 1 if supported, else method 0
148
142
  */
149
143
  #ifndef MEM_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */
150
- # if defined(__INTEL_COMPILER) || defined(__GNUC__) || defined(__ICCARM__)
144
+ # ifdef __GNUC__
151
145
  # define MEM_FORCE_MEMORY_ACCESS 1
152
146
  # endif
153
147
  #endif
@@ -190,30 +184,19 @@ MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }
190
184
 
191
185
  #elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)
192
186
 
193
- /* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
194
- /* currently only defined for gcc and icc */
195
- #if defined(_MSC_VER) || (defined(__INTEL_COMPILER) && defined(WIN32))
196
- __pragma( pack(push, 1) )
197
- typedef struct { U16 v; } unalign16;
198
- typedef struct { U32 v; } unalign32;
199
- typedef struct { U64 v; } unalign64;
200
- typedef struct { size_t v; } unalignArch;
201
- __pragma( pack(pop) )
202
- #else
203
- typedef struct { U16 v; } __attribute__((packed)) unalign16;
204
- typedef struct { U32 v; } __attribute__((packed)) unalign32;
205
- typedef struct { U64 v; } __attribute__((packed)) unalign64;
206
- typedef struct { size_t v; } __attribute__((packed)) unalignArch;
207
- #endif
187
+ typedef __attribute__((aligned(1))) U16 unalign16;
188
+ typedef __attribute__((aligned(1))) U32 unalign32;
189
+ typedef __attribute__((aligned(1))) U64 unalign64;
190
+ typedef __attribute__((aligned(1))) size_t unalignArch;
208
191
 
209
- MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign16*)ptr)->v; }
210
- MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign32*)ptr)->v; }
211
- MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign64*)ptr)->v; }
212
- MEM_STATIC size_t MEM_readST(const void* ptr) { return ((const unalignArch*)ptr)->v; }
192
+ MEM_STATIC U16 MEM_read16(const void* ptr) { return *(const unalign16*)ptr; }
193
+ MEM_STATIC U32 MEM_read32(const void* ptr) { return *(const unalign32*)ptr; }
194
+ MEM_STATIC U64 MEM_read64(const void* ptr) { return *(const unalign64*)ptr; }
195
+ MEM_STATIC size_t MEM_readST(const void* ptr) { return *(const unalignArch*)ptr; }
213
196
 
214
- MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign16*)memPtr)->v = value; }
215
- MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign32*)memPtr)->v = value; }
216
- MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign64*)memPtr)->v = value; }
197
+ MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(unalign16*)memPtr = value; }
198
+ MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(unalign32*)memPtr = value; }
199
+ MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(unalign64*)memPtr = value; }
217
200
 
218
201
  #else
219
202
 
@@ -257,6 +240,14 @@ MEM_STATIC void MEM_write64(void* memPtr, U64 value)
257
240
 
258
241
  #endif /* MEM_FORCE_MEMORY_ACCESS */
259
242
 
243
+ MEM_STATIC U32 MEM_swap32_fallback(U32 in)
244
+ {
245
+ return ((in << 24) & 0xff000000 ) |
246
+ ((in << 8) & 0x00ff0000 ) |
247
+ ((in >> 8) & 0x0000ff00 ) |
248
+ ((in >> 24) & 0x000000ff );
249
+ }
250
+
260
251
  MEM_STATIC U32 MEM_swap32(U32 in)
261
252
  {
262
253
  #if defined(_MSC_VER) /* Visual Studio */
@@ -265,22 +256,13 @@ MEM_STATIC U32 MEM_swap32(U32 in)
265
256
  || (defined(__clang__) && __has_builtin(__builtin_bswap32))
266
257
  return __builtin_bswap32(in);
267
258
  #else
268
- return ((in << 24) & 0xff000000 ) |
269
- ((in << 8) & 0x00ff0000 ) |
270
- ((in >> 8) & 0x0000ff00 ) |
271
- ((in >> 24) & 0x000000ff );
259
+ return MEM_swap32_fallback(in);
272
260
  #endif
273
261
  }
274
262
 
275
- MEM_STATIC U64 MEM_swap64(U64 in)
263
+ MEM_STATIC U64 MEM_swap64_fallback(U64 in)
276
264
  {
277
- #if defined(_MSC_VER) /* Visual Studio */
278
- return _byteswap_uint64(in);
279
- #elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
280
- || (defined(__clang__) && __has_builtin(__builtin_bswap64))
281
- return __builtin_bswap64(in);
282
- #else
283
- return ((in << 56) & 0xff00000000000000ULL) |
265
+ return ((in << 56) & 0xff00000000000000ULL) |
284
266
  ((in << 40) & 0x00ff000000000000ULL) |
285
267
  ((in << 24) & 0x0000ff0000000000ULL) |
286
268
  ((in << 8) & 0x000000ff00000000ULL) |
@@ -288,6 +270,17 @@ MEM_STATIC U64 MEM_swap64(U64 in)
288
270
  ((in >> 24) & 0x0000000000ff0000ULL) |
289
271
  ((in >> 40) & 0x000000000000ff00ULL) |
290
272
  ((in >> 56) & 0x00000000000000ffULL);
273
+ }
274
+
275
+ MEM_STATIC U64 MEM_swap64(U64 in)
276
+ {
277
+ #if defined(_MSC_VER) /* Visual Studio */
278
+ return _byteswap_uint64(in);
279
+ #elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
280
+ || (defined(__clang__) && __has_builtin(__builtin_bswap64))
281
+ return __builtin_bswap64(in);
282
+ #else
283
+ return MEM_swap64_fallback(in);
291
284
  #endif
292
285
  }
293
286
 
@@ -1,5 +1,5 @@
1
1
  /*
2
- * Copyright (c) Yann Collet, Facebook, Inc.
2
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
3
3
  * All rights reserved.
4
4
  *
5
5
  * This source code is licensed under both the BSD-style license (found in the
@@ -12,7 +12,7 @@
12
12
  /* ====== Dependencies ======= */
13
13
  #include "zstd_deps.h" /* size_t */
14
14
  #include "debug.h" /* assert */
15
- #include "zstd_internal.h" /* ZSTD_customMalloc, ZSTD_customFree */
15
+ #include "zstd_internal.h" /* ZSTD_customCalloc, ZSTD_customFree */
16
16
  #include "pool.h"
17
17
 
18
18
  /* ====== Compiler specifics ====== */
@@ -96,9 +96,7 @@ static void* POOL_thread(void* opaque) {
96
96
  /* If the intended queue size was 0, signal after finishing job */
97
97
  ZSTD_pthread_mutex_lock(&ctx->queueMutex);
98
98
  ctx->numThreadsBusy--;
99
- if (ctx->queueSize == 1) {
100
- ZSTD_pthread_cond_signal(&ctx->queuePushCond);
101
- }
99
+ ZSTD_pthread_cond_signal(&ctx->queuePushCond);
102
100
  ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
103
101
  }
104
102
  } /* for (;;) */
@@ -128,7 +126,7 @@ POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
128
126
  * empty and full queues.
129
127
  */
130
128
  ctx->queueSize = queueSize + 1;
131
- ctx->queue = (POOL_job*)ZSTD_customMalloc(ctx->queueSize * sizeof(POOL_job), customMem);
129
+ ctx->queue = (POOL_job*)ZSTD_customCalloc(ctx->queueSize * sizeof(POOL_job), customMem);
132
130
  ctx->queueHead = 0;
133
131
  ctx->queueTail = 0;
134
132
  ctx->numThreadsBusy = 0;
@@ -142,7 +140,7 @@ POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
142
140
  }
143
141
  ctx->shutdown = 0;
144
142
  /* Allocate space for the thread handles */
145
- ctx->threads = (ZSTD_pthread_t*)ZSTD_customMalloc(numThreads * sizeof(ZSTD_pthread_t), customMem);
143
+ ctx->threads = (ZSTD_pthread_t*)ZSTD_customCalloc(numThreads * sizeof(ZSTD_pthread_t), customMem);
146
144
  ctx->threadCapacity = 0;
147
145
  ctx->customMem = customMem;
148
146
  /* Check for errors */
@@ -175,7 +173,7 @@ static void POOL_join(POOL_ctx* ctx) {
175
173
  /* Join all of the threads */
176
174
  { size_t i;
177
175
  for (i = 0; i < ctx->threadCapacity; ++i) {
178
- ZSTD_pthread_join(ctx->threads[i], NULL); /* note : could fail */
176
+ ZSTD_pthread_join(ctx->threads[i]); /* note : could fail */
179
177
  } }
180
178
  }
181
179
 
@@ -190,6 +188,17 @@ void POOL_free(POOL_ctx *ctx) {
190
188
  ZSTD_customFree(ctx, ctx->customMem);
191
189
  }
192
190
 
191
+ /*! POOL_joinJobs() :
192
+ * Waits for all queued jobs to finish executing.
193
+ */
194
+ void POOL_joinJobs(POOL_ctx* ctx) {
195
+ ZSTD_pthread_mutex_lock(&ctx->queueMutex);
196
+ while(!ctx->queueEmpty || ctx->numThreadsBusy > 0) {
197
+ ZSTD_pthread_cond_wait(&ctx->queuePushCond, &ctx->queueMutex);
198
+ }
199
+ ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
200
+ }
201
+
193
202
  void ZSTD_freeThreadPool (ZSTD_threadPool* pool) {
194
203
  POOL_free (pool);
195
204
  }
@@ -211,7 +220,7 @@ static int POOL_resize_internal(POOL_ctx* ctx, size_t numThreads)
211
220
  return 0;
212
221
  }
213
222
  /* numThreads > threadCapacity */
214
- { ZSTD_pthread_t* const threadPool = (ZSTD_pthread_t*)ZSTD_customMalloc(numThreads * sizeof(ZSTD_pthread_t), ctx->customMem);
223
+ { ZSTD_pthread_t* const threadPool = (ZSTD_pthread_t*)ZSTD_customCalloc(numThreads * sizeof(ZSTD_pthread_t), ctx->customMem);
215
224
  if (!threadPool) return 1;
216
225
  /* replace existing thread pool */
217
226
  ZSTD_memcpy(threadPool, ctx->threads, ctx->threadCapacity * sizeof(*threadPool));
@@ -262,7 +271,9 @@ static int isQueueFull(POOL_ctx const* ctx) {
262
271
  static void
263
272
  POOL_add_internal(POOL_ctx* ctx, POOL_function function, void *opaque)
264
273
  {
265
- POOL_job const job = {function, opaque};
274
+ POOL_job job;
275
+ job.function = function;
276
+ job.opaque = opaque;
266
277
  assert(ctx != NULL);
267
278
  if (ctx->shutdown) return;
268
279
 
@@ -330,6 +341,11 @@ void POOL_free(POOL_ctx* ctx) {
330
341
  (void)ctx;
331
342
  }
332
343
 
344
+ void POOL_joinJobs(POOL_ctx* ctx){
345
+ assert(!ctx || ctx == &g_poolCtx);
346
+ (void)ctx;
347
+ }
348
+
333
349
  int POOL_resize(POOL_ctx* ctx, size_t numThreads) {
334
350
  (void)ctx; (void)numThreads;
335
351
  return 0;
@@ -1,5 +1,5 @@
1
1
  /*
2
- * Copyright (c) Yann Collet, Facebook, Inc.
2
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
3
3
  * All rights reserved.
4
4
  *
5
5
  * This source code is licensed under both the BSD-style license (found in the
@@ -38,6 +38,12 @@ POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
38
38
  */
39
39
  void POOL_free(POOL_ctx* ctx);
40
40
 
41
+
42
+ /*! POOL_joinJobs() :
43
+ * Waits for all queued jobs to finish executing.
44
+ */
45
+ void POOL_joinJobs(POOL_ctx* ctx);
46
+
41
47
  /*! POOL_resize() :
42
48
  * Expands or shrinks pool's number of threads.
43
49
  * This is more efficient than releasing + creating a new context,
@@ -1,5 +1,5 @@
1
1
  /*
2
- * Copyright (c) Facebook, Inc.
2
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
3
3
  * All rights reserved.
4
4
  *
5
5
  * This source code is licensed under both the BSD-style license (found in the
@@ -12,7 +12,7 @@
12
12
  #define ZSTD_PORTABILITY_MACROS_H
13
13
 
14
14
  /**
15
- * This header file contains macro defintions to support portability.
15
+ * This header file contains macro definitions to support portability.
16
16
  * This header is shared between C and ASM code, so it MUST only
17
17
  * contain macro definitions. It MUST not contain any C code.
18
18
  *
@@ -88,7 +88,7 @@
88
88
  #endif
89
89
 
90
90
  /**
91
- * Only enable assembly for GNUC comptabile compilers,
91
+ * Only enable assembly for GNUC compatible compilers,
92
92
  * because other platforms may not support GAS assembly syntax.
93
93
  *
94
94
  * Only enable assembly for Linux / MacOS, other platforms may
@@ -134,4 +134,23 @@
134
134
  # define ZSTD_ENABLE_ASM_X86_64_BMI2 0
135
135
  #endif
136
136
 
137
+ /*
138
+ * For x86 ELF targets, add .note.gnu.property section for Intel CET in
139
+ * assembly sources when CET is enabled.
140
+ *
141
+ * Additionally, any function that may be called indirectly must begin
142
+ * with ZSTD_CET_ENDBRANCH.
143
+ */
144
+ #if defined(__ELF__) && (defined(__x86_64__) || defined(__i386__)) \
145
+ && defined(__has_include)
146
+ # if __has_include(<cet.h>)
147
+ # include <cet.h>
148
+ # define ZSTD_CET_ENDBRANCH _CET_ENDBR
149
+ # endif
150
+ #endif
151
+
152
+ #ifndef ZSTD_CET_ENDBRANCH
153
+ # define ZSTD_CET_ENDBRANCH
154
+ #endif
155
+
137
156
  #endif /* ZSTD_PORTABILITY_MACROS_H */
@@ -23,8 +23,7 @@ int g_ZSTD_threading_useless_symbol;
23
23
  #if defined(ZSTD_MULTITHREAD) && defined(_WIN32)
24
24
 
25
25
  /**
26
- * Windows minimalist Pthread Wrapper, based on :
27
- * http://www.cse.wustl.edu/~schmidt/win32-cv-1.html
26
+ * Windows minimalist Pthread Wrapper
28
27
  */
29
28
 
30
29
 
@@ -35,37 +34,92 @@ int g_ZSTD_threading_useless_symbol;
35
34
 
36
35
  /* === Implementation === */
37
36
 
37
+ typedef struct {
38
+ void* (*start_routine)(void*);
39
+ void* arg;
40
+ int initialized;
41
+ ZSTD_pthread_cond_t initialized_cond;
42
+ ZSTD_pthread_mutex_t initialized_mutex;
43
+ } ZSTD_thread_params_t;
44
+
38
45
  static unsigned __stdcall worker(void *arg)
39
46
  {
40
- ZSTD_pthread_t* const thread = (ZSTD_pthread_t*) arg;
41
- thread->arg = thread->start_routine(thread->arg);
47
+ void* (*start_routine)(void*);
48
+ void* thread_arg;
49
+
50
+ /* Inialized thread_arg and start_routine and signal main thread that we don't need it
51
+ * to wait any longer.
52
+ */
53
+ {
54
+ ZSTD_thread_params_t* thread_param = (ZSTD_thread_params_t*)arg;
55
+ thread_arg = thread_param->arg;
56
+ start_routine = thread_param->start_routine;
57
+
58
+ /* Signal main thread that we are running and do not depend on its memory anymore */
59
+ ZSTD_pthread_mutex_lock(&thread_param->initialized_mutex);
60
+ thread_param->initialized = 1;
61
+ ZSTD_pthread_cond_signal(&thread_param->initialized_cond);
62
+ ZSTD_pthread_mutex_unlock(&thread_param->initialized_mutex);
63
+ }
64
+
65
+ start_routine(thread_arg);
66
+
42
67
  return 0;
43
68
  }
44
69
 
45
70
  int ZSTD_pthread_create(ZSTD_pthread_t* thread, const void* unused,
46
71
  void* (*start_routine) (void*), void* arg)
47
72
  {
73
+ ZSTD_thread_params_t thread_param;
48
74
  (void)unused;
49
- thread->arg = arg;
50
- thread->start_routine = start_routine;
51
- thread->handle = (HANDLE) _beginthreadex(NULL, 0, worker, thread, 0, NULL);
52
75
 
53
- if (!thread->handle)
76
+ thread_param.start_routine = start_routine;
77
+ thread_param.arg = arg;
78
+ thread_param.initialized = 0;
79
+ *thread = NULL;
80
+
81
+ /* Setup thread initialization synchronization */
82
+ if(ZSTD_pthread_cond_init(&thread_param.initialized_cond, NULL)) {
83
+ /* Should never happen on Windows */
84
+ return -1;
85
+ }
86
+ if(ZSTD_pthread_mutex_init(&thread_param.initialized_mutex, NULL)) {
87
+ /* Should never happen on Windows */
88
+ ZSTD_pthread_cond_destroy(&thread_param.initialized_cond);
89
+ return -1;
90
+ }
91
+
92
+ /* Spawn thread */
93
+ *thread = (HANDLE)_beginthreadex(NULL, 0, worker, &thread_param, 0, NULL);
94
+ if (!thread) {
95
+ ZSTD_pthread_mutex_destroy(&thread_param.initialized_mutex);
96
+ ZSTD_pthread_cond_destroy(&thread_param.initialized_cond);
54
97
  return errno;
55
- else
56
- return 0;
98
+ }
99
+
100
+ /* Wait for thread to be initialized */
101
+ ZSTD_pthread_mutex_lock(&thread_param.initialized_mutex);
102
+ while(!thread_param.initialized) {
103
+ ZSTD_pthread_cond_wait(&thread_param.initialized_cond, &thread_param.initialized_mutex);
104
+ }
105
+ ZSTD_pthread_mutex_unlock(&thread_param.initialized_mutex);
106
+ ZSTD_pthread_mutex_destroy(&thread_param.initialized_mutex);
107
+ ZSTD_pthread_cond_destroy(&thread_param.initialized_cond);
108
+
109
+ return 0;
57
110
  }
58
111
 
59
- int ZSTD_pthread_join(ZSTD_pthread_t thread, void **value_ptr)
112
+ int ZSTD_pthread_join(ZSTD_pthread_t thread)
60
113
  {
61
114
  DWORD result;
62
115
 
63
- if (!thread.handle) return 0;
116
+ if (!thread) return 0;
117
+
118
+ result = WaitForSingleObject(thread, INFINITE);
119
+ CloseHandle(thread);
64
120
 
65
- result = WaitForSingleObject(thread.handle, INFINITE);
66
121
  switch (result) {
67
122
  case WAIT_OBJECT_0:
68
- if (value_ptr) *value_ptr = thread.arg;
69
123
  return 0;
70
124
  case WAIT_ABANDONED:
71
125
  return EINVAL;
@@ -23,8 +23,7 @@ extern "C" {
23
23
  #if defined(ZSTD_MULTITHREAD) && defined(_WIN32)
24
24
 
25
25
  /**
26
- * Windows minimalist Pthread Wrapper, based on :
27
- * http://www.cse.wustl.edu/~schmidt/win32-cv-1.html
26
+ * Windows minimalist Pthread Wrapper
28
27
  */
29
28
  #ifdef WINVER
30
29
  # undef WINVER
@@ -62,16 +61,12 @@ extern "C" {
62
61
  #define ZSTD_pthread_cond_broadcast(a) WakeAllConditionVariable((a))
63
62
 
64
63
  /* ZSTD_pthread_create() and ZSTD_pthread_join() */
65
- typedef struct {
66
- HANDLE handle;
67
- void* (*start_routine)(void*);
68
- void* arg;
69
- } ZSTD_pthread_t;
64
+ typedef HANDLE ZSTD_pthread_t;
70
65
 
71
66
  int ZSTD_pthread_create(ZSTD_pthread_t* thread, const void* unused,
72
67
  void* (*start_routine) (void*), void* arg);
73
68
 
74
- int ZSTD_pthread_join(ZSTD_pthread_t thread, void** value_ptr);
69
+ int ZSTD_pthread_join(ZSTD_pthread_t thread);
75
70
 
76
71
  /**
77
72
  * add here more wrappers as required
@@ -99,7 +94,7 @@ int ZSTD_pthread_join(ZSTD_pthread_t thread, void** value_ptr);
99
94
 
100
95
  #define ZSTD_pthread_t pthread_t
101
96
  #define ZSTD_pthread_create(a, b, c, d) pthread_create((a), (b), (c), (d))
102
- #define ZSTD_pthread_join(a, b) pthread_join((a),(b))
97
+ #define ZSTD_pthread_join(a) pthread_join((a),NULL)
103
98
 
104
99
  #else /* DEBUGLEVEL >= 1 */
105
100
 
@@ -124,7 +119,7 @@ int ZSTD_pthread_cond_destroy(ZSTD_pthread_cond_t* cond);
124
119
 
125
120
  #define ZSTD_pthread_t pthread_t
126
121
  #define ZSTD_pthread_create(a, b, c, d) pthread_create((a), (b), (c), (d))
127
- #define ZSTD_pthread_join(a, b) pthread_join((a),(b))
122
+ #define ZSTD_pthread_join(a) pthread_join((a),NULL)
128
123
 
129
124
  #endif
130
125
 
@@ -1,9 +1,9 @@
1
1
  /*
2
2
  * xxHash - Fast Hash algorithm
3
- * Copyright (c) Yann Collet, Facebook, Inc.
3
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
4
4
  *
5
5
  * You can contact the author at :
6
- * - xxHash homepage: http://www.xxhash.com
6
+ * - xxHash homepage: https://cyan4973.github.io/xxHash/
7
7
  * - xxHash source repository : https://github.com/Cyan4973/xxHash
8
8
  *
9
9
  * This source code is licensed under both the BSD-style license (found in the
@@ -1,9 +1,9 @@
1
1
  /*
2
2
  * xxHash - Fast Hash algorithm
3
- * Copyright (c) Yann Collet, Facebook, Inc.
3
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
4
4
  *
5
5
  * You can contact the author at :
6
- * - xxHash homepage: http://www.xxhash.com
6
+ * - xxHash homepage: https://cyan4973.github.io/xxHash/
7
7
  * - xxHash source repository : https://github.com/Cyan4973/xxHash
8
8
  *
9
9
  * This source code is licensed under both the BSD-style license (found in the
@@ -1314,7 +1314,7 @@ XXH3_128bits_reset_withSecretandSeed(XXH3_state_t* statePtr,
1314
1314
  * care, as what works on one compiler/platform/optimization level may cause
1315
1315
  * another to read garbage data or even crash.
1316
1316
  *
1317
- * See http://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html for details.
1317
+ * See https://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html for details.
1318
1318
  *
1319
1319
  * Prefer these methods in priority order (0 > 3 > 1 > 2)
1320
1320
  */
@@ -1534,7 +1534,7 @@ static void* XXH_memcpy(void* dest, const void* src, size_t size) { return ZSTD_
1534
1534
  * @brief Used to prevent unwanted optimizations for @p var.
1535
1535
  *
1536
1536
  * It uses an empty GCC inline assembly statement with a register constraint
1537
- * which forces @p var into a general purpose register (eg eax, ebx, ecx
1537
+ * which forces @p var into a general purpose register (e.g. eax, ebx, ecx
1538
1538
  * on x86) and marks it as modified.
1539
1539
  *
1540
1540
  * This is used in a few places to avoid unwanted autovectorization (e.g.
@@ -1655,7 +1655,7 @@ static xxh_u32 XXH_read32(const void* ptr)
1655
1655
 
1656
1656
  /*
1657
1657
  * Portable and safe solution. Generally efficient.
1658
- * see: http://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html
1658
+ * see: https://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html
1659
1659
  */
1660
1660
  static xxh_u32 XXH_read32(const void* memPtr)
1661
1661
  {
@@ -2296,7 +2296,7 @@ static xxh_u64 XXH_read64(const void* ptr)
2296
2296
 
2297
2297
  /*
2298
2298
  * Portable and safe solution. Generally efficient.
2299
- * see: http://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html
2299
+ * see: https://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html
2300
2300
  */
2301
2301
  static xxh_u64 XXH_read64(const void* memPtr)
2302
2302
  {
@@ -2809,7 +2809,7 @@ enum XXH_VECTOR_TYPE /* fake enum */ {
2809
2809
  * @ingroup tuning
2810
2810
  * @brief Selects the minimum alignment for XXH3's accumulators.
2811
2811
  *
2812
- * When using SIMD, this should match the alignment reqired for said vector
2812
+ * When using SIMD, this should match the alignment required for said vector
2813
2813
  * type, so, for example, 32 for AVX2.
2814
2814
  *
2815
2815
  * Default: Auto detected.
@@ -3026,7 +3026,7 @@ enum XXH_VECTOR_TYPE /* fake enum */ {
3026
3026
  * have more than 2 NEON (F0/F1) micro-ops. If you are only using NEON instructions,
3027
3027
  * you are only using 2/3 of the CPU bandwidth.
3028
3028
  *
3029
- * This is even more noticable on the more advanced cores like the A76 which
3029
+ * This is even more noticeable on the more advanced cores like the A76 which
3030
3030
  * can dispatch 8 micro-ops per cycle, but still only 2 NEON micro-ops at once.
3031
3031
  *
3032
3032
  * Therefore, @ref XXH3_NEON_LANES lanes will be processed using NEON, and the
@@ -1,5 +1,5 @@
1
1
  /*
2
- * Copyright (c) Yann Collet, Facebook, Inc.
2
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
3
3
  * All rights reserved.
4
4
  *
5
5
  * This source code is licensed under both the BSD-style license (found in the
@@ -1,5 +1,5 @@
1
1
  /*
2
- * Copyright (c) Facebook, Inc.
2
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
3
3
  * All rights reserved.
4
4
  *
5
5
  * This source code is licensed under both the BSD-style license (found in the