container_benchmark.cpp

#include <iostream>
#include <vector>
#include <array>
#include <list>
#include "C:\\Users\\rir\\etl-18.1.3\\include\\etl\\vector.h"
#include "C:\\Users\\rir\\etl-18.1.3\\include\\etl\\array.h"
#include "C:\\Users\\rir\\etl-18.1.3\\include\\etl\\list.h"
#include <benchmark/benchmark.h>

constexpr size_t CONTAINER_SIZE = 10'000;

static void etl_vector_resize(benchmark::State& state) {
    auto vector = etl::vector<int, CONTAINER_SIZE>();
    for (auto _ : state) {
        vector.resize(CONTAINER_SIZE);
        vector.resize(0);
    }
}
BENCHMARK(etl_vector_resize);

static void stl_vector_resize(benchmark::State& state) {
    auto vector = std::vector<int>();
    for (auto _ : state) {
        vector.resize(CONTAINER_SIZE);
        vector.resize(0);
    }
}
BENCHMARK(stl_vector_resize);

static void etl_push_back(benchmark::State& state) {
    auto vector = etl::vector<int, CONTAINER_SIZE>();
    for (auto _ : state) {
        for (size_t i = 0; i < CONTAINER_SIZE; ++i) {
            vector.push_back(i);
        }
    }
}

BENCHMARK(etl_push_back);

static void stl_push_back(benchmark::State& state) {
    auto vector = std::vector<int>();
    for (auto _ : state) {
        for (size_t i = 0; i < CONTAINER_SIZE; ++i) {
            vector.push_back(i);
        }
    }
}

BENCHMARK(stl_push_back);

static void etl_erase(benchmark::State& state) {
    auto vector = etl::vector<int, CONTAINER_SIZE>(CONTAINER_SIZE);
    for (auto _ : state) {
        for (size_t i = 0; i < CONTAINER_SIZE; ++i) {
            vector.erase(vector.begin());
        }
    }
}

BENCHMARK(etl_erase);

static void stl_erase(benchmark::State& state) {
    auto vector = std::vector<int>(CONTAINER_SIZE);
    for (auto _ : state) {
        for (size_t i = 0; i < CONTAINER_SIZE; ++i) {
            vector.erase(vector.begin());
        }
    }
}

BENCHMARK(stl_erase);

static void etl_reverse(benchmark::State& state) {
    auto vector = etl::vector<int, CONTAINER_SIZE>(CONTAINER_SIZE);
    for (auto _ : state) {
        etl::reverse(vector.begin(), vector.end());
    }
}

BENCHMARK(etl_reverse);

static void stl_reverse(benchmark::State& state) {
    auto vector = std::vector<int>(CONTAINER_SIZE);
    for (auto _ : state) {
        std::reverse(vector.begin(), vector.end());
    }
}

BENCHMARK(stl_reverse);

static void etl_insert(benchmark::State& state) {
    auto vector = etl::vector<int, CONTAINER_SIZE>();
    for (auto _ : state) {
        for (size_t i = 0; i < CONTAINER_SIZE; ++i) {
            auto it = vector.begin();
            vector.insert(it, 1);
        }
    }
}

BENCHMARK(etl_insert);

static void stl_insert(benchmark::State& state) {
    auto vector = std::vector<int>();
    for (auto _ : state) {
        for (size_t i = 0; i < CONTAINER_SIZE; ++i) {
            auto it = vector.begin();
            vector.insert(it, 1);
        }
    }
}

BENCHMARK(stl_insert);

static void etl_array_access(benchmark::State& state) {
    auto array = etl::array<int, CONTAINER_SIZE>();
    for (auto _ : state) {
        for (size_t i = 0; i < CONTAINER_SIZE; ++i) {
            array[i] = i;
        }
    }
}

BENCHMARK(etl_array_access);

static void stl_array_access(benchmark::State& state) {
    auto array = std::array<int, CONTAINER_SIZE>();
    for (auto _ : state) {
        for (size_t i = 0; i < CONTAINER_SIZE; ++i) {
            array[i] = i;
        }
    }
}

BENCHMARK(stl_array_access);

static void etl_array_swap(benchmark::State& state) {
    auto array = etl::array<int, CONTAINER_SIZE>();
    auto other = etl::array<int, CONTAINER_SIZE>();
    for (auto _ : state) {
        array.swap(other);
    }
}

BENCHMARK(etl_array_swap);

static void stl_array_swap(benchmark::State& state) {
    auto array = std::array<int, CONTAINER_SIZE>();
    auto other = std::array<int, CONTAINER_SIZE>();
    for (auto _ : state) {
        array.swap(other);
    }
}

BENCHMARK(stl_array_swap);

BENCHMARK_MAIN();