std::vector<bool> performance penalty tester

#include <iostream>
#include <vector>
#include <chrono>
#include <cstdint>

template<typename T>
struct Pattern {
    static constexpr T value[] = {1, 1, 1, 0, 1, 0, 0, 0, 1};
};
template<class T> constexpr T Pattern<T>::value[];

static size_t const PN = std::size(Pattern<int>::value);
static size_t const REPEAT_COUNT = 50 * 1000 * 1000;

static int64_t now()
{
    using namespace std;
    using namespace chrono;
    return duration_cast< milliseconds >(system_clock::now().time_since_epoch()).count();
}

template <typename T>
inline void doNotOptimizeAway(T&& datum) {
    asm volatile ("" : "+r" (datum));
}

template<typename T>
void test(char const *tName)
{
    using namespace std;

    vector<T> vec;
    vec.resize(PN * REPEAT_COUNT);
    vector<T> vec2;
    vec2.resize(PN * REPEAT_COUNT);

    int64_t t0 = now();

    size_t pos = 0;
    for(size_t i=0; i<REPEAT_COUNT; ++i){
        for(int val: Pattern<T>::value) {
            vec[pos++] = val;
        }
    }

    int64_t t1 = now();

//  for(T val: vec)
//      doNotOptimizeAway(val);
    size_t n = vec.size();
    for(size_t i=0; i!=n; ++i)
        vec2[i] = vec[i];

    int64_t t2 = now();

    std::cout << tName << ":"
        " write " << (t1-t0) << " ms;"
        " read+write " << (t2-t1) << " ms."
        " ==> read: " << ((t2-t1)-(t1-t0)) << std::endl;
    return;
}

int main()
{
    size_t const TEST_REP = 5;

    std::cout << "sizeof(int) == " << sizeof(int) << std::endl;
    for(size_t i=0; i<TEST_REP; ++i)
        test<int>("int");

    std::cout << "sizeof(bool) == " << sizeof(bool) << std::endl;
    for(size_t i=0; i<TEST_REP; ++i)
        test<bool>("bool");

    std::cout << "sizeof(char) == " << sizeof(char) << std::endl;
    for(size_t i=0; i<TEST_REP; ++i)
        test<char>("char");

    std::cout << "sizeof(int_fast8_t) == " << sizeof(int_fast8_t) << std::endl;
    for(size_t i=0; i<TEST_REP; ++i)
        test<int_fast8_t>("int_fast8_t");

    std::cout << "sizeof(uint_fast8_t) == " << sizeof(uint_fast8_t) << std::endl;
    for(size_t i=0; i<TEST_REP; ++i)
        test<uint_fast8_t>("uint_fast8_t");

    return 0;
}

// https://not-in-list.blogspot.com/2024/04/stdvector-perormance-penalty.html