126 lines
4.6 KiB
Odin
126 lines
4.6 KiB
Odin
package grime
|
|
|
|
FArena :: struct {
|
|
mem: []byte,
|
|
used: int,
|
|
}
|
|
@require_results
|
|
farena_make :: proc(backing: []byte) -> FArena {
|
|
arena := FArena {mem = backing}
|
|
return arena
|
|
}
|
|
farena_init :: proc(arena: ^FArena, backing: []byte) {
|
|
assert(arena != nil)
|
|
arena.mem = backing
|
|
arena.used = 0
|
|
}
|
|
@require_results
|
|
farena_push :: proc(arena: ^FArena, $Type: typeid, amount: int, alignment: int = MEMORY_ALIGNMENT_DEFAULT) -> []Type {
|
|
assert(arena != nil)
|
|
if amount == 0 {
|
|
return {}
|
|
}
|
|
desired := size_of(Type) * amount
|
|
to_commit := align_pow2(desired, alignment)
|
|
unused := len(arena.mem) - arena.used
|
|
assert(to_commit <= unused)
|
|
ptr := cursor(arena.mem[arena.used:])
|
|
arena.used += to_commit
|
|
return slice(ptr, amount)
|
|
}
|
|
@require_results
|
|
farena_grow :: proc(arena: ^FArena, old_allocation: []byte, requested_size: int, alignment: int = MEMORY_ALIGNMENT_DEFAULT, should_zero: bool = true) -> (allocation: []byte, err: AllocatorError) {
|
|
if len(old_allocation) == 0 {
|
|
return {}, .Invalid_Argument
|
|
}
|
|
alloc_end := end(old_allocation)
|
|
arena_end := cursor(arena.mem)[arena.used:]
|
|
if alloc_end != arena_end {
|
|
// Not at the end, can't grow in place
|
|
return {}, .Out_Of_Memory
|
|
}
|
|
// Calculate growth
|
|
grow_amount := requested_size - len(old_allocation)
|
|
aligned_grow := align_pow2(grow_amount, alignment)
|
|
unused := len(arena.mem) - arena.used
|
|
if aligned_grow > unused {
|
|
// Not enough space
|
|
return {}, .Out_Of_Memory
|
|
}
|
|
arena.used += aligned_grow
|
|
allocation = slice(cursor(old_allocation), requested_size)
|
|
if should_zero {
|
|
mem_zero( cursor(allocation)[len(old_allocation):], grow_amount )
|
|
}
|
|
err = .None
|
|
return
|
|
}
|
|
@require_results
|
|
farena_shirnk :: proc(arena: ^FArena, old_allocation: []byte, requested_size: int, alignment: int = MEMORY_ALIGNMENT_DEFAULT) -> (allocation: []byte, err: AllocatorError) {
|
|
if len(old_allocation) == 0 {
|
|
return {}, .Invalid_Argument
|
|
}
|
|
alloc_end := end(old_allocation)
|
|
arena_end := cursor(arena.mem)[arena.used:]
|
|
if alloc_end != arena_end {
|
|
// Not at the end, can't shrink but return adjusted size
|
|
allocation = old_allocation[:requested_size]
|
|
err = .None
|
|
return
|
|
}
|
|
// Calculate shrinkage
|
|
aligned_original := align_pow2(len(old_allocation), MEMORY_ALIGNMENT_DEFAULT)
|
|
aligned_new := align_pow2(requested_size, alignment)
|
|
arena.used -= (aligned_original - aligned_new)
|
|
allocation = old_allocation[:requested_size]
|
|
return
|
|
}
|
|
farena_reset :: proc(arena: ^FArena) {
|
|
arena.used = 0
|
|
}
|
|
farena_rewind :: proc(arena: ^FArena, save_point: AllocatorSP) {
|
|
assert(save_point.type_sig == farena_allocator_proc)
|
|
assert(save_point.slot >= 0 && save_point.slot <= arena.used)
|
|
arena.used = save_point.slot
|
|
}
|
|
farena_save :: #force_inline proc(arena: FArena) -> AllocatorSP { return AllocatorSP { type_sig = farena_allocator_proc, slot = arena.used } }
|
|
farena_allocator_proc :: proc(input: AllocatorProc_In, output: ^AllocatorProc_Out) {
|
|
assert(output != nil)
|
|
assert(input.data != nil)
|
|
arena := transmute(^FArena) input.data
|
|
switch input.op
|
|
{
|
|
case .Alloc, .Alloc_NoZero:
|
|
output.allocation = to_bytes(farena_push(arena, byte, input.requested_size, input.alignment))
|
|
if input.op == .Alloc {
|
|
zero(output.allocation)
|
|
}
|
|
case .Free:
|
|
// No-op for arena
|
|
case .Reset:
|
|
farena_reset(arena)
|
|
case .Grow, .Grow_NoZero:
|
|
output.allocation, output.error = farena_grow(arena, input.old_allocation, input.requested_size, input.alignment, input.op == .Grow)
|
|
case .Shrink:
|
|
output.allocation, output.error = farena_shirnk(arena, input.old_allocation, input.requested_size, input.alignment)
|
|
case .Rewind:
|
|
farena_rewind(arena, input.save_point)
|
|
case .SavePoint:
|
|
output.save_point = farena_save(arena^)
|
|
case .Query:
|
|
output.features = {.Alloc, .Reset, .Grow, .Shrink, .Rewind}
|
|
output.max_alloc = len(arena.mem) - arena.used
|
|
output.min_alloc = 0
|
|
output.left = output.max_alloc
|
|
output.save_point = farena_save(arena^)
|
|
}
|
|
}
|
|
when ODIN_DEBUG {
|
|
farena_ainfo :: #force_inline proc "contextless" (arena: ^FArena) -> AllocatorInfo { return AllocatorInfo{proc_id = .FArena, data = arena} }
|
|
farena_allocator :: #force_inline proc "contextless" (arena: ^FArena) -> Odin_Allocator { return transmute(Odin_Allocator) AllocatorInfo{proc_id = .FArena, data = arena} }
|
|
}
|
|
else {
|
|
farena_ainfo :: #force_inline proc "contextless" (arena: ^FArena) -> AllocatorInfo { return AllocatorInfo{procedure = farena_allocator_proc, data = arena} }
|
|
farena_allocator :: #force_inline proc "contextless" (arena: ^FArena) -> Odin_Allocator { return transmute(Odin_Allocator) AllocatorInfo{procedure = farena_allocator_proc, data = arena} }
|
|
}
|