package core:mem/virtual

Source

Allocator_Error :: runtime.Allocator_Error

Arena :: struct {
	kind:               Arena_Kind,
	curr_block:         ^Memory_Block,
	total_used:         uint,
	total_reserved:     uint,
	minimum_block_size: uint,
	temp_count:         uint,
	mutex:              sync.Mutex,
}

Arena_Kind :: enum uint {
	Growing = 0, // Chained memory blocks (singly linked list).
	Static  = 1, // Fixed reservation sized.
	Buffer  = 2, // Uses a fixed sized buffer.
}

Arena_Temp :: struct {
	arena: ^Arena,
	block: ^Memory_Block,
	used:  uint,
}

Memory_Block :: struct {
	prev:      ^Memory_Block,
	base:      [^]u8,
	used:      uint,
	committed: uint,
	reserved:  uint,
}

Memory_Block_Flag :: enum u32 {
	Overflow_Protection, 
}

Memory_Block_Flags :: distinct bit_set[Memory_Block_Flag; u32]

Protect_Flag :: enum u32 {
	Read, 
	Write, 
	Execute, 
}

Protect_Flags :: distinct bit_set[Protect_Flag; u32]

DEFAULT_ARENA_GROWING_MINIMUM_BLOCK_SIZE :: DEFAULT_ARENA_STATIC_COMMIT_SIZE

DEFAULT_ARENA_STATIC_COMMIT_SIZE :: mem.Megabyte

DEFAULT_ARENA_STATIC_RESERVE_SIZE :: mem.Gigabyte when size_of(uintptr) == 8 else 128 * mem.Megabyte

Protect_No_Access :: Protect_Flags{}

DEFAULT_PAGE_SIZE: uint = …

alloc_from_memory_block :: proc(block: ^Memory_Block, min_size, alignment: uint) -> (data: []u8, err: runtime.Allocator_Error) {…}

arena_alloc :: proc(arena: ^Arena, size: uint, alignment: uint, loc := #caller_location) -> (data: []u8, err: runtime.Allocator_Error) {…}

arena_allocator :: proc(arena: ^Arena) -> runtime.Allocator {…}

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

arena_check_temp :: proc(arena: ^Arena, loc := #caller_location) {…}

arena_destroy :: proc(arena: ^Arena, loc := #caller_location) {…}

arena_free_all :: proc(arena: ^Arena, loc := #caller_location) {…}

arena_growing_bootstrap_new_by_name :: proc($T: typeid, $field_name: string = , minimum_block_size: uint = DEFAULT_ARENA_GROWING_MINIMUM_BLOCK_SIZE) -> (ptr: ^typeid, err: runtime.Allocator_Error) {…}

arena_growing_bootstrap_new_by_offset :: proc($T: typeid, offset_to_arena: uintptr, minimum_block_size: uint = DEFAULT_ARENA_GROWING_MINIMUM_BLOCK_SIZE) -> (ptr: ^typeid, err: runtime.Allocator_Error) {…}

arena_growing_free_last_memory_block :: proc(arena: ^Arena, loc := #caller_location) {…}

arena_init_buffer :: proc(arena: ^Arena, buffer: []u8) -> (err: runtime.Allocator_Error) {…}

arena_init_growing :: proc(arena: ^Arena, reserved: uint = DEFAULT_ARENA_GROWING_MINIMUM_BLOCK_SIZE) -> (err: runtime.Allocator_Error) {…}

arena_init_static :: proc(arena: ^Arena, reserved: uint, commit_size: uint = DEFAULT_ARENA_STATIC_COMMIT_SIZE) -> (err: runtime.Allocator_Error) {…}

arena_static_bootstrap_new_by_name :: proc($T: typeid, $field_name: string = , reserved: uint) -> (ptr: ^typeid, err: runtime.Allocator_Error) {…}

arena_static_bootstrap_new_by_offset :: proc($T: typeid, offset_to_arena: uintptr, reserved: uint) -> (ptr: ^typeid, err: runtime.Allocator_Error) {…}

arena_static_reset_to :: proc(arena: ^Arena, pos: uint, loc := #caller_location) -> bool {…}

arena_temp_begin :: proc(arena: ^Arena, loc := #caller_location) -> (temp: Arena_Temp) {…}

arena_temp_end :: proc(temp: Arena_Temp, loc := #caller_location) {…}

arena_temp_ignore :: proc(temp: Arena_Temp, loc := #caller_location) {…}

commit :: proc "contextless" (data: rawptr, size: uint) -> runtime.Allocator_Error {…}

decommit :: proc "contextless" (data: rawptr, size: uint) {…}

memory_block_alloc :: proc(committed, reserved: uint, flags: Memory_Block_Flags) -> (block: ^Memory_Block, err: runtime.Allocator_Error) {…}

memory_block_dealloc :: proc(block_to_free: ^Memory_Block) {…}

protect :: proc "contextless" (data: rawptr, size: uint, flags: Protect_Flags) -> bool {…}

release :: proc "contextless" (data: rawptr, size: uint) {…}

reserve :: proc "contextless" (size: uint) -> (data: []u8, err: runtime.Allocator_Error) {…}

reserve_and_commit :: proc "contextless" (size: uint) -> (data: []u8, err: runtime.Allocator_Error) {…}

arena_growing_bootstrap_new :: proc{
	arena_growing_bootstrap_new_by_offset,
	arena_growing_bootstrap_new_by_name,
}

arena_static_bootstrap_new :: proc{
	arena_static_bootstrap_new_by_offset,
	arena_static_bootstrap_new_by_name,
}