changed parameter name to ZSTD_c_overlapLog

from overlapSizeLog.

Reasoning :
`overlapLog` is already used everwhere, in the code, command line and documentation.
`ZSTD_c_overlapSizeLog` feels unnecessarily different.

diff --git a/doc/zstd_manual.html b/doc/zstd_manual.html
index d74b41802ab6e186da9fbf851d46b7024a793028..338ee7f2e79642d7b32ecd89e16ee75cbec5afe4 100644 (file)
--- a/doc/zstd_manual.html
+++ b/doc/zstd_manual.html
@@ -445,7 +445,7 @@ size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict);
                               *                    , for all strategies > fast, effective maximum is 6.
                               * Special: value 0 means "use default minMatchLength". */
     ZSTD_c_targetLength=106, </b>/* Impact of this field depends on strategy.<b>
-                              * For strategies btopt & btultra:
+                              * For strategies btopt, btultra & btultra2:
                               *     Length of Match considered "good enough" to stop search.
                               *     Larger values make compression stronger, and slower.
                               * For strategy fast:
@@ -506,15 +506,20 @@ size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict);
     ZSTD_c_jobSize=401,      </b>/* Size of a compression job. This value is enforced only when nbWorkers >= 1.<b>
                               * Each compression job is completed in parallel, so this value can indirectly impact the nb of active threads.
                               * 0 means default, which is dynamically determined based on compression parameters.
-                              * Job size must be a minimum of overlapSize, or 1 MB, whichever is largest.
+                              * Job size must be a minimum of overlap size, or 1 MB, whichever is largest.
                               * The minimum size is automatically and transparently enforced */
-    ZSTD_c_overlapSizeLog=402, </b>/* Size of previous job reloaded at the beginning of each job, as a fraction of window size.<b>
+    ZSTD_c_overlapLog=402,   </b>/* Control the overlap size, as a fraction of window size.<b>
+                              * The overlap size is an amount of data reloaded from previous job at the beginning of a new job.
+                              * It helps preserve compression ratio, while each job is compressed in parallel.
                               * This value is enforced only when nbWorkers >= 1.
                               * Larger values increase compression ratio, but decrease speed.
-                              * Values range from 0 (no overlap) to 9 (overlap a full windowSize).
-                              * Each rank (except 0) increase/decrease load size by a factor 2
-                              * 9: full window;  8: w/2;  7: w/4;  6: w/8;  5:w/16;  4: w/32;  3:w/64;  2:w/128;  1:w/256;
-                              * default value is 6 : use 1/8th of windowSize */
+                              * Values range from 0 to 9 (overlap a full windowSize).
+                              * - 0 means "auto" : value will be determined by the library, depending on strategy
+                              * - 1 means "no overlap"
+                              * - 9 means "full overlap", using a full window size.
+                              * Each intermediate rank increases/decreases load size by a factor 2 :
+                              * 9: full window;  8: w/2;  7: w/4;  6: w/8;  5:w/16;  4: w/32;  3:w/64;  2:w/128;  1:no overlap;  0:auto
+                              * default value varies between 6 and 9, depending on strategy */
 
     </b>/* note : additional experimental parameters are also available<b>
      * within the experimental section of the API.

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index fb1a38a2386fdb769b0c646b8e124855b18fa894..8d61fdbd82197a2898d81af4af2fa3843a1ba1b7 100644 (file)
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -305,7 +305,7 @@ ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param)
 #endif
         return bounds;
 
-    case ZSTD_c_overlapSizeLog:
+    case ZSTD_c_overlapLog:
         bounds.lowerBound = ZSTD_OVERLAPLOG_MIN;
         bounds.upperBound = ZSTD_OVERLAPLOG_MAX;
         return bounds;
@@ -404,7 +404,7 @@ static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param)
     case ZSTD_c_forceMaxWindow :
     case ZSTD_c_nbWorkers:
     case ZSTD_c_jobSize:
-    case ZSTD_c_overlapSizeLog:
+    case ZSTD_c_overlapLog:
     case ZSTD_c_rsyncable:
     case ZSTD_c_enableLongDistanceMatching:
     case ZSTD_c_ldmHashLog:
@@ -466,7 +466,7 @@ size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value)
         return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 
     case ZSTD_c_jobSize:
-    case ZSTD_c_overlapSizeLog:
+    case ZSTD_c_overlapLog:
     case ZSTD_c_rsyncable:
         return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 
@@ -587,7 +587,7 @@ size_t ZSTD_CCtxParam_setParameter(ZSTD_CCtx_params* CCtxParams,
         return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_jobSize, value);
 #endif
 
-    case ZSTD_c_overlapSizeLog :
+    case ZSTD_c_overlapLog :
 #ifndef ZSTD_MULTITHREAD
         return ERROR(parameter_unsupported);
 #else
@@ -698,7 +698,7 @@ size_t ZSTD_CCtxParam_getParameter(
         *value = CCtxParams->jobSize;
         break;
 #endif
-    case ZSTD_c_overlapSizeLog :
+    case ZSTD_c_overlapLog :
 #ifndef ZSTD_MULTITHREAD
         return ERROR(parameter_unsupported);
 #else
@@ -4012,8 +4012,8 @@ size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
     if (cctx->streamStage == zcss_init) {
         ZSTD_CCtx_params params = cctx->requestedParams;
         ZSTD_prefixDict const prefixDict = cctx->prefixDict;
-        memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));  /* single usage */
-        assert(prefixDict.dict==NULL || cctx->cdict==NULL);   /* only one can be set */
+        memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));   /* single usage */
+        assert(prefixDict.dict==NULL || cctx->cdict==NULL);    /* only one can be set */
         DEBUGLOG(4, "ZSTD_compressStream2 : transparent init stage");
         if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = input->size + 1;  /* auto-fix pledgedSrcSize */
         params.cParams = ZSTD_getCParamsFromCCtxParams(

diff --git a/lib/zstd.h b/lib/zstd.h
index 17e109b795814cf165c7d1a7bf76bc6b35d452a6..3f1bc5cf19d0a02486e9ec1c31a925d9ffdabf9a 100644 (file)
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -602,15 +602,20 @@ typedef enum {
     ZSTD_c_jobSize=401,      /* Size of a compression job. This value is enforced only when nbWorkers >= 1.
                               * Each compression job is completed in parallel, so this value can indirectly impact the nb of active threads.
                               * 0 means default, which is dynamically determined based on compression parameters.
-                              * Job size must be a minimum of overlapSize, or 1 MB, whichever is largest.
+                              * Job size must be a minimum of overlap size, or 1 MB, whichever is largest.
                               * The minimum size is automatically and transparently enforced */
-    ZSTD_c_overlapSizeLog=402, /* Size of previous job reloaded at the beginning of each job, as a fraction of window size.
+    ZSTD_c_overlapLog=402,   /* Control the overlap size, as a fraction of window size.
+                              * The overlap size is an amount of data reloaded from previous job at the beginning of a new job.
+                              * It helps preserve compression ratio, while each job is compressed in parallel.
                               * This value is enforced only when nbWorkers >= 1.
                               * Larger values increase compression ratio, but decrease speed.
-                              * Values range from 0 (no overlap) to 9 (overlap a full windowSize).
-                              * Each rank (except 0) increase/decrease load size by a factor 2
-                              * 9: full window;  8: w/2;  7: w/4;  6: w/8;  5:w/16;  4: w/32;  3:w/64;  2:w/128;  1:w/256;
-                              * default value is 6 : use 1/8th of windowSize */
+                              * Values range from 0 to 9 (overlap a full windowSize).
+                              * - 0 means "auto" : value will be determined by the library, depending on strategy
+                              * - 1 means "no overlap"
+                              * - 9 means "full overlap", using a full window size.
+                              * Each intermediate rank increases/decreases load size by a factor 2 :
+                              * 9: full window;  8: w/2;  7: w/4;  6: w/8;  5:w/16;  4: w/32;  3:w/64;  2:w/128;  1:no overlap;  0:auto
+                              * default value varies between 6 and 9, depending on strategy */
 
     /* note : additional experimental parameters are also available
      * within the experimental section of the API.

diff --git a/programs/fileio.c b/programs/fileio.c
index cda5295b4b8fea9ec168ccfdda12e79a9a569873..4e4adbdbb174d5a072a5480394f352185fcacb0f 100644 (file)
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -562,7 +562,7 @@ static cRess_t FIO_createCResources(const char* dictFileName, int cLevel,
             g_overlapLog = 9;   /* full overlap */
         if (g_overlapLog != FIO_OVERLAP_LOG_NOTSET) {
             DISPLAYLEVEL(3,"set overlapLog = %u \n", g_overlapLog);
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_c_overlapSizeLog, g_overlapLog) );
+            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_c_overlapLog, g_overlapLog) );
         }
         CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_c_rsyncable, g_rsyncable) );
 #endif

