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,
	default_commit_size: uint,
	// commit size <= reservation size
	minimum_block_size:  uint,
	// block size == total reservation
	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,
}

Map_File_Error :: enum int {
	None, 
	Open_Failure, 
	Stat_Failure, 
	Negative_Size, 
	Too_Large_Size, 
	Map_Failure, 
}

Map_File_Flag :: enum u32 {
	Read, 
	Write, 
}

Map_File_Flags :: distinct bit_set[Map_File_Flag; u32]

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_COMMIT_SIZE :: 8 * mem.Megabyte

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, default_commit_size: uint = 0) -> (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 = DEFAULT_ARENA_STATIC_RESERVE_SIZE, 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) {…}

make_aligned :: proc(arena: ^Arena, $T: typeid/[]T, #any_int len: int, alignment: uint, loc := #caller_location) -> (T, runtime.Allocator_Error) {…}

make_multi_pointer :: proc(arena: ^Arena, $T: typeid/[^]T, #any_int len: int, loc := #caller_location) -> ($/[^]T, runtime.Allocator_Error) {…}

make_slice :: proc(arena: ^Arena, $T: typeid/[]T, #any_int len: int, loc := #caller_location) -> (T, runtime.Allocator_Error) {…}

map_file_from_file_descriptor :: proc(fd: uintptr, flags: Map_File_Flags) -> (data: []u8, error: Map_File_Error) {…}

map_file_from_path :: proc(filename: string, flags: Map_File_Flags) -> (data: []u8, error: Map_File_Error) {…}

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

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

new :: proc(arena: ^Arena, $T: typeid, loc := #caller_location) -> (ptr: ^typeid, err: runtime.Allocator_Error) {…}

new_aligned :: proc(arena: ^Arena, $T: typeid, alignment: uint, loc := #caller_location) -> (ptr: ^typeid, err: runtime.Allocator_Error) {…}

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,
}

make :: proc{
	make_slice,
	make_multi_pointer,
}

map_file :: proc{
	map_file_from_path,
	map_file_from_file_descriptor,
}