-r# : test all compression levels from -bX to #

diff --git a/programs/bench.c b/programs/bench.c
index 6179dda0fb8798aa5e49a06d5a50239fe530166b..e233c17fb3aae2ea686f207053e03335fc14d674 100644 (file)
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -419,49 +419,46 @@ static size_t BMK_findMaxMem(U64 requiredMem)
 }
 
 static void BMK_benchCLevel(void* srcBuffer, size_t benchedSize,
-                            const char* displayName, int cLevel,
+                            const char* displayName, int cLevel, int cLevelLast,
                             const size_t* fileSizes, unsigned nbFiles,
                             const void* dictBuffer, size_t dictBufferSize)
 {
     benchResult_t result, total;
-    
-    if (cLevel < 0) {
-        int l;
-        memset(&total, 0, sizeof(total));
-        const char* pch = strrchr(displayName, '\\'); /* Windows */
-        if (!pch) pch = strrchr(displayName, '/'); /* Linux */
-        if (pch) displayName = pch+1;
-
-        if (g_displayLevel == 1)
-            DISPLAY("bench %s: input %u bytes, %i iterations, %u KB blocks\n", ZSTD_VERSION, (U32)benchedSize, nbIterations, (U32)(g_blockSize>>10));
-
-        for (l=1; l <= -cLevel; l++) {           
-            BMK_benchMem(srcBuffer, benchedSize,
-                         displayName, l,
-                         fileSizes, nbFiles,
-                         dictBuffer, dictBufferSize, &result);
-            if (g_displayLevel == 1) {
-                DISPLAY("%-3i%11i (%5.3f) %6.1f MB/s %6.1f MB/s  %s\n", -l, (int)result.cSize, result.ratio, result.cSpeed, result.dSpeed, displayName);
-                total.cSize += result.cSize;
-                total.cSpeed += result.cSpeed;
-                total.dSpeed += result.dSpeed;
-                total.ratio += result.ratio;
-            }
-        }
-        if (g_displayLevel == 1)
-        {
-            total.cSize /= -cLevel;
-            total.cSpeed /= -cLevel;
-            total.dSpeed /= -cLevel;
-            total.ratio /= -cLevel;
-            DISPLAY("avg%11i (%5.3f) %6.1f MB/s %6.1f MB/s  %s\n", (int)total.cSize, total.ratio, total.cSpeed, total.dSpeed, displayName);            
+    int l;
+
+    const char* pch = strrchr(displayName, '\\'); /* Windows */
+    if (!pch) pch = strrchr(displayName, '/'); /* Linux */
+    if (pch) displayName = pch+1;
+
+    memset(&result, 0, sizeof(result));
+    memset(&total, 0, sizeof(total));
+ 
+    if (g_displayLevel == 1)
+        DISPLAY("bench %s: input %u bytes, %i iterations, %u KB blocks\n", ZSTD_VERSION, (U32)benchedSize, nbIterations, (U32)(g_blockSize>>10));
+
+    if (cLevelLast < cLevel) cLevelLast = cLevel;
+
+    for (l=cLevel; l <= cLevelLast; l++) {           
+        BMK_benchMem(srcBuffer, benchedSize,
+                     displayName, l,
+                     fileSizes, nbFiles,
+                     dictBuffer, dictBufferSize, &result);
+        if (g_displayLevel == 1) {
+            DISPLAY("%-3i%11i (%5.3f) %6.1f MB/s %6.1f MB/s  %s\n", -l, (int)result.cSize, result.ratio, result.cSpeed, result.dSpeed, displayName);
+            total.cSize += result.cSize;
+            total.cSpeed += result.cSpeed;
+            total.dSpeed += result.dSpeed;
+            total.ratio += result.ratio;
         }
-        return;
     }
-    BMK_benchMem(srcBuffer, benchedSize,
-                 displayName, cLevel,
-                 fileSizes, nbFiles,
-                 dictBuffer, dictBufferSize, &result);
+    if (g_displayLevel == 1 && cLevelLast > cLevel)
+    {
+        total.cSize /= 1+cLevelLast-cLevel;
+        total.cSpeed /= 1+cLevelLast-cLevel;
+        total.dSpeed /= 1+cLevelLast-cLevel;
+        total.ratio /= 1+cLevelLast-cLevel;
+        DISPLAY("avg%11i (%5.3f) %6.1f MB/s %6.1f MB/s  %s\n", (int)total.cSize, total.ratio, total.cSpeed, total.dSpeed, displayName);            
+    }
 }
 
 static U64 BMK_getTotalFileSize(const char** fileNamesTable, unsigned nbFiles)
@@ -497,7 +494,7 @@ static void BMK_loadFiles(void* buffer, size_t bufferSize,
 }
 
 static void BMK_benchFileTable(const char** fileNamesTable, unsigned nbFiles,
-                               const char* dictFileName, int cLevel)
+                               const char* dictFileName, int cLevel, int cLevelLast)
 {
     void* srcBuffer;
     size_t benchedSize;
@@ -537,7 +534,7 @@ static void BMK_benchFileTable(const char** fileNamesTable, unsigned nbFiles,
     else displayName = fileNamesTable[0];
 
     BMK_benchCLevel(srcBuffer, benchedSize,
-                    displayName, cLevel,
+                    displayName, cLevel, cLevelLast,
                     fileSizes, nbFiles,
                     dictBuffer, dictBufferSize);
 
@@ -548,7 +545,7 @@ static void BMK_benchFileTable(const char** fileNamesTable, unsigned nbFiles,
 }
 
 
-static void BMK_syntheticTest(int cLevel, double compressibility)
+static void BMK_syntheticTest(int cLevel, int cLevelLast, double compressibility)
 {
     char name[20] = {0};
     size_t benchedSize = 10000000;
@@ -562,7 +559,7 @@ static void BMK_syntheticTest(int cLevel, double compressibility)
 
     /* Bench */
     snprintf (name, sizeof(name), "Synthetic %2u%%", (unsigned)(compressibility*100));
-    BMK_benchCLevel(srcBuffer, benchedSize, name, cLevel, &benchedSize, 1, NULL, 0);
+    BMK_benchCLevel(srcBuffer, benchedSize, name, cLevel, cLevelLast, &benchedSize, 1, NULL, 0);
 
     /* clean up */
     free(srcBuffer);
@@ -570,14 +567,14 @@ static void BMK_syntheticTest(int cLevel, double compressibility)
 
 
 int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles,
-                   const char* dictFileName, int cLevel)
+                   const char* dictFileName, int cLevel, int cLevelLast)
 {
     double compressibility = (double)g_compressibilityDefault / 100;
 
     if (nbFiles == 0)
-        BMK_syntheticTest(cLevel, compressibility);
+        BMK_syntheticTest(cLevel, cLevelLast, compressibility);
     else
-        BMK_benchFileTable(fileNamesTable, nbFiles, dictFileName, cLevel);
+        BMK_benchFileTable(fileNamesTable, nbFiles, dictFileName, cLevel, cLevelLast);
     return 0;
 }
 

diff --git a/programs/bench.h b/programs/bench.h
index bf8e7d4b53acbcc123a03d24ab3f8c80bf3bf3a9..d1d8bd88b7d21a4264dd60bf485a4a628e9cf7f5 100644 (file)
--- a/programs/bench.h
+++ b/programs/bench.h
@@ -27,7 +27,7 @@
 
 /* Main function */
 int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles,
-                   const char* dictFileName, int cLevel);
+                   const char* dictFileName, int cLevel, int cLevelLast);
 
 /* Set Parameters */
 void BMK_SetNbIterations(int nbLoops);