diff --git a/tests/roundTripCrash.c b/tests/roundTripCrash.c
index 13cf51579687457795f8e9a5f73cb1366653b81b..3f4ace8c980051e50e1cf427c21089b25c043424 100644 (file)
--- a/tests/roundTripCrash.c
+++ b/tests/roundTripCrash.c
@@ -95,7 +95,7 @@ static size_t cctxParamRoundTripTest(void* resultBuff, size_t resultBuffCapacity
     /* Set parameters */
     CHECK_Z( ZSTD_CCtxParam_setParameter(cctxParams, ZSTD_c_compressionLevel, cLevel) );
     CHECK_Z( ZSTD_CCtxParam_setParameter(cctxParams, ZSTD_c_nbWorkers, 2) );
-    CHECK_Z( ZSTD_CCtxParam_setParameter(cctxParams, ZSTD_c_overlapSizeLog, 5) );
+    CHECK_Z( ZSTD_CCtxParam_setParameter(cctxParams, ZSTD_c_overlapLog, 5) );
 
 
     /* Apply parameters */

diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 0de58b66fe94a89967913f4ea591beda6be0dc8f..0e23d9e2be8d7b2f58bffb5ca40ba48f3c66dadb 100644 (file)
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -1904,7 +1904,7 @@ static int fuzzerTests_newAPI(U32 seed, U32 nbTests, unsigned startTest,
                     CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_c_nbWorkers, nbThreads, opaqueAPI) );
                     if (nbThreads > 1) {
                         U32 const jobLog = FUZ_rand(&lseed) % (testLog+1);
-                        CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_c_overlapSizeLog, FUZ_rand(&lseed) % 10, opaqueAPI) );
+                        CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_c_overlapLog, FUZ_rand(&lseed) % 10, opaqueAPI) );
                         CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_c_jobSize, (U32)FUZ_rLogLength(&lseed, jobLog), opaqueAPI) );
                     }
                 }