vector vs dynamic array benchmarks - what is the bottleneck?

Question

It's encouraged to use STL over dynamic arrays but I'm curious what could be the bottleneck? MAX_PACKET_LENGTH is 32768.

---------------------------------------------------------------------------
Benchmark                                    Time           CPU Iterations
---------------------------------------------------------------------------
BM_VectorInit                             1335 ns       1193 ns     497778
BM_RawInit                                  58 ns         55 ns   10000000


static void BM_VectorInit(benchmark::State &state)
{
    for (auto _ : state) 
    {
        std::vector<char> a(MAX_PACKET_LENGTH);
    }
}

static void BM_RawInit(benchmark::State &state)
{
    for (auto _ : state) 
    {
        auto a = new char[MAX_PACKET_LENGTH];
        delete[] a;
    }
}

Answer 1

First, as @juanchopanza suggests - we can't reproduce your figures if you don't provide a proper test program; you've just given us two functions which do nothing and won't result in anything in the binary.

Anyway, it seems the overhead is due to std::vector zero-initializing the char values.

If you want to avoid that happening, or just to level the playing field for benchmarking, use a struct which wraps a char and doesn't initialize it as the vector element type, and run your tests again. I wouldn't recommend actually using such a silly struct in production code though - use the types you actually need.

And speaking of using what you need - it's perfectly ok to use:

auto buffer_ptr = std::make_unique<char[]>(MAX_PACKET_LENGTH);

and then maybe:

auto buffer = std::span<char>(raw_buffer.get(), MAX_PACKET_LENGTH);

and you can use spans almost everywhere you can use std::vectors. (Note, though, that std::span is only coming in C++20 and for now you'll need a GSL implementation).

Answer 2

You are comparing the cost of constructing a std::vector with the cost of allocating an array on the heap. When you create a std::vector, it internally allocates an array on the heap, but there is additional overhead since the std::vector is itself an object that needs to be constructed and stored (possibly on the stack or on the heap). Therefore, it should take longer to create a std::vector than it takes to create a new char[].

That being said, there is another difference between BM_RawInit and BM_VectorInit. When you construct a std::vector with one integer argument, as in std::vector<char> a(MAX_PACKET_LENGTH), two things happen. Space will be allocated on the heap for MAX_PACKET_LENGTH items and those items will also be default constructed. On the other hand, when you do new char[MAX_PACKET_LENGTH], only allocation occurs.

For a better comparison, try to create a third benchmark that only allocates space, like this:

static void BM_VectorReserve(benchmark::State &state)
{
    for (auto _ : state) 
    {
        std::vector<char> a;
        a.reserve(MAX_PACKET_LENGTH);
    }
}

This isn't a perfect comparison, though, because a small amount of memory will be allocated on the first line where we declare a, and then when we call reserve, that initial memory will be released. After that, the std::vector will allocate enough space for MAX_PACKET_LENGTH items. In real code, this is often negligible, but for the sake of your benchmark, it would partially explain why BM_VectorReserve takes longer than BM_RawInit.