core/mem/virtual

mem_virtual

Types

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

Source

Arena is a generalized arena allocator that supports 3 different variants.

Growing: A linked list of `Memory_Block`s allocated with virtual memory.
	Static: A single `Memory_Block` allocated with virtual memory.
	Buffer: A single `Memory_Block` created from a user provided []byte.

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

Source

import "base:sanitizer"

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

Source

An Arena_Temp is a way to produce temporary watermarks to reset an arena to a previous state. All uses of an Arena_Temp must be handled by ending them with arena_temp_end or ignoring them with arena_temp_ignore.

Map_File_Error :: enum int {
	None           = 0,
	Open_Failure   = 1,
	Stat_Failure   = 2,
	Negative_Size  = 3,
	Too_Large_Size = 4,
	Map_Failure    = 5,
}

Source

Map_File_Flag :: enum u32 {
	Read  = 0,
	Write = 1,
}

Source

Map_File_Flags :: bit_set[Map_File_Flag; u32]Source

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

Source

Memory_Block_Flag :: enum u32 {
	Overflow_Protection = 0,
}

Source

Memory_Block_Flags :: bit_set[Memory_Block_Flag; u32]Source

Platform_Memory_Block :: struct {
	block:     Memory_Block,
	committed: uint,
	reserved:  uint,
}

Source

Protect_Flag :: enum u32 {
	Read    = 0,
	Write   = 1,
	Execute = 2,
}

Source

Protect_Flags :: bit_set[Protect_Flag; u32]Source

Constants

Allocator_Error :: Allocator_ErrorSource

DEFAULT_ARENA_GROWING_COMMIT_SIZE :: _ = 8*mem.MegabyteSource

DEFAULT_ARENA_GROWING_MINIMUM_BLOCK_SIZE :: DEFAULT_ARENA_STATIC_COMMIT_SIZESource

DEFAULT_ARENA_STATIC_COMMIT_SIZE :: MegabyteSource

1 MiB should be enough to start with

Protect_No_Access :: Protect_Flags = Protect_Flags{}Source

Procedures

_commit :: proc(data: rawptr, size: uint) -> (Allocator_Error)Source

_decommit :: proc(data: rawptr, size: uint)Source

_map_file :: proc(fd: uintptr, size: i64, flags: Map_File_Flags) -> (data: []u8, error: Map_File_Error)Source

_protect :: proc(data: rawptr, size: uint, flags: Protect_Flags) -> (bool)Source

_release :: proc(data: rawptr, size: uint)Source

_reserve :: proc(size: uint, address_hint: uintptr) -> (data: []u8, err: Allocator_Error)Source

_unmap_file :: proc(data: []u8)Source

alloc_from_memory_block :: proc(block: ^Memory_Block, min_size: uint, alignment: uint, default_commit_size: uint) -> (data: []u8, err: Allocator_Error)

Source

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

Source

Allocates memory from the provided arena.

arena_allocator :: proc(arena: ^Arena) -> (mem.Allocator)Source

Create an Allocator from the provided Arena

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

Source

The allocator procedure used by an Allocator produced by arena_allocator

