zstd-native-ruby 1.0.0 → 1.0.2

data/{vendor → ext/zstd_native}/zstd/lib/compress/zstd_lazy.c

@@ -1050,44 +1050,6 @@ ZSTD_row_getNEONMask(const U32 rowEntries, const BYTE* const src, const BYTE tag
     }
 }
 #endif
-#if defined(ZSTD_ARCH_RISCV_RVV) && (__riscv_xlen == 64)
-FORCE_INLINE_TEMPLATE ZSTD_VecMask
-ZSTD_row_getRVVMask(int rowEntries, const BYTE* const src, const BYTE tag, const U32 head)
-{
-    ZSTD_VecMask matches;
-    size_t vl;
-
-    if (rowEntries == 16) {
-        vl = __riscv_vsetvl_e8m1(16);
-        {
-            vuint8m1_t chunk = __riscv_vle8_v_u8m1(src, vl);
-            vbool8_t mask = __riscv_vmseq_vx_u8m1_b8(chunk, tag, vl);
-            vuint16m1_t mask_u16 = __riscv_vreinterpret_v_b8_u16m1(mask);
-            matches = __riscv_vmv_x_s_u16m1_u16(mask_u16);
-            return ZSTD_rotateRight_U16((U16)matches, head);
-        }
-
-    } else if (rowEntries == 32) {
-        vl = __riscv_vsetvl_e8m2(32);
-        {
-            vuint8m2_t chunk = __riscv_vle8_v_u8m2(src, vl);
-            vbool4_t mask = __riscv_vmseq_vx_u8m2_b4(chunk, tag, vl);
-            vuint32m1_t mask_u32 = __riscv_vreinterpret_v_b4_u32m1(mask);
-            matches = __riscv_vmv_x_s_u32m1_u32(mask_u32);
-            return ZSTD_rotateRight_U32((U32)matches, head);
-        }
-    } else { // rowEntries = 64
-        vl = __riscv_vsetvl_e8m4(64);
-        {
-            vuint8m4_t chunk = __riscv_vle8_v_u8m4(src, vl);
-            vbool2_t mask = __riscv_vmseq_vx_u8m4_b2(chunk, tag, vl);
-            vuint64m1_t mask_u64 = __riscv_vreinterpret_v_b2_u64m1(mask);
-            matches = __riscv_vmv_x_s_u64m1_u64(mask_u64);
-            return ZSTD_rotateRight_U64(matches, head);
-        }
-    }
-}
-#endif
 
 /* Returns a ZSTD_VecMask (U64) that has the nth group (determined by
  * ZSTD_row_matchMaskGroupWidth) of bits set to 1 if the newly-computed "tag"
@@ -1107,20 +1069,14 @@ ZSTD_row_getMatchMask(const BYTE* const tagRow, const BYTE tag, const U32 headGr
 
     return ZSTD_row_getSSEMask(rowEntries / 16, src, tag, headGrouped);
 
-#elif defined(ZSTD_ARCH_RISCV_RVV) && (__riscv_xlen == 64)
-
-    return ZSTD_row_getRVVMask(rowEntries, src, tag, headGrouped);
+#else /* SW or NEON-LE */
 
-#else
-
-#if defined(ZSTD_ARCH_ARM_NEON)
+# if defined(ZSTD_ARCH_ARM_NEON)
   /* This NEON path only works for little endian - otherwise use SWAR below */
     if (MEM_isLittleEndian()) {
         return ZSTD_row_getNEONMask(rowEntries, src, tag, headGrouped);
     }
