zstd-native-ruby 1.0.0 → 1.0.2

data/{vendor → ext/zstd_native}/zstd/lib/dictBuilder/zdict.c

@@ -168,7 +168,7 @@ static void ZDICT_initDictItem(dictItem* d)
 #define MINMATCHLENGTH 7   /* heuristic determined experimentally */
 static dictItem ZDICT_analyzePos(
                        BYTE* doneMarks,
-                       const unsigned* suffix, U32 start,
+                       const int* suffix, U32 start,
                        const void* buffer, U32 minRatio, U32 notificationLevel)
 {
     U32 lengthList[LLIMIT] = {0};
@@ -293,10 +293,8 @@ static dictItem ZDICT_analyzePos(
         for (i=(int)(maxLength-2); i>=0; i--)
             cumulLength[i] = cumulLength[i+1] + lengthList[i];
 
-        {   unsigned u;
-            for (u=LLIMIT-1; u>=MINMATCHLENGTH; u--) if (cumulLength[u]>=minRatio) break;
-            maxLength = u;
-        }
+        for (i=LLIMIT-1; i>=MINMATCHLENGTH; i--) if (cumulLength[i]>=minRatio) break;
+        maxLength = i;
 
         /* reduce maxLength in case of final into repetitive data */
         {   U32 l = (U32)maxLength;
@@ -308,10 +306,8 @@ static dictItem ZDICT_analyzePos(
 
         /* calculate savings */
         savings[5] = 0;
-        {   unsigned u;
-            for (u=MINMATCHLENGTH; u<=maxLength; u++)
-                savings[u] = savings[u-1] + (lengthList[u] * (u-3));
-        }
+        for (i=MINMATCHLENGTH; i<=(int)maxLength; i++)
+            savings[i] = savings[i-1] + (lengthList[i] * (i-3));
 
         DISPLAYLEVEL(4, "Selected dict at position %u, of length %u : saves %u (ratio: %.2f)  \n",
                      (unsigned)pos, (unsigned)maxLength, (unsigned)savings[maxLength], (double)savings[maxLength] / (double)maxLength);
@@ -387,11 +383,11 @@ static U32 ZDICT_tryMerge(dictItem* table, dictItem elt, U32 eltNbToSkip, const
 
         if ((table[u].pos + table[u].length >= elt.pos) && (table[u].pos < elt.pos)) {  /* overlap, existing < new */
             /* append */
-            int const addedLength = (int)eltEnd - (int)(table[u].pos + table[u].length); /* note: can be negative */
+            int const addedLength = (int)eltEnd - (int)(table[u].pos + table[u].length);
             table[u].savings += elt.length / 8;    /* rough approx bonus */
             if (addedLength > 0) {   /* otherwise, elt fully included into existing */
-                table[u].length += (unsigned)addedLength;
-                table[u].savings += elt.savings * (unsigned)addedLength / elt.length;   /* rough approx */
+                table[u].length += addedLength;
+                table[u].savings += elt.savings * addedLength / elt.length;   /* rough approx */
             }
             /* sort : improve rank */
             elt = table[u];
@@ -403,7 +399,7 @@ static U32 ZDICT_tryMerge(dictItem* table, dictItem elt, U32 eltNbToSkip, const
 
         if (MEM_read64(buf + table[u].pos) == MEM_read64(buf + elt.pos + 1)) {
             if (isIncluded(buf + table[u].pos, buf + elt.pos + 1, table[u].length)) {
-                size_t const addedLength = MAX( elt.length - table[u].length , 1 );
+                size_t const addedLength = MAX( (int)elt.length - (int)table[u].length , 1 );
                 table[u].pos = elt.pos;
                 table[u].savings += (U32)(elt.savings * addedLength / elt.length);
                 table[u].length = MIN(elt.length, table[u].length + 1);
@@ -471,8 +467,8 @@ static size_t ZDICT_trainBuffer_legacy(dictItem* dictList, U32 dictListSize,
                             const size_t* fileSizes, unsigned nbFiles,
                             unsigned minRatio, U32 notificationLevel)
 {
-    unsigned* const suffix0 = (unsigned*)malloc((bufferSize+2)*sizeof(*suffix0));
-    unsigned* const suffix = suffix0+1;
+    int* const suffix0 = (int*)malloc((bufferSize+2)*sizeof(*suffix0));
+    int* const suffix = suffix0+1;
     U32* reverseSuffix = (U32*)malloc((bufferSize)*sizeof(*reverseSuffix));
     BYTE* doneMarks = (BYTE*)malloc((bufferSize+16)*sizeof(*doneMarks));   /* +16 for overflow security */
     U32* filePos = (U32*)malloc(nbFiles * sizeof(*filePos));
@@ -507,11 +503,11 @@ static size_t ZDICT_trainBuffer_legacy(dictItem* dictList, U32 dictListSize,
 
     /* sort */
     DISPLAYLEVEL(2, "sorting %u files of total size %u MB ...\n", nbFiles, (unsigned)(bufferSize>>20));
-    {   int const divSuftSortResult = divsufsort((const unsigned char*)buffer, (int*)suffix, (int)bufferSize, 0);
+    {   int const divSuftSortResult = divsufsort((const unsigned char*)buffer, suffix, (int)bufferSize, 0);
         if (divSuftSortResult != 0) { result = ERROR(GENERIC); goto _cleanup; }
     }
-    suffix[bufferSize] = (unsigned)bufferSize;   /* leads into noise */
-    suffix0[0] = (unsigned)bufferSize;           /* leads into noise */
+    suffix[bufferSize] = (int)bufferSize;   /* leads into noise */
+    suffix0[0] = (int)bufferSize;           /* leads into noise */
     /* build reverse suffix sort */
     {   size_t pos;
         for (pos=0; pos < bufferSize; pos++)

data/ext/zstd_native/zstd/lib/dll/example/build_package.bat

@@ -0,0 +1,20 @@
+@ECHO OFF
+MKDIR bin\dll bin\static bin\example bin\include
+COPY tests\fullbench.c bin\example\
+COPY programs\datagen.c bin\example\
+COPY programs\datagen.h bin\example\
+COPY programs\util.h bin\example\
+COPY programs\platform.h bin\example\
+COPY lib\common\mem.h bin\example\
+COPY lib\common\zstd_internal.h bin\example\
+COPY lib\common\error_private.h bin\example\
+COPY lib\common\xxhash.h bin\example\
+COPY lib\libzstd.a bin\static\libzstd_static.lib
+COPY lib\dll\libzstd.* bin\dll\
+COPY lib\dll\example\Makefile bin\example\
+COPY lib\dll\example\fullbench-dll.* bin\example\
+COPY lib\dll\example\README.md bin\
+COPY lib\zstd.h bin\include\
+COPY lib\common\zstd_errors.h bin\include\
+COPY lib\dictBuilder\zdict.h bin\include\
+COPY programs\zstd.exe bin\zstd.exe

data/{vendor → ext/zstd_native}/zstd/lib/legacy/zstd_v01.c

@@ -430,7 +430,7 @@ static unsigned FSE_isError(size_t code) { return (code > (size_t)(-FSE_ERROR_ma
 
 static short FSE_abs(short a)
 {
-    return a<0? (short)-a : a;
+    return a<0? -a : a;
 }
 
 
@@ -1823,12 +1823,11 @@ static size_t ZSTD_decompressSequences(
     BYTE* const ostart = (BYTE* const)dst;
     BYTE* op = ostart;
     BYTE* const oend = ostart + maxDstSize;
-    size_t errorCode = 0;
-    size_t dumpsLength = 0;
+    size_t errorCode, dumpsLength;
     const BYTE* litPtr = litStart;
     const BYTE* const litEnd = litStart + litSize;
-    int nbSeq = 0;
-    const BYTE* dumps = NULL;
+    int nbSeq;
+    const BYTE* dumps;
     U32* DTableLL = dctx->LLTable;
     U32* DTableML = dctx->MLTable;
     U32* DTableOffb = dctx->OffTable;
@@ -1916,7 +1915,7 @@ size_t ZSTDv01_decompressDCtx(void* ctx, void* dst, size_t maxDstSize, const voi
     size_t remainingSize = srcSize;
     U32 magicNumber;
     size_t errorCode=0;
-    blockProperties_t blockProperties = { 0 };
+    blockProperties_t blockProperties;
 
     /* Frame Header */
     if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);

data/{vendor → ext/zstd_native}/zstd/lib/legacy/zstd_v03.c

@@ -1111,7 +1111,7 @@ static unsigned FSE_isError(size_t code) { return ERR_isError(code); }
 ****************************************************************/
 static short FSE_abs(short a)
 {
-    return a<0 ? (short)-a : a;
+    return a<0 ? -a : a;
 }
 
 static size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,

data/{vendor → ext/zstd_native}/zstd/lib/legacy/zstd_v04.c

@@ -1094,7 +1094,7 @@ static unsigned FSE_isError(size_t code) { return ERR_isError(code); }
 ****************************************************************/
 static short FSE_abs(short a)
 {
-    return a<0 ? (short)-a : a;
+    return a<0 ? -a : a;
 }
 
 static size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,

data/{vendor → ext/zstd_native}/zstd/lib/legacy/zstd_v05.c

@@ -1224,7 +1224,7 @@ const char* FSEv05_getErrorName(size_t code) { return ERR_getErrorName(code); }
 /*-**************************************************************
 *  FSEv05 NCount encoding-decoding
 ****************************************************************/
-static short FSEv05_abs(short a) { return a<0 ? (short)-a : a; }
+static short FSEv05_abs(short a) { return a<0 ? -a : a; }
 
 
 size_t FSEv05_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,

data/{vendor → ext/zstd_native}/zstd/lib/legacy/zstd_v06.c

@@ -1202,7 +1202,7 @@ static unsigned HUFv06_isError(size_t code) { return ERR_isError(code); }
 /*-**************************************************************
 *  FSE NCount encoding-decoding
 ****************************************************************/
-static short FSEv06_abs(short a) { return a<0 ? (short)-a : a; }
+static short FSEv06_abs(short a) { return a<0 ? -a : a; }
 
 size_t FSEv06_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
                  const void* headerBuffer, size_t hbSize)

data/{vendor → ext/zstd_native}/zstd/lib/libzstd.mk

@@ -206,10 +206,7 @@ endif
 endif
 CPPFLAGS  += -DZSTD_LEGACY_SUPPORT=$(ZSTD_LEGACY_SUPPORT)
 
-# Include install_oses.mk from the same directory
-include $(dir $(lastword $(MAKEFILE_LIST)))/install_oses.mk
-LN ?= ln
-CP ?= cp -f
+UNAME := $(shell sh -c 'MSYSTEM="MSYS" uname')
 
 ifndef BUILD_DIR
 ifeq ($(UNAME), Darwin)

data/{vendor → ext/zstd_native}/zstd/lib/libzstd.pc.in

@@ -14,4 +14,3 @@ Version: @VERSION@
 Libs: -L${libdir} -lzstd @LIBS_MT@
 Libs.private: @LIBS_PRIVATE@
 Cflags: -I${includedir} @LIBS_MT@
-License: BSD-3-Clause OR GPL-2.0-only

data/{vendor → ext/zstd_native}/zstd/lib/zstd.h

@@ -111,7 +111,7 @@ extern "C" {
 /*------   Version   ------*/
 #define ZSTD_VERSION_MAJOR    1
 #define ZSTD_VERSION_MINOR    5
-#define ZSTD_VERSION_RELEASE  8
+#define ZSTD_VERSION_RELEASE  7
 #define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
 
 /*! ZSTD_versionNumber() :
@@ -176,30 +176,30 @@ ZSTDLIB_API size_t ZSTD_decompress( void* dst, size_t dstCapacity,
 
 /*======  Decompression helper functions  ======*/
 
-/*! @brief Returns the decompressed content size stored in a ZSTD frame header.
- *
- *  @since v1.3.0
- *
- *  @param src Pointer to the beginning of a ZSTD encoded frame.
- *  @param srcSize Size of the buffer pointed to by @p src. It must be at least as large as the frame header.
- *                 Any value greater than or equal to `ZSTD_frameHeaderSize_max` is sufficient.
- *  @return The decompressed size in bytes when the value is available in the frame header.
- *  @retval ZSTD_CONTENTSIZE_UNKNOWN The frame does not encode a decompressed size (typical for streaming).
- *  @retval ZSTD_CONTENTSIZE_ERROR An error occurred (e.g. invalid magic number, @p srcSize too small).
- *
- *  @note The return value is not compatible with `ZSTD_isError()`.
- *  @note A return value of 0 denotes a valid but empty frame. Skippable frames also report 0.
- *  @note The decompressed size field is optional. When it is absent (the function returns @c ZSTD_CONTENTSIZE_UNKNOWN),
- *        the caller must rely on streaming decompression or an application-specific upper bound. `ZSTD_decompress()`
- *        only requires an upper bound, so applications may enforce their own block limits (for example 16 KB).
- *  @note The decompressed size is guaranteed to be present when compression was performed with single-pass APIs such as
- *        `ZSTD_compress()`, `ZSTD_compressCCtx()`, `ZSTD_compress_usingDict()`, or `ZSTD_compress_usingCDict()`.
- *  @note The decompressed size is a 64-bit value and may exceed the addressable space of the system. Use streaming
- *        decompression when the value is too large to materialize in contiguous memory.
- *  @warning When processing untrusted input, validate the returned size against the application's limits; attackers may
- *           forge an arbitrarily large value.
- *  @note This function replaces `ZSTD_getDecompressedSize()`.
- */
+/*! ZSTD_getFrameContentSize() : requires v1.3.0+
+ * `src` should point to the start of a ZSTD encoded frame.
+ * `srcSize` must be at least as large as the frame header.
+ *           hint : any size >= `ZSTD_frameHeaderSize_max` is large enough.
+ * @return : - decompressed size of `src` frame content, if known
+ *           - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined
+ *           - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small)
+ *  note 1 : a 0 return value means the frame is valid but "empty".
+ *           When invoking this method on a skippable frame, it will return 0.
+ *  note 2 : decompressed size is an optional field, it may not be present (typically in streaming mode).
+ *           When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size.
+ *           In which case, it's necessary to use streaming mode to decompress data.
+ *           Optionally, application can rely on some implicit limit,
+ *           as ZSTD_decompress() only needs an upper bound of decompressed size.
+ *           (For example, data could be necessarily cut into blocks <= 16 KB).
+ *  note 3 : decompressed size is always present when compression is completed using single-pass functions,
+ *           such as ZSTD_compress(), ZSTD_compressCCtx() ZSTD_compress_usingDict() or ZSTD_compress_usingCDict().
+ *  note 4 : decompressed size can be very large (64-bits value),
+ *           potentially larger than what local system can handle as a single memory segment.
+ *           In which case, it's necessary to use streaming mode to decompress data.
+ *  note 5 : If source is untrusted, decompressed size could be wrong or intentionally modified.
+ *           Always ensure return value fits within application's authorized limits.
+ *           Each application can set its own limits.
+ *  note 6 : This function replaces ZSTD_getDecompressedSize() */
 #define ZSTD_CONTENTSIZE_UNKNOWN (0ULL - 1)
 #define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
 ZSTDLIB_API unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize);
@@ -1868,14 +1868,15 @@ ZSTDLIB_STATIC_API const ZSTD_DDict* ZSTD_initStaticDDict(
 typedef void* (*ZSTD_allocFunction) (void* opaque, size_t size);
 typedef void  (*ZSTD_freeFunction) (void* opaque, void* address);
 typedef struct { ZSTD_allocFunction customAlloc; ZSTD_freeFunction customFree; void* opaque; } ZSTD_customMem;
-#if defined(__clang__) && __clang_major__ >= 5
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
-#endif
 static
 #ifdef __GNUC__
 __attribute__((__unused__))
 #endif
+
+#if defined(__clang__) && __clang_major__ >= 5
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
+#endif
 ZSTD_customMem const ZSTD_defaultCMem = { NULL, NULL, NULL };  /**< this constant defers to stdlib's functions */
 #if defined(__clang__) && __clang_major__ >= 5
 #pragma clang diagnostic pop
@@ -3137,18 +3138,6 @@ ZSTDLIB_STATIC_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx);
 
 
 
-/*! ZSTD_isDeterministicBuild() :
- * Returns 1 if the library is built using standard compilation flags,
- * and participates in determinism guarantees with other builds of the
- * same version.
- * If this function returns 0, it means the library was compiled with
- * non-standard compilation flags that change the output of the
- * compressor.
- * This is mainly used for Zstd's determinism test suite, which is only
- * run when this function returns 1.
- */
-ZSTDLIB_API int ZSTD_isDeterministicBuild(void);
-
 
 /* ========================================= */
 /**       Block level API (DEPRECATED)       */

data/{vendor → ext/zstd_native}/zstd/programs/Makefile

@@ -170,7 +170,7 @@ endif
 
 zstd : $(BUILD_DIR)/zstd
 	if [ $(BIN_ISDIFFERENT) -eq 1 ]; then \
-		$(CP) $<$(EXT) $@$(EXT); \
+		cp -f $<$(EXT) $@$(EXT); \
 		echo zstd build completed; \
 	else \
 		echo zstd already built; \
@@ -271,7 +271,7 @@ zstd-dictBuilder: $(ZSTDLIB_COMMON_SRC) $(ZSTDLIB_COMPRESS_SRC) $(ZDICT_SRC) zst
 
 CLEAN += zstdmt
 zstdmt: zstd
-	$(LN) -sf zstd zstdmt
+	ln -sf zstd zstdmt
 
 .PHONY: generate_res
 generate_res: $(RES64_FILE) $(RES32_FILE)
@@ -345,7 +345,7 @@ include $(wildcard $(DEPFILES))
 #-----------------------------------------------------------------------------
 # make install is validated only for Linux, macOS, BSD, Hurd and Solaris targets
 #-----------------------------------------------------------------------------
-ifneq (,$(filter $(INSTALL_OS_LIST),$(UNAME)))
+ifneq (,$(filter Linux Darwin GNU/kFreeBSD GNU OpenBSD FreeBSD NetBSD DragonFly SunOS Haiku AIX MSYS_NT% CYGWIN_NT%,$(UNAME)))
 
 HAVE_COLORNEVER = $(shell echo a | egrep --color=never a > /dev/null 2> /dev/null && echo 1 || echo 0)
 EGREP_OPTIONS ?=
@@ -414,15 +414,15 @@ install:
 	[ -e $(DESTDIR)$(MAN1DIR) ] || $(INSTALL) -d -m 755 $(DESTDIR)$(MAN1DIR)/
 	@echo Installing binaries
 	$(INSTALL_PROGRAM) zstd$(EXT) $(DESTDIR)$(BINDIR)/zstd$(EXT)
-	$(LN) -sf zstd$(EXT) $(DESTDIR)$(BINDIR)/zstdcat$(EXT)
-	$(LN) -sf zstd$(EXT) $(DESTDIR)$(BINDIR)/unzstd$(EXT)
-	$(LN) -sf zstd$(EXT) $(DESTDIR)$(BINDIR)/zstdmt$(EXT)
+	ln -sf zstd$(EXT) $(DESTDIR)$(BINDIR)/zstdcat$(EXT)
+	ln -sf zstd$(EXT) $(DESTDIR)$(BINDIR)/unzstd$(EXT)
+	ln -sf zstd$(EXT) $(DESTDIR)$(BINDIR)/zstdmt$(EXT)
 	$(INSTALL_SCRIPT) zstdless $(DESTDIR)$(BINDIR)/zstdless
 	$(INSTALL_SCRIPT) zstdgrep $(DESTDIR)$(BINDIR)/zstdgrep
 	@echo Installing man pages
 	$(INSTALL_MAN) zstd.1 $(DESTDIR)$(MAN1DIR)/zstd.1
-	$(LN) -sf zstd.1 $(DESTDIR)$(MAN1DIR)/zstdcat.1
-	$(LN) -sf zstd.1 $(DESTDIR)$(MAN1DIR)/unzstd.1
+	ln -sf zstd.1 $(DESTDIR)$(MAN1DIR)/zstdcat.1
+	ln -sf zstd.1 $(DESTDIR)$(MAN1DIR)/unzstd.1
 	$(INSTALL_MAN) zstdgrep.1 $(DESTDIR)$(MAN1DIR)/zstdgrep.1
 	$(INSTALL_MAN) zstdless.1 $(DESTDIR)$(MAN1DIR)/zstdless.1
 	@echo zstd installation completed

data/{vendor → ext/zstd_native}/zstd/programs/README.md

@@ -153,7 +153,7 @@ Usage: zstd [OPTIONS...] [INPUT... | -] [-o OUTPUT]
 Options:
   -o OUTPUT                     Write output to a single file, OUTPUT.
   -k, --keep                    Preserve INPUT file(s). [Default]
-  --rm                          Remove INPUT file(s) after successful (de)compression to file.
+  --rm                          Remove INPUT file(s) after successful (de)compression.
 
   -#                            Desired compression level, where `#` is a number between 1 and 19;
                                 lower numbers provide faster compression, higher numbers yield

data/{vendor → ext/zstd_native}/zstd/programs/benchzstd.c

@@ -208,7 +208,7 @@ BMK_advancedParams_t BMK_initAdvancedParams(void)
     BMK_advancedParams_t const res = {
         BMK_both,               /* mode */
         BMK_TIMETEST_DEFAULT_S, /* nbSeconds */
-        0,                      /* chunkSizeMax */
+        0,                      /* blockSize */
         0,               /* targetCBlockSize */
         0,                      /* nbWorkers */
         0,                      /* realTime */
@@ -227,6 +227,16 @@ BMK_advancedParams_t BMK_initAdvancedParams(void)
 /* ********************************************************
  *  Bench functions
  **********************************************************/
+typedef struct {
+    const void* srcPtr;
+    size_t srcSize;
+    void* cPtr;
+    size_t cRoom;
+    size_t cSize;
+    void* resPtr;
+    size_t resSize;
+} blockParam_t;
+
 #undef MIN
 #undef MAX
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
@@ -425,16 +435,16 @@ static BMK_benchOutcome_t BMK_benchMemAdvancedNoAlloc(
         const char* displayName,
         const BMK_advancedParams_t* adv)
 {
-    size_t const chunkSizeMax =
-            ((adv->chunkSizeMax >= 32 && (adv->mode != BMK_decodeOnly))
-                     ? adv->chunkSizeMax
+    size_t const blockSize =
+            ((adv->blockSize >= 32 && (adv->mode != BMK_decodeOnly))
+                     ? adv->blockSize
                      : srcSize)
             + (!srcSize); /* avoid div by 0 */
     BMK_benchResult_t benchResult;
     size_t const loadedCompressedSize = srcSize;
     size_t cSize                      = 0;
     double ratio                      = 0.;
-    U32 nbChunks = 0;
+    U32 nbBlocks;
 
     assert(cctx != NULL);
     assert(dctx != NULL);
@@ -490,42 +500,41 @@ static BMK_benchOutcome_t BMK_benchMemAdvancedNoAlloc(
         }
     }
 
-    /* Init data chunks  */
+    /* Init data blocks  */
     {
         const char* srcPtr = (const char*)srcBuffer;
         char* cPtr         = (char*)compressedBuffer;
         char* resPtr       = (char*)(*resultBufferPtr);
-        U32 fileNb, chunkID;
-        for (chunkID = 0, fileNb = 0; fileNb < nbFiles; fileNb++) {
+        U32 fileNb;
+        for (nbBlocks = 0, fileNb = 0; fileNb < nbFiles; fileNb++) {
             size_t remaining              = fileSizes[fileNb];
-            U32 const nbChunksforThisFile = (adv->mode == BMK_decodeOnly)
+            U32 const nbBlocksforThisFile = (adv->mode == BMK_decodeOnly)
                     ? 1
-                    : (U32)((remaining + (chunkSizeMax - 1)) / chunkSizeMax);
-            U32 const chunkIdEnd       = chunkID + nbChunksforThisFile;
-            for (; chunkID < chunkIdEnd; chunkID++) {
-                size_t const chunkSize = MIN(remaining, chunkSizeMax);
-                srcPtrs[chunkID]       = srcPtr;
-                srcSizes[chunkID]      = chunkSize;
-                cPtrs[chunkID]         = cPtr;
-                cCapacities[chunkID]   = (adv->mode == BMK_decodeOnly)
-                             ? chunkSize
-                             : ZSTD_compressBound(chunkSize);
-                resPtrs[chunkID]       = resPtr;
-                resSizes[chunkID]      = (adv->mode == BMK_decodeOnly)
+                    : (U32)((remaining + (blockSize - 1)) / blockSize);
+            U32 const blockEnd            = nbBlocks + nbBlocksforThisFile;
+            for (; nbBlocks < blockEnd; nbBlocks++) {
+                size_t const thisBlockSize = MIN(remaining, blockSize);
+                srcPtrs[nbBlocks]          = srcPtr;
+                srcSizes[nbBlocks]         = thisBlockSize;
+                cPtrs[nbBlocks]            = cPtr;
+                cCapacities[nbBlocks]      = (adv->mode == BMK_decodeOnly)
+                             ? thisBlockSize
+                             : ZSTD_compressBound(thisBlockSize);
+                resPtrs[nbBlocks]          = resPtr;
+                resSizes[nbBlocks]         = (adv->mode == BMK_decodeOnly)
                                 ? (size_t)ZSTD_findDecompressedSize(
-                                srcPtr, chunkSize)
-                                : chunkSize;
-                srcPtr += chunkSize;
-                cPtr += cCapacities[chunkID];
-                resPtr += chunkSize;
-                remaining -= chunkSize;
+                                srcPtr, thisBlockSize)
+                                : thisBlockSize;
+                srcPtr += thisBlockSize;
+                cPtr += cCapacities[nbBlocks];
+                resPtr += thisBlockSize;
+                remaining -= thisBlockSize;
                 if (adv->mode == BMK_decodeOnly) {
-                    cSizes[chunkID]  = chunkSize;
-                    benchResult.cSize = chunkSize;
+                    cSizes[nbBlocks]  = thisBlockSize;
+                    benchResult.cSize = thisBlockSize;
                 }
             }
         }
-        nbChunks = chunkID;
     }
 
     /* warming up `compressedBuffer` */
@@ -560,7 +569,7 @@ static BMK_benchOutcome_t BMK_benchMemAdvancedNoAlloc(
         cbp.initFn        = local_initCCtx; /* BMK_initCCtx */
         cbp.initPayload   = &cctxprep;
         cbp.errorFn       = ZSTD_isError;
-        cbp.blockCount    = nbChunks;
+        cbp.blockCount    = nbBlocks;
         cbp.srcBuffers    = srcPtrs;
         cbp.srcSizes      = srcSizes;
         cbp.dstBuffers    = cPtrs;
@@ -579,7 +588,7 @@ static BMK_benchOutcome_t BMK_benchMemAdvancedNoAlloc(
         dbp.initFn        = local_initDCtx;
         dbp.initPayload   = &dctxprep;
         dbp.errorFn       = ZSTD_isError;
-        dbp.blockCount    = nbChunks;
+        dbp.blockCount    = nbBlocks;
         dbp.srcBuffers    = (const void* const*)cPtrs;
         dbp.srcSizes      = cSizes;
         dbp.dstBuffers    = resPtrs;
@@ -681,7 +690,8 @@ static BMK_benchOutcome_t BMK_benchMemAdvancedNoAlloc(
         } /* while (!(compressionCompleted && decompressionCompleted)) */
 
         /* CRC Checking */
-        {   const BYTE* resultBuffer = (const BYTE*)(*resultBufferPtr);
+        {
+            const BYTE* resultBuffer = (const BYTE*)(*resultBufferPtr);
             U64 const crcCheck       = XXH64(resultBuffer, srcSize, 0);
             if ((adv->mode == BMK_both) && (crcOrig != crcCheck)) {
                 size_t u;
@@ -694,14 +704,14 @@ static BMK_benchOutcome_t BMK_benchMemAdvancedNoAlloc(
                         unsigned segNb, bNb, pos;
                         size_t bacc = 0;
                         DISPLAY("Decoding error at pos %u ", (unsigned)u);
-                        for (segNb = 0; segNb < nbChunks; segNb++) {
+                        for (segNb = 0; segNb < nbBlocks; segNb++) {
                             if (bacc + srcSizes[segNb] > u)
                                 break;
                             bacc += srcSizes[segNb];
                         }
                         pos = (U32)(u - bacc);
                         bNb = pos / (128 KB);
-                        DISPLAY("(sample %u, chunk %u, pos %u) \n",
+                        DISPLAY("(sample %u, block %u, pos %u) \n",
                                 segNb,
                                 bNb,
                                 pos);
@@ -785,24 +795,25 @@ BMK_benchOutcome_t BMK_benchMemAdvanced(
     int const dstParamsError =
             !dstBuffer ^ !dstCapacity; /* must be both NULL or none */
 
-    size_t const chunkSize =
-            ((adv->chunkSizeMax >= 32 && (adv->mode != BMK_decodeOnly))
-                     ? adv->chunkSizeMax
+    size_t const blockSize =
+            ((adv->blockSize >= 32 && (adv->mode != BMK_decodeOnly))
+                     ? adv->blockSize
                      : srcSize)
             + (!srcSize) /* avoid div by 0 */;
-    U32 const nbChunksMax =
-            (U32)((srcSize + (chunkSize - 1)) / chunkSize) + nbFiles;
+    U32 const maxNbBlocks =
+            (U32)((srcSize + (blockSize - 1)) / blockSize) + nbFiles;
 
+    /* these are the blockTable parameters, just split up */
     const void** const srcPtrs =
-            (const void**)malloc(nbChunksMax * sizeof(void*));
-    size_t* const srcSizes = (size_t*)malloc(nbChunksMax * sizeof(size_t));
+            (const void**)malloc(maxNbBlocks * sizeof(void*));
+    size_t* const srcSizes = (size_t*)malloc(maxNbBlocks * sizeof(size_t));
 
-    void** const cPtrs        = (void**)malloc(nbChunksMax * sizeof(void*));
-    size_t* const cSizes      = (size_t*)malloc(nbChunksMax * sizeof(size_t));
-    size_t* const cCapacities = (size_t*)malloc(nbChunksMax * sizeof(size_t));
+    void** const cPtrs        = (void**)malloc(maxNbBlocks * sizeof(void*));
+    size_t* const cSizes      = (size_t*)malloc(maxNbBlocks * sizeof(size_t));
+    size_t* const cCapacities = (size_t*)malloc(maxNbBlocks * sizeof(size_t));
 
-    void** const resPtrs   = (void**)malloc(nbChunksMax * sizeof(void*));
-    size_t* const resSizes = (size_t*)malloc(nbChunksMax * sizeof(size_t));
+    void** const resPtrs   = (void**)malloc(maxNbBlocks * sizeof(void*));
+    size_t* const resSizes = (size_t*)malloc(maxNbBlocks * sizeof(size_t));
 
     BMK_timedFnState_t* timeStateCompress = BMK_createTimedFnState(
             adv->nbSeconds * 1000, BMK_RUNTEST_DEFAULT_MS);
@@ -814,7 +825,7 @@ BMK_benchOutcome_t BMK_benchMemAdvanced(
 
     const size_t maxCompressedSize = dstCapacity
             ? dstCapacity
-            : ZSTD_compressBound(srcSize) + (nbChunksMax * 1024);
+            : ZSTD_compressBound(srcSize) + (maxNbBlocks * 1024);
 
     void* const internalDstBuffer =
             dstBuffer ? NULL : malloc(maxCompressedSize);
@@ -953,12 +964,12 @@ static int BMK_benchCLevels(
     }
 
     if (displayLevel == 1 && !adv->additionalParam) /* --quiet mode */
-        OUTPUT("bench %s %s: input %u bytes, %u seconds, %u KB chunks\n",
+        OUTPUT("bench %s %s: input %u bytes, %u seconds, %u KB blocks\n",
                ZSTD_VERSION_STRING,
                ZSTD_GIT_COMMIT_STRING,
                (unsigned)benchedSize,
                adv->nbSeconds,
-               (unsigned)(adv->chunkSizeMax >> 10));
+               (unsigned)(adv->blockSize >> 10));
 
     for (level = startCLevel; level <= endCLevel; level++) {
         BMK_benchOutcome_t res = BMK_benchMemAdvanced(
@@ -989,7 +1000,7 @@ int BMK_syntheticTest(
 {
     char nameBuff[20]        = { 0 };
     const char* name         = nameBuff;
-    size_t const benchedSize = adv->chunkSizeMax ? adv->chunkSizeMax : 10000000;
+    size_t const benchedSize = adv->blockSize ? adv->blockSize : 10000000;
 
     /* Memory allocation */
     void* const srcBuffer = malloc(benchedSize);

data/{vendor → ext/zstd_native}/zstd/programs/benchzstd.h

@@ -92,9 +92,9 @@ typedef enum {
 } BMK_mode_t;
 
 typedef struct {
-    BMK_mode_t mode;        /* 0: both, 1: compress only 2: decode only */
+    BMK_mode_t mode;        /* 0: all, 1: compress only 2: decode only */
     unsigned nbSeconds;     /* default timing is in nbSeconds */
-    size_t chunkSizeMax;    /* Maximum size of each independent chunk */
+    size_t blockSize;       /* Maximum size of each block*/
     size_t targetCBlockSize;/* Approximative size of compressed blocks */
     int nbWorkers;          /* multithreading */
     unsigned realTime;      /* real time priority */

data/{vendor → ext/zstd_native}/zstd/programs/dibio.c

@@ -280,15 +280,8 @@ static fileStats DiB_fileStats(const char** fileNamesTable, int nbFiles, size_t
     for (n=0; n<nbFiles; n++) {
       S64 const fileSize = DiB_getFileSize(fileNamesTable[n]);
       /* TODO: is there a minimum sample size? What if the file is 1-byte? */
-      /* Skip empty or invalid files */
-      if (fileSize <= 0) {
-        if (fileSize < 0) {
-          DISPLAYLEVEL(3, "Sample file '%s' is unreadable or stat failed, skipping...\n",
-                       fileNamesTable[n]);
-        } else {
-          DISPLAYLEVEL(3, "Sample file '%s' has zero size, skipping...\n",
-                     fileNamesTable[n]);
-        }
+      if (fileSize == 0) {
+        DISPLAYLEVEL(3, "Sample file '%s' has zero size, skipping...\n", fileNamesTable[n]);
         continue;
       }
 
@@ -369,9 +362,9 @@ int DiB_trainFromFiles(const char* dictFileName, size_t maxDictSize,
         DISPLAYLEVEL(2, "!  As a consequence, only the first %u bytes of each sample are loaded \n", SAMPLESIZE_MAX);
     }
     if (fs.nbSamples < 5) {
-        DISPLAYLEVEL(2, "!  Warning : nb of samples too low for proper processing !\n");
-        DISPLAYLEVEL(2, "!  Please provide _one file per sample_.\n");
-        DISPLAYLEVEL(2, "!  Alternatively, split file(s) into fixed-size samples, with --split=#\n");
+        DISPLAYLEVEL(2, "!  Warning : nb of samples too low for proper processing ! \n");
+        DISPLAYLEVEL(2, "!  Please provide _one file per sample_. \n");
+        DISPLAYLEVEL(2, "!  Alternatively, split files into fixed-size blocks representative of samples, with -B# \n");
         EXM_THROW(14, "nb of samples too low");   /* we now clearly forbid this case */
     }
     if (fs.totalSizeToLoad < (S64)maxDictSize * 8) {