view release on metacpan or  search on metacpan

ext/zstd/contrib/largeNbDicts/largeNbDicts.c  view on Meta::CPAN

    return (data[(size - 1) / 2] + data[size / 2]) / 2;
}

static int benchMem(slice_collection_t dstBlocks, slice_collection_t srcBlocks,
                    ddict_collection_t ddictionaries,
                    cdict_collection_t cdictionaries, unsigned nbRounds,
                    int benchCompression, const char *exeName,
                    ZSTD_CCtx_params *cctxParams,
                    metricAggregatePref_e metricAggregatePref)
{
    assert(dstBlocks.nbSlices == srcBlocks.nbSlices);
    if (benchCompression) assert(cctxParams);

    unsigned const ms_per_round = RUN_TIME_DEFAULT_MS;
    unsigned const total_time_ms = nbRounds * ms_per_round;

    double *const speedPerRound = (double *)malloc(nbRounds * sizeof(double));

    BMK_timedFnState_t* const benchState =
            BMK_createTimedFnState(total_time_ms, ms_per_round);

    decompressInstructions di = createDecompressInstructions(ddictionaries);
    compressInstructions ci =
        createCompressInstructions(cdictionaries, cctxParams);
    void* payload = benchCompression ? (void*)&ci : (void*)&di;
    BMK_benchParams_t const bp = {
        .benchFn = benchCompression ? compress : decompress,
        .benchPayload = payload,
        .initFn = NULL,
        .initPayload = NULL,
        .errorFn = ZSTD_isError,
        .blockCount = dstBlocks.nbSlices,
        .srcBuffers = (const void* const*) srcBlocks.slicePtrs,
        .srcSizes = srcBlocks.capacities,
        .dstBuffers = dstBlocks.slicePtrs,
        .dstCapacities = dstBlocks.capacities,
        .blockResults = NULL
    };

    size_t roundNb = 0;
    for (;;) {
        BMK_runOutcome_t const outcome = BMK_benchTimedFn(benchState, bp);
        CONTROL(BMK_isSuccessful_runOutcome(outcome));

        BMK_runTime_t const result = BMK_extract_runTime(outcome);
        double const dTime_ns = result.nanoSecPerRun;
        double const dTime_sec = (double)dTime_ns / 1000000000;
        size_t const srcSize = result.sumOfReturn;
        double const speed_MBps = (double)srcSize / dTime_sec / (1 MB);
        speedPerRound[roundNb] = speed_MBps;
        if (benchCompression)
            DISPLAY("Compression Speed : %.1f MB/s \r", speed_MBps);
        else
            DISPLAY("Decompression Speed : %.1f MB/s \r", speed_MBps);

        fflush(stdout);
        if (BMK_isCompleted_TimedFn(benchState)) break;
        roundNb++;
    }
    DISPLAY("\n");
    /* BMK_benchTimedFn may not run exactly nbRounds iterations */
    double speedAggregated =
        aggregateData(speedPerRound, roundNb + 1, metricAggregatePref);
    if (metricAggregatePref == fastest)
      DISPLAY("Fastest Speed : %.1f MB/s \n", speedAggregated);
    else
      DISPLAY("Median Speed : %.1f MB/s \n", speedAggregated);

    char* csvFileName = malloc(strlen(exeName) + 5);
    strcpy(csvFileName, exeName);
    strcat(csvFileName, ".csv");
    FILE* csvFile = fopen(csvFileName, "r");
    if (!csvFile) {
        csvFile = fopen(csvFileName, "wt");
        assert(csvFile);
        fprintf(csvFile, "%s\n", exeName);
        /* Print table headers */
        fprintf(
            csvFile,
            "Compression/Decompression,Level,nbDicts,dictAttachPref,metricAggregatePref,Speed\n");
    } else {
        fclose(csvFile);
        csvFile = fopen(csvFileName, "at");
        assert(csvFile);
    }

    int cLevel = -1;
    int dictAttachPref = -1;
    if (benchCompression) {
      ZSTD_CCtxParams_getParameter(cctxParams, ZSTD_c_compressionLevel,
                                   &cLevel);
      ZSTD_CCtxParams_getParameter(cctxParams, ZSTD_c_forceAttachDict,
                                   &dictAttachPref);
    }
    fprintf(csvFile, "%s,%d,%ld,%d,%d,%.1f\n",
            benchCompression ? "Compression" : "Decompression", cLevel,
            benchCompression ? ci.nbDicts : di.nbDicts, dictAttachPref,
            metricAggregatePref, speedAggregated);
    fclose(csvFile);
    free(csvFileName);

    freeDecompressInstructions(di);
    freeCompressInstructions(ci);
    BMK_freeTimedFnState(benchState);

    return 0;   /* success */
}


/*! bench() :
 *  fileName : file to load for benchmarking purpose
 *  dictionary : optional (can be NULL), file to load as dictionary,
 *              if none provided : will be calculated on the fly by the program.
 * @return : 0 is success, 1+ otherwise */
int bench(const char **fileNameTable, unsigned nbFiles, const char *dictionary,
          size_t blockSize, int clevel, unsigned nbDictMax, unsigned nbBlocks,
          unsigned nbRounds, int benchCompression,
          ZSTD_dictContentType_e dictContentType, ZSTD_CCtx_params *cctxParams,
          const char *exeName, metricAggregatePref_e metricAggregatePref)
{
    int result = 0;