mmap-based paging based solutions which seem pretty fast actually - funny enough

main.cpp

@@ -4,13 +4,15 @@
 #include<cstdint>
 #include<chrono>
 #include<vector>
+#include<stdlib.h>
 #include"TurboList.hpp"
 #include"turbolist.h"
-#include<stdlib.h>
+#include"arena.h"
 
 // #define PRINT_DBG
 // #define N 65535
-#define N 65535000
+// #define N 65535000
+#define N 65535*100
 
 static inline size_t ms_now() noexcept {
 	auto now = std::chrono::system_clock::now();
@@ -28,21 +30,59 @@ int main() {
 
 	// std::vector //
 
-	std::vector<int> vec;
+	{
 		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 //
 
-	TurboList<int> list;
+	{
-
 		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);
@@ -51,13 +91,14 @@ int main() {
 		for(int i = 0; i < list.size(); ++i) {
 			printf("%d\n", list[i]);
 		}
-#endif /* PRINT_DBG */
+#endif // PRINT_DBG
+	}
 
 	// C turbolist //
 
-	turbolist clist = turbolist_create();
+	/*
-
 	auto before_cturbolist = ms_now();
+	turbolist clist = turbolist_create();
 	for(int i = 0; i < N; ++i) {
 		turbolist_insert(&clist, i);
 	}
@@ -68,6 +109,89 @@ int main() {
 	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*) alloc(&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);
+
+#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*)alloc(&a, sizeof(int), sizeof(int), 1)) + 1;
+	for(int i = 0; i < N; ++i) {
+		int *value = (int*)alloc(&a, sizeof(int), sizeof(int), 1);
+		*value = i;
+
+		value = (int*)alloc(&a1, sizeof(int), sizeof(int), 1);
+		*value = i;
+		value = (int*)alloc(&a2, sizeof(int), sizeof(int), 1);
+		*value = i;
+		value = (int*)alloc(&a3, sizeof(int), sizeof(int), 1);
+		*value = i;
+		value = (int*)alloc(&a4, sizeof(int), sizeof(int), 1);
+		*value = i;
+		value = (int*)alloc(&a5, sizeof(int), sizeof(int), 1);
+		*value = i;
+		value = (int*)alloc(&a6, sizeof(int), sizeof(int), 1);
+		*value = i;
+		value = (int*)alloc(&a7, sizeof(int), sizeof(int), 1);
+		*value = i;
+		value = (int*)alloc(&a8, sizeof(int), sizeof(int), 1);
+		*value = i;
+		value = (int*)alloc(&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;

turbolist.h

@@ -42,7 +42,7 @@ static TL_NOINLINE void __turbolist_grow_and_insert(turbolist *tl, int elem) {
 		turbolist_insert(tl, elem);
 }
 
-static inline turbolist turbolist_create_adv(void* (*malloc_like)(size_t size), void (*free_like)(void*), uint32_t initial_size = 0, uint32_t initial_cap = 16) {
+static inline turbolist turbolist_create_adv(void* (*malloc_like)(size_t size), void (*free_like)(void*), uint32_t initial_size, uint32_t initial_cap) {
 	assert(initial_size <= initial_cap);
 
 	turbolist tl;
@@ -57,8 +57,8 @@ static inline turbolist turbolist_create_adv(void* (*malloc_like)(size_t size),
 }
 
 #ifndef NO_CSTDLIB
-static inline turbolist turbolist_create(uint32_t initial_size = 0, uint32_t initial_cap = 16) {
+static inline turbolist turbolist_create() {
-	return turbolist_create_adv(malloc, free, initial_size, initial_cap);
+	return turbolist_create_adv(malloc, free, 0, 16);
 }
 #endif /* NO_CSTDLIB */