prenex/turbolist
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

malloclike and freelike in C and C++ both working

Browse Source
This commit is contained in:
masterexplorer 2024-08-27 17:37:31 +02:00
parent 1426a742dc
commit edcf43202d
3 changed files with 26 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
TurboList.hpp
View File

@ -1,6 +1,5 @@
#ifndef TURBO_LIST_HPP #ifndef TURBO_LIST_HPP
#define TURBO_LIST_HPP #define TURBO_LIST_HPP
// TODO: malloclike and freelike refactor
#include<cstdint> #include<cstdint>
#include<cstdlib> #include<cstdlib>
@ -17,7 +16,10 @@
#define TL_UNLIKELY(x) __builtin_expect(!!(x), 0) #define TL_UNLIKELY(x) __builtin_expect(!!(x), 0)
#endif /* TL_UNLIKELY */ #endif /* TL_UNLIKELY */
template<typename T> typedef void*(MallocLike)(size_t);
typedef void(FreeLike)(void*);
template<typename T, MallocLike MALLOC = malloc, FreeLike FREE = free>
class TurboList { class TurboList {
T *old; T *old;
T *nex; T *nex;
@ -29,11 +31,11 @@ class TurboList {
TL_NOINLINE void grow_and_insert(T elem) noexcept { TL_NOINLINE void grow_and_insert(T elem) noexcept {
// assert(mid == 0); // assert(mid == 0);
if(old) free(old); if(old) FREE(old);
old = nex; old = nex;
mid = end; mid = end;
capacity *= 2; capacity *= 2;
nex = (int *) malloc(this->capacity * sizeof(T)); nex = (int *) MALLOC(this->capacity * sizeof(T));
// Will go into the INSERT code path here // Will go into the INSERT code path here
insert(elem); insert(elem);
@ -46,12 +48,12 @@ public:
end(initial_size), end(initial_size),
capacity(initial_cap) { capacity(initial_cap) {
nex = (int *) malloc(this->capacity * sizeof(T)); nex = (int *) MALLOC(this->capacity * sizeof(T));
} }
inline ~TurboList() noexcept { inline ~TurboList() noexcept {
if(nex) free(nex); if(nex) FREE(nex);
if(old) free(old); if(old) FREE(old);
} }
inline T& operator[](uint32_t i) noexcept { inline T& operator[](uint32_t i) noexcept {

1
main.cpp
View File

@ -6,6 +6,7 @@
#include<vector> #include<vector>
#include"TurboList.hpp" #include"TurboList.hpp"
#include"turbolist.h" #include"turbolist.h"
#include<stdlib.h>
// #define PRINT_DBG // #define PRINT_DBG
// #define N 65535 // #define N 65535

24
turbolist.h
View File

@ -1,9 +1,7 @@
#ifndef TURBO_LIST_H #ifndef TURBO_LIST_H
#define TURBO_LIST_H #define TURBO_LIST_H
// TODO: malloclike and freelike refactor
#include<stdint.h> #include<stdint.h>
#include<stdlib.h>
#include<assert.h> #include<assert.h>
#ifndef TL_NOINLINE #ifndef TL_NOINLINE
@ -25,6 +23,8 @@ struct turbolist{
uint32_t end; // non-inclusive e . . . . uint32_t end; // non-inclusive e . . . .
uint32_t capacity; uint32_t capacity;
void* (*malloc)(size_t size);
void (*free)(void*);
}; };
typedef struct turbolist turbolist; typedef struct turbolist turbolist;
@ -32,17 +32,17 @@ static inline void turbolist_insert(turbolist *tl, int elem);
static TL_NOINLINE void __turbolist_grow_and_insert(turbolist *tl, int elem) { static TL_NOINLINE void __turbolist_grow_and_insert(turbolist *tl, int elem) {
// assert(mid == 0); // assert(mid == 0);
if(tl->old) free(tl->old); if(tl->old) tl->free(tl->old);
tl->old = tl->nex; tl->old = tl->nex;
tl->mid = tl->end; tl->mid = tl->end;
tl->capacity *= 2; tl->capacity *= 2;
tl->nex = (int *) malloc(tl->capacity * sizeof(int)); tl->nex = (int *) tl->malloc(tl->capacity * sizeof(int));
// Will go into the INSERT code path here // Will go into the INSERT code path here
turbolist_insert(tl, elem); turbolist_insert(tl, elem);
} }
static inline turbolist turbolist_create(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 = 0, uint32_t initial_cap = 16) {
assert(initial_size <= initial_cap); assert(initial_size <= initial_cap);
turbolist tl; turbolist tl;
@ -50,13 +50,21 @@ static inline turbolist turbolist_create(uint32_t initial_size = 0, uint32_t ini
tl.mid = 0; tl.mid = 0;
tl.end = initial_size; tl.end = initial_size;
tl.capacity = initial_cap; tl.capacity = initial_cap;
tl.nex = (int *) malloc(tl.capacity * sizeof(int)); tl.malloc = malloc_like;
tl.free = free_like;
tl.nex = (int *) tl.malloc(tl.capacity * sizeof(int));
return tl; return tl;
} }
#ifndef NO_CSTDLIB
static inline turbolist turbolist_create(uint32_t initial_size = 0, uint32_t initial_cap = 16) {
return turbolist_create_adv(malloc, free, initial_size, initial_cap);
}
#endif /* NO_CSTDLIB */
static inline void turbolist_delete(turbolist *tl) { static inline void turbolist_delete(turbolist *tl) {
if(tl->nex) free(tl->nex); if(tl->nex) tl->free(tl->nex);
if(tl->old) free(tl->old); if(tl->old) tl->free(tl->old);
} }
static inline int turbolist_get(turbolist *tl, uint32_t i) { static inline int turbolist_get(turbolist *tl, uint32_t i) {