libec-test.c

#include <assert.h>
#include <stdio.h>
#include <time.h>

#include <liberasurecode/erasurecode.h>

typedef struct {
    char * backend;
    size_t chunk_size;
    size_t total_size;
    double encode_time;
    double decode_time;
} test_result;

void test_once(test_result * result, int desc, struct ec_args * args, char * data) {
    clock_t start;
    char **encoded_data = NULL;
    char **encoded_parity = NULL;
    char *available_frags[args->k];
    char *out_data = NULL;
    uint64_t encoded_fragment_len = 0, out_data_len = 0;
    int rc;

    start = clock();
    rc = liberasurecode_encode(desc, data, result->chunk_size,
                               &encoded_data, &encoded_parity,
                               &encoded_fragment_len);
    result->encode_time += (double)(clock() - start) / CLOCKS_PER_SEC;
    assert(0 == rc);

    for (rc = 0; rc < args->m; ++rc) {
        available_frags[rc] = encoded_parity[rc];
    }
    for (; rc < args->k; ++rc) {
        available_frags[rc] = encoded_data[rc];
    }

    start = clock();
    rc = liberasurecode_decode(desc, available_frags, args->k,
                               encoded_fragment_len, true,
                               &out_data, &out_data_len);
    result->decode_time += (double)(clock() - start) / CLOCKS_PER_SEC;
    assert(0 == rc);
    assert(out_data_len == result->chunk_size);
    assert(0 == strncmp(data, out_data, out_data_len));

    rc = liberasurecode_decode_cleanup(desc, out_data);
    assert(0 == rc);
    rc = liberasurecode_encode_cleanup(desc, encoded_data, encoded_parity);
    assert(0 == rc);
}

#ifdef CSV
    #define NA_FORMAT "\"%1$s\",%2$zd,\"N/A\"\n"
    #define RESULT_FORMAT "\"%1$s\",%2$zd,%3$f,%4$f\n"
#else
    #define NA_FORMAT "%1$-35s  not available                                 (chunk_size = %2$zd)\n"
    #define RESULT_FORMAT "%1$-35s Encode: %3$8.2f MiB/s  Decode: %4$8.2f MiB/s (chunk_size = %2$zd)\n"
#endif

void test(test_result * result, char * backend_name, ec_backend_id_t backend_id, size_t size, int repeats) {
    result->backend = backend_name;
    result->chunk_size = size;
    result->total_size = repeats * size;
    result->encode_time = result->decode_time = 0.0;

    struct ec_args args = {
        .k = 10,
        .m = 5,
        .hd = 4,
    };
    int desc = liberasurecode_instance_create(backend_id, &args);
    if (-EBACKENDNOTAVAIL == desc) {
        result->encode_time = result->decode_time = -1.0;
        return;
    }
    assert(desc > 0);

    char * data = calloc(size, sizeof(char));
    int i;
    for (i = 0; i < repeats; ++i) {
        test_once(result, desc, &args, data);
    }

    desc = liberasurecode_instance_destroy(desc);
    assert(desc == 0);
    free(data);
}

#define TEST(backend) \
    {#backend, backend, 1 << 10, 1 << 18}, \
    {#backend, backend, 1 << 12, 1 << 16}, \
    {#backend, backend, 1 << 16, 1 << 12}, \
    {#backend, backend, 1 << 20, 1 << 8}

int main(int argc, char **argv) {
    struct {
        char * backend_name;
        ec_backend_id_t backend_id;
        size_t chunk_size;
        int repeats;
    } tests[] = {
        TEST(EC_BACKEND_NULL),
        TEST(EC_BACKEND_FLAT_XOR_HD),
        TEST(EC_BACKEND_ISA_L_RS_VAND),
        TEST(EC_BACKEND_ISA_L_RS_CAUCHY),
        TEST(EC_BACKEND_JERASURE_RS_VAND),
        TEST(EC_BACKEND_JERASURE_RS_CAUCHY),
        TEST(EC_BACKEND_LIBERASURECODE_RS_VAND),
        TEST(EC_BACKEND_SHSS)
    };
    int i, l = sizeof(tests) / sizeof(tests[0]);
    test_result result;
    bool quick = false;
    for (i = 1; i < argc; ++i) {
        if (!strcmp(argv[i], "quick")) {
            quick = true;
            break;
        }
    }
    for (i = 0; i < l; ++i) {
        test(
            &result,
            tests[i].backend_name,
            tests[i].backend_id,
            tests[i].chunk_size,
            quick ? 1 : tests[i].repeats);

        if (result.encode_time < 0) {
            printf(NA_FORMAT, result.backend, result.chunk_size);
        } else {
            printf(RESULT_FORMAT,
                result.backend,
                result.chunk_size,
                result.total_size / result.encode_time / (1 << 20),
                result.total_size / result.decode_time / (1 << 20));
        }
    }
    return 0;
}

makefile

CFLAGS = -Werror -Wall -g

CFLAGS += `pkg-config --cflags erasurecode-1`
LDFLAGS += `pkg-config --libs erasurecode-1`

libec-test: libec-test.c
	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)

.PHONY: benchmark valgrind clean

benchmark: libec-test
	./libec-test
valgrind: libec-test
	valgrind --leak-check=full ./libec-test quick
clean:
	rm -f libec-test