diff --git a/programs/zstdcli.c b/programs/zstdcli.c
index d710bdc4332234cab933a2a6d70d301c487bd033..18fabcfec64ed70d316745b537f0c869899da02b 100644 (file)
--- a/programs/zstdcli.c
+++ b/programs/zstdcli.c
@@ -142,9 +142,9 @@ static int usage_advanced(const char* programName)
 #ifndef ZSTD_NOBENCH
     DISPLAY( "Benchmark arguments :\n");
     DISPLAY( " -b#    : benchmark file(s), using # compression level (default : 1) \n");
+    DISPLAY( " -r#    : test all compression levels from -bX to # (default: 1)\n");
     DISPLAY( " -i#    : iteration loops [1-9](default : 3)\n");
     DISPLAY( " -B#    : cut file into independent blocks of size # (default: no block)\n");
-    DISPLAY( " -r#    : test all compression levels from 1 to # (default: disabled)\n");
 #endif
     return 0;
 }
@@ -179,19 +179,19 @@ int main(int argCount, const char** argv)
         nextArgumentIsOutFileName=0,
         nextArgumentIsMaxDict=0;
     unsigned cLevel = 1;
+    unsigned cLevelLast = 1;
     const char** filenameTable = (const char**)malloc(argCount * sizeof(const char*));   /* argCount >= 1 */
     unsigned filenameIdx = 0;
     const char* programName = argv[0];
     const char* outFileName = NULL;
     const char* dictFileName = NULL;
     char* dynNameSpace = NULL;
-    int rangeBench = 1;
     unsigned maxDictSize = g_defaultMaxDictSize;
     unsigned dictCLevel = g_defaultDictCLevel;
     unsigned dictSelect = g_defaultSelectivityLevel;
 
     /* init */
-    (void)rangeBench; (void)dictCLevel;   /* not used when ZSTD_NOBENCH / ZSTD_NODICT set */
+    (void)cLevelLast; (void)dictCLevel;   /* not used when ZSTD_NOBENCH / ZSTD_NODICT set */
     if (filenameTable==NULL) { DISPLAY("not enough memory\n"); exit(1); }
     displayOut = stderr;
     /* Pick out program name from path. Don't rely on stdlib because of conflicting behavior */
@@ -313,8 +313,14 @@ int main(int argCount, const char** argv)
 
                     /* range bench (benchmark only) */
                 case 'r':
-                        rangeBench = -1;
+                        /* compression Level */
                         argument++;
+                        if ((*argument>='0') && (*argument<='9')) {
+                            cLevelLast = 0;
+                            while ((*argument >= '0') && (*argument <= '9'))
+                                cLevelLast *= 10, cLevelLast += *argument++ - '0';
+                            continue;
+                        }
                         break;
 #endif   /* ZSTD_NOBENCH */
 
@@ -369,7 +375,7 @@ int main(int argCount, const char** argv)
     if (bench) {
 #ifndef ZSTD_NOBENCH
         BMK_setNotificationLevel(displayLevel);
-        BMK_benchFiles(filenameTable, filenameIdx, dictFileName, cLevel*rangeBench);
+        BMK_benchFiles(filenameTable, filenameIdx, dictFileName, cLevel, cLevelLast);
 #endif
         goto _end;
     }