From 84c1716de710d2d9067c9f8a50487e3ab2d6fa42 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Sun, 20 Sep 2020 13:37:27 +0200 Subject: Possible to redefine STC memory allocator globally. --- README.md | 4 ++-- examples/inits.c | 15 +++++++-------- examples/queue.c | 4 ++-- stc/carray.h | 8 ++++---- stc/cbitset.h | 8 ++++---- stc/cdefs.h | 12 ++++++++++-- stc/clist.h | 4 ++-- stc/cmap.h | 12 ++++++------ stc/cstr.h | 12 ++++++------ stc/cvec.h | 8 ++++---- 10 files changed, 47 insertions(+), 40 deletions(-) diff --git a/README.md b/README.md index d10021ec..28fbb3f6 100644 --- a/README.md +++ b/README.md @@ -173,7 +173,7 @@ int main() { cvec_ix_pop_back(&bignums); // erase the last uint64_t value; - c_forrange (i, cvec_size(bignums)) + c_forrange (i, cvec_ix_size(bignums)) value = bignums.data[i]; cvec_ix_del(&bignums); } @@ -191,7 +191,7 @@ int main() { cvec_str_emplace_back(&names, "Joe"); cstr_assign(&names.data[1], "Jake"); // replace "Joe". // Use push_back() to add a new cstr_t object to be moved into the vector, e.g.: - cvec_str_push_back(&names, cstr_from("%d elements so far", cvec_size(names))); + cvec_str_push_back(&names, cstr_from("%d elements so far", cvec_str_size(names))); printf("%s\n", names.data[1].str); // Access the string char* c_foreach (i, cvec_str, names) diff --git a/examples/inits.c b/examples/inits.c index 14fe8a64..27ee3c9b 100644 --- a/examples/inits.c +++ b/examples/inits.c @@ -10,18 +10,17 @@ using_cmap_strkey(cnt, int); typedef struct {int x, y;} ipair_t; inline static int ipair_compare(const ipair_t* a, const ipair_t* b) { - int c = c_default_compare(&a->x, &b->x); - return c != 0 ? c : c_default_compare(&a->y, &b->y); + int cx = c_default_compare(&a->x, &b->x); + return cx == 0 ? c_default_compare(&a->y, &b->y) : cx; } + using_cvec(ip, ipair_t, c_default_del, ipair_compare); using_clist(ip, ipair_t, c_default_del, ipair_compare); - using_cvec(f, float); using_cpqueue(f, cvec_f, >); - -int main(void) { - +int main(void) +{ // CVEC FLOAT / PRIORITY QUEUE cvec_f floats = cvec_INIT; @@ -32,11 +31,11 @@ int main(void) { // CVEC PRIORITY QUEUE - cpqueue_f_build(&floats); // reorganise vec + cpqueue_f_build(&floats); // make heap c_push_items(&floats, cpqueue_f, {40.0f, 20.0f, 50.0f, 30.0f, 10.0f}); // sorted: - while (cvec_size(floats) > 0) { + while (! cpqueue_f_empty(floats)) { printf("%.1f ", *cpqueue_f_top(&floats)); cpqueue_f_pop(&floats); } diff --git a/examples/queue.c b/examples/queue.c index e4426884..c56214a7 100644 --- a/examples/queue.c +++ b/examples/queue.c @@ -14,12 +14,12 @@ int main() { cqueue_i queue = cqueue_i_init(); // Push ten million random numbers onto the queue. - c_forrange (i, int, 0, n) + c_forrange (n) cqueue_i_push(&queue, crand_uniform_i32(&rng, &dist)); // Push or pop on the queue ten million times printf("%d\n", n); - c_forrange (i, int, n, 0, -1) { + c_forrange (n) { // range uses initial n only. int r = crand_uniform_i32(&rng, &dist); if (r & 1) ++n, cqueue_i_push(&queue, r); diff --git a/stc/carray.h b/stc/carray.h index 5a525d66..4e164f42 100644 --- a/stc/carray.h +++ b/stc/carray.h @@ -87,7 +87,7 @@ STC_INLINE size_t _carray3_size(const size_t* zdim) { if (self->_xdim & _carray_OWN) { \ c_foreach_3 (i, carray##D##X, *self) \ valueDestroy(i.get); \ - free(self->data); \ + c_free(self->data); \ } \ } @@ -122,7 +122,7 @@ STC_INLINE size_t _carray3_size(const size_t* zdim) { \ STC_INLINE carray1##X \ carray1##X##_make(size_t xdim, Value val) { \ - Value* m = c_new_n(Value, xdim); \ + Value* m = c_new_2(Value, xdim); \ for (size_t i=0; i> 6) * 8), size}; + cbitset_t set = {(uint64_t *) c_malloc(((size + 63) >> 6) * 8), size}; cbitset_set_all(&set, value); return set; } @@ -101,11 +101,11 @@ STC_INLINE cstr_t cbitset_to_str(cbitset_t set) { } STC_INLINE cbitset_t cbitset_clone(cbitset_t other) { size_t bytes = ((other.size + 63) >> 6) * 8; - cbitset_t set = {(uint64_t *) memcpy(malloc(bytes), other._arr, bytes), other.size}; + cbitset_t set = {(uint64_t *) memcpy(c_malloc(bytes), other._arr, bytes), other.size}; return set; } STC_INLINE void cbitset_del(cbitset_t* self) { - free(self->_arr); + c_free(self->_arr); } STC_INLINE size_t cbitset_size(cbitset_t set) {return set.size;} @@ -170,7 +170,7 @@ STC_INLINE bool cbitset_itval(cbitset_iter_t it) { STC_API void cbitset_resize(cbitset_t* self, size_t size, bool value) { size_t new_n = (size + 63) >> 6, osize = self->size, old_n = (osize + 63) >> 6; - self->_arr = (uint64_t *) realloc(self->_arr, new_n * 8); + self->_arr = (uint64_t *) c_realloc(self->_arr, new_n * 8); self->size = size; if (new_n >= old_n) { memset(self->_arr + old_n, value ? 0xff : 0x0, (new_n - old_n) * 8); diff --git a/stc/cdefs.h b/stc/cdefs.h index ebf24738..7b06f74d 100644 --- a/stc/cdefs.h +++ b/stc/cdefs.h @@ -57,8 +57,16 @@ enum {_c_max_buffer = 512}; #define c_static_assert(cond, msg) typedef char static_assert_##msg[(cond) ? 1 : -1] #define c_container_of(ptr, type, member) \ ((type *)((char *)(ptr) - offsetof(type, member))) -#define c_new(T) ((T *) malloc(sizeof(T))) -#define c_new_n(T, n) ((T *) malloc(sizeof(T) * (n))) + +#define c_new(...) c_MACRO_OVERLOAD(c_new, __VA_ARGS__) +#define c_new_1(T) ((T *) c_malloc(sizeof(T))) +#define c_new_2(T, n) ((T *) c_malloc(sizeof(T) * (n))) +#ifndef c_malloc +#define c_malloc(sz) malloc(sz) +#define c_calloc(n, sz) calloc(n, sz) +#define c_realloc(p, sz) realloc(p, sz) +#define c_free(p) free(p) +#endif #define c_swap(T, x, y) do { T __t = x; x = y; y = __t; } while (0) #define c_no_compare(x, y) (0) #define c_mem_equals(x, y) (memcmp(x, y, sizeof(*(y))) == 0) diff --git a/stc/clist.h b/stc/clist.h index 9eb8f7b6..9aa83437 100644 --- a/stc/clist.h +++ b/stc/clist.h @@ -276,7 +276,7 @@ STC_API size_t _clist_size(const clist_void* self); node->next = next; \ if (del == next) self->last = node = NULL; \ else if (self->last == del) self->last = node, node = NULL; \ - valueDestroy(&del->value); free(del); \ + valueDestroy(&del->value); c_free(del); \ return node; \ } \ \ @@ -323,7 +323,7 @@ STC_API size_t _clist_size(const clist_void* self); #define _c_clist_insert_after(self, X, node, val) \ - clist_##X##_node_t *entry = c_new (clist_##X##_node_t), \ + clist_##X##_node_t *entry = c_new_1 (clist_##X##_node_t), \ *next = self->last ? node->next : entry; \ entry->value = val; \ entry->next = next; \ diff --git a/stc/cmap.h b/stc/cmap.h index 7dfbe58f..fa427a6e 100644 --- a/stc/cmap.h +++ b/stc/cmap.h @@ -337,8 +337,8 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t; \ STC_API void ctype##_##X##_del(ctype##_##X* self) { \ ctype##_##X##_wipe_(self); \ - free(self->_hashx); \ - free(self->table); \ + c_free(self->_hashx); \ + c_free(self->table); \ } \ \ STC_API void ctype##_##X##_clear(ctype##_##X* self) { \ @@ -398,8 +398,8 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t; if (self->size > newcap) return; \ newcap = (size_t) (newcap / self->max_load_factor) | 1; \ ctype##_##X tmp = { \ - c_new_n(ctype##_##X##_value_t, newcap), \ - (uint8_t *) calloc(newcap + 1, sizeof(uint8_t)), \ + c_new_2 (ctype##_##X##_value_t, newcap), \ + (uint8_t *) c_calloc(newcap + 1, sizeof(uint8_t)), \ self->size, (uint32_t) newcap, \ self->max_load_factor, self->shrink_limit_factor \ }; \ @@ -414,8 +414,8 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t; slot[b.idx] = *e, \ hashx[b.idx] = (uint8_t) b.hx; \ } \ - free(tmp._hashx); \ - free(tmp.table); \ + c_free(tmp._hashx); \ + c_free(tmp.table); \ } \ \ STC_API void \ diff --git a/stc/cstr.h b/stc/cstr.h index ac6d87b8..60404705 100644 --- a/stc/cstr.h +++ b/stc/cstr.h @@ -73,7 +73,7 @@ cstr_init() {return cstr_INIT;} STC_INLINE void cstr_del(cstr_t* self) { if (cstr_capacity(*self)) - free(_cstr_rep(self)); + c_free(_cstr_rep(self)); } STC_INLINE cstr_t @@ -125,7 +125,7 @@ cstr_assign(cstr_t* self, const char* str) { STC_INLINE cstr_t* cstr_take(cstr_t* self, cstr_t s) { if (self->str != s.str && cstr_capacity(*self)) - free(_cstr_rep(self)); + c_free(_cstr_rep(self)); self->str = s.str; return self; } @@ -212,7 +212,7 @@ STC_API void cstr_reserve(cstr_t* self, size_t cap) { size_t len = cstr_size(*self), oldcap = cstr_capacity(*self); if (cap > oldcap) { - size_t* rep = (size_t *) realloc(oldcap ? _cstr_rep(self) : NULL, _cstr_mem(cap)); + size_t* rep = (size_t *) c_realloc(oldcap ? _cstr_rep(self) : NULL, _cstr_mem(cap)); self->str = (char *) (rep + 2); self->str[rep[0] = len] = '\0'; rep[1] = _cstr_cap(cap); @@ -230,7 +230,7 @@ cstr_resize(cstr_t* self, size_t len, char fill) { STC_API cstr_t cstr_n(const char* str, size_t len) { if (len == 0) return cstr_INIT; - size_t *rep = (size_t *) malloc(_cstr_mem(len)); + size_t *rep = (size_t *) c_malloc(_cstr_mem(len)); cstr_t s = {(char *) memcpy(rep + 2, str, len)}; s.str[rep[0] = len] = '\0'; rep[1] = _cstr_cap(len); @@ -305,10 +305,10 @@ STC_INLINE void _cstr_internal_move(cstr_t* self, size_t pos1, size_t pos2) { STC_API void cstr_replace_n(cstr_t* self, size_t pos, size_t len, const char* str, size_t n) { char buf[_c_max_buffer]; - char* xstr = (char *) memcpy(n > _c_max_buffer ? malloc(n) : buf, str, n); + char* xstr = (char *) memcpy(n > _c_max_buffer ? c_malloc(n) : buf, str, n); _cstr_internal_move(self, pos + len, pos + n); memcpy(&self->str[pos], xstr, n); - if (n > _c_max_buffer) free(xstr); + if (n > _c_max_buffer) c_free(xstr); } STC_API void diff --git a/stc/cvec.h b/stc/cvec.h index 44387858..3754732d 100644 --- a/stc/cvec.h +++ b/stc/cvec.h @@ -210,14 +210,14 @@ STC_API void \ cvec_##X##_del(cvec_##X* self) { \ cvec_##X##_clear(self); \ - if (self->data) free(_cvec_alloced(self->data)); \ + if (self->data) c_free(_cvec_alloced(self->data)); \ } \ \ STC_API void \ cvec_##X##_reserve(cvec_##X* self, size_t cap) { \ size_t len = cvec_size(*self); \ if (cap >= len) { \ - size_t* rep = (size_t *) realloc(_cvec_alloced(self->data), 2 * sizeof(size_t) + cap * sizeof(Value)); \ + size_t* rep = (size_t *) c_realloc(_cvec_alloced(self->data), 2 * sizeof(size_t) + cap * sizeof(Value)); \ self->data = (Value *) (rep + 2); \ rep[0] = len; \ rep[1] = cap; \ @@ -243,7 +243,7 @@ enum {max_buf = _c_max_buffer / sizeof(Value) + 1}; \ Value buf[max_buf]; \ size_t len = finish - first, idx = pos - self->data, size = cvec_size(*self); \ - cvec_##X##_value_t* xbuf = (len > max_buf ? c_new_n(cvec_##X##_value_t, len) : &buf[0]); \ + cvec_##X##_value_t* xbuf = (len > max_buf ? c_new_2(cvec_##X##_value_t, len) : &buf[0]); \ for (size_t i=0; i cvec_capacity(*self)) \ @@ -252,7 +252,7 @@ memmove(pos + len, pos, (size - idx) * sizeof(Value)); \ memcpy(pos, xbuf, len * sizeof(Value)); \ _cvec_size(self) += len; \ - if (len > max_buf) free(xbuf); \ + if (len > max_buf) c_free(xbuf); \ cvec_##X##_iter_t it = {pos}; return it; \ } \ \ -- cgit v1.2.3