turbolist/main.cpp

// g++ main.cpp -o main

#include<cstdio>
#include<cstdint>
#include<chrono>
#include<vector>
#include<stdlib.h>
#include"TurboList.hpp"

#define TLT int
#include "turbolist.h"

#include"arena.h/arena.h"

// #define PRINT_DBG
// #define N 65535
// #define N 65535000
#define N 65535*100

static inline size_t ms_now() noexcept {
	auto now = std::chrono::system_clock::now();
	auto dur = now.time_since_epoch();
	auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(dur).count();
	return ms;
}

static inline void printt(const char *prefix, size_t before, size_t after) noexcept {
	printf("%s ", prefix);
	printf("took %zd ms\n", (after - before));
}

int main() {

	// std::vector //

	{
		auto before_vector = ms_now();
		std::vector<int> vec;
		/*
		std::vector<int> vec1;
		std::vector<int> vec2;
		std::vector<int> vec3;
		std::vector<int> vec4;
		std::vector<int> vec5;
		std::vector<int> vec6;
		std::vector<int> vec7;
		std::vector<int> vec8;
		std::vector<int> vec9;
		*/
		for(int i = 0; i < N; ++i) {
			vec.push_back(i);
			/*
			vec1.push_back(i);
			vec2.push_back(i);
			vec3.push_back(i);
			vec4.push_back(i);
			vec5.push_back(i);
			vec6.push_back(i);
			vec7.push_back(i);
			vec8.push_back(i);
			vec9.push_back(i);
			*/
		}
		auto after_vector = ms_now();
		printt("vector", before_vector, after_vector);
	}

	// TurboList //

	{
		auto before_TurboList = ms_now();
		TurboList<int> list;
		/*
		TurboList<int> list1;
		TurboList<int> list2;
		TurboList<int> list3;
		TurboList<int> list4;
		TurboList<int> list5;
		TurboList<int> list6;
		TurboList<int> list7;
		TurboList<int> list8;
		TurboList<int> list9;
		*/
		for(int i = 0; i < N; ++i) {
			list.insert(i);
			/*
			list1.insert(i);
			list2.insert(i);
			list3.insert(i);
			list4.insert(i);
			list5.insert(i);
			list6.insert(i);
			list7.insert(i);
			list8.insert(i);
			list9.insert(i);
			*/
		}
		auto after_TurboList = ms_now();
		printt("TurboList", before_TurboList, after_TurboList);
		assert(list.size() == N);

#ifdef PRINT_DBG
		for(int i = 0; i < list.size(); ++i) {
			printf("%d\n", list[i]);
		}
#endif // PRINT_DBG
	}

	// C turbolist //

	auto before_cturbolist = ms_now();
	turbolist clist = turbolist_create();
	for(int i = 0; i < N; ++i) {
		turbolist_insert(&clist, i);
	}
	auto after_cturbolist = ms_now();
	printt("C turbolist", before_cturbolist, after_cturbolist);
	assert(turbolist_size(&clist) == N);

#ifdef PRINT_DBG
	for(int i = 0; i < turbolist_size(clist); ++i) {
		printf("%d\n", turbolist_get(clist, i));
	}
#endif // PRINT_DBG

	turbolist_delete(&clist);

	// C arena turbolist //

	{
		auto before_carenaturbolist = ms_now();
		turbolist clist = turbolist_create_adv(
			// malloc-like
			[](size_t size) {
				static thread_local arena a = newarena((ptrdiff_t)1 << 33);
				return (void*) aralloc(&a, sizeof(uint8_t), sizeof(uint8_t), size);
			},
			// free-like
			[](void *ptr) {},
			// initial size
			0,
			// initial cap
			16
		);
		for(int i = 0; i < N; ++i) {
			turbolist_insert(&clist, i);
		}
		auto after_carenaturbolist = ms_now();
		printt("C arena turbolist", before_carenaturbolist, after_carenaturbolist);
		assert(turbolist_size(&clist) == N);

#ifdef PRINT_DBG
		for(int i = 0; i < turbolist_size(clist); ++i) {
			printf("%d\n", turbolist_get(clist, i));
		}
#endif // PRINT_DBG

		turbolist_delete(&clist);
	}

	// C ARENA //

	auto before_arena = ms_now();
	arena a = newarena((ptrdiff_t)1 << 33);
	/*
	arena a1 = newarena((ptrdiff_t)1 << 33);
	arena a2 = newarena((ptrdiff_t)1 << 33);
	arena a3 = newarena((ptrdiff_t)1 << 33);
	arena a4 = newarena((ptrdiff_t)1 << 33);
	arena a5 = newarena((ptrdiff_t)1 << 33);
	arena a6 = newarena((ptrdiff_t)1 << 33);
	arena a7 = newarena((ptrdiff_t)1 << 33);
	arena a8 = newarena((ptrdiff_t)1 << 33);
	arena a9 = newarena((ptrdiff_t)1 << 33);
	*/
	// steps at first real elem, there should be N from here!
	int *arenalist = ((int *)aralloc(&a, sizeof(int), sizeof(int), 1)) + 1;
	for(int i = 0; i < N; ++i) {
		int *value = (int *)aralloc(&a, sizeof(int), sizeof(int), 1);
		*value = i;

		/*
		value = (int*)aralloc(&a1, sizeof(int), sizeof(int), 1);
		*value = i;
		value = (int*)aralloc(&a2, sizeof(int), sizeof(int), 1);
		*value = i;
		value = (int*)aralloc(&a3, sizeof(int), sizeof(int), 1);
		*value = i;
		value = (int*)aralloc(&a4, sizeof(int), sizeof(int), 1);
		*value = i;
		value = (int*)aralloc(&a5, sizeof(int), sizeof(int), 1);
		*value = i;
		value = (int*)aralloc(&a6, sizeof(int), sizeof(int), 1);
		*value = i;
		value = (int*)aralloc(&a7, sizeof(int), sizeof(int), 1);
		*value = i;
		value = (int*)aralloc(&a8, sizeof(int), sizeof(int), 1);
		*value = i;
		value = (int*)aralloc(&a9, sizeof(int), sizeof(int), 1);
		*value = i;
		*/
	}
	auto after_arena = ms_now();
	printt("C arena", before_arena, after_arena);

#ifdef PRINT_DBG
	// Rem.: You can collect up size on insertion if needed...
	for(int i = 0; i < N; ++i) {
		printf("%d\n", arenalist[i]);
	}
#endif /* PRINT_DBG */

	return 0;
}