odp_crc.c

Performance test application for CRC hash APIs

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2021 Nokia
 */
 
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <inttypes.h>
#include <getopt.h>
 
#include <odp_api.h>
#include <odp/helper/odph_api.h>
 
#define KB 1024ull
#define MB (1024ull * 1024ull)
 
/* Command line options */
typedef struct {
    uint32_t size;
    uint32_t rounds;
    uint32_t offset;
    uint32_t test;
} options_t;
 
static options_t options;
static const options_t options_def = {
    .size = 16,
    .rounds = 10000,
    .offset = 0,
    .test = 0,
};
 
static void print_usage(void)
{
    printf("\n"
           "CRC performance test\n"
           "\n"
           "Usage: odp_crc_perf [options]\n"
           "\n"
           "  -s, --size    Size of buffer in KB (default %u)\n"
           "  -r, --rounds  Number of test rounds (default %u)\n"
           "                Rounded down to nearest multiple of 8\n"
           "  -o, --offset  Offset of data (default %u)\n"
           "  -t, --test    Which API to test (default %u)\n"
           "                0: both\n"
           "                1: odp_hash_crc32c\n"
           "                2: odp_hash_crc32\n"
           "  -h, --help    This help\n"
           "\n",
           options_def.size, options_def.rounds, options_def.offset,
           options.test);
}
 
static int parse_options(int argc, char *argv[])
{
    int opt;
    int long_index;
    int ret = 0;
 
    static const struct option longopts[] = {
        { "size", required_argument, NULL, 's' },
        { "rounds", required_argument, NULL, 'r' },
        { "offset", required_argument, NULL, 'o' },
        { "test", required_argument, NULL, 't' },
        { "help", no_argument, NULL, 'h' },
        { NULL, 0, NULL, 0 }
    };
 
    static const char *shortopts = "+s:r:o:t:h";
 
    options = options_def;
 
    while (1) {
        opt = getopt_long(argc, argv, shortopts, longopts, &long_index);
 
        if (opt == -1)
            break;
 
        switch (opt) {
        case 's':
            options.size = atol(optarg);
            break;
        case 'r':
            options.rounds = atol(optarg);
            break;
        case 'o':
            options.offset = atol(optarg);
            break;
        case 't':
            options.test = atol(optarg);
            break;
        case 'h':
            /* fall through */
        default:
            print_usage();
            ret = -1;
            break;
        }
    }
 
    if (options.size < 1) {
        ODPH_ERR("Invalid size: %" PRIu32 "\n", options.size);
        return -1;
    }
 
    if (options.offset > 4 * KB) {
        ODPH_ERR("Invalid offset: %" PRIu32 "\n", options.offset);
        return -1;
    }
 
    if (options.test > 2) {
        ODPH_ERR("Invalid API to test: %" PRIu32 "\n", options.test);
        return -1;
    }
 
    return ret;
}
 
static void report(uint64_t nsec)
{
    uint64_t size = (uint64_t)options.size * KB;
    uint32_t rounds = options.rounds & ~7ul;
    double mb, seconds;
 
    printf("size: %d KB  rounds: %d  offset: %d  ",
           options.size, rounds, options.offset);
    mb = (double)(size * (uint64_t)rounds) / (double)MB;
    seconds = (double)nsec / (double)ODP_TIME_SEC_IN_NS;
    printf("MB: %.3f  seconds: %.3f  ", mb, seconds);
    printf("MB/s: %.3f", mb / seconds);
    printf("\n\n");
}
 
static uint64_t measure_crc32c(uint8_t *data, uint32_t size)
{
    void *p = data + options.offset;
    uint32_t crc = 1;
    volatile uint32_t v;
    odp_time_t start = odp_time_local();
 
    for (uint32_t i = 0; i < options.rounds / 8; i++) {
        crc ^= odp_hash_crc32c(p, size, crc);
        crc ^= odp_hash_crc32c(p, size, crc);
        crc ^= odp_hash_crc32c(p, size, crc);
        crc ^= odp_hash_crc32c(p, size, crc);
 
        crc ^= odp_hash_crc32c(p, size, crc);
        crc ^= odp_hash_crc32c(p, size, crc);
        crc ^= odp_hash_crc32c(p, size, crc);
        crc ^= odp_hash_crc32c(p, size, crc);
    }
 
    /* Make sure that crc is not optimized out. */
    v = crc;
 
    /* Quell "unused" warning. */
    (void)v;
 
    return odp_time_diff_ns(odp_time_local(), start);
}
 
