template.h File Reference

#include <derive-c/core/includes/def.h>
#include "includes.h"
#include <derive-c/core/alloc/def.h>
#include <derive-c/core/self/def.h>
#include <derive-c/container/vector/dynamic/template.h>
#include <derive-c/core/self/undef.h>
#include <derive-c/core/alloc/undef.h>
#include <derive-c/core/includes/undef.h>

Go to the source code of this file.

Data Structures
struct	slab_info
struct	SELF
	An allocator that prints to stdout when it allocates or frees memory. More...

Macros
#define	BLOCK_SIZE   64
	A slab allocator for fixed-size allocations with freelist tracking.
#define	SLAB_SIZE   4096
#define	SLAB_VECTOR   NS(NAME, slab_vector)
#define	ITEM   NS(NAME, slab_info)
#define	ITEM_CLONE   NS(NAME, slab_info_clone)
#define	ITEM_DELETE   NS(NAME, slab_info_delete)
#define	ITEM_DEBUG   NS(NAME, slab_info_debug)
#define	INTERNAL_NAME   SLAB_VECTOR

Functions
	DC_STATIC_ASSERT (BLOCK_SIZE > 0, "Block size must be larger than zero")
	DC_STATIC_ASSERT (SLAB_SIZE >=BLOCK_SIZE, "Slab size must be at least block size")
	DC_STATIC_ASSERT (BLOCK_SIZE >=sizeof(void *), "Block size must be at least pointer size for freelist")
static slab_info	slab_info_clone (slab_info const *self)
static void	slab_info_delete (slab_info *)
static void	slab_info_debug (slab_info const *, dc_debug_fmt, FILE *)
static DC_PUBLIC SELF	new (ref alloc_ref)
static DC_INTERNAL void PRIV	allocate_new_slab (SELF *self)
static DC_PUBLIC void *	allocate_uninit (SELF *self, size_t size)
static DC_PUBLIC void *	allocate_zeroed (SELF *self, size_t size)
static DC_PUBLIC void	deallocate (SELF *self, void *ptr, size_t size)
static DC_PUBLIC void *	reallocate (SELF *self, void *ptr, size_t old_size, size_t new_size)
static DC_PUBLIC void	reset (SELF *self)
static DC_PUBLIC void	delete (SELF *self)
static DC_PUBLIC void	debug (SELF const *self, dc_debug_fmt fmt, FILE *stream)
	DC_TRAIT_REFERENCABLE_BY_PTR (SELF)
	DC_TRAIT_ALLOC (SELF)

Macro Definition Documentation

BLOCK_SIZE

#define BLOCK_SIZE   64

A slab allocator for fixed-size allocations with freelist tracking.

Definition at line 15 of file template.h.

INTERNAL_NAME

#define INTERNAL_NAME   SLAB_VECTOR

Definition at line 49 of file template.h.

ITEM

#define ITEM   NS(NAME, slab_info)

Definition at line 45 of file template.h.

ITEM_CLONE

#define ITEM_CLONE   NS(NAME, slab_info_clone)

Definition at line 46 of file template.h.

ITEM_DEBUG

#define ITEM_DEBUG   NS(NAME, slab_info_debug)

Definition at line 48 of file template.h.

ITEM_DELETE

#define ITEM_DELETE   NS(NAME, slab_info_delete)

Definition at line 47 of file template.h.

SLAB_SIZE

#define SLAB_SIZE   4096

Definition at line 22 of file template.h.

SLAB_VECTOR

#define SLAB_VECTOR   NS(NAME, slab_vector)

Definition at line 30 of file template.h.

Function Documentation

allocate_new_slab()

DC_INTERNAL void PRIV allocate_new_slab ( SELF * self )

static

