package core:mem/tlsf

Source

Allocator :: struct {
	// Empty lists point at this block to indicate they are free.
	block_null:    Block_Header,
	// Bitmaps for free lists.
	fl_bitmap:     u32 `fmt:"-"`,
	sl_bitmap:     [25]u32 `fmt:"-"`,
	// Head of free lists.
	blocks:        [25][32]^Block_Header `fmt:"-"`,
	// Keep track of pools so we can deallocate them.
	// If `pool.allocator` is blank, we don't do anything.
	// We also use this linked list of pools to report
	// statistics like how much memory is still available,
	// fragmentation, etc.
	pool:          Pool,
	// If we're expected to grow when we run out of memory,
	// how much should we ask the backing allocator for?
	new_pool_size: uint,
}

Block_Header :: struct {
	prev_phys_block: ^Block_Header,
	size:            uint,
	// Next and previous free blocks.
	next_free:       ^Block_Header,
	prev_free:       ^Block_Header,
}

Error :: enum u8 {
	None                      = 0, 
	Invalid_Backing_Allocator = 1, 
	Invalid_Alignment         = 2, 
	Backing_Buffer_Too_Small  = 3, 
	Backing_Buffer_Too_Large  = 4, 
	Backing_Allocator_Error   = 5, 
}

Pool :: struct {
	data:      []u8 `fmt:"-"`,
	allocator: runtime.Allocator,
	next:      ^Pool,
}

ALIGN_SIZE: int : 1 << ALIGN_SIZE_LOG2

ALIGN_SIZE_LOG2: int : 3 when size_of(uintptr) == 8 else 2

BLOCK_HEADER_FREE :: uint(1 << 0)

BLOCK_HEADER_OVERHEAD :: uint(size_of(uint))

BLOCK_HEADER_PREV_FREE :: uint(1 << 1)

BLOCK_SIZE_MAX :: uint(1) << FL_INDEX_MAX

BLOCK_SIZE_MIN :: uint(size_of(Block_Header) - size_of(^Block_Header))

BLOCK_START_OFFSET: uintptr : offset_of(Block_Header, size) + size_of(Block_Header{}.size)

FL_INDEX_COUNT: int : FL_INDEX_MAX - FL_INDEX_SHIFT + 1

FL_INDEX_MAX: int : 32 when size_of(uintptr) == 8 else 30

FL_INDEX_SHIFT: int : TLSF_SL_INDEX_COUNT_LOG2 + ALIGN_SIZE_LOG2

INITIAL_POOL_OVERHEAD: int : 48

POOL_OVERHEAD: uint : 2 * BLOCK_HEADER_OVERHEAD

SL_INDEX_COUNT: int : 1 << TLSF_SL_INDEX_COUNT_LOG2

SMALL_BLOCK_SIZE: int : 1 << FL_INDEX_SHIFT

TLSF_SL_INDEX_COUNT_LOG2: int : #config(TLSF_SL_INDEX_COUNT_LOG2, 5)

allocator :: proc(t: ^Allocator) -> runtime.Allocator {…}

allocator_proc :: proc(
	allocator_data:  rawptr, 
	mode:            runtime.Allocator_Mode, 
	size, alignment: int, 
	old_memory:      rawptr, 
	old_size:        int, 
	location := #caller_location, 
) -> ([]u8, runtime.Allocator_Error) {…}

destroy :: proc(control: ^Allocator) {…}

estimate_pool_from_size_alignment :: proc(count: int, size: int, alignment: int) -> (pool_size: int) {…}

estimate_pool_from_typeid :: proc(count: int, type: typeid) -> (pool_size: int) {…}

ffs :: proc "contextless" (word: u32) -> (bit: i32) {…}

fls :: proc "contextless" (word: u32) -> (bit: i32) {…}

fls_uint :: proc "contextless" (size: uint) -> (bit: i32) {…}

free_with_size :: proc(control: ^Allocator, ptr: rawptr, size: uint) {…}

init_from_allocator :: proc(control: ^Allocator, backing: runtime.Allocator, initial_pool_size: int, new_pool_size: int = 0) -> Error {…}

init_from_buffer :: proc(control: ^Allocator, buf: []u8) -> Error {…}

estimate_pool_size :: proc{
	estimate_pool_from_size_alignment,
	estimate_pool_from_typeid,
}

init :: proc{
	init_from_buffer,
	init_from_allocator,
}