arena_check_temp :: proc(arena: ^Arena, loc = #caller_location)Source

Asserts that all uses of Arena_Temp has been used by an Arena

arena_destroy :: proc(arena: ^Arena, loc = #caller_location)Source

Frees all of the memory allocated by the arena and zeros all of the values of an arena. A buffer based arena does not delete the provided []byte bufffer.

arena_free_all :: proc(arena: ^Arena, loc = #caller_location)Source

Deallocates all but the first memory block of the arena and resets the allocator's usage to 0.

arena_growing_bootstrap_new_by_name :: proc(T: typeid, field_name: string, minimum_block_size: uint) -> (ptr: ^T, err: Allocator_Error)

Source

Ability to bootstrap allocate a struct with an arena within the struct itself using the growing variant strategy.

arena_growing_bootstrap_new_by_offset :: proc(T: typeid, offset_to_arena: uintptr, minimum_block_size: uint) -> (ptr: ^T, err: Allocator_Error)

Source

Ability to bootstrap allocate a struct with an arena within the struct itself using the growing variant strategy.

arena_growing_free_last_memory_block :: proc(arena: ^Arena, loc = #caller_location)Source

Frees the last memory block of a Growing Arena

arena_init_buffer :: proc(arena: ^Arena, buffer: []u8) -> (err: Allocator_Error)Source

Initialization of an Arena to be a .Buffer variant. A buffer arena contains single Memory_Block created from a user provided []byte.

arena_init_growing :: proc(arena: ^Arena, reserved: uint) -> (err: Allocator_Error)Source

Initialization of an Arena to be a .Growing variant. A growing arena is a linked list of Memory_Blocks allocated with virtual memory.

arena_init_static :: proc(arena: ^Arena, reserved: uint, commit_size: uint) -> (err: Allocator_Error)Source

Initialization of an Arena to be a .Static variant. A static arena contains a single Memory_Block allocated with virtual memory.

arena_static_bootstrap_new_by_name :: proc(T: typeid, field_name: string, reserved: uint) -> (ptr: ^T, err: Allocator_Error)

Source

Ability to bootstrap allocate a struct with an arena within the struct itself using the static variant strategy.

arena_static_bootstrap_new_by_offset :: proc(T: typeid, offset_to_arena: uintptr, reserved: uint) -> (ptr: ^T, err: Allocator_Error)

Source

Ability to bootstrap allocate a struct with an arena within the struct itself using the static variant strategy.

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

Resets the memory of a Static or Buffer arena to a specific position (offset) and zeroes the previously used memory.

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

Begins the section of temporary arena memory.

arena_temp_end :: proc(temp: Arena_Temp, loc = #caller_location)Source

Ends the section of temporary arena memory by resetting the memory to the stored position.

arena_temp_ignore :: proc(temp: Arena_Temp, loc = #caller_location)Source

Ignore the use of a arena_temp_begin entirely by __not__ resetting to the stored position.

commit :: proc(data: rawptr, size: uint) -> (Allocator_Error)Source

decommit :: proc(data: rawptr, size: uint)Source

make_aligned :: proc(arena: ^Arena, T: typeid, len: int, alignment: uint, loc = #caller_location) -> (Allocator_Error, T)

Source

make_aligned allocates and initializes a slice. Like new, the second argument is a type, not a value. Unlike new, make's return value is the same as the type of its argument, not a pointer to it.

Note: Prefer using the procedure group make.

make_multi_pointer :: proc(arena: ^Arena, T: typeid, len: int, loc = #caller_location) -> (Allocator_Error, T)Source

make_multi_pointer allocates and initializes a dynamic array. Like new, the second argument is a type, not a value. Unlike new, make's return value is the same as the type of its argument, not a pointer to it.

This is "similar" to doing raw_data(make([]E, len, allocator)).

Note: Prefer using the procedure group make.

make_slice :: proc(arena: ^Arena, T: typeid, len: int, loc = #caller_location) -> (Allocator_Error, T)Source

make_slice allocates and initializes a slice. Like new, the second argument is a type, not a value. Unlike new, make's return value is the same as the type of its argument, not a pointer to it.

Note: Prefer using the procedure group make.

map_file_from_file :: proc(f: ^os.File, flags: Map_File_Flags) -> (data: []u8, error: Map_File_Error)Source

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

memory_block_alloc :: proc(committed: uint, reserved: uint, alignment: uint, flags: Memory_Block_Flags) -> (block: ^Memory_Block, err: Allocator_Error)

Source

memory_block_dealloc :: proc(block_to_free: ^Memory_Block)Source

new :: proc(arena: ^Arena, T: typeid, loc = #caller_location) -> (ptr: ^T, err: Allocator_Error)Source

The new procedure allocates memory for a type T from a virtual.Arena. The second argument is a type, not a value, and the value return is a pointer to a newly allocated value of that type using the specified allocator.

new_aligned :: proc(arena: ^Arena, T: typeid, alignment: uint, loc = #caller_location) -> (ptr: ^T, err: Allocator_Error)

Source

The new_aligned procedure allocates memory for a type T from a virtual.Arena with a specified alignment. The second argument is a type, not a value, and the value return is a pointer to a newly allocated value of that type using the specified allocator.

new_clone :: proc(arena: ^Arena, data: T, loc = #caller_location) -> (ptr: ^T, err: Allocator_Error)Source

The new_clone procedure allocates memory for a type T from a virtual.Arena. The second argument is a value that is to be copied to the allocated data. The value returned is a pointer to a newly allocated value of that type using the specified allocator.

platform_memory_alloc :: proc(to_commit: uint, to_reserve: uint) -> (block: ^Platform_Memory_Block, err: Allocator_Error)

Source

platform_memory_commit :: proc(block: ^Platform_Memory_Block, to_commit: uint) -> (err: Allocator_Error)Source

platform_memory_free :: proc(block: ^Platform_Memory_Block)Source

protect :: proc(data: rawptr, size: uint, flags: Protect_Flags) -> (bool)Source

release :: proc(data: rawptr, size: uint)Source

reserve :: proc(size: uint, address_hint: uintptr = uintptr(0)) -> (data: []u8, err: Allocator_Error)Source

reserve_and_commit :: proc(size: uint) -> (data: []u8, err: Allocator_Error)Source

unmap_file :: proc(data: []u8)Source

Procedure Groups

arena_growing_bootstrap_new :: proc{arena_growing_bootstrap_new_by_offset, arena_growing_bootstrap_new_by_name}Source

Ability to bootstrap allocate a struct with an arena within the struct itself using the growing variant strategy.

arena_static_bootstrap_new :: proc{arena_static_bootstrap_new_by_offset, arena_static_bootstrap_new_by_name}Source

Ability to bootstrap allocate a struct with an arena within the struct itself using the static variant strategy.

make :: proc{make_slice, make_multi_pointer}Source

map_file :: proc{map_file_from_path, map_file_from_file}Source

mem_virtual

Types

Constants

Procedures

Procedure Groups

Find anything

Settings