static void test_odp_hash_crc32c(uint8_t *data)
{
    uint64_t size = (uint64_t)options.size * KB;
    uint64_t nsec;
 
    /* Warm-up. */
    measure_crc32c(data, size);
 
    /* Actual measurement. */
    nsec = measure_crc32c(data, size);
 
    report(nsec);
}
 
static uint64_t measure_crc32(uint8_t *data, uint32_t size)
{
    void *p = data + options.offset;
    uint32_t crc = 1;
    volatile uint32_t v;
    odp_time_t start = odp_time_local();
 
    for (uint32_t i = 0; i < options.rounds / 8; i++) {
        crc ^= odp_hash_crc32(p, size, crc);
        crc ^= odp_hash_crc32(p, size, crc);
        crc ^= odp_hash_crc32(p, size, crc);
        crc ^= odp_hash_crc32(p, size, crc);
 
        crc ^= odp_hash_crc32(p, size, crc);
        crc ^= odp_hash_crc32(p, size, crc);
        crc ^= odp_hash_crc32(p, size, crc);
        crc ^= odp_hash_crc32(p, size, crc);
    }
 
    /* Make sure that crc is not optimized out. */
    v = crc;
 
    /* Quell "unused" warning. */
    (void)v;
 
    return odp_time_diff_ns(odp_time_local(), start);
}
 
static void test_odp_hash_crc32(uint8_t *data)
{
    uint64_t size = (uint64_t)options.size * KB;
    uint64_t nsec;
 
    /* Warm-up. */
    measure_crc32(data, size);
 
    /* Actual measurement. */
    nsec = measure_crc32(data, size);
 
    report(nsec);
}
 
int main(int argc, char **argv)
{
    odp_instance_t instance;
    odp_init_t init;
 
    if (parse_options(argc, argv))
        exit(EXIT_FAILURE);
 
    /* List features not to be used */
    odp_init_param_init(&init);
    init.not_used.feat.cls = 1;
    init.not_used.feat.compress = 1;
    init.not_used.feat.crypto = 1;
    init.not_used.feat.ipsec = 1;
    init.not_used.feat.schedule = 1;
    init.not_used.feat.stash = 1;
    init.not_used.feat.timer = 1;
    init.not_used.feat.tm = 1;
 
    /* Init ODP before calling anything else */
    if (odp_init_global(&instance, &init, NULL)) {
        ODPH_ERR("Global init failed.\n");
        exit(EXIT_FAILURE);
    }
 
    /* Init this thread */
    if (odp_init_local(instance, ODP_THREAD_CONTROL)) {
        ODPH_ERR("Local init failed.\n");
        exit(EXIT_FAILURE);
    }
 
    odp_sys_info_print();
 
    uint8_t *buf, *data;
    uint32_t size = options.size * KB;
    uint64_t seed = 1;
    const unsigned long page = 4 * KB;
 
    /* One extra page for alignment, another one for offset. */
    buf = (uint8_t *)malloc(size + page * 2);
 
    if (!buf) {
        ODPH_ERR("Memory allocation failed.\n");
        exit(EXIT_FAILURE);
    }
 
    /* Align to start of page. */
    data = (uint8_t *)(((uintptr_t)buf + (page - 1)) & ~(page - 1));
 
    if (odp_random_test_data(data, size, &seed) != (int32_t)size) {
        ODPH_ERR("odp_random_test_data() failed.\n");
        exit(EXIT_FAILURE);
    }
 
    if (options.test == 0 || options.test == 1) {
        printf("odp_hash_crc32c\n"
               "---------------\n");
        test_odp_hash_crc32c(data);
    }
 
    if (options.test == 0 || options.test == 2) {
        printf("odp_hash_crc32\n"
               "--------------\n");
        test_odp_hash_crc32(data);
    }
 
    free(buf);
 
    if (odp_term_local()) {
        ODPH_ERR("Local terminate failed.\n");
        exit(EXIT_FAILURE);
    }
 
    if (odp_term_global(instance)) {
        ODPH_ERR("Global terminate failed.\n");
        exit(EXIT_FAILURE);
    }
 
    return 0;
}