-
-
-#endif
+# endif /* ZSTD_ARCH_ARM_NEON */
     /* SWAR */
     {   const int chunkSize = sizeof(size_t);
         const size_t shiftAmount = ((chunkSize * 8) - chunkSize);

data/{vendor → ext/zstd_native}/zstd/lib/compress/zstd_opt.c

@@ -1382,8 +1382,16 @@ _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
             assert(storeEnd < ZSTD_OPT_SIZE);
             DEBUGLOG(6, "last stretch copied into pos=%u (llen=%u,mlen=%u,ofc=%u)",
                         storeEnd, lastStretch.litlen, lastStretch.mlen, lastStretch.off);
-            opt[storeEnd] = lastStretch;  /* note: litlen will be fixed */
-            storeStart = storeEnd;
+            if (lastStretch.litlen > 0) {
+                /* last "sequence" is unfinished: just a bunch of literals */
+                opt[storeEnd].litlen = lastStretch.litlen;
+                opt[storeEnd].mlen = 0;
+                storeStart = storeEnd-1;
+                opt[storeStart] = lastStretch;
+            } {
+                opt[storeEnd] = lastStretch;  /* note: litlen will be fixed */
+                storeStart = storeEnd;
+            }
             while (1) {
                 ZSTD_optimal_t nextStretch = opt[stretchPos];
                 opt[storeStart].litlen = nextStretch.litlen;

data/{vendor → ext/zstd_native}/zstd/lib/compress/zstdmt_compress.c

@@ -1008,20 +1008,18 @@ static void ZSTDMT_releaseAllJobResources(ZSTDMT_CCtx* mtctx)
 {
     unsigned jobID;
     DEBUGLOG(3, "ZSTDMT_releaseAllJobResources");
-    if (mtctx->jobs) {
-        for (jobID=0; jobID <= mtctx->jobIDMask; jobID++) {
-            /* Copy the mutex/cond out */
-            ZSTD_pthread_mutex_t const mutex = mtctx->jobs[jobID].job_mutex;
-            ZSTD_pthread_cond_t const cond = mtctx->jobs[jobID].job_cond;
-            
-            DEBUGLOG(4, "job%02u: release dst address %08X", jobID, (U32)(size_t)mtctx->jobs[jobID].dstBuff.start);
-            ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[jobID].dstBuff);
-            
-            /* Clear the job description, but keep the mutex/cond */
-            ZSTD_memset(&mtctx->jobs[jobID], 0, sizeof(mtctx->jobs[jobID]));
-            mtctx->jobs[jobID].job_mutex = mutex;
-            mtctx->jobs[jobID].job_cond = cond;
-        }
+    for (jobID=0; jobID <= mtctx->jobIDMask; jobID++) {
+        /* Copy the mutex/cond out */
+        ZSTD_pthread_mutex_t const mutex = mtctx->jobs[jobID].job_mutex;
+        ZSTD_pthread_cond_t const cond = mtctx->jobs[jobID].job_cond;
+
+        DEBUGLOG(4, "job%02u: release dst address %08X", jobID, (U32)(size_t)mtctx->jobs[jobID].dstBuff.start);
+        ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[jobID].dstBuff);
+
+        /* Clear the job description, but keep the mutex/cond */
+        ZSTD_memset(&mtctx->jobs[jobID], 0, sizeof(mtctx->jobs[jobID]));
+        mtctx->jobs[jobID].job_mutex = mutex;
+        mtctx->jobs[jobID].job_cond = cond;
     }
     mtctx->inBuff.buffer = g_nullBuffer;
     mtctx->inBuff.filled = 0;
@@ -1270,7 +1268,8 @@ size_t ZSTDMT_initCStream_internal(
 
     if (mtctx->allJobsCompleted == 0) {   /* previous compression not correctly finished */
         ZSTDMT_waitForAllJobsCompleted(mtctx);
-        ZSTDMT_releaseAllJobResources(mtctx); /* Will set allJobsCompleted to 1 */
+        ZSTDMT_releaseAllJobResources(mtctx);
+        mtctx->allJobsCompleted = 1;
     }
 
     mtctx->params = params;

data/{vendor → ext/zstd_native}/zstd/lib/decompress/huf_decompress.c

@@ -15,7 +15,6 @@
 /* **************************************************************
 *  Dependencies
 ****************************************************************/
-#include <stddef.h>               /* size_t */
 #include "../common/zstd_deps.h"  /* ZSTD_memcpy, ZSTD_memset */
 #include "../common/compiler.h"
 #include "../common/bitstream.h"  /* BIT_* */
@@ -196,7 +195,7 @@ static size_t HUF_DecompressFastArgs_init(HUF_DecompressFastArgs* args, void* ds
 
     const BYTE* const istart = (const BYTE*)src;
 
-    BYTE* const oend = (BYTE*)ZSTD_maybeNullPtrAdd(dst, (ptrdiff_t)dstSize);
+    BYTE* const oend = ZSTD_maybeNullPtrAdd((BYTE*)dst, dstSize);
 
     /* The fast decoding loop assumes 64-bit little-endian.
      * This condition is false on x32.
@@ -579,7 +578,7 @@ HUF_decompress1X1_usingDTable_internal_body(
     const HUF_DTable* DTable)
 {
     BYTE* op = (BYTE*)dst;
-    BYTE* const oend = (BYTE*)ZSTD_maybeNullPtrAdd(op, (ptrdiff_t)dstSize);
+    BYTE* const oend = ZSTD_maybeNullPtrAdd(op, dstSize);
     const void* dtPtr = DTable + 1;
     const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;
     BIT_DStream_t bitD;
@@ -785,19 +784,19 @@ void HUF_decompress4X1_usingDTable_internal_fast_c_loop(HUF_DecompressFastArgs*
         }
 #endif
 
-#define HUF_4X1_DECODE_SYMBOL(_stream, _symbol)        \
-    do {                                               \
-        U64 const index = bits[(_stream)] >> 53;       \
-        U16 const entry = dtable[index];               \
-        bits[(_stream)] <<= entry & 0x3F;              \
-        op[(_stream)][(_symbol)] = (BYTE)(entry >> 8); \
+#define HUF_4X1_DECODE_SYMBOL(_stream, _symbol)                 \
+    do {                                                        \
+        int const index = (int)(bits[(_stream)] >> 53);         \
+        int const entry = (int)dtable[index];                   \
+        bits[(_stream)] <<= (entry & 0x3F);                     \
+        op[(_stream)][(_symbol)] = (BYTE)((entry >> 8) & 0xFF); \
     } while (0)
 
-#define HUF_5X1_RELOAD_STREAM(_stream)                              \
+#define HUF_4X1_RELOAD_STREAM(_stream)                              \
     do {                                                            \
-        U64 const ctz = ZSTD_countTrailingZeros64(bits[(_stream)]); \
-        U64 const nbBits = ctz & 7;                                 \
-        U64 const nbBytes = ctz >> 3;                               \
+        int const ctz = ZSTD_countTrailingZeros64(bits[(_stream)]); \
+        int const nbBits = ctz & 7;                                 \
+        int const nbBytes = ctz >> 3;                               \
         op[(_stream)] += 5;                                         \
         ip[(_stream)] -= nbBytes;                                   \
         bits[(_stream)] = MEM_read64(ip[(_stream)]) | 1;            \
@@ -816,11 +815,11 @@ void HUF_decompress4X1_usingDTable_internal_fast_c_loop(HUF_DecompressFastArgs*
             HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X1_DECODE_SYMBOL, 4);
 
             /* Reload each of the 4 the bitstreams */
-            HUF_4X_FOR_EACH_STREAM(HUF_5X1_RELOAD_STREAM);
+            HUF_4X_FOR_EACH_STREAM(HUF_4X1_RELOAD_STREAM);
         } while (op[3] < olimit);
 
 #undef HUF_4X1_DECODE_SYMBOL
-#undef HUF_5X1_RELOAD_STREAM
+#undef HUF_4X1_RELOAD_STREAM
     }
 
 _out:
@@ -846,7 +845,7 @@ HUF_decompress4X1_usingDTable_internal_fast(
 {
     void const* dt = DTable + 1;
     BYTE const* const ilowest = (BYTE const*)cSrc;
-    BYTE* const oend = (BYTE*)ZSTD_maybeNullPtrAdd(dst, (ptrdiff_t)dstSize);
+    BYTE* const oend = ZSTD_maybeNullPtrAdd((BYTE*)dst, dstSize);
     HUF_DecompressFastArgs args;
     {   size_t const ret = HUF_DecompressFastArgs_init(&args, dst, dstSize, cSrc, cSrcSize, DTable);
         FORWARD_IF_ERROR(ret, "Failed to init fast loop args");
@@ -1363,7 +1362,7 @@ HUF_decompress1X2_usingDTable_internal_body(
 
     /* decode */
     {   BYTE* const ostart = (BYTE*) dst;
-        BYTE* const oend = (BYTE*)ZSTD_maybeNullPtrAdd(ostart, (ptrdiff_t)dstSize);
+        BYTE* const oend = ZSTD_maybeNullPtrAdd(ostart, dstSize);
         const void* const dtPtr = DTable+1;   /* force compiler to not use strict-aliasing */
         const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;
         DTableDesc const dtd = HUF_getDTableDesc(DTable);
@@ -1603,65 +1602,57 @@ void HUF_decompress4X2_usingDTable_internal_fast_c_loop(HUF_DecompressFastArgs*
         }
 #endif
 
-#define HUF_4X2_DECODE_SYMBOL(_stream, _decode3)               \
-    do {                                                       \
-        if ((_decode3) || (_stream) != 3) {                    \
-            U64 const index = bits[(_stream)] >> 53;           \
-            size_t const entry = MEM_readLE32(&dtable[index]); \
-            MEM_write16(op[(_stream)], (U16)entry);            \
-            bits[(_stream)] <<= (entry >> 16) & 0x3F;          \
-            op[(_stream)] += entry >> 24;                      \
-        }                                                      \
+#define HUF_4X2_DECODE_SYMBOL(_stream, _decode3)                      \
+    do {                                                              \
+        if ((_decode3) || (_stream) != 3) {                           \
+            int const index = (int)(bits[(_stream)] >> 53);           \
+            HUF_DEltX2 const entry = dtable[index];                   \
+            MEM_write16(op[(_stream)], entry.sequence); \
+            bits[(_stream)] <<= (entry.nbBits) & 0x3F;                \
+            op[(_stream)] += (entry.length);                          \
+        }                                                             \
     } while (0)
 
-#define HUF_5X2_RELOAD_STREAM(_stream, _decode3)                        \
+#define HUF_4X2_RELOAD_STREAM(_stream)                                  \
     do {                                                                \
-        if (_decode3) HUF_4X2_DECODE_SYMBOL(3, 1);                      \
+        HUF_4X2_DECODE_SYMBOL(3, 1);                                    \
         {                                                               \
-            U64 const ctz = ZSTD_countTrailingZeros64(bits[(_stream)]); \
-            U64 const nbBits = ctz & 7;                                 \
-            U64 const nbBytes = ctz >> 3;                               \
+            int const ctz = ZSTD_countTrailingZeros64(bits[(_stream)]); \
+            int const nbBits = ctz & 7;                                 \
+            int const nbBytes = ctz >> 3;                               \
             ip[(_stream)] -= nbBytes;                                   \
             bits[(_stream)] = MEM_read64(ip[(_stream)]) | 1;            \
             bits[(_stream)] <<= nbBits;                                 \
         }                                                               \
     } while (0)
 
-#if defined(__aarch64__)
-#  define HUF_4X2_4WAY 1
-#else
-#  define HUF_4X2_4WAY 0
-#endif
-#define HUF_4X2_3WAY !HUF_4X2_4WAY
-
         /* Manually unroll the loop because compilers don't consistently
          * unroll the inner loops, which destroys performance.
          */
         do {
-            /* Decode 5 symbols from each of the first 3 or 4 streams.
-             * In the 3-way case the final stream will be decoded during
-             * the reload phase to reduce register pressure.
+            /* Decode 5 symbols from each of the first 3 streams.
+             * The final stream will be decoded during the reload phase
+             * to reduce register pressure.
              */
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, HUF_4X2_4WAY);
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, HUF_4X2_4WAY);
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, HUF_4X2_4WAY);
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, HUF_4X2_4WAY);
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, HUF_4X2_4WAY);
-
-            /* In the 3-way case decode one symbol from the final stream. */
-            HUF_4X2_DECODE_SYMBOL(3, HUF_4X2_3WAY);
-
-            /* In the 3-way case decode 4 symbols from the final stream &
-             * reload bitstreams. The final stream is reloaded last, meaning
-             * that all 5 symbols are decoded from the final stream before
-             * it is reloaded.
+            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, 0);
+            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, 0);
+            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, 0);
+            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, 0);
+            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, 0);
+
+            /* Decode one symbol from the final stream */
+            HUF_4X2_DECODE_SYMBOL(3, 1);
+
+            /* Decode 4 symbols from the final stream & reload bitstreams.
+             * The final stream is reloaded last, meaning that all 5 symbols
+             * are decoded from the final stream before it is reloaded.
              */
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_5X2_RELOAD_STREAM, HUF_4X2_3WAY);
+            HUF_4X_FOR_EACH_STREAM(HUF_4X2_RELOAD_STREAM);
         } while (op[3] < olimit);
     }
 
 #undef HUF_4X2_DECODE_SYMBOL
-#undef HUF_5X2_RELOAD_STREAM
+#undef HUF_4X2_RELOAD_STREAM
 
 _out:
 
@@ -1680,7 +1671,7 @@ HUF_decompress4X2_usingDTable_internal_fast(
     HUF_DecompressFastLoopFn loopFn) {
     void const* dt = DTable + 1;
     const BYTE* const ilowest = (const BYTE*)cSrc;
-    BYTE* const oend = (BYTE*)ZSTD_maybeNullPtrAdd(dst, (ptrdiff_t)dstSize);
+    BYTE* const oend = ZSTD_maybeNullPtrAdd((BYTE*)dst, dstSize);
     HUF_DecompressFastArgs args;
     {
         size_t const ret = HUF_DecompressFastArgs_init(&args, dst, dstSize, cSrc, cSrcSize, DTable);