gistfile1.txt

#include <iostream>
#include <etl/algorithm.h>
#include <chrono>
#include <random>
#include <algorithm>

template<typename Clock, size_t Iterations, typename R, typename ...Args,
        typename = std::enable_if_t<std::is_same_v<typename Clock::time_point, decltype(Clock::now())>>
>
constexpr auto measure(R (&fn)(Args...), Args &&... args) {
    const auto start = Clock::now();
    for (size_t i = 0; i < Iterations; ++i) {
        fn(std::forward<Args>(args)...);
    }

    const auto end = Clock::now();
    return (end - start) / Iterations;
}

/// Converts an r-value reference to a const-qualified l-value reference
template<typename T>
constexpr const T &const_ref(T &&t) { return static_cast<const T &>(t); }

constexpr size_t N_TESTS = 14;
constexpr size_t CONTAINER_SIZE = 10000; // num elements in container
constexpr size_t REPETITIONS = 100000; // num iterations
constexpr size_t RANGE_MAX = 1000; // max value of container element

using CLOCK = std::chrono::system_clock;

template<size_t Size>
void setup(int (&array)[Size]) {
    std::mt19937_64 engine{0};
    std::uniform_int_distribution<int> distribution{0, RANGE_MAX};

    for (int &i : array) {
        i = distribution(engine);
    }
}


void print_results(CLOCK::duration (&res)[N_TESTS * 2]) {
    for (int i = 0; i < (N_TESTS * 2) - 1; i += 2) {
        //printf("%ll, %ll", res[i].count(), res[i + 1].count());
        std::cout << res[i].count() << ", " << res[i + 1].count() << "\n";
    }
}

void measure_algorithms() {
    CLOCK::duration results[N_TESTS * 2];

    int array[CONTAINER_SIZE];
    int copy[CONTAINER_SIZE];

    setup(array);
    setup(copy);

    int i = 0;

    results[i++] = measure<CLOCK, REPETITIONS, ptrdiff_t>(
            etl::count,
            etl::begin(array),
            etl::end(array),
            const_ref(1)
    );

    results[i++] = measure<CLOCK, REPETITIONS, ptrdiff_t>(
            std::count,
            std::begin(array),
            std::end(array),
            const_ref(1)
    );

    results[i++] = measure<CLOCK, REPETITIONS, ptrdiff_t>(
            etl::count_if,
            etl::begin(array),
            etl::end(array),
            [](auto i) { return i % 2 == 0; }
    );

    results[i++] = measure<CLOCK, REPETITIONS, ptrdiff_t>(
            std::count_if,
            std::begin(array),
            std::end(array),
            [](auto i) { return i % 2 == 0; }
    );

    results[i++] = measure<CLOCK, REPETITIONS>(
            etl::copy<decltype(etl::begin(array)), decltype(etl::begin(copy))>,
            etl::begin(array),
            etl::end(array),
            etl::begin(array)
    );

    results[i++] = measure<CLOCK, REPETITIONS>(
            std::copy<decltype(std::begin(array)), decltype(std::begin(copy))>,
            std::begin(array),
            std::end(array),
            std::begin(array)
    );

    results[i++] = measure<CLOCK, REPETITIONS, int *>(
            etl::copy_if,
            etl::begin(array),
            etl::end(array),
            etl::begin(array),
            [](auto i) { return i % 2 == 0; }
    );

    results[i++] = measure<CLOCK, REPETITIONS, int *>(
            std::copy_if,
            std::begin(array),
            std::end(array),
            std::begin(array),
            [](auto i) { return i % 2 == 0; }
    );

    results[i++] = measure<CLOCK, REPETITIONS>(
            etl::find<decltype(etl::begin(array)), int>,
            etl::begin(array),
            etl::end(array),
            const_ref((int) RANGE_MAX + 1)
    );

    results[i++] = measure<CLOCK, REPETITIONS>(
            std::find<decltype(std::begin(array)), int>,
            std::begin(array),
            std::end(array),
            const_ref((int) RANGE_MAX + 1)
    );

    results[i++] = measure<CLOCK, REPETITIONS, int *>(
            etl::find_if,
            etl::begin(array),
            etl::end(array),
            [](auto i) { return i % 2 == 0; }
    );

    results[i++] = measure<CLOCK, REPETITIONS, int *>(
            std::find_if,
            std::begin(array),
            std::end(array),
            [](auto i) { return i % 2 == 0; }
    );

    results[i++] = measure<CLOCK, REPETITIONS, bool>(
            etl::equal,
            etl::begin(array),
            etl::end(array),
            etl::begin(array)
    );

    results[i++] = measure<CLOCK, REPETITIONS, bool>(
            std::equal,
            std::begin(array),
            std::end(array),
            std::begin(array)
    );

    setup(array);

    results[i++] = measure<CLOCK, REPETITIONS>(
            etl::fill<decltype(etl::begin(array)), int>,
            etl::begin(array),
            etl::end(array),
            const_ref(1)
    );

    setup(array);

    results[i++] = measure<CLOCK, REPETITIONS>(
            std::fill<decltype(std::begin(array)), int>,
            std::begin(array),
            std::end(array),
            const_ref(1)
    );

    setup(array);

    results[i++] = measure<CLOCK, REPETITIONS>(
            etl::fill_n<decltype(etl::begin(array)), size_t, int>,
            etl::begin(array),
            (size_t) CONTAINER_SIZE,
            const_ref(1)
    );

    setup(array);

    results[i++] = measure<CLOCK, REPETITIONS>(
            std::fill_n<decltype(std::begin(array)), const size_t &, int>,
            std::begin(array),
            CONTAINER_SIZE,
            const_ref(1)
    );

    setup(array);

    results[i++] = measure<CLOCK, REPETITIONS, int *>(
            etl::transform,
            etl::begin(array),
            etl::end(array),
            etl::begin(copy),
            [](int i) { return i + 1; }
    );

    results[i++] = measure<CLOCK, REPETITIONS, int *>(
            std::transform,
            std::begin(array),
            std::end(array),
            std::begin(copy),
            [](int i) { return i + 1; }
    );

    results[i++] = measure<CLOCK, REPETITIONS>(
            etl::swap<int, CONTAINER_SIZE>,
            array,
            copy
    );

    results[i++] = measure<CLOCK, REPETITIONS>(
            std::swap<int, CONTAINER_SIZE>,
            array,
            copy
    );

    results[i++] = measure<CLOCK, REPETITIONS>(
            etl::iter_swap<decltype(etl::begin(array)), decltype(etl::end(array))>,
            etl::begin(array),
            etl::end(array)
    );

    results[i++] = measure<CLOCK, REPETITIONS>(
            std::iter_swap<decltype(std::begin(array)), decltype(std::end(array))>,
            std::begin(array),
            std::end(array)
    );

    results[i++] = measure<CLOCK, REPETITIONS>(
            etl::swap_ranges<decltype(etl::begin(array)), decltype(etl::end(array))>,
            etl::begin(array),
            etl::end(array),
            etl::begin(copy)
    );

    results[i++] = measure<CLOCK, REPETITIONS>(
            std::swap_ranges<decltype(std::begin(array)), decltype(std::end(array))>,
            std::begin(array),
            std::end(array),
            std::begin(copy)
    );

    results[i++] = measure<CLOCK, REPETITIONS>(
            etl::rotate<decltype(etl::begin(array))>,
            etl::begin(array),
            etl::begin(array) + 1,
            etl::end(array)
    );

    results[i++] = measure<CLOCK, REPETITIONS>(
            std::rotate<decltype(std::begin(array))>,
            std::begin(array),
            etl::begin(array) + 1,
            std::end(array)
    );

    print_results(results);
}

int main() {
    measure_algorithms();
}