#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