Definition at line 70 of file template.h.

                                                                      {
    DC_ASSUME(self);
 
    size_t blocks_per_slab = SLAB_SIZE / BLOCK_SIZE;
    void* slab_ptr = NS(ALLOC, allocate_uninit)(self->alloc_ref, SLAB_SIZE);
 
    NS(NAME, slab_info) info = {.ptr = slab_ptr};
    NS(SLAB_VECTOR, push)(&self->slabs, info);
 
    for (size_t i = 0; i < blocks_per_slab; i++) {
        void* block_ptr = (char*)slab_ptr + (i * BLOCK_SIZE);
        // Temporarily unpoison to write the freelist pointer
        dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_READ_WRITE,
                              block_ptr, sizeof(void*));
        *(void**)block_ptr = self->free_list_head;
        self->free_list_head = block_ptr;
        // Mark the entire block as inaccessible (NONE) - including the freelist pointer
        dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_NONE, block_ptr,
                              BLOCK_SIZE);
    }
}

allocate_uninit()

DC_PUBLIC void * allocate_uninit ( SELF * self, size_t size )

static

Definition at line 92 of file template.h.

                                                                          {
    DC_ASSUME(self);
    DC_ASSERT(size > 0, "Cannot allocate zero sized");
 
    if (size > BLOCK_SIZE) {
        return NS(ALLOC, allocate_uninit)(self->alloc_ref, size);
    }
 
    if (self->free_list_head == NULL) {
        PRIV(NS(SELF, allocate_new_slab))(self);
    }
 
    void* block = self->free_list_head;
 
    // Temporarily mark as READ_WRITE to read the freelist pointer
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_READ_WRITE, block,
                          sizeof(void*));
    void* next = *(void**)block;
    self->free_list_head = next;
 
    // Mark the allocated region as writable but uninitialized (WRITE)
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_WRITE, block, size);
    // Mark any remaining space in the block as inaccessible
    if (size < BLOCK_SIZE) {
        dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_NONE,
                              (char*)block + size, BLOCK_SIZE - size);
    }
 
    return block;
}

allocate_zeroed()

DC_PUBLIC void * allocate_zeroed ( SELF * self, size_t size )

static

Definition at line 123 of file template.h.

                                                                          {
    DC_ASSUME(self);
    DC_ASSERT(size > 0, "Cannot allocate zero sized");
 
    void* ptr = NS(SELF, allocate_uninit)(self, size);
    memset(ptr, 0, size);
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_READ_WRITE, ptr, size);
    return ptr;
}

DC_STATIC_ASSERT() [1/3]

DC_STATIC_ASSERT	(	BLOCK_SIZE	,
		0	,
		"Block size must be larger than zero"	)

DC_STATIC_ASSERT() [2/3]

DC_STATIC_ASSERT	(	BLOCK_SIZE >=	sizeofvoid *,
		"Block size must be at least pointer size for freelist"	)

DC_STATIC_ASSERT() [3/3]

DC_STATIC_ASSERT	(	SLAB_SIZE >=	BLOCK_SIZE,
		"Slab size must be at least block size"	)

DC_TRAIT_ALLOC()

DC_TRAIT_ALLOC

(

SELF

)

DC_TRAIT_REFERENCABLE_BY_PTR()

DC_TRAIT_REFERENCABLE_BY_PTR

(

SELF

)

deallocate()

DC_PUBLIC void deallocate ( SELF * self, void * ptr, size_t size )

static

Definition at line 133 of file template.h.

                                                                               {
    DC_ASSUME(self);
    DC_ASSUME(ptr);
    DC_ASSERT(size > 0, "Cannot deallocate zero sized");
 
    if (size > BLOCK_SIZE) {
        NS(ALLOC, deallocate)(self->alloc_ref, ptr, size);
        return;
    }
 
    // Temporarily unpoison to write the freelist pointer
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_READ_WRITE, ptr,
                          sizeof(void*));
    *(void**)ptr = self->free_list_head;
    self->free_list_head = ptr;
 
    // Mark the entire block as inaccessible (NONE) - including the freelist pointer
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_NONE, ptr, BLOCK_SIZE);
}

debug()

DC_PUBLIC void debug ( SELF const * self, dc_debug_fmt fmt, FILE * stream )

static

Definition at line 204 of file template.h.

                                                                                        {
    DC_ASSUME(self);
    fprintf(stream, DC_EXPAND_STRING(SELF) "@%p {\n", (void*)self);
    fmt = dc_debug_fmt_scope_begin(fmt);
 
    dc_debug_fmt_print(fmt, stream, "block_size: %zu,\n", (size_t)BLOCK_SIZE);
    dc_debug_fmt_print(fmt, stream, "slab_size: %zu,\n", (size_t)SLAB_SIZE);
    dc_debug_fmt_print(fmt, stream, "blocks_per_slab: %zu,\n", (size_t)(SLAB_SIZE / BLOCK_SIZE));
    dc_debug_fmt_print(fmt, stream, "num_slabs: %zu,\n", NS(SLAB_VECTOR, size)(&self->slabs));
 
    dc_debug_fmt_print(fmt, stream, "alloc: ");
    NS(ALLOC, debug)(NS(NS(ALLOC, ref), deref)(self->alloc_ref), fmt, stream);
    fprintf(stream, "\n");
 
    fmt = dc_debug_fmt_scope_end(fmt);
    dc_debug_fmt_print(fmt, stream, "}");
}

delete()

DC_PUBLIC void delete ( SELF * self )

static

Definition at line 197 of file template.h.

                                                   {
    DC_ASSUME(self);
 
    NS(SELF, reset)(self);
    NS(SLAB_VECTOR, delete)(&self->slabs);
}

new()

DC_PUBLIC SELF new ( ref alloc_ref )

static

Definition at line 61 of file template.h.

                                                              {
    return (SELF){
        .slabs = NS(SLAB_VECTOR, new)(alloc_ref),
        .free_list_head = NULL,
        .alloc_ref = alloc_ref,
        .derive_c_slaballoc = {},
    };
}

reallocate()

DC_PUBLIC void * reallocate ( SELF * self, void * ptr, size_t old_size, size_t new_size )

static

Definition at line 153 of file template.h.

                                                             {
    DC_ASSUME(self);
    DC_ASSUME(ptr);
    DC_ASSERT(old_size > 0, "Cannot reallocate zero sized");
    DC_ASSERT(new_size > 0, "Cannot allocate zero sized");
 
    if (old_size > BLOCK_SIZE && new_size > BLOCK_SIZE) {
        return NS(ALLOC, reallocate)(self->alloc_ref, ptr, old_size, new_size);
    }
 
    void* new_ptr = NS(SELF, allocate_uninit)(self, new_size);
 
    size_t copy_size = (old_size < new_size) ? old_size : new_size;
    memcpy(new_ptr, ptr, copy_size);
 
    if (new_size <= old_size) {
        dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_READ_WRITE,
                              new_ptr, new_size);
    } else {
        dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_READ_WRITE,
                              new_ptr, copy_size);
    }
 
    NS(SELF, deallocate)(self, ptr, old_size);
 
    return new_ptr;
}

reset()

DC_PUBLIC void reset ( SELF * self )

static

Definition at line 182 of file template.h.

                                                  {
    DC_ASSUME(self);
 
    size_t num_slabs = NS(SLAB_VECTOR, size)(&self->slabs);
    for (size_t i = 0; i < num_slabs; i++) {
        NS(NAME, slab_info) const* info = NS(SLAB_VECTOR, read)(&self->slabs, i);
        dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_WRITE, info->ptr,
                              SLAB_SIZE);
        NS(ALLOC, deallocate)(self->alloc_ref, info->ptr, SLAB_SIZE);
    }
 
    NS(SLAB_VECTOR, remove_at)(&self->slabs, 0, num_slabs);
    self->free_list_head = NULL;
}

slab_info_clone()

slab_info slab_info_clone ( slab_info const * self )

static

Definition at line 38 of file template.h.

                                                                                      {
    return *self;
}

slab_info_debug()

void slab_info_debug ( slab_info const * , dc_debug_fmt , FILE *  )

static

Definition at line 42 of file template.h.

                                               {}

slab_info_delete()

void slab_info_delete ( slab_info * )

static

Definition at line 41 of file template.h.

{}