From 2b9096517c0f69bce6308ea81ff50c9caa8b2fe8 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 09:20:56 +1100 Subject: [PATCH 01/72] [mem]: Code formatting --- core/mem/alloc.odin | 220 +++++++++++++++++++++---- core/mem/allocators.odin | 175 +++++++++++--------- core/mem/mem.odin | 16 +- core/mem/mutex_allocator.odin | 14 +- core/mem/raw.odin | 38 +++-- core/mem/rollback_stack_allocator.odin | 81 ++++----- core/mem/tracking_allocator.odin | 36 ++-- 7 files changed, 390 insertions(+), 190 deletions(-) diff --git a/core/mem/alloc.odin b/core/mem/alloc.odin index e51d971e1..558e810e3 100644 --- a/core/mem/alloc.odin +++ b/core/mem/alloc.odin @@ -63,30 +63,58 @@ DEFAULT_PAGE_SIZE :: 4 * 1024 @(require_results) -alloc :: proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> (rawptr, Allocator_Error) { +alloc :: proc( + size: int, + alignment: int = DEFAULT_ALIGNMENT, + allocator := context.allocator, + loc := #caller_location, +) -> (rawptr, Allocator_Error) { data, err := runtime.mem_alloc(size, alignment, allocator, loc) return raw_data(data), err } @(require_results) -alloc_bytes :: proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) { +alloc_bytes :: proc( + size: int, + alignment: int = DEFAULT_ALIGNMENT, + allocator := context.allocator, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { return runtime.mem_alloc(size, alignment, allocator, loc) } @(require_results) -alloc_bytes_non_zeroed :: proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) { +alloc_bytes_non_zeroed :: proc( + size: int, + alignment: int = DEFAULT_ALIGNMENT, + allocator := context.allocator, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { return runtime.mem_alloc_non_zeroed(size, alignment, allocator, loc) } -free :: proc(ptr: rawptr, allocator := context.allocator, loc := #caller_location) -> Allocator_Error { +free :: proc( + ptr: rawptr, + allocator := context.allocator, + loc := #caller_location, +) -> Allocator_Error { return runtime.mem_free(ptr, allocator, loc) } -free_with_size :: proc(ptr: rawptr, byte_count: int, allocator := context.allocator, loc := #caller_location) -> Allocator_Error { +free_with_size :: proc( + ptr: rawptr, + byte_count: int, + allocator := context.allocator, + loc := #caller_location, +) -> Allocator_Error { return runtime.mem_free_with_size(ptr, byte_count, allocator, loc) } -free_bytes :: proc(bytes: []byte, allocator := context.allocator, loc := #caller_location) -> Allocator_Error { +free_bytes :: proc( + bytes: []byte, + allocator := context.allocator, + loc := #caller_location, +) -> Allocator_Error { return runtime.mem_free_bytes(bytes, allocator, loc) } @@ -95,13 +123,26 @@ free_all :: proc(allocator := context.allocator, loc := #caller_location) -> All } @(require_results) -resize :: proc(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> (rawptr, Allocator_Error) { +resize :: proc( + ptr: rawptr, + old_size: int, + new_size: int, + alignment: int = DEFAULT_ALIGNMENT, + allocator := context.allocator, + loc := #caller_location, +) -> (rawptr, Allocator_Error) { data, err := runtime.mem_resize(ptr, old_size, new_size, alignment, allocator, loc) return raw_data(data), err } @(require_results) -resize_bytes :: proc(old_data: []byte, new_size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) { +resize_bytes :: proc( + old_data: []byte, + new_size: int, + alignment: int = DEFAULT_ALIGNMENT, + allocator := context.allocator, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { return runtime.mem_resize(raw_data(old_data), len(old_data), new_size, alignment, allocator, loc) } @@ -115,7 +156,11 @@ query_features :: proc(allocator: Allocator, loc := #caller_location) -> (set: A } @(require_results) -query_info :: proc(pointer: rawptr, allocator: Allocator, loc := #caller_location) -> (props: Allocator_Query_Info) { +query_info :: proc( + pointer: rawptr, + allocator: Allocator, + loc := #caller_location, +) -> (props: Allocator_Query_Info) { props.pointer = pointer if allocator.procedure != nil { allocator.procedure(allocator.data, .Query_Info, 0, 0, &props, 0, loc) @@ -123,25 +168,44 @@ query_info :: proc(pointer: rawptr, allocator: Allocator, loc := #caller_locatio return } - - -delete_string :: proc(str: string, allocator := context.allocator, loc := #caller_location) -> Allocator_Error { +delete_string :: proc( + str: string, + allocator := context.allocator, + loc := #caller_location, +) -> Allocator_Error { return runtime.delete_string(str, allocator, loc) } -delete_cstring :: proc(str: cstring, allocator := context.allocator, loc := #caller_location) -> Allocator_Error { + +delete_cstring :: proc( + str: cstring, + allocator := context.allocator, + loc := #caller_location, +) -> Allocator_Error { return runtime.delete_cstring(str, allocator, loc) } -delete_dynamic_array :: proc(array: $T/[dynamic]$E, loc := #caller_location) -> Allocator_Error { + +delete_dynamic_array :: proc( + array: $T/[dynamic]$E, + loc := #caller_location, +) -> Allocator_Error { return runtime.delete_dynamic_array(array, loc) } -delete_slice :: proc(array: $T/[]$E, allocator := context.allocator, loc := #caller_location) -> Allocator_Error { + +delete_slice :: proc( + array: $T/[]$E, + allocator := context.allocator, + loc := #caller_location, +) -> Allocator_Error { return runtime.delete_slice(array, allocator, loc) } -delete_map :: proc(m: $T/map[$K]$V, loc := #caller_location) -> Allocator_Error { + +delete_map :: proc( + m: $T/map[$K]$V, + loc := #caller_location, +) -> Allocator_Error { return runtime.delete_map(m, loc) } - delete :: proc{ delete_string, delete_cstring, @@ -150,46 +214,102 @@ delete :: proc{ delete_map, } - @(require_results) -new :: proc($T: typeid, allocator := context.allocator, loc := #caller_location) -> (^T, Allocator_Error) { +new :: proc( + $T: typeid, + allocator := context.allocator, + loc := #caller_location, +) -> (^T, Allocator_Error) { return new_aligned(T, align_of(T), allocator, loc) } + @(require_results) -new_aligned :: proc($T: typeid, alignment: int, allocator := context.allocator, loc := #caller_location) -> (t: ^T, err: Allocator_Error) { +new_aligned :: proc( + $T: typeid, + alignment: int, + allocator := context.allocator, + loc := #caller_location, +) -> (t: ^T, err: Allocator_Error) { return runtime.new_aligned(T, alignment, allocator, loc) } + @(require_results) -new_clone :: proc(data: $T, allocator := context.allocator, loc := #caller_location) -> (t: ^T, err: Allocator_Error) { +new_clone :: proc( + data: $T, + allocator := context.allocator, + loc := #caller_location, +) -> (t: ^T, err: Allocator_Error) { return runtime.new_clone(data, allocator, loc) } @(require_results) -make_aligned :: proc($T: typeid/[]$E, #any_int len: int, alignment: int, allocator := context.allocator, loc := #caller_location) -> (slice: T, err: Allocator_Error) { +make_aligned :: proc( + $T: typeid/[]$E, + #any_int len: int, + alignment: int, + allocator := context.allocator, + loc := #caller_location, +) -> (slice: T, err: Allocator_Error) { return runtime.make_aligned(T, len, alignment, allocator, loc) } + @(require_results) -make_slice :: proc($T: typeid/[]$E, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) { +make_slice :: proc( + $T: typeid/[]$E, + #any_int len: int, + allocator := context.allocator, + loc := #caller_location, +) -> (T, Allocator_Error) { return runtime.make_slice(T, len, allocator, loc) } + @(require_results) -make_dynamic_array :: proc($T: typeid/[dynamic]$E, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) { +make_dynamic_array :: proc( + $T: typeid/[dynamic]$E, + allocator := context.allocator, + loc := #caller_location, +) -> (T, Allocator_Error) { return runtime.make_dynamic_array(T, allocator, loc) } + @(require_results) -make_dynamic_array_len :: proc($T: typeid/[dynamic]$E, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) { +make_dynamic_array_len :: proc( + $T: typeid/[dynamic]$E, + #any_int len: int, + allocator := context.allocator, + loc := #caller_location, +) -> (T, Allocator_Error) { return runtime.make_dynamic_array_len_cap(T, len, len, allocator, loc) } + @(require_results) -make_dynamic_array_len_cap :: proc($T: typeid/[dynamic]$E, #any_int len: int, #any_int cap: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) { +make_dynamic_array_len_cap :: proc( + $T: typeid/[dynamic]$E, + #any_int len: int, + #any_int cap: int, + allocator := context.allocator, + loc := #caller_location, +) -> (array: T, err: Allocator_Error) { return runtime.make_dynamic_array_len_cap(T, len, cap, allocator, loc) } + @(require_results) -make_map :: proc($T: typeid/map[$K]$E, #any_int cap: int = 1< (m: T, err: Allocator_Error) { +make_map :: proc( + $T: typeid/map[$K]$E, + #any_int cap: int = 1< (m: T, err: Allocator_Error) { return runtime.make_map(T, cap, allocator, loc) } + @(require_results) -make_multi_pointer :: proc($T: typeid/[^]$E, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (mp: T, err: Allocator_Error) { +make_multi_pointer :: proc( + $T: typeid/[^]$E, + #any_int len: int, + allocator := context.allocator, + loc := #caller_location +) -> (mp: T, err: Allocator_Error) { return runtime.make_multi_pointer(T, len, allocator, loc) } @@ -202,26 +322,58 @@ make :: proc{ make_multi_pointer, } - @(require_results) -default_resize_align :: proc(old_memory: rawptr, old_size, new_size, alignment: int, allocator := context.allocator, loc := #caller_location) -> (res: rawptr, err: Allocator_Error) { +default_resize_align :: proc( + old_memory: rawptr, + old_size: int, + new_size: int, + alignment: int, + allocator := context.allocator, + loc := #caller_location, +) -> (res: rawptr, err: Allocator_Error) { data: []byte - data, err = default_resize_bytes_align(([^]byte)(old_memory)[:old_size], new_size, alignment, allocator, loc) + data, err = default_resize_bytes_align( + ([^]byte) (old_memory)[:old_size], + new_size, + alignment, + allocator, + loc, + ) res = raw_data(data) return } @(require_results) -default_resize_bytes_align_non_zeroed :: proc(old_data: []byte, new_size, alignment: int, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) { +default_resize_bytes_align_non_zeroed :: proc( + old_data: []byte, + new_size: int, + alignment: int, + allocator := context.allocator, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { return _default_resize_bytes_align(old_data, new_size, alignment, false, allocator, loc) } + @(require_results) -default_resize_bytes_align :: proc(old_data: []byte, new_size, alignment: int, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) { +default_resize_bytes_align :: proc( + old_data: []byte, + new_size: int, + alignment: int, + allocator := context.allocator, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { return _default_resize_bytes_align(old_data, new_size, alignment, true, allocator, loc) } @(require_results) -_default_resize_bytes_align :: #force_inline proc(old_data: []byte, new_size, alignment: int, should_zero: bool, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) { +_default_resize_bytes_align :: #force_inline proc( + old_data: []byte, + new_size: int, + alignment: int, + should_zero: bool, + allocator := context.allocator, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { old_memory := raw_data(old_data) old_size := len(old_data) if old_memory == nil { diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index a5b93ad05..7bc1a6d77 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -3,9 +3,14 @@ package mem import "base:intrinsics" import "base:runtime" -nil_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, - size, alignment: int, - old_memory: rawptr, old_size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { +nil_allocator_proc :: proc( + allocator_data: rawptr, + mode: Allocator_Mode, + size, alignment: int, + old_memory: rawptr, + old_size: int, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { return nil, nil } @@ -16,8 +21,6 @@ nil_allocator :: proc() -> Allocator { } } -// Custom allocators - Arena :: struct { data: []byte, offset: int, @@ -30,7 +33,6 @@ Arena_Temp_Memory :: struct { prev_offset: int, } - arena_init :: proc(a: ^Arena, data: []byte) { a.data = data a.offset = 0 @@ -54,9 +56,15 @@ arena_allocator :: proc(arena: ^Arena) -> Allocator { } } -arena_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, - size, alignment: int, - old_memory: rawptr, old_size: int, location := #caller_location) -> ([]byte, Allocator_Error) { +arena_allocator_proc :: proc( + allocator_data: rawptr, + mode: Allocator_Mode, + size: int, + alignment: int, + old_memory: rawptr, + old_size: int, + location := #caller_location, +) -> ([]byte, Allocator_Error) { arena := cast(^Arena)allocator_data switch mode { @@ -120,8 +128,6 @@ end_arena_temp_memory :: proc(tmp: Arena_Temp_Memory) { tmp.arena.temp_count -= 1 } - - Scratch_Allocator :: struct { data: []byte, curr_offset: int, @@ -151,9 +157,14 @@ scratch_allocator_destroy :: proc(s: ^Scratch_Allocator) { s^ = {} } -scratch_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, - size, alignment: int, - old_memory: rawptr, old_size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { +scratch_allocator_proc :: proc( + allocator_data: rawptr, + mode: Allocator_Mode, + size, alignment: int, + old_memory: rawptr, + old_size: int, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { s := (^Scratch_Allocator)(allocator_data) @@ -299,10 +310,6 @@ scratch_allocator :: proc(allocator: ^Scratch_Allocator) -> Allocator { } } - - - - Stack_Allocation_Header :: struct { prev_offset: int, padding: int, @@ -339,34 +346,44 @@ stack_allocator :: proc(stack: ^Stack) -> Allocator { } } - -stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, - size, alignment: int, - old_memory: rawptr, old_size: int, location := #caller_location) -> ([]byte, Allocator_Error) { +stack_allocator_proc :: proc( + allocator_data: rawptr, + mode: Allocator_Mode, + size: int, + alignment: int, + old_memory: rawptr, + old_size: int, + location := #caller_location, +) -> ([]byte, Allocator_Error) { s := cast(^Stack)allocator_data if s.data == nil { return nil, .Invalid_Argument } - raw_alloc :: proc(s: ^Stack, size, alignment: int, zero_memory: bool) -> ([]byte, Allocator_Error) { + raw_alloc :: proc( + s: ^Stack, + size: int, + alignment: int, + zero_memory: bool, + ) -> ([]byte, Allocator_Error) { curr_addr := uintptr(raw_data(s.data)) + uintptr(s.curr_offset) - padding := calc_padding_with_header(curr_addr, uintptr(alignment), size_of(Stack_Allocation_Header)) + padding := calc_padding_with_header( + curr_addr, + uintptr(alignment), + size_of(Stack_Allocation_Header), + ) if s.curr_offset + padding + size > len(s.data) { return nil, .Out_Of_Memory } s.prev_offset = s.curr_offset s.curr_offset += padding - next_addr := curr_addr + uintptr(padding) header := (^Stack_Allocation_Header)(next_addr - size_of(Stack_Allocation_Header)) header.padding = padding header.prev_offset = s.prev_offset - s.curr_offset += size - s.peak_used = max(s.peak_used, s.curr_offset) - if zero_memory { zero(rawptr(next_addr), size) } @@ -467,12 +484,6 @@ stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, return nil, nil } - - - - - - Small_Stack_Allocation_Header :: struct { padding: u8, } @@ -505,9 +516,14 @@ small_stack_allocator :: proc(stack: ^Small_Stack) -> Allocator { } } -small_stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, - size, alignment: int, - old_memory: rawptr, old_size: int, location := #caller_location) -> ([]byte, Allocator_Error) { +small_stack_allocator_proc :: proc( + allocator_data: rawptr, + mode: Allocator_Mode, + size, alignment: int, + old_memory: rawptr, + old_size: int, + location := #caller_location, +) -> ([]byte, Allocator_Error) { s := cast(^Small_Stack)allocator_data if s.data == nil { @@ -612,10 +628,6 @@ small_stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, return nil, nil } - - - - Dynamic_Pool :: struct { block_size: int, out_band_size: int, @@ -632,15 +644,18 @@ Dynamic_Pool :: struct { block_allocator: Allocator, } - DYNAMIC_POOL_BLOCK_SIZE_DEFAULT :: 65536 DYNAMIC_POOL_OUT_OF_BAND_SIZE_DEFAULT :: 6554 - - -dynamic_pool_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, - size, alignment: int, - old_memory: rawptr, old_size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { +dynamic_pool_allocator_proc :: proc( + allocator_data: rawptr, + mode: Allocator_Mode, + size: int, + alignment: int, + old_memory: rawptr, + old_size: int, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { pool := (^Dynamic_Pool)(allocator_data) switch mode { @@ -689,19 +704,21 @@ dynamic_pool_allocator :: proc(pool: ^Dynamic_Pool) -> Allocator { } } -dynamic_pool_init :: proc(pool: ^Dynamic_Pool, - block_allocator := context.allocator, - array_allocator := context.allocator, - block_size := DYNAMIC_POOL_BLOCK_SIZE_DEFAULT, - out_band_size := DYNAMIC_POOL_OUT_OF_BAND_SIZE_DEFAULT, - alignment := 8) { - pool.block_size = block_size - pool.out_band_size = out_band_size - pool.alignment = alignment +dynamic_pool_init :: proc( + pool: ^Dynamic_Pool, + block_allocator := context.allocator, + array_allocator := context.allocator, + block_size := DYNAMIC_POOL_BLOCK_SIZE_DEFAULT, + out_band_size := DYNAMIC_POOL_OUT_OF_BAND_SIZE_DEFAULT, + alignment := 8, +) { + pool.block_size = block_size + pool.out_band_size = out_band_size + pool.alignment = alignment pool.block_allocator = block_allocator pool.out_band_allocations.allocator = array_allocator - pool. unused_blocks.allocator = array_allocator - pool. used_blocks.allocator = array_allocator + pool.unused_blocks.allocator = array_allocator + pool.used_blocks.allocator = array_allocator } dynamic_pool_destroy :: proc(pool: ^Dynamic_Pool) { @@ -709,11 +726,9 @@ dynamic_pool_destroy :: proc(pool: ^Dynamic_Pool) { delete(pool.unused_blocks) delete(pool.used_blocks) delete(pool.out_band_allocations) - zero(pool, size_of(pool^)) } - @(require_results) dynamic_pool_alloc :: proc(pool: ^Dynamic_Pool, bytes: int) -> (rawptr, Allocator_Error) { data, err := dynamic_pool_alloc_bytes(pool, bytes) @@ -736,9 +751,14 @@ dynamic_pool_alloc_bytes :: proc(p: ^Dynamic_Pool, bytes: int) -> ([]byte, Alloc new_block = pop(&p.unused_blocks) } else { data: []byte - data, err = p.block_allocator.procedure(p.block_allocator.data, Allocator_Mode.Alloc, - p.block_size, p.alignment, - nil, 0) + data, err = p.block_allocator.procedure( + p.block_allocator.data, + Allocator_Mode.Alloc, + p.block_size, + p.alignment, + nil, + 0, + ) new_block = raw_data(data) } @@ -808,10 +828,14 @@ dynamic_pool_free_all :: proc(p: ^Dynamic_Pool) { clear(&p.unused_blocks) } - -panic_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, - size, alignment: int, - old_memory: rawptr, old_size: int,loc := #caller_location) -> ([]byte, Allocator_Error) { +panic_allocator_proc :: proc( + allocator_data: rawptr, + mode: Allocator_Mode, + size, alignment: int, + old_memory: rawptr, + old_size: int, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { switch mode { case .Alloc: @@ -859,11 +883,6 @@ panic_allocator :: proc() -> Allocator { } } - - - - - Buddy_Block :: struct #align(align_of(uint)) { size: uint, is_free: bool, @@ -929,7 +948,6 @@ buddy_block_coalescence :: proc(head, tail: ^Buddy_Block) { } } - @(require_results) buddy_block_find_best :: proc(head, tail: ^Buddy_Block, size: uint) -> ^Buddy_Block { assert(size != 0) @@ -998,7 +1016,6 @@ buddy_block_find_best :: proc(head, tail: ^Buddy_Block, size: uint) -> ^Buddy_Bl return nil } - Buddy_Allocator :: struct { head: ^Buddy_Block, tail: ^Buddy_Block, @@ -1089,9 +1106,13 @@ buddy_allocator_free :: proc(b: ^Buddy_Allocator, ptr: rawptr) -> Allocator_Erro return nil } -buddy_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, - size, alignment: int, - old_memory: rawptr, old_size: int,loc := #caller_location) -> ([]byte, Allocator_Error) { +buddy_allocator_proc :: proc( + allocator_data: rawptr, mode: Allocator_Mode, + size, alignment: int, + old_memory: rawptr, + old_size: int, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { b := (^Buddy_Allocator)(allocator_data) diff --git a/core/mem/mem.odin b/core/mem/mem.odin index d423cc1eb..9e47c9602 100644 --- a/core/mem/mem.odin +++ b/core/mem/mem.odin @@ -14,10 +14,12 @@ Exabyte :: runtime.Exabyte set :: proc "contextless" (data: rawptr, value: byte, len: int) -> rawptr { return runtime.memset(data, i32(value), len) } + zero :: proc "contextless" (data: rawptr, len: int) -> rawptr { intrinsics.mem_zero(data, len) return data } + zero_explicit :: proc "contextless" (data: rawptr, len: int) -> rawptr { // This routine tries to avoid the compiler optimizing away the call, // so that it is always executed. It is intended to provided @@ -27,20 +29,22 @@ zero_explicit :: proc "contextless" (data: rawptr, len: int) -> rawptr { intrinsics.atomic_thread_fence(.Seq_Cst) // Prevent reordering return data } + zero_item :: proc "contextless" (item: $P/^$T) -> P { intrinsics.mem_zero(item, size_of(T)) return item } + zero_slice :: proc "contextless" (data: $T/[]$E) -> T { zero(raw_data(data), size_of(E)*len(data)) return data } - copy :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr { intrinsics.mem_copy(dst, src, len) return dst } + copy_non_overlapping :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr { intrinsics.mem_copy_non_overlapping(dst, src, len) return dst @@ -120,6 +124,7 @@ compare_ptrs :: proc "contextless" (a, b: rawptr, n: int) -> int { } ptr_offset :: intrinsics.ptr_offset + ptr_sub :: intrinsics.ptr_sub @(require_results) @@ -211,6 +216,7 @@ align_forward_uintptr :: proc(ptr, align: uintptr) -> uintptr { align_forward_int :: proc(ptr, align: int) -> int { return int(align_forward_uintptr(uintptr(ptr), uintptr(align))) } + @(require_results) align_forward_uint :: proc(ptr, align: uint) -> uint { return uint(align_forward_uintptr(uintptr(ptr), uintptr(align))) @@ -230,6 +236,7 @@ align_backward_uintptr :: proc(ptr, align: uintptr) -> uintptr { align_backward_int :: proc(ptr, align: int) -> int { return int(align_backward_uintptr(uintptr(ptr), uintptr(align))) } + @(require_results) align_backward_uint :: proc(ptr, align: uint) -> uint { return uint(align_backward_uintptr(uintptr(ptr), uintptr(align))) @@ -247,7 +254,6 @@ reinterpret_copy :: proc "contextless" ($T: typeid, ptr: rawptr) -> (value: T) { return } - Fixed_Byte_Buffer :: distinct [dynamic]byte @(require_results) @@ -264,8 +270,6 @@ make_fixed_byte_buffer :: proc "contextless" (backing: []byte) -> Fixed_Byte_Buf return transmute(Fixed_Byte_Buffer)d } - - @(require_results) align_formula :: proc "contextless" (size, align: int) -> int { result := size + align-1 @@ -276,12 +280,10 @@ align_formula :: proc "contextless" (size, align: int) -> int { calc_padding_with_header :: proc "contextless" (ptr: uintptr, align: uintptr, header_size: int) -> int { p, a := ptr, align modulo := p & (a-1) - padding := uintptr(0) if modulo != 0 { padding = a - modulo } - needed_space := uintptr(header_size) if padding < needed_space { needed_space -= padding @@ -296,8 +298,6 @@ calc_padding_with_header :: proc "contextless" (ptr: uintptr, align: uintptr, he return int(padding) } - - @(require_results, deprecated="prefer 'slice.clone'") clone_slice :: proc(slice: $T/[]$E, allocator := context.allocator, loc := #caller_location) -> (new_slice: T) { new_slice, _ = make(T, len(slice), allocator, loc) diff --git a/core/mem/mutex_allocator.odin b/core/mem/mutex_allocator.odin index 591703eab..1cccc7dac 100644 --- a/core/mem/mutex_allocator.odin +++ b/core/mem/mutex_allocator.odin @@ -13,7 +13,6 @@ mutex_allocator_init :: proc(m: ^Mutex_Allocator, backing_allocator: Allocator) m.mutex = {} } - @(require_results) mutex_allocator :: proc(m: ^Mutex_Allocator) -> Allocator { return Allocator{ @@ -22,11 +21,16 @@ mutex_allocator :: proc(m: ^Mutex_Allocator) -> Allocator { } } -mutex_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, - size, alignment: int, - old_memory: rawptr, old_size: int, loc := #caller_location) -> (result: []byte, err: Allocator_Error) { +mutex_allocator_proc :: proc( + allocator_data: rawptr, + mode: Allocator_Mode, + size: int, + alignment: int, + old_memory: rawptr, + old_size: int, + loc := #caller_location, +) -> (result: []byte, err: Allocator_Error) { m := (^Mutex_Allocator)(allocator_data) - sync.mutex_guard(&m.mutex) return m.backing.procedure(m.backing.data, mode, size, alignment, old_memory, old_size, loc) } diff --git a/core/mem/raw.odin b/core/mem/raw.odin index f56206957..7fda3229d 100644 --- a/core/mem/raw.odin +++ b/core/mem/raw.odin @@ -3,22 +3,36 @@ package mem import "base:builtin" import "base:runtime" -Raw_Any :: runtime.Raw_Any -Raw_String :: runtime.Raw_String -Raw_Cstring :: runtime.Raw_Cstring -Raw_Slice :: runtime.Raw_Slice -Raw_Dynamic_Array :: runtime.Raw_Dynamic_Array -Raw_Map :: runtime.Raw_Map -Raw_Soa_Pointer :: runtime.Raw_Soa_Pointer +Raw_Any :: runtime.Raw_Any + +Raw_String :: runtime.Raw_String + +Raw_Cstring :: runtime.Raw_Cstring + +Raw_Slice :: runtime.Raw_Slice + +Raw_Dynamic_Array :: runtime.Raw_Dynamic_Array + +Raw_Map :: runtime.Raw_Map + +Raw_Soa_Pointer :: runtime.Raw_Soa_Pointer + +Raw_Complex32 :: runtime.Raw_Complex32 + +Raw_Complex64 :: runtime.Raw_Complex64 + +Raw_Complex128 :: runtime.Raw_Complex128 + +Raw_Quaternion64 :: runtime.Raw_Quaternion64 -Raw_Complex32 :: runtime.Raw_Complex32 -Raw_Complex64 :: runtime.Raw_Complex64 -Raw_Complex128 :: runtime.Raw_Complex128 -Raw_Quaternion64 :: runtime.Raw_Quaternion64 Raw_Quaternion128 :: runtime.Raw_Quaternion128 + Raw_Quaternion256 :: runtime.Raw_Quaternion256 -Raw_Quaternion64_Vector_Scalar :: runtime.Raw_Quaternion64_Vector_Scalar + +Raw_Quaternion64_Vector_Scalar :: runtime.Raw_Quaternion64_Vector_Scalar + Raw_Quaternion128_Vector_Scalar :: runtime.Raw_Quaternion128_Vector_Scalar + Raw_Quaternion256_Vector_Scalar :: runtime.Raw_Quaternion256_Vector_Scalar make_any :: proc "contextless" (data: rawptr, id: typeid) -> any { diff --git a/core/mem/rollback_stack_allocator.odin b/core/mem/rollback_stack_allocator.odin index f5e428d87..761435552 100644 --- a/core/mem/rollback_stack_allocator.odin +++ b/core/mem/rollback_stack_allocator.odin @@ -1,45 +1,47 @@ package mem -// The Rollback Stack Allocator was designed for the test runner to be fast, -// able to grow, and respect the Tracking Allocator's requirement for -// individual frees. It is not overly concerned with fragmentation, however. -// -// It has support for expansion when configured with a block allocator and -// limited support for out-of-order frees. -// -// Allocation has constant-time best and usual case performance. -// At worst, it is linear according to the number of memory blocks. -// -// Allocation follows a first-fit strategy when there are multiple memory -// blocks. -// -// Freeing has constant-time best and usual case performance. -// At worst, it is linear according to the number of memory blocks and number -// of freed items preceding the last item in a block. -// -// Resizing has constant-time performance, if it's the last item in a block, or -// the new size is smaller. Naturally, this becomes linear-time if there are -// multiple blocks to search for the pointer's owning block. Otherwise, the -// allocator defaults to a combined alloc & free operation internally. -// -// Out-of-order freeing is accomplished by collapsing a run of freed items -// from the last allocation backwards. -// -// Each allocation has an overhead of 8 bytes and any extra bytes to satisfy -// the requested alignment. +/* +The Rollback Stack Allocator was designed for the test runner to be fast, +able to grow, and respect the Tracking Allocator's requirement for +individual frees. It is not overly concerned with fragmentation, however. +It has support for expansion when configured with a block allocator and +limited support for out-of-order frees. + +Allocation has constant-time best and usual case performance. +At worst, it is linear according to the number of memory blocks. + +Allocation follows a first-fit strategy when there are multiple memory +blocks. + +Freeing has constant-time best and usual case performance. +At worst, it is linear according to the number of memory blocks and number +of freed items preceding the last item in a block. + +Resizing has constant-time performance, if it's the last item in a block, or +the new size is smaller. Naturally, this becomes linear-time if there are +multiple blocks to search for the pointer's owning block. Otherwise, the +allocator defaults to a combined alloc & free operation internally. + +Out-of-order freeing is accomplished by collapsing a run of freed items +from the last allocation backwards. + +Each allocation has an overhead of 8 bytes and any extra bytes to satisfy +the requested alignment. +*/ import "base:runtime" ROLLBACK_STACK_DEFAULT_BLOCK_SIZE :: 4 * Megabyte -// This limitation is due to the size of `prev_ptr`, but it is only for the -// head block; any allocation in excess of the allocator's `block_size` is -// valid, so long as the block allocator can handle it. -// -// This is because allocations over the block size are not split up if the item -// within is freed; they are immediately returned to the block allocator. -ROLLBACK_STACK_MAX_HEAD_BLOCK_SIZE :: 2 * Gigabyte +/* +This limitation is due to the size of `prev_ptr`, but it is only for the +head block; any allocation in excess of the allocator's `block_size` is +valid, so long as the block allocator can handle it. +This is because allocations over the block size are not split up if the item +within is freed; they are immediately returned to the block allocator. +*/ +ROLLBACK_STACK_MAX_HEAD_BLOCK_SIZE :: 2 * Gigabyte Rollback_Stack_Header :: bit_field u64 { prev_offset: uintptr | 32, @@ -60,7 +62,6 @@ Rollback_Stack :: struct { block_allocator: Allocator, } - @(private="file", require_results) rb_ptr_in_bounds :: proc(block: ^Rollback_Stack_Block, ptr: rawptr) -> bool { start := raw_data(block.buffer) @@ -294,9 +295,13 @@ rollback_stack_allocator :: proc(stack: ^Rollback_Stack) -> Allocator { } @(require_results) -rollback_stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, - size, alignment: int, - old_memory: rawptr, old_size: int, location := #caller_location, +rollback_stack_allocator_proc :: proc( + allocator_data: rawptr, + mode: Allocator_Mode, + size, alignment: int, + old_memory: rawptr, + old_size: int, + location := #caller_location, ) -> (result: []byte, err: Allocator_Error) { stack := cast(^Rollback_Stack)allocator_data diff --git a/core/mem/tracking_allocator.odin b/core/mem/tracking_allocator.odin index 1b57e5fb4..356180be1 100644 --- a/core/mem/tracking_allocator.odin +++ b/core/mem/tracking_allocator.odin @@ -12,22 +12,23 @@ Tracking_Allocator_Entry :: struct { err: Allocator_Error, location: runtime.Source_Code_Location, } + Tracking_Allocator_Bad_Free_Entry :: struct { memory: rawptr, location: runtime.Source_Code_Location, } -Tracking_Allocator :: struct { - backing: Allocator, - allocation_map: map[rawptr]Tracking_Allocator_Entry, - bad_free_array: [dynamic]Tracking_Allocator_Bad_Free_Entry, - mutex: sync.Mutex, - clear_on_free_all: bool, - total_memory_allocated: i64, - total_allocation_count: i64, - total_memory_freed: i64, - total_free_count: i64, - peak_memory_allocated: i64, +Tracking_Allocator :: struct { + backing: Allocator, + allocation_map: map[rawptr]Tracking_Allocator_Entry, + bad_free_array: [dynamic]Tracking_Allocator_Bad_Free_Entry, + mutex: sync.Mutex, + clear_on_free_all: bool, + total_memory_allocated: i64, + total_allocation_count: i64, + total_memory_freed: i64, + total_free_count: i64, + peak_memory_allocated: i64, current_memory_allocated: i64, } @@ -35,7 +36,6 @@ tracking_allocator_init :: proc(t: ^Tracking_Allocator, backing_allocator: Alloc t.backing = backing_allocator t.allocation_map.allocator = internals_allocator t.bad_free_array.allocator = internals_allocator - if .Free_All in query_features(t.backing) { t.clear_on_free_all = true } @@ -46,7 +46,6 @@ tracking_allocator_destroy :: proc(t: ^Tracking_Allocator) { delete(t.bad_free_array) } - // Clear only the current allocation data while keeping the totals intact. tracking_allocator_clear :: proc(t: ^Tracking_Allocator) { sync.mutex_lock(&t.mutex) @@ -78,9 +77,14 @@ tracking_allocator :: proc(data: ^Tracking_Allocator) -> Allocator { } } -tracking_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, - size, alignment: int, - old_memory: rawptr, old_size: int, loc := #caller_location) -> (result: []byte, err: Allocator_Error) { +tracking_allocator_proc :: proc( + allocator_data: rawptr, + mode: Allocator_Mode, + size, alignment: int, + old_memory: rawptr, + old_size: int, + loc := #caller_location, +) -> (result: []byte, err: Allocator_Error) { track_alloc :: proc(data: ^Tracking_Allocator, entry: ^Tracking_Allocator_Entry) { data.total_memory_allocated += i64(entry.size) data.total_allocation_count += 1 From da6213196dd4c64cf53d163dd7392531e26f3ad2 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 09:42:04 +1100 Subject: [PATCH 02/72] [mem]: API for using arena directly --- core/mem/allocators.odin | 71 +++++++++++++++++++++------------------- 1 file changed, 38 insertions(+), 33 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 7bc1a6d77..52a05958f 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -3,6 +3,13 @@ package mem import "base:intrinsics" import "base:runtime" +nil_allocator :: proc() -> Allocator { + return Allocator{ + procedure = nil_allocator_proc, + data = nil, + } +} + nil_allocator_proc :: proc( allocator_data: rawptr, mode: Allocator_Mode, @@ -14,13 +21,6 @@ nil_allocator_proc :: proc( return nil, nil } -nil_allocator :: proc() -> Allocator { - return Allocator{ - procedure = nil_allocator_proc, - data = nil, - } -} - Arena :: struct { data: []byte, offset: int, @@ -56,6 +56,30 @@ arena_allocator :: proc(arena: ^Arena) -> Allocator { } } +arena_alloc_non_zeroed :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([]byte, Allocator_Error) { + #no_bounds_check end := &a.data[a.offset] + ptr := align_forward(end, uintptr(alignment)) + total_size := size + ptr_sub((^byte)(ptr), (^byte)(end)) + if a.offset + total_size > len(a.data) { + return nil, .Out_Of_Memory + } + a.offset += total_size + a.peak_used = max(a.peak_used, a.offset) + return byte_slice(ptr, size), nil +} + +arena_alloc :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([]byte, Allocator_Error) { + bytes, err := arena_alloc_non_zeroed(a, size, alignment) + if bytes != nil { + zero(raw_data(bytes), size) + } + return bytes, err +} + +arena_free_all :: proc(a: ^Arena) { + a.offset = 0 +} + arena_allocator_proc :: proc( allocator_data: rawptr, mode: Allocator_Mode, @@ -66,49 +90,28 @@ arena_allocator_proc :: proc( location := #caller_location, ) -> ([]byte, Allocator_Error) { arena := cast(^Arena)allocator_data - switch mode { - case .Alloc, .Alloc_Non_Zeroed: - #no_bounds_check end := &arena.data[arena.offset] - - ptr := align_forward(end, uintptr(alignment)) - - total_size := size + ptr_sub((^byte)(ptr), (^byte)(end)) - - if arena.offset + total_size > len(arena.data) { - return nil, .Out_Of_Memory - } - - arena.offset += total_size - arena.peak_used = max(arena.peak_used, arena.offset) - if mode != .Alloc_Non_Zeroed { - zero(ptr, size) - } - return byte_slice(ptr, size), nil - + case .Alloc: + return arena_alloc(arena, size, alignment) + case .Alloc_Non_Zeroed: + return arena_alloc_non_zeroed(arena, size, alignment) case .Free: return nil, .Mode_Not_Implemented - case .Free_All: - arena.offset = 0 - + arena_free_all(arena) case .Resize: return default_resize_bytes_align(byte_slice(old_memory, old_size), size, alignment, arena_allocator(arena)) - case .Resize_Non_Zeroed: return default_resize_bytes_align_non_zeroed(byte_slice(old_memory, old_size), size, alignment, arena_allocator(arena)) - case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { set^ = {.Alloc, .Alloc_Non_Zeroed, .Free_All, .Resize, .Resize_Non_Zeroed, .Query_Features} } return nil, nil - case .Query_Info: return nil, .Mode_Not_Implemented } - return nil, nil } @@ -128,6 +131,8 @@ end_arena_temp_memory :: proc(tmp: Arena_Temp_Memory) { tmp.arena.temp_count -= 1 } + + Scratch_Allocator :: struct { data: []byte, curr_offset: int, From e5106e48a809a313be35c3554e9dc310c117eefe Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 10:09:05 +1100 Subject: [PATCH 03/72] [mem]: API for using scratch allocator directly --- core/mem/allocators.odin | 285 ++++++++++++++++++++++----------------- 1 file changed, 165 insertions(+), 120 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 52a05958f..2be4d5b61 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -56,6 +56,14 @@ arena_allocator :: proc(arena: ^Arena) -> Allocator { } } +arena_alloc :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([]byte, Allocator_Error) { + bytes, err := arena_alloc_non_zeroed(a, size, alignment) + if bytes != nil { + zero_slice(bytes) + } + return bytes, err +} + arena_alloc_non_zeroed :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([]byte, Allocator_Error) { #no_bounds_check end := &a.data[a.offset] ptr := align_forward(end, uintptr(alignment)) @@ -68,14 +76,6 @@ arena_alloc_non_zeroed :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNM return byte_slice(ptr, size), nil } -arena_alloc :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([]byte, Allocator_Error) { - bytes, err := arena_alloc_non_zeroed(a, size, alignment) - if bytes != nil { - zero(raw_data(bytes), size) - } - return bytes, err -} - arena_free_all :: proc(a: ^Arena) { a.offset = 0 } @@ -162,6 +162,153 @@ scratch_allocator_destroy :: proc(s: ^Scratch_Allocator) { s^ = {} } +scratch_allocator_alloc :: proc( + s: ^Scratch_Allocator, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + bytes, err := scratch_allocator_alloc_non_zeroed(s, size, alignment, loc) + if bytes != nil { + zero_slice(bytes) + } + return bytes, err +} + +scratch_allocator_alloc_non_zeroed :: proc( + s: ^Scratch_Allocator, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + if s.data == nil { + DEFAULT_BACKING_SIZE :: 4 * Megabyte + if !(context.allocator.procedure != scratch_allocator_proc && context.allocator.data != s) { + panic("cyclic initialization of the scratch allocator with itself", loc) + } + scratch_allocator_init(s, DEFAULT_BACKING_SIZE) + } + size := size + size = align_forward_int(size, alignment) + switch { + case s.curr_offset+size <= len(s.data): + start := uintptr(raw_data(s.data)) + ptr := start + uintptr(s.curr_offset) + ptr = align_forward_uintptr(ptr, uintptr(alignment)) + s.prev_allocation = rawptr(ptr) + offset := int(ptr - start) + s.curr_offset = offset + size + return byte_slice(rawptr(ptr), size), nil + case size <= len(s.data): + start := uintptr(raw_data(s.data)) + ptr := align_forward_uintptr(start, uintptr(alignment)) + s.prev_allocation = rawptr(ptr) + offset := int(ptr - start) + s.curr_offset = offset + size + return byte_slice(rawptr(ptr), size), nil + } + a := s.backup_allocator + if a.procedure == nil { + a = context.allocator + s.backup_allocator = a + } + ptr, err := alloc_bytes_non_zeroed(size, alignment, a, loc) + if err != nil { + return ptr, err + } + if s.leaked_allocations == nil { + s.leaked_allocations, err = make([dynamic][]byte, a) + } + append(&s.leaked_allocations, ptr) + if logger := context.logger; logger.lowest_level <= .Warning { + if logger.procedure != nil { + logger.procedure(logger.data, .Warning, "mem.Scratch_Allocator resorted to backup_allocator" , logger.options, loc) + } + } + return ptr, err +} + +scratch_allocator_free :: proc(s: ^Scratch_Allocator, ptr: rawptr, loc := #caller_location) -> Allocator_Error { + if s.data == nil { + panic("Free on an uninitialized scratch allocator", loc) + } + if ptr == nil { + return nil + } + start := uintptr(raw_data(s.data)) + end := start + uintptr(len(s.data)) + old_ptr := uintptr(ptr) + if s.prev_allocation == ptr { + s.curr_offset = int(uintptr(s.prev_allocation) - start) + s.prev_allocation = nil + return nil + } + if start <= old_ptr && old_ptr < end { + // NOTE(bill): Cannot free this pointer but it is valid + return nil + } + if len(s.leaked_allocations) != 0 { + for data, i in s.leaked_allocations { + ptr := raw_data(data) + if ptr == ptr { + free_bytes(data, s.backup_allocator, loc) + ordered_remove(&s.leaked_allocations, i, loc) + return nil + } + } + } + return .Invalid_Pointer +} + +scratch_allocator_free_all :: proc(s: ^Scratch_Allocator, loc := #caller_location) { + s.curr_offset = 0 + s.prev_allocation = nil + for ptr in s.leaked_allocations { + free_bytes(ptr, s.backup_allocator, loc) + } + clear(&s.leaked_allocations) +} + +scratch_allocator_resize_non_zeroed :: proc( + s: ^Scratch_Allocator, + old_memory: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location +) -> ([]byte, Allocator_Error) { + begin := uintptr(raw_data(s.data)) + end := begin + uintptr(len(s.data)) + old_ptr := uintptr(old_memory) + if begin <= old_ptr && old_ptr < end && old_ptr+uintptr(size) < end { + s.curr_offset = int(old_ptr-begin)+size + return byte_slice(old_memory, size), nil + } + data, err := scratch_allocator_alloc_non_zeroed(s, size, alignment, loc) + if err != nil { + return data, err + } + // TODO(flysand): OOB access on size < old_size. + runtime.copy(data, byte_slice(old_memory, old_size)) + err = scratch_allocator_free(s, old_memory, loc) + return data, err +} + +scratch_allocator_resize :: proc( + s: ^Scratch_Allocator, + old_memory: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location +) -> ([]byte, Allocator_Error) { + bytes, err := scratch_allocator_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) + if bytes != nil && size > old_size { + zero_slice(bytes[size:]) + } + return bytes, err +} + scratch_allocator_proc :: proc( allocator_data: rawptr, mode: Allocator_Mode, @@ -170,9 +317,7 @@ scratch_allocator_proc :: proc( old_size: int, loc := #caller_location, ) -> ([]byte, Allocator_Error) { - s := (^Scratch_Allocator)(allocator_data) - if s.data == nil { DEFAULT_BACKING_SIZE :: 4 * Megabyte if !(context.allocator.procedure != scratch_allocator_proc && @@ -181,129 +326,29 @@ scratch_allocator_proc :: proc( } scratch_allocator_init(s, DEFAULT_BACKING_SIZE) } - size := size - switch mode { - case .Alloc, .Alloc_Non_Zeroed: - size = align_forward_int(size, alignment) - - switch { - case s.curr_offset+size <= len(s.data): - start := uintptr(raw_data(s.data)) - ptr := start + uintptr(s.curr_offset) - ptr = align_forward_uintptr(ptr, uintptr(alignment)) - if mode != .Alloc_Non_Zeroed { - zero(rawptr(ptr), size) - } - - s.prev_allocation = rawptr(ptr) - offset := int(ptr - start) - s.curr_offset = offset + size - return byte_slice(rawptr(ptr), size), nil - - case size <= len(s.data): - start := uintptr(raw_data(s.data)) - ptr := align_forward_uintptr(start, uintptr(alignment)) - if mode != .Alloc_Non_Zeroed { - zero(rawptr(ptr), size) - } - - s.prev_allocation = rawptr(ptr) - offset := int(ptr - start) - s.curr_offset = offset + size - return byte_slice(rawptr(ptr), size), nil - } - a := s.backup_allocator - if a.procedure == nil { - a = context.allocator - s.backup_allocator = a - } - - ptr, err := alloc_bytes(size, alignment, a, loc) - if err != nil { - return ptr, err - } - if s.leaked_allocations == nil { - s.leaked_allocations, err = make([dynamic][]byte, a) - } - append(&s.leaked_allocations, ptr) - - if logger := context.logger; logger.lowest_level <= .Warning { - if logger.procedure != nil { - logger.procedure(logger.data, .Warning, "mem.Scratch_Allocator resorted to backup_allocator" , logger.options, loc) - } - } - - return ptr, err - + case .Alloc: + return scratch_allocator_alloc(s, size, alignment, loc) + case .Alloc_Non_Zeroed: + return scratch_allocator_alloc_non_zeroed(s, size, alignment, loc) case .Free: - if old_memory == nil { - return nil, nil - } - start := uintptr(raw_data(s.data)) - end := start + uintptr(len(s.data)) - old_ptr := uintptr(old_memory) - - if s.prev_allocation == old_memory { - s.curr_offset = int(uintptr(s.prev_allocation) - start) - s.prev_allocation = nil - return nil, nil - } - - if start <= old_ptr && old_ptr < end { - // NOTE(bill): Cannot free this pointer but it is valid - return nil, nil - } - - if len(s.leaked_allocations) != 0 { - for data, i in s.leaked_allocations { - ptr := raw_data(data) - if ptr == old_memory { - free_bytes(data, s.backup_allocator) - ordered_remove(&s.leaked_allocations, i) - return nil, nil - } - } - } - return nil, .Invalid_Pointer - // panic("invalid pointer passed to default_temp_allocator"); - + return nil, scratch_allocator_free(s, old_memory, loc) case .Free_All: - s.curr_offset = 0 - s.prev_allocation = nil - for ptr in s.leaked_allocations { - free_bytes(ptr, s.backup_allocator) - } - clear(&s.leaked_allocations) - - case .Resize, .Resize_Non_Zeroed: - begin := uintptr(raw_data(s.data)) - end := begin + uintptr(len(s.data)) - old_ptr := uintptr(old_memory) - if begin <= old_ptr && old_ptr < end && old_ptr+uintptr(size) < end { - s.curr_offset = int(old_ptr-begin)+size - return byte_slice(old_memory, size), nil - } - data, err := scratch_allocator_proc(allocator_data, .Alloc, size, alignment, old_memory, old_size, loc) - if err != nil { - return data, err - } - runtime.copy(data, byte_slice(old_memory, old_size)) - _, err = scratch_allocator_proc(allocator_data, .Free, 0, alignment, old_memory, old_size, loc) - return data, err - + scratch_allocator_free_all(s, loc) + case .Resize: + return scratch_allocator_resize(s, old_memory, old_size, size, alignment, loc) + case .Resize_Non_Zeroed: + return scratch_allocator_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Free_All, .Resize, .Resize_Non_Zeroed, .Query_Features} } return nil, nil - case .Query_Info: return nil, .Mode_Not_Implemented } - return nil, nil } From 834f082dbabb807e01f483c6a4d61a51a4dad47c Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 10:24:00 +1100 Subject: [PATCH 04/72] [mem]: Initialize scratch allocator during calls to free and resize --- core/mem/allocators.odin | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 2be4d5b61..4ffb02085 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -261,6 +261,9 @@ scratch_allocator_free :: proc(s: ^Scratch_Allocator, ptr: rawptr, loc := #calle } scratch_allocator_free_all :: proc(s: ^Scratch_Allocator, loc := #caller_location) { + if s.data == nil { + panic("free_all called on an unitialized scratch allocator", loc) + } s.curr_offset = 0 s.prev_allocation = nil for ptr in s.leaked_allocations { @@ -277,6 +280,13 @@ scratch_allocator_resize_non_zeroed :: proc( alignment := DEFAULT_ALIGNMENT, loc := #caller_location ) -> ([]byte, Allocator_Error) { + if s.data == nil { + DEFAULT_BACKING_SIZE :: 4 * Megabyte + if !(context.allocator.procedure != scratch_allocator_proc && context.allocator.data != s) { + panic("cyclic initialization of the scratch allocator with itself", loc) + } + scratch_allocator_init(s, DEFAULT_BACKING_SIZE) + } begin := uintptr(raw_data(s.data)) end := begin + uintptr(len(s.data)) old_ptr := uintptr(old_memory) @@ -318,14 +328,6 @@ scratch_allocator_proc :: proc( loc := #caller_location, ) -> ([]byte, Allocator_Error) { s := (^Scratch_Allocator)(allocator_data) - if s.data == nil { - DEFAULT_BACKING_SIZE :: 4 * Megabyte - if !(context.allocator.procedure != scratch_allocator_proc && - context.allocator.data != allocator_data) { - panic("cyclic initialization of the scratch allocator with itself") - } - scratch_allocator_init(s, DEFAULT_BACKING_SIZE) - } size := size switch mode { case .Alloc: From 9750b64096024990ee84b5727d6db34ffc686948 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 10:55:54 +1100 Subject: [PATCH 05/72] [mem]: API for using stack allocator directly --- core/mem/allocators.odin | 283 +++++++++++++++++++++++---------------- 1 file changed, 169 insertions(+), 114 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 4ffb02085..bade70ce0 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -289,6 +289,7 @@ scratch_allocator_resize_non_zeroed :: proc( } begin := uintptr(raw_data(s.data)) end := begin + uintptr(len(s.data)) + // TODO(flysand): Doesn't handle old_memory == nil old_ptr := uintptr(old_memory) if begin <= old_ptr && old_ptr < end && old_ptr+uintptr(size) < end { s.curr_offset = int(old_ptr-begin)+size @@ -362,10 +363,7 @@ scratch_allocator :: proc(allocator: ^Scratch_Allocator) -> Allocator { } } -Stack_Allocation_Header :: struct { - prev_offset: int, - padding: int, -} + // Stack is a stack-like allocator which has a strict memory freeing order Stack :: struct { @@ -375,6 +373,11 @@ Stack :: struct { peak_used: int, } +Stack_Allocation_Header :: struct { + prev_offset: int, + padding: int, +} + stack_init :: proc(s: ^Stack, data: []byte) { s.data = data s.prev_offset = 0 @@ -398,6 +401,156 @@ stack_allocator :: proc(stack: ^Stack) -> Allocator { } } +stack_allocator_alloc_non_zeroed :: proc( + s: ^Stack, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location +) -> ([]byte, Allocator_Error) { + if s.data == nil { + panic("Stack allocation on an uninitialized stack allocator", loc) + } + curr_addr := uintptr(raw_data(s.data)) + uintptr(s.curr_offset) + padding := calc_padding_with_header( + curr_addr, + uintptr(alignment), + size_of(Stack_Allocation_Header), + ) + if s.curr_offset + padding + size > len(s.data) { + return nil, .Out_Of_Memory + } + s.prev_offset = s.curr_offset + s.curr_offset += padding + next_addr := curr_addr + uintptr(padding) + header := (^Stack_Allocation_Header)(next_addr - size_of(Stack_Allocation_Header)) + header.padding = padding + header.prev_offset = s.prev_offset + s.curr_offset += size + s.peak_used = max(s.peak_used, s.curr_offset) + return byte_slice(rawptr(next_addr), size), nil +} + +stack_allocator_alloc :: proc( + s: ^Stack, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location +) -> ([]byte, Allocator_Error) { + bytes, err := stack_allocator_alloc_non_zeroed(s, size, alignment, loc) + if bytes != nil { + zero_slice(bytes) + } + return bytes, err +} + +stack_allocator_free :: proc( + s: ^Stack, + old_memory: rawptr, + loc := #caller_location, +) -> (Allocator_Error) { + if s.data == nil { + panic("Stack free on an uninitialized stack allocator", loc) + } + if old_memory == nil { + return nil + } + start := uintptr(raw_data(s.data)) + end := start + uintptr(len(s.data)) + curr_addr := uintptr(old_memory) + if !(start <= curr_addr && curr_addr < end) { + panic("Out of bounds memory address passed to stack allocator (free)", loc) + } + if curr_addr >= start+uintptr(s.curr_offset) { + // NOTE(bill): Allow double frees + return nil + } + header := (^Stack_Allocation_Header)(curr_addr - size_of(Stack_Allocation_Header)) + old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data))) + if old_offset != header.prev_offset { + // panic("Out of order stack allocator free"); + return .Invalid_Pointer + } + s.curr_offset = old_offset + s.prev_offset = header.prev_offset + return nil +} + +stack_allocator_free_all :: proc(s: ^Stack) { + if s.data == nil { + panic("Stack free all on an uninitialized stack allocator", loc) + } + s.prev_offset = 0 + s.curr_offset = 0 +} + +stack_allocator_resize_non_zeroed :: proc( + s: ^Stack, + old_memory: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + if s.data == nil { + panic("Stack free all on an uninitialized stack allocator", loc) + } + if old_memory == nil { + return stack_allocator_alloc_non_zeroed(s, size, alignment, loc) + } + if size == 0 { + return nil, nil + } + start := uintptr(raw_data(s.data)) + end := start + uintptr(len(s.data)) + curr_addr := uintptr(old_memory) + if !(start <= curr_addr && curr_addr < end) { + panic("Out of bounds memory address passed to stack allocator (resize)") + } + if curr_addr >= start+uintptr(s.curr_offset) { + // NOTE(bill): Allow double frees + return nil, nil + } + if old_size == size { + return byte_slice(old_memory, size), nil + } + header := (^Stack_Allocation_Header)(curr_addr - size_of(Stack_Allocation_Header)) + old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data))) + if old_offset != header.prev_offset { + data, err := stack_allocator_alloc_non_zeroed(s, size, alignment, loc) + if err == nil { + runtime.copy(data, byte_slice(old_memory, old_size)) + } + return data, err + } + old_memory_size := uintptr(s.curr_offset) - (curr_addr - start) + assert(old_memory_size == uintptr(old_size)) + diff := size - old_size + s.curr_offset += diff // works for smaller sizes too + if diff > 0 { + zero(rawptr(curr_addr + uintptr(diff)), diff) + } + return byte_slice(old_memory, size), nil +} + +stack_allocator_resize :: proc( + s: ^Stack, + old_memory: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + bytes, err := stack_allocator_alloc_non_zeroed(s, size, alignment, loc) + if bytes != nil { + if old_memory == nil { + zero_slice(bytes) + } else if size > old_size { + zero_slice(bytes[old_size:]) + } + } + return bytes, err +} + stack_allocator_proc :: proc( allocator_data: rawptr, mode: Allocator_Mode, @@ -408,121 +561,22 @@ stack_allocator_proc :: proc( location := #caller_location, ) -> ([]byte, Allocator_Error) { s := cast(^Stack)allocator_data - if s.data == nil { return nil, .Invalid_Argument } - - raw_alloc :: proc( - s: ^Stack, - size: int, - alignment: int, - zero_memory: bool, - ) -> ([]byte, Allocator_Error) { - curr_addr := uintptr(raw_data(s.data)) + uintptr(s.curr_offset) - padding := calc_padding_with_header( - curr_addr, - uintptr(alignment), - size_of(Stack_Allocation_Header), - ) - if s.curr_offset + padding + size > len(s.data) { - return nil, .Out_Of_Memory - } - s.prev_offset = s.curr_offset - s.curr_offset += padding - next_addr := curr_addr + uintptr(padding) - header := (^Stack_Allocation_Header)(next_addr - size_of(Stack_Allocation_Header)) - header.padding = padding - header.prev_offset = s.prev_offset - s.curr_offset += size - s.peak_used = max(s.peak_used, s.curr_offset) - if zero_memory { - zero(rawptr(next_addr), size) - } - return byte_slice(rawptr(next_addr), size), nil - } - switch mode { - case .Alloc, .Alloc_Non_Zeroed: - return raw_alloc(s, size, alignment, mode == .Alloc) + case .Alloc: + return stack_allocator_alloc(s, size, alignment, loc) + case .Alloc_Non_Zeroed: + return stack_allocator_alloc_non_zeroed(s, size, alignment, loc) case .Free: - if old_memory == nil { - return nil, nil - } - start := uintptr(raw_data(s.data)) - end := start + uintptr(len(s.data)) - curr_addr := uintptr(old_memory) - - if !(start <= curr_addr && curr_addr < end) { - panic("Out of bounds memory address passed to stack allocator (free)") - } - - if curr_addr >= start+uintptr(s.curr_offset) { - // NOTE(bill): Allow double frees - return nil, nil - } - - header := (^Stack_Allocation_Header)(curr_addr - size_of(Stack_Allocation_Header)) - old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data))) - - if old_offset != header.prev_offset { - // panic("Out of order stack allocator free"); - return nil, .Invalid_Pointer - } - - s.curr_offset = old_offset - s.prev_offset = header.prev_offset - + return nil, stack_allocator_free(s, old_memory, loc) case .Free_All: - s.prev_offset = 0 - s.curr_offset = 0 - - case .Resize, .Resize_Non_Zeroed: - if old_memory == nil { - return raw_alloc(s, size, alignment, mode == .Resize) - } - if size == 0 { - return nil, nil - } - - start := uintptr(raw_data(s.data)) - end := start + uintptr(len(s.data)) - curr_addr := uintptr(old_memory) - if !(start <= curr_addr && curr_addr < end) { - panic("Out of bounds memory address passed to stack allocator (resize)") - } - - if curr_addr >= start+uintptr(s.curr_offset) { - // NOTE(bill): Allow double frees - return nil, nil - } - - if old_size == size { - return byte_slice(old_memory, size), nil - } - - header := (^Stack_Allocation_Header)(curr_addr - size_of(Stack_Allocation_Header)) - old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data))) - - if old_offset != header.prev_offset { - data, err := raw_alloc(s, size, alignment, mode == .Resize) - if err == nil { - runtime.copy(data, byte_slice(old_memory, old_size)) - } - return data, err - } - - old_memory_size := uintptr(s.curr_offset) - (curr_addr - start) - assert(old_memory_size == uintptr(old_size)) - - diff := size - old_size - s.curr_offset += diff // works for smaller sizes too - if diff > 0 { - zero(rawptr(curr_addr + uintptr(diff)), diff) - } - - return byte_slice(old_memory, size), nil - + stack_allocator_free_all(s) + case .Resize: + return stack_allocator_resize(s, old_memory, old_size, size, alignment, loc) + case .Resize_Non_Zeroed: + return stack_allocator_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { @@ -532,10 +586,11 @@ stack_allocator_proc :: proc( case .Query_Info: return nil, .Mode_Not_Implemented } - return nil, nil } + + Small_Stack_Allocation_Header :: struct { padding: u8, } From de220a9aa5382b50a828eef42eb8e5895909b661 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 11:06:59 +1100 Subject: [PATCH 06/72] [mem]: Remove the extra word 'allocator' in procedures --- core/mem/allocators.odin | 95 +++++++++++++++++++++------------------- 1 file changed, 49 insertions(+), 46 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index bade70ce0..97c6d03c9 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -131,9 +131,12 @@ end_arena_temp_memory :: proc(tmp: Arena_Temp_Memory) { tmp.arena.temp_count -= 1 } +/* old procedures */ +Scratch_Allocator :: Scratch +scratch_allocator_init :: scratch_init +scratch_allocator_destroy :: scratch_destroy - -Scratch_Allocator :: struct { +Scratch :: struct { data: []byte, curr_offset: int, prev_allocation: rawptr, @@ -141,7 +144,7 @@ Scratch_Allocator :: struct { leaked_allocations: [dynamic][]byte, } -scratch_allocator_init :: proc(s: ^Scratch_Allocator, size: int, backup_allocator := context.allocator) -> Allocator_Error { +scratch_init :: proc(s: ^Scratch, size: int, backup_allocator := context.allocator) -> Allocator_Error { s.data = make_aligned([]byte, size, 2*align_of(rawptr), backup_allocator) or_return s.curr_offset = 0 s.prev_allocation = nil @@ -150,7 +153,7 @@ scratch_allocator_init :: proc(s: ^Scratch_Allocator, size: int, backup_allocato return nil } -scratch_allocator_destroy :: proc(s: ^Scratch_Allocator) { +scratch_destroy :: proc(s: ^Scratch) { if s == nil { return } @@ -162,21 +165,21 @@ scratch_allocator_destroy :: proc(s: ^Scratch_Allocator) { s^ = {} } -scratch_allocator_alloc :: proc( - s: ^Scratch_Allocator, +scratch_alloc :: proc( + s: ^Scratch, size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location, ) -> ([]byte, Allocator_Error) { - bytes, err := scratch_allocator_alloc_non_zeroed(s, size, alignment, loc) + bytes, err := scratch_alloc_non_zeroed(s, size, alignment, loc) if bytes != nil { zero_slice(bytes) } return bytes, err } -scratch_allocator_alloc_non_zeroed :: proc( - s: ^Scratch_Allocator, +scratch_alloc_non_zeroed :: proc( + s: ^Scratch, size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location, @@ -186,7 +189,7 @@ scratch_allocator_alloc_non_zeroed :: proc( if !(context.allocator.procedure != scratch_allocator_proc && context.allocator.data != s) { panic("cyclic initialization of the scratch allocator with itself", loc) } - scratch_allocator_init(s, DEFAULT_BACKING_SIZE) + scratch_init(s, DEFAULT_BACKING_SIZE) } size := size size = align_forward_int(size, alignment) @@ -222,13 +225,13 @@ scratch_allocator_alloc_non_zeroed :: proc( append(&s.leaked_allocations, ptr) if logger := context.logger; logger.lowest_level <= .Warning { if logger.procedure != nil { - logger.procedure(logger.data, .Warning, "mem.Scratch_Allocator resorted to backup_allocator" , logger.options, loc) + logger.procedure(logger.data, .Warning, "mem.Scratch resorted to backup_allocator" , logger.options, loc) } } return ptr, err } -scratch_allocator_free :: proc(s: ^Scratch_Allocator, ptr: rawptr, loc := #caller_location) -> Allocator_Error { +scratch_free :: proc(s: ^Scratch, ptr: rawptr, loc := #caller_location) -> Allocator_Error { if s.data == nil { panic("Free on an uninitialized scratch allocator", loc) } @@ -260,7 +263,7 @@ scratch_allocator_free :: proc(s: ^Scratch_Allocator, ptr: rawptr, loc := #calle return .Invalid_Pointer } -scratch_allocator_free_all :: proc(s: ^Scratch_Allocator, loc := #caller_location) { +scratch_free_all :: proc(s: ^Scratch, loc := #caller_location) { if s.data == nil { panic("free_all called on an unitialized scratch allocator", loc) } @@ -272,8 +275,8 @@ scratch_allocator_free_all :: proc(s: ^Scratch_Allocator, loc := #caller_locatio clear(&s.leaked_allocations) } -scratch_allocator_resize_non_zeroed :: proc( - s: ^Scratch_Allocator, +scratch_resize_non_zeroed :: proc( + s: ^Scratch, old_memory: rawptr, old_size: int, size: int, @@ -285,7 +288,7 @@ scratch_allocator_resize_non_zeroed :: proc( if !(context.allocator.procedure != scratch_allocator_proc && context.allocator.data != s) { panic("cyclic initialization of the scratch allocator with itself", loc) } - scratch_allocator_init(s, DEFAULT_BACKING_SIZE) + scratch_init(s, DEFAULT_BACKING_SIZE) } begin := uintptr(raw_data(s.data)) end := begin + uintptr(len(s.data)) @@ -295,25 +298,25 @@ scratch_allocator_resize_non_zeroed :: proc( s.curr_offset = int(old_ptr-begin)+size return byte_slice(old_memory, size), nil } - data, err := scratch_allocator_alloc_non_zeroed(s, size, alignment, loc) + data, err := scratch_alloc_non_zeroed(s, size, alignment, loc) if err != nil { return data, err } // TODO(flysand): OOB access on size < old_size. runtime.copy(data, byte_slice(old_memory, old_size)) - err = scratch_allocator_free(s, old_memory, loc) + err = scratch_free(s, old_memory, loc) return data, err } -scratch_allocator_resize :: proc( - s: ^Scratch_Allocator, +scratch_resize :: proc( + s: ^Scratch, old_memory: rawptr, old_size: int, size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location ) -> ([]byte, Allocator_Error) { - bytes, err := scratch_allocator_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) + bytes, err := scratch_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) if bytes != nil && size > old_size { zero_slice(bytes[size:]) } @@ -328,21 +331,21 @@ scratch_allocator_proc :: proc( old_size: int, loc := #caller_location, ) -> ([]byte, Allocator_Error) { - s := (^Scratch_Allocator)(allocator_data) + s := (^Scratch)(allocator_data) size := size switch mode { case .Alloc: - return scratch_allocator_alloc(s, size, alignment, loc) + return scratch_alloc(s, size, alignment, loc) case .Alloc_Non_Zeroed: - return scratch_allocator_alloc_non_zeroed(s, size, alignment, loc) + return scratch_alloc_non_zeroed(s, size, alignment, loc) case .Free: - return nil, scratch_allocator_free(s, old_memory, loc) + return nil, scratch_free(s, old_memory, loc) case .Free_All: - scratch_allocator_free_all(s, loc) + scratch_free_all(s, loc) case .Resize: - return scratch_allocator_resize(s, old_memory, old_size, size, alignment, loc) + return scratch_resize(s, old_memory, old_size, size, alignment, loc) case .Resize_Non_Zeroed: - return scratch_allocator_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) + return scratch_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { @@ -356,7 +359,7 @@ scratch_allocator_proc :: proc( } @(require_results) -scratch_allocator :: proc(allocator: ^Scratch_Allocator) -> Allocator { +scratch_allocator :: proc(allocator: ^Scratch) -> Allocator { return Allocator{ procedure = scratch_allocator_proc, data = allocator, @@ -401,7 +404,7 @@ stack_allocator :: proc(stack: ^Stack) -> Allocator { } } -stack_allocator_alloc_non_zeroed :: proc( +stack_alloc_non_zeroed :: proc( s: ^Stack, size: int, alignment := DEFAULT_ALIGNMENT, @@ -430,20 +433,20 @@ stack_allocator_alloc_non_zeroed :: proc( return byte_slice(rawptr(next_addr), size), nil } -stack_allocator_alloc :: proc( +stack_alloc :: proc( s: ^Stack, size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location ) -> ([]byte, Allocator_Error) { - bytes, err := stack_allocator_alloc_non_zeroed(s, size, alignment, loc) + bytes, err := stack_alloc_non_zeroed(s, size, alignment, loc) if bytes != nil { zero_slice(bytes) } return bytes, err } -stack_allocator_free :: proc( +stack_free :: proc( s: ^Stack, old_memory: rawptr, loc := #caller_location, @@ -475,7 +478,7 @@ stack_allocator_free :: proc( return nil } -stack_allocator_free_all :: proc(s: ^Stack) { +stack_free_all :: proc(s: ^Stack, loc := #caller_location) { if s.data == nil { panic("Stack free all on an uninitialized stack allocator", loc) } @@ -483,7 +486,7 @@ stack_allocator_free_all :: proc(s: ^Stack) { s.curr_offset = 0 } -stack_allocator_resize_non_zeroed :: proc( +stack_resize_non_zeroed :: proc( s: ^Stack, old_memory: rawptr, old_size: int, @@ -495,7 +498,7 @@ stack_allocator_resize_non_zeroed :: proc( panic("Stack free all on an uninitialized stack allocator", loc) } if old_memory == nil { - return stack_allocator_alloc_non_zeroed(s, size, alignment, loc) + return stack_alloc_non_zeroed(s, size, alignment, loc) } if size == 0 { return nil, nil @@ -516,7 +519,7 @@ stack_allocator_resize_non_zeroed :: proc( header := (^Stack_Allocation_Header)(curr_addr - size_of(Stack_Allocation_Header)) old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data))) if old_offset != header.prev_offset { - data, err := stack_allocator_alloc_non_zeroed(s, size, alignment, loc) + data, err := stack_alloc_non_zeroed(s, size, alignment, loc) if err == nil { runtime.copy(data, byte_slice(old_memory, old_size)) } @@ -532,7 +535,7 @@ stack_allocator_resize_non_zeroed :: proc( return byte_slice(old_memory, size), nil } -stack_allocator_resize :: proc( +stack_resize :: proc( s: ^Stack, old_memory: rawptr, old_size: int, @@ -540,7 +543,7 @@ stack_allocator_resize :: proc( alignment := DEFAULT_ALIGNMENT, loc := #caller_location, ) -> ([]byte, Allocator_Error) { - bytes, err := stack_allocator_alloc_non_zeroed(s, size, alignment, loc) + bytes, err := stack_alloc_non_zeroed(s, size, alignment, loc) if bytes != nil { if old_memory == nil { zero_slice(bytes) @@ -558,7 +561,7 @@ stack_allocator_proc :: proc( alignment: int, old_memory: rawptr, old_size: int, - location := #caller_location, + loc := #caller_location, ) -> ([]byte, Allocator_Error) { s := cast(^Stack)allocator_data if s.data == nil { @@ -566,17 +569,17 @@ stack_allocator_proc :: proc( } switch mode { case .Alloc: - return stack_allocator_alloc(s, size, alignment, loc) + return stack_alloc(s, size, alignment, loc) case .Alloc_Non_Zeroed: - return stack_allocator_alloc_non_zeroed(s, size, alignment, loc) + return stack_alloc_non_zeroed(s, size, alignment, loc) case .Free: - return nil, stack_allocator_free(s, old_memory, loc) + return nil, stack_free(s, old_memory, loc) case .Free_All: - stack_allocator_free_all(s) + stack_free_all(s, loc) case .Resize: - return stack_allocator_resize(s, old_memory, old_size, size, alignment, loc) + return stack_resize(s, old_memory, old_size, size, alignment, loc) case .Resize_Non_Zeroed: - return stack_allocator_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) + return stack_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { From 4843db0960abb49de9357d048083a46bb603b2ae Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 12:23:55 +1100 Subject: [PATCH 07/72] [mem]: API for using small stack allocator directly --- core/mem/allocators.odin | 356 ++++++++++++++++++++++----------------- 1 file changed, 203 insertions(+), 153 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 97c6d03c9..a9a362014 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -33,6 +33,14 @@ Arena_Temp_Memory :: struct { prev_offset: int, } +@(require_results) +arena_allocator :: proc(arena: ^Arena) -> Allocator { + return Allocator{ + procedure = arena_allocator_proc, + data = arena, + } +} + arena_init :: proc(a: ^Arena, data: []byte) { a.data = data a.offset = 0 @@ -48,14 +56,6 @@ init_arena :: proc(a: ^Arena, data: []byte) { a.temp_count = 0 } -@(require_results) -arena_allocator :: proc(arena: ^Arena) -> Allocator { - return Allocator{ - procedure = arena_allocator_proc, - data = arena, - } -} - arena_alloc :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([]byte, Allocator_Error) { bytes, err := arena_alloc_non_zeroed(a, size, alignment) if bytes != nil { @@ -144,6 +144,14 @@ Scratch :: struct { leaked_allocations: [dynamic][]byte, } +@(require_results) +scratch_allocator :: proc(allocator: ^Scratch) -> Allocator { + return Allocator{ + procedure = scratch_allocator_proc, + data = allocator, + } +} + scratch_init :: proc(s: ^Scratch, size: int, backup_allocator := context.allocator) -> Allocator_Error { s.data = make_aligned([]byte, size, 2*align_of(rawptr), backup_allocator) or_return s.curr_offset = 0 @@ -275,6 +283,21 @@ scratch_free_all :: proc(s: ^Scratch, loc := #caller_location) { clear(&s.leaked_allocations) } +scratch_resize :: proc( + s: ^Scratch, + old_memory: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location +) -> ([]byte, Allocator_Error) { + bytes, err := scratch_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) + if bytes != nil && size > old_size { + zero_slice(bytes[size:]) + } + return bytes, err +} + scratch_resize_non_zeroed :: proc( s: ^Scratch, old_memory: rawptr, @@ -308,21 +331,6 @@ scratch_resize_non_zeroed :: proc( return data, err } -scratch_resize :: proc( - s: ^Scratch, - old_memory: rawptr, - old_size: int, - size: int, - alignment := DEFAULT_ALIGNMENT, - loc := #caller_location -) -> ([]byte, Allocator_Error) { - bytes, err := scratch_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) - if bytes != nil && size > old_size { - zero_slice(bytes[size:]) - } - return bytes, err -} - scratch_allocator_proc :: proc( allocator_data: rawptr, mode: Allocator_Mode, @@ -358,14 +366,6 @@ scratch_allocator_proc :: proc( return nil, nil } -@(require_results) -scratch_allocator :: proc(allocator: ^Scratch) -> Allocator { - return Allocator{ - procedure = scratch_allocator_proc, - data = allocator, - } -} - // Stack is a stack-like allocator which has a strict memory freeing order @@ -381,6 +381,14 @@ Stack_Allocation_Header :: struct { padding: int, } +@(require_results) +stack_allocator :: proc(stack: ^Stack) -> Allocator { + return Allocator{ + procedure = stack_allocator_proc, + data = stack, + } +} + stack_init :: proc(s: ^Stack, data: []byte) { s.data = data s.prev_offset = 0 @@ -396,12 +404,17 @@ init_stack :: proc(s: ^Stack, data: []byte) { s.peak_used = 0 } -@(require_results) -stack_allocator :: proc(stack: ^Stack) -> Allocator { - return Allocator{ - procedure = stack_allocator_proc, - data = stack, +stack_alloc :: proc( + s: ^Stack, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location +) -> ([]byte, Allocator_Error) { + bytes, err := stack_alloc_non_zeroed(s, size, alignment, loc) + if bytes != nil { + zero_slice(bytes) } + return bytes, err } stack_alloc_non_zeroed :: proc( @@ -433,19 +446,6 @@ stack_alloc_non_zeroed :: proc( return byte_slice(rawptr(next_addr), size), nil } -stack_alloc :: proc( - s: ^Stack, - size: int, - alignment := DEFAULT_ALIGNMENT, - loc := #caller_location -) -> ([]byte, Allocator_Error) { - bytes, err := stack_alloc_non_zeroed(s, size, alignment, loc) - if bytes != nil { - zero_slice(bytes) - } - return bytes, err -} - stack_free :: proc( s: ^Stack, old_memory: rawptr, @@ -486,6 +486,25 @@ stack_free_all :: proc(s: ^Stack, loc := #caller_location) { s.curr_offset = 0 } +stack_resize :: proc( + s: ^Stack, + old_memory: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + bytes, err := stack_alloc_non_zeroed(s, size, alignment, loc) + if bytes != nil { + if old_memory == nil { + zero_slice(bytes) + } else if size > old_size { + zero_slice(bytes[old_size:]) + } + } + return bytes, err +} + stack_resize_non_zeroed :: proc( s: ^Stack, old_memory: rawptr, @@ -535,25 +554,6 @@ stack_resize_non_zeroed :: proc( return byte_slice(old_memory, size), nil } -stack_resize :: proc( - s: ^Stack, - old_memory: rawptr, - old_size: int, - size: int, - alignment := DEFAULT_ALIGNMENT, - loc := #caller_location, -) -> ([]byte, Allocator_Error) { - bytes, err := stack_alloc_non_zeroed(s, size, alignment, loc) - if bytes != nil { - if old_memory == nil { - zero_slice(bytes) - } else if size > old_size { - zero_slice(bytes[old_size:]) - } - } - return bytes, err -} - stack_allocator_proc :: proc( allocator_data: rawptr, mode: Allocator_Mode, @@ -626,6 +626,129 @@ small_stack_allocator :: proc(stack: ^Small_Stack) -> Allocator { } } +small_stack_alloc :: proc( + s: ^Small_Stack, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + bytes, err := small_stack_alloc_non_zeroed(s, size, alignment, loc) + if bytes != nil { + zero_slice(bytes) + } + return bytes, err +} + +small_stack_alloc_non_zeroed :: proc( + s: ^Small_Stack, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + if s.data == nil { + return nil, .Invalid_Argument + } + alignment := alignment + alignment := clamp(alignment, 1, 8*size_of(Stack_Allocation_Header{}.padding)/2) + curr_addr := uintptr(raw_data(s.data)) + uintptr(s.offset) + padding := calc_padding_with_header(curr_addr, uintptr(alignment), size_of(Small_Stack_Allocation_Header)) + if s.offset + padding + size > len(s.data) { + return nil, .Out_Of_Memory + } + s.offset += padding + next_addr := curr_addr + uintptr(padding) + header := (^Small_Stack_Allocation_Header)(next_addr - size_of(Small_Stack_Allocation_Header)) + header.padding = auto_cast padding + s.offset += size + s.peak_used = max(s.peak_used, s.offset) + return byte_slice(rawptr(next_addr), size), nil +} + +small_stack_free :: proc( + s: ^Small_Stack, + old_memory: rawptr, + loc := #caller_location, +) -> Allocator_Error { + if old_memory == nil { + return nil, nil + } + start := uintptr(raw_data(s.data)) + end := start + uintptr(len(s.data)) + curr_addr := uintptr(old_memory) + if !(start <= curr_addr && curr_addr < end) { + // panic("Out of bounds memory address passed to stack allocator (free)"); + return nil, .Invalid_Pointer + } + if curr_addr >= start+uintptr(s.offset) { + // NOTE(bill): Allow double frees + return nil, nil + } + header := (^Small_Stack_Allocation_Header)(curr_addr - size_of(Small_Stack_Allocation_Header)) + old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data))) + s.offset = old_offset +} + +small_stack_free_all :: proc(s: ^Small_Stack) { + s.offset = 0 +} + +small_stack_resize :: proc( + s: ^Small_Stack, + old_memory: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + bytes, err := small_stack_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) + if bytes != nil { + if old_memory == nil { + zero_slice(bytes) + } else if size > old_size { + zero_slice(bytes[old_size:]) + } + } + return bytes, err +} + +small_stack_resize_non_zeroed :: proc( + s: ^Small_Stack, + old_memory: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + if old_memory == nil { + return small_stack_alloc_non_zeroed(s, size, align, loc) + } + if size == 0 { + return nil, nil + } + alignment := alignment + alignment := clamp(alignment, 1, 8*size_of(Stack_Allocation_Header{}.padding)/2) + start := uintptr(raw_data(s.data)) + end := start + uintptr(len(s.data)) + curr_addr := uintptr(old_memory) + if !(start <= curr_addr && curr_addr < end) { + // panic("Out of bounds memory address passed to stack allocator (resize)"); + return nil, .Invalid_Pointer + } + if curr_addr >= start+uintptr(s.offset) { + // NOTE(bill): Treat as a double free + return nil, nil + } + if old_size == size { + return byte_slice(old_memory, size), nil + } + data, err := small_stack_alloc_non_zeroed(s, size, alignment, loc) + if err == nil { + runtime.copy(data, byte_slice(old_memory, old_size)) + } + return data, err + +} + small_stack_allocator_proc :: proc( allocator_data: rawptr, mode: Allocator_Mode, @@ -635,109 +758,36 @@ small_stack_allocator_proc :: proc( location := #caller_location, ) -> ([]byte, Allocator_Error) { s := cast(^Small_Stack)allocator_data - if s.data == nil { return nil, .Invalid_Argument } - - align := clamp(alignment, 1, 8*size_of(Stack_Allocation_Header{}.padding)/2) - - raw_alloc :: proc(s: ^Small_Stack, size, alignment: int, zero_memory: bool) -> ([]byte, Allocator_Error) { - curr_addr := uintptr(raw_data(s.data)) + uintptr(s.offset) - padding := calc_padding_with_header(curr_addr, uintptr(alignment), size_of(Small_Stack_Allocation_Header)) - if s.offset + padding + size > len(s.data) { - return nil, .Out_Of_Memory - } - s.offset += padding - - next_addr := curr_addr + uintptr(padding) - header := (^Small_Stack_Allocation_Header)(next_addr - size_of(Small_Stack_Allocation_Header)) - header.padding = auto_cast padding - - s.offset += size - - s.peak_used = max(s.peak_used, s.offset) - - if zero_memory { - zero(rawptr(next_addr), size) - } - return byte_slice(rawptr(next_addr), size), nil - } - switch mode { - case .Alloc, .Alloc_Non_Zeroed: - return raw_alloc(s, size, align, mode == .Alloc) + case .Alloc: + return small_stack_alloc(s, size, alignment, loc) + case .Alloc_Non_Zeroed: + return small_stack_alloc_non_zeroed(s, size, alignment, loc) case .Free: - if old_memory == nil { - return nil, nil - } - start := uintptr(raw_data(s.data)) - end := start + uintptr(len(s.data)) - curr_addr := uintptr(old_memory) - - if !(start <= curr_addr && curr_addr < end) { - // panic("Out of bounds memory address passed to stack allocator (free)"); - return nil, .Invalid_Pointer - } - - if curr_addr >= start+uintptr(s.offset) { - // NOTE(bill): Allow double frees - return nil, nil - } - - header := (^Small_Stack_Allocation_Header)(curr_addr - size_of(Small_Stack_Allocation_Header)) - old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data))) - - s.offset = old_offset - + return nil, small_stack_free(s, old_memory, loc) case .Free_All: - s.offset = 0 - - case .Resize, .Resize_Non_Zeroed: - if old_memory == nil { - return raw_alloc(s, size, align, mode == .Resize) - } - if size == 0 { - return nil, nil - } - - start := uintptr(raw_data(s.data)) - end := start + uintptr(len(s.data)) - curr_addr := uintptr(old_memory) - if !(start <= curr_addr && curr_addr < end) { - // panic("Out of bounds memory address passed to stack allocator (resize)"); - return nil, .Invalid_Pointer - } - - if curr_addr >= start+uintptr(s.offset) { - // NOTE(bill): Treat as a double free - return nil, nil - } - - if old_size == size { - return byte_slice(old_memory, size), nil - } - - data, err := raw_alloc(s, size, align, mode == .Resize) - if err == nil { - runtime.copy(data, byte_slice(old_memory, old_size)) - } - return data, err - + small_stack_free_all(s) + case .Resize: + return small_stack_resize(s, old_memory, old_size, size, alignment, loc) + case .Resize_Non_Zeroed: + return small_stack_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Free_All, .Resize, .Resize_Non_Zeroed, .Query_Features} } return nil, nil - case .Query_Info: return nil, .Mode_Not_Implemented } - return nil, nil } + + Dynamic_Pool :: struct { block_size: int, out_band_size: int, From aea3e9a585e07765a1d5c71448460665e25414e2 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 12:26:47 +1100 Subject: [PATCH 08/72] [mem]: Fix vet errors --- core/mem/allocators.odin | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index a9a362014..2d9d6d114 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -649,7 +649,7 @@ small_stack_alloc_non_zeroed :: proc( return nil, .Invalid_Argument } alignment := alignment - alignment := clamp(alignment, 1, 8*size_of(Stack_Allocation_Header{}.padding)/2) + alignment = clamp(alignment, 1, 8*size_of(Stack_Allocation_Header{}.padding)/2) curr_addr := uintptr(raw_data(s.data)) + uintptr(s.offset) padding := calc_padding_with_header(curr_addr, uintptr(alignment), size_of(Small_Stack_Allocation_Header)) if s.offset + padding + size > len(s.data) { @@ -670,22 +670,23 @@ small_stack_free :: proc( loc := #caller_location, ) -> Allocator_Error { if old_memory == nil { - return nil, nil + return nil } start := uintptr(raw_data(s.data)) end := start + uintptr(len(s.data)) curr_addr := uintptr(old_memory) if !(start <= curr_addr && curr_addr < end) { // panic("Out of bounds memory address passed to stack allocator (free)"); - return nil, .Invalid_Pointer + return .Invalid_Pointer } if curr_addr >= start+uintptr(s.offset) { // NOTE(bill): Allow double frees - return nil, nil + return nil } header := (^Small_Stack_Allocation_Header)(curr_addr - size_of(Small_Stack_Allocation_Header)) old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data))) s.offset = old_offset + return nil } small_stack_free_all :: proc(s: ^Small_Stack) { @@ -719,14 +720,14 @@ small_stack_resize_non_zeroed :: proc( alignment := DEFAULT_ALIGNMENT, loc := #caller_location, ) -> ([]byte, Allocator_Error) { + alignment := alignment + alignment = clamp(alignment, 1, 8*size_of(Stack_Allocation_Header{}.padding)/2) if old_memory == nil { - return small_stack_alloc_non_zeroed(s, size, align, loc) + return small_stack_alloc_non_zeroed(s, size, alignment, loc) } if size == 0 { return nil, nil } - alignment := alignment - alignment := clamp(alignment, 1, 8*size_of(Stack_Allocation_Header{}.padding)/2) start := uintptr(raw_data(s.data)) end := start + uintptr(len(s.data)) curr_addr := uintptr(old_memory) @@ -755,7 +756,7 @@ small_stack_allocator_proc :: proc( size, alignment: int, old_memory: rawptr, old_size: int, - location := #caller_location, + loc := #caller_location, ) -> ([]byte, Allocator_Error) { s := cast(^Small_Stack)allocator_data if s.data == nil { From f8641ddd1b096663ed45f9179014ff5201b65225 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 12:33:12 +1100 Subject: [PATCH 09/72] [mem]: Rename dynamic pool to dynamic arena --- core/mem/allocators.odin | 61 ++++++++++++++++++++++++---------------- 1 file changed, 36 insertions(+), 25 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 2d9d6d114..7c33d1c9f 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -788,8 +788,19 @@ small_stack_allocator_proc :: proc( } +/* old stuff */ +Dynamic_Pool :: Dynamic_Arena +DYNAMIC_POOL_BLOCK_SIZE_DEFAULT :: DYNAMIC_ARENA_BLOCK_SIZE_DEFAULT +DYNAMIC_POOL_OUT_OF_BAND_SIZE_DEFAULT :: DYNAMIC_ARENA_OUT_OF_BAND_SIZE_DEFAULT +dynamic_pool_allocator_proc :: dynamic_arena_allocator_proc +dynamic_pool_free_all :: dynamic_arena_free_all +dynamic_pool_reset :: dynamic_arena_reset +dynamic_pool_alloc_bytes :: dynamic_arena_alloc_bytes +dynamic_pool_alloc :: dynamic_arena_alloc +dynamic_pool_init :: dynamic_arena_init +dynamic_pool_allocator :: dynamic_arena_allocator -Dynamic_Pool :: struct { +Dynamic_Arena :: struct { block_size: int, out_band_size: int, alignment: int, @@ -805,10 +816,10 @@ Dynamic_Pool :: struct { block_allocator: Allocator, } -DYNAMIC_POOL_BLOCK_SIZE_DEFAULT :: 65536 -DYNAMIC_POOL_OUT_OF_BAND_SIZE_DEFAULT :: 6554 +DYNAMIC_ARENA_BLOCK_SIZE_DEFAULT :: 65536 +DYNAMIC_ARENA_OUT_OF_BAND_SIZE_DEFAULT :: 6554 -dynamic_pool_allocator_proc :: proc( +dynamic_arena_allocator_proc :: proc( allocator_data: rawptr, mode: Allocator_Mode, size: int, @@ -817,21 +828,21 @@ dynamic_pool_allocator_proc :: proc( old_size: int, loc := #caller_location, ) -> ([]byte, Allocator_Error) { - pool := (^Dynamic_Pool)(allocator_data) + pool := (^Dynamic_Arena)(allocator_data) switch mode { case .Alloc, .Alloc_Non_Zeroed: - return dynamic_pool_alloc_bytes(pool, size) + return dynamic_arena_alloc_bytes(pool, size) case .Free: return nil, .Mode_Not_Implemented case .Free_All: - dynamic_pool_free_all(pool) + dynamic_arena_free_all(pool) return nil, nil case .Resize, .Resize_Non_Zeroed: if old_size >= size { return byte_slice(old_memory, size), nil } - data, err := dynamic_pool_alloc_bytes(pool, size) + data, err := dynamic_arena_alloc_bytes(pool, size) if err == nil { runtime.copy(data, byte_slice(old_memory, old_size)) } @@ -856,21 +867,20 @@ dynamic_pool_allocator_proc :: proc( return nil, nil } - @(require_results) -dynamic_pool_allocator :: proc(pool: ^Dynamic_Pool) -> Allocator { +dynamic_arena_allocator :: proc(pool: ^Dynamic_Arena) -> Allocator { return Allocator{ - procedure = dynamic_pool_allocator_proc, + procedure = dynamic_arena_allocator_proc, data = pool, } } -dynamic_pool_init :: proc( - pool: ^Dynamic_Pool, +dynamic_arena_init :: proc( + pool: ^Dynamic_Arena, block_allocator := context.allocator, array_allocator := context.allocator, - block_size := DYNAMIC_POOL_BLOCK_SIZE_DEFAULT, - out_band_size := DYNAMIC_POOL_OUT_OF_BAND_SIZE_DEFAULT, + block_size := DYNAMIC_ARENA_BLOCK_SIZE_DEFAULT, + out_band_size := DYNAMIC_ARENA_OUT_OF_BAND_SIZE_DEFAULT, alignment := 8, ) { pool.block_size = block_size @@ -882,8 +892,8 @@ dynamic_pool_init :: proc( pool.used_blocks.allocator = array_allocator } -dynamic_pool_destroy :: proc(pool: ^Dynamic_Pool) { - dynamic_pool_free_all(pool) +dynamic_arena_destroy :: proc(pool: ^Dynamic_Arena) { + dynamic_arena_free_all(pool) delete(pool.unused_blocks) delete(pool.used_blocks) delete(pool.out_band_allocations) @@ -891,14 +901,14 @@ dynamic_pool_destroy :: proc(pool: ^Dynamic_Pool) { } @(require_results) -dynamic_pool_alloc :: proc(pool: ^Dynamic_Pool, bytes: int) -> (rawptr, Allocator_Error) { - data, err := dynamic_pool_alloc_bytes(pool, bytes) +dynamic_arena_alloc :: proc(pool: ^Dynamic_Arena, bytes: int) -> (rawptr, Allocator_Error) { + data, err := dynamic_arena_alloc_bytes(pool, bytes) return raw_data(data), err } @(require_results) -dynamic_pool_alloc_bytes :: proc(p: ^Dynamic_Pool, bytes: int) -> ([]byte, Allocator_Error) { - cycle_new_block :: proc(p: ^Dynamic_Pool) -> (err: Allocator_Error) { +dynamic_arena_alloc_bytes :: proc(p: ^Dynamic_Arena, bytes: int) -> ([]byte, Allocator_Error) { + cycle_new_block :: proc(p: ^Dynamic_Arena) -> (err: Allocator_Error) { if p.block_allocator.procedure == nil { panic("You must call pool_init on a Pool before using it") } @@ -960,8 +970,7 @@ dynamic_pool_alloc_bytes :: proc(p: ^Dynamic_Pool, bytes: int) -> ([]byte, Alloc return ([^]byte)(memory)[:bytes], nil } - -dynamic_pool_reset :: proc(p: ^Dynamic_Pool) { +dynamic_arena_reset :: proc(p: ^Dynamic_Arena) { if p.current_block != nil { append(&p.unused_blocks, p.current_block) p.current_block = nil @@ -980,8 +989,8 @@ dynamic_pool_reset :: proc(p: ^Dynamic_Pool) { p.bytes_left = 0 // Make new allocations call `cycle_new_block` again. } -dynamic_pool_free_all :: proc(p: ^Dynamic_Pool) { - dynamic_pool_reset(p) +dynamic_arena_free_all :: proc(p: ^Dynamic_Arena) { + dynamic_arena_reset(p) for block in p.unused_blocks { free(block, p.block_allocator) @@ -989,6 +998,8 @@ dynamic_pool_free_all :: proc(p: ^Dynamic_Pool) { clear(&p.unused_blocks) } + + panic_allocator_proc :: proc( allocator_data: rawptr, mode: Allocator_Mode, From 03f6b9bbf6bdd9ccf2f566a2da108d1f8b3a38e1 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 12:59:19 +1100 Subject: [PATCH 10/72] [mem]: Add alloc_non_zeroed variant to dynamic pool --- core/mem/allocators.odin | 303 +++++++++++++++++++-------------------- 1 file changed, 151 insertions(+), 152 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 7c33d1c9f..4c6ab09b1 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -795,30 +795,158 @@ DYNAMIC_POOL_OUT_OF_BAND_SIZE_DEFAULT :: DYNAMIC_ARENA_OUT_OF_BAND_SIZE_DEFAULT dynamic_pool_allocator_proc :: dynamic_arena_allocator_proc dynamic_pool_free_all :: dynamic_arena_free_all dynamic_pool_reset :: dynamic_arena_reset -dynamic_pool_alloc_bytes :: dynamic_arena_alloc_bytes -dynamic_pool_alloc :: dynamic_arena_alloc +dynamic_pool_alloc_bytes :: dynamic_arena_alloc +dynamic_pool_alloc :: _dynamic_arena_alloc_ptr dynamic_pool_init :: dynamic_arena_init dynamic_pool_allocator :: dynamic_arena_allocator - -Dynamic_Arena :: struct { - block_size: int, - out_band_size: int, - alignment: int, - - unused_blocks: [dynamic]rawptr, - used_blocks: [dynamic]rawptr, - out_band_allocations: [dynamic]rawptr, - - current_block: rawptr, - current_pos: rawptr, - bytes_left: int, - - block_allocator: Allocator, -} +dynamic_pool_destroy :: dynamic_arena_destroy DYNAMIC_ARENA_BLOCK_SIZE_DEFAULT :: 65536 DYNAMIC_ARENA_OUT_OF_BAND_SIZE_DEFAULT :: 6554 +Dynamic_Arena :: struct { + block_size: int, + out_band_size: int, + alignment: int, + unused_blocks: [dynamic]rawptr, + used_blocks: [dynamic]rawptr, + out_band_allocations: [dynamic]rawptr, + current_block: rawptr, + current_pos: rawptr, + bytes_left: int, + block_allocator: Allocator, +} + +dynamic_arena_init :: proc( + pool: ^Dynamic_Arena, + block_allocator := context.allocator, + array_allocator := context.allocator, + block_size := DYNAMIC_ARENA_BLOCK_SIZE_DEFAULT, + out_band_size := DYNAMIC_ARENA_OUT_OF_BAND_SIZE_DEFAULT, + alignment := DEFAULT_ALIGNMENT, +) { + pool.block_size = block_size + pool.out_band_size = out_band_size + pool.alignment = alignment + pool.block_allocator = block_allocator + pool.out_band_allocations.allocator = array_allocator + pool.unused_blocks.allocator = array_allocator + pool.used_blocks.allocator = array_allocator +} + +@(require_results) +dynamic_arena_allocator :: proc(pool: ^Dynamic_Arena) -> Allocator { + return Allocator{ + procedure = dynamic_arena_allocator_proc, + data = pool, + } +} + +dynamic_arena_destroy :: proc(pool: ^Dynamic_Arena) { + dynamic_arena_free_all(pool) + delete(pool.unused_blocks) + delete(pool.used_blocks) + delete(pool.out_band_allocations) + zero(pool, size_of(pool^)) +} + +@(private="file") +_dynamic_arena_cycle_new_block :: proc(p: ^Dynamic_Arena, loc := #caller_location) -> (err: Allocator_Error) { + if p.block_allocator.procedure == nil { + panic("You must call pool_init on a Pool before using it", loc) + } + if p.current_block != nil { + append(&p.used_blocks, p.current_block, loc=loc) + } + new_block: rawptr + if len(p.unused_blocks) > 0 { + new_block = pop(&p.unused_blocks) + } else { + data: []byte + data, err = p.block_allocator.procedure( + p.block_allocator.data, + Allocator_Mode.Alloc, + p.block_size, + p.alignment, + nil, + 0, + ) + new_block = raw_data(data) + } + p.bytes_left = p.block_size + p.current_pos = new_block + p.current_block = new_block + return +} + +@(private, require_results) +_dynamic_arena_alloc_ptr :: proc(pool: ^Dynamic_Arena, size: int, loc := #caller_location) -> (rawptr, Allocator_Error) { + data, err := dynamic_arena_alloc(pool, size, loc) + return raw_data(data), err +} + +@(require_results) +dynamic_arena_alloc :: proc(p: ^Dynamic_Arena, size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { + bytes, err := dynamic_arena_alloc_non_zeroed(p, size, loc) + if bytes != nil { + zero_slice(bytes) + } + return bytes, err +} + +@(require_results) +dynamic_arena_alloc_non_zeroed :: proc(p: ^Dynamic_Arena, size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { + n := align_formula(size, p.alignment) + if n > p.block_size { + return nil, .Invalid_Argument + } + if n >= p.out_band_size { + assert(p.block_allocator.procedure != nil, "Backing block allocator must be initialized", loc=loc) + memory, err := alloc_bytes_non_zeroed(p.block_size, p.alignment, p.block_allocator, loc) + if memory != nil { + append(&p.out_band_allocations, raw_data(memory), loc = loc) + } + return memory, err + } + if p.bytes_left < n { + err := _dynamic_arena_cycle_new_block(p, loc) + if err != nil { + return nil, err + } + if p.current_block == nil { + return nil, .Out_Of_Memory + } + } + memory := p.current_pos + p.current_pos = ([^]byte)(p.current_pos)[n:] + p.bytes_left -= n + return ([^]byte)(memory)[:size], nil +} + +dynamic_arena_reset :: proc(p: ^Dynamic_Arena, loc := #caller_location) { + if p.current_block != nil { + append(&p.unused_blocks, p.current_block, loc=loc) + p.current_block = nil + } + for block in p.used_blocks { + append(&p.unused_blocks, block, loc=loc) + } + clear(&p.used_blocks) + for a in p.out_band_allocations { + free(a, p.block_allocator, loc=loc) + } + clear(&p.out_band_allocations) + p.bytes_left = 0 // Make new allocations call `_dynamic_arena_cycle_new_block` again. +} + +dynamic_arena_free_all :: proc(p: ^Dynamic_Arena) { + dynamic_arena_reset(p) + for block in p.unused_blocks { + free(block, p.block_allocator) + } + clear(&p.unused_blocks) +} + dynamic_arena_allocator_proc :: proc( allocator_data: rawptr, mode: Allocator_Mode, @@ -831,8 +959,10 @@ dynamic_arena_allocator_proc :: proc( pool := (^Dynamic_Arena)(allocator_data) switch mode { - case .Alloc, .Alloc_Non_Zeroed: - return dynamic_arena_alloc_bytes(pool, size) + case .Alloc: + return dynamic_arena_alloc(pool, size, loc) + case .Alloc_Non_Zeroed: + return dynamic_arena_alloc_non_zeroed(pool, size, loc) case .Free: return nil, .Mode_Not_Implemented case .Free_All: @@ -842,7 +972,7 @@ dynamic_arena_allocator_proc :: proc( if old_size >= size { return byte_slice(old_memory, size), nil } - data, err := dynamic_arena_alloc_bytes(pool, size) + data, err := dynamic_arena_alloc(pool, size) if err == nil { runtime.copy(data, byte_slice(old_memory, old_size)) } @@ -867,137 +997,6 @@ dynamic_arena_allocator_proc :: proc( return nil, nil } -@(require_results) -dynamic_arena_allocator :: proc(pool: ^Dynamic_Arena) -> Allocator { - return Allocator{ - procedure = dynamic_arena_allocator_proc, - data = pool, - } -} - -dynamic_arena_init :: proc( - pool: ^Dynamic_Arena, - block_allocator := context.allocator, - array_allocator := context.allocator, - block_size := DYNAMIC_ARENA_BLOCK_SIZE_DEFAULT, - out_band_size := DYNAMIC_ARENA_OUT_OF_BAND_SIZE_DEFAULT, - alignment := 8, -) { - pool.block_size = block_size - pool.out_band_size = out_band_size - pool.alignment = alignment - pool.block_allocator = block_allocator - pool.out_band_allocations.allocator = array_allocator - pool.unused_blocks.allocator = array_allocator - pool.used_blocks.allocator = array_allocator -} - -dynamic_arena_destroy :: proc(pool: ^Dynamic_Arena) { - dynamic_arena_free_all(pool) - delete(pool.unused_blocks) - delete(pool.used_blocks) - delete(pool.out_band_allocations) - zero(pool, size_of(pool^)) -} - -@(require_results) -dynamic_arena_alloc :: proc(pool: ^Dynamic_Arena, bytes: int) -> (rawptr, Allocator_Error) { - data, err := dynamic_arena_alloc_bytes(pool, bytes) - return raw_data(data), err -} - -@(require_results) -dynamic_arena_alloc_bytes :: proc(p: ^Dynamic_Arena, bytes: int) -> ([]byte, Allocator_Error) { - cycle_new_block :: proc(p: ^Dynamic_Arena) -> (err: Allocator_Error) { - if p.block_allocator.procedure == nil { - panic("You must call pool_init on a Pool before using it") - } - - if p.current_block != nil { - append(&p.used_blocks, p.current_block) - } - - new_block: rawptr - if len(p.unused_blocks) > 0 { - new_block = pop(&p.unused_blocks) - } else { - data: []byte - data, err = p.block_allocator.procedure( - p.block_allocator.data, - Allocator_Mode.Alloc, - p.block_size, - p.alignment, - nil, - 0, - ) - new_block = raw_data(data) - } - - p.bytes_left = p.block_size - p.current_pos = new_block - p.current_block = new_block - return - } - - n := align_formula(bytes, p.alignment) - if n > p.block_size { - return nil, .Invalid_Argument - } - if n >= p.out_band_size { - assert(p.block_allocator.procedure != nil) - memory, err := p.block_allocator.procedure(p.block_allocator.data, Allocator_Mode.Alloc, - p.block_size, p.alignment, - nil, 0) - if memory != nil { - append(&p.out_band_allocations, raw_data(memory)) - } - return memory, err - } - - if p.bytes_left < n { - err := cycle_new_block(p) - if err != nil { - return nil, err - } - if p.current_block == nil { - return nil, .Out_Of_Memory - } - } - - memory := p.current_pos - p.current_pos = ([^]byte)(p.current_pos)[n:] - p.bytes_left -= n - return ([^]byte)(memory)[:bytes], nil -} - -dynamic_arena_reset :: proc(p: ^Dynamic_Arena) { - if p.current_block != nil { - append(&p.unused_blocks, p.current_block) - p.current_block = nil - } - - for block in p.used_blocks { - append(&p.unused_blocks, block) - } - clear(&p.used_blocks) - - for a in p.out_band_allocations { - free(a, p.block_allocator) - } - clear(&p.out_band_allocations) - - p.bytes_left = 0 // Make new allocations call `cycle_new_block` again. -} - -dynamic_arena_free_all :: proc(p: ^Dynamic_Arena) { - dynamic_arena_reset(p) - - for block in p.unused_blocks { - free(block, p.block_allocator) - } - clear(&p.unused_blocks) -} - panic_allocator_proc :: proc( From b350a35b7738c6f7ba7ee65dd403b86de32213c5 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 13:10:29 +1100 Subject: [PATCH 11/72] [mem]: Add resize_non_zeroed variant to dynamic arena, and rename pool to arena --- core/mem/allocators.odin | 126 +++++++++++++++++++++++---------------- 1 file changed, 76 insertions(+), 50 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 4c6ab09b1..d7e3cfbfd 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -880,14 +880,14 @@ _dynamic_arena_cycle_new_block :: proc(p: ^Dynamic_Arena, loc := #caller_locatio } @(private, require_results) -_dynamic_arena_alloc_ptr :: proc(pool: ^Dynamic_Arena, size: int, loc := #caller_location) -> (rawptr, Allocator_Error) { - data, err := dynamic_arena_alloc(pool, size, loc) +_dynamic_arena_alloc_ptr :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_location) -> (rawptr, Allocator_Error) { + data, err := dynamic_arena_alloc(a, size, loc) return raw_data(data), err } @(require_results) -dynamic_arena_alloc :: proc(p: ^Dynamic_Arena, size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { - bytes, err := dynamic_arena_alloc_non_zeroed(p, size, loc) +dynamic_arena_alloc :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { + bytes, err := dynamic_arena_alloc_non_zeroed(a, size, loc) if bytes != nil { zero_slice(bytes) } @@ -895,56 +895,91 @@ dynamic_arena_alloc :: proc(p: ^Dynamic_Arena, size: int, loc := #caller_locatio } @(require_results) -dynamic_arena_alloc_non_zeroed :: proc(p: ^Dynamic_Arena, size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { - n := align_formula(size, p.alignment) - if n > p.block_size { +dynamic_arena_alloc_non_zeroed :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { + n := align_formula(size, a.alignment) + if n > a.block_size { return nil, .Invalid_Argument } - if n >= p.out_band_size { - assert(p.block_allocator.procedure != nil, "Backing block allocator must be initialized", loc=loc) - memory, err := alloc_bytes_non_zeroed(p.block_size, p.alignment, p.block_allocator, loc) + if n >= a.out_band_size { + assert(a.block_allocator.procedure != nil, "Backing block allocator must be initialized", loc=loc) + memory, err := alloc_bytes_non_zeroed(a.block_size, a.alignment, a.block_allocator, loc) if memory != nil { - append(&p.out_band_allocations, raw_data(memory), loc = loc) + append(&a.out_band_allocations, raw_data(memory), loc = loc) } return memory, err } - if p.bytes_left < n { - err := _dynamic_arena_cycle_new_block(p, loc) + if a.bytes_left < n { + err := _dynamic_arena_cycle_new_block(a, loc) if err != nil { return nil, err } - if p.current_block == nil { + if a.current_block == nil { return nil, .Out_Of_Memory } } - memory := p.current_pos - p.current_pos = ([^]byte)(p.current_pos)[n:] - p.bytes_left -= n + memory := a.current_pos + a.current_pos = ([^]byte)(a.current_pos)[n:] + a.bytes_left -= n return ([^]byte)(memory)[:size], nil } -dynamic_arena_reset :: proc(p: ^Dynamic_Arena, loc := #caller_location) { - if p.current_block != nil { - append(&p.unused_blocks, p.current_block, loc=loc) - p.current_block = nil +dynamic_arena_reset :: proc(a: ^Dynamic_Arena, loc := #caller_location) { + if a.current_block != nil { + append(&a.unused_blocks, a.current_block, loc=loc) + a.current_block = nil } - for block in p.used_blocks { - append(&p.unused_blocks, block, loc=loc) + for block in a.used_blocks { + append(&a.unused_blocks, block, loc=loc) } - clear(&p.used_blocks) - for a in p.out_band_allocations { - free(a, p.block_allocator, loc=loc) + clear(&a.used_blocks) + for a in a.out_band_allocations { + free(a, a.block_allocator, loc=loc) } - clear(&p.out_band_allocations) - p.bytes_left = 0 // Make new allocations call `_dynamic_arena_cycle_new_block` again. + clear(&a.out_band_allocations) + a.bytes_left = 0 // Make new allocations call `_dynamic_arena_cycle_new_block` again. } -dynamic_arena_free_all :: proc(p: ^Dynamic_Arena) { - dynamic_arena_reset(p) - for block in p.unused_blocks { - free(block, p.block_allocator) +dynamic_arena_free_all :: proc(a: ^Dynamic_Arena, loc := #caller_location) { + dynamic_arena_reset(a) + for block in a.unused_blocks { + free(block, a.block_allocator, loc) } - clear(&p.unused_blocks) + clear(&a.unused_blocks) +} + +dynamic_arena_resize :: proc( + a: ^Dynamic_Arena, + old_memory: rawptr, + old_size: int, + size: int, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + bytes, err := dynamic_arena_resize_non_zeroed(a, old_memory, old_size, size, loc) + if bytes != nil { + if old_memory == nil { + zero_slice(bytes) + } else if size > old_size { + zero_slice(bytes[old_size:]) + } + } + return bytes, err +} + +dynamic_arena_resize_non_zeroed :: proc( + a: ^Dynamic_Arena, + old_memory: rawptr, + old_size: int, + size: int, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + if old_size >= size { + return byte_slice(old_memory, size), nil + } + data, err := dynamic_arena_alloc_non_zeroed(a, size, loc) + if err == nil { + runtime.copy(data, byte_slice(old_memory, old_size)) + } + return data, err } dynamic_arena_allocator_proc :: proc( @@ -956,35 +991,26 @@ dynamic_arena_allocator_proc :: proc( old_size: int, loc := #caller_location, ) -> ([]byte, Allocator_Error) { - pool := (^Dynamic_Arena)(allocator_data) - + arena := (^Dynamic_Arena)(allocator_data) switch mode { case .Alloc: - return dynamic_arena_alloc(pool, size, loc) + return dynamic_arena_alloc(arena, size, loc) case .Alloc_Non_Zeroed: - return dynamic_arena_alloc_non_zeroed(pool, size, loc) + return dynamic_arena_alloc_non_zeroed(arena, size, loc) case .Free: return nil, .Mode_Not_Implemented case .Free_All: - dynamic_arena_free_all(pool) - return nil, nil - case .Resize, .Resize_Non_Zeroed: - if old_size >= size { - return byte_slice(old_memory, size), nil - } - data, err := dynamic_arena_alloc(pool, size) - if err == nil { - runtime.copy(data, byte_slice(old_memory, old_size)) - } - return data, err - + dynamic_arena_free_all(arena, loc) + case .Resize: + return dynamic_arena_resize(arena, old_memory, old_size, size, loc) + case .Resize_Non_Zeroed: + return dynamic_arena_resize_non_zeroed(arena, old_memory, old_size, size, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { set^ = {.Alloc, .Alloc_Non_Zeroed, .Free_All, .Resize, .Resize_Non_Zeroed, .Query_Features, .Query_Info} } return nil, nil - case .Query_Info: info := (^Allocator_Query_Info)(old_memory) if info != nil && info.pointer != nil { From 6d3cffa13c4e43400eaaa33a0c551cef5cd3e44c Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 13:14:58 +1100 Subject: [PATCH 12/72] [mem]: Add @require_results to all functions returning values --- core/mem/allocators.odin | 32 +++++++++++++++++++++++++------- 1 file changed, 25 insertions(+), 7 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index d7e3cfbfd..1efc60033 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -56,6 +56,7 @@ init_arena :: proc(a: ^Arena, data: []byte) { a.temp_count = 0 } +@(require_results) arena_alloc :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([]byte, Allocator_Error) { bytes, err := arena_alloc_non_zeroed(a, size, alignment) if bytes != nil { @@ -64,6 +65,7 @@ arena_alloc :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([] return bytes, err } +@(require_results) arena_alloc_non_zeroed :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([]byte, Allocator_Error) { #no_bounds_check end := &a.data[a.offset] ptr := align_forward(end, uintptr(alignment)) @@ -173,6 +175,7 @@ scratch_destroy :: proc(s: ^Scratch) { s^ = {} } +@(require_results) scratch_alloc :: proc( s: ^Scratch, size: int, @@ -186,6 +189,7 @@ scratch_alloc :: proc( return bytes, err } +@(require_results) scratch_alloc_non_zeroed :: proc( s: ^Scratch, size: int, @@ -239,6 +243,7 @@ scratch_alloc_non_zeroed :: proc( return ptr, err } +@(require_results) scratch_free :: proc(s: ^Scratch, ptr: rawptr, loc := #caller_location) -> Allocator_Error { if s.data == nil { panic("Free on an uninitialized scratch allocator", loc) @@ -283,6 +288,7 @@ scratch_free_all :: proc(s: ^Scratch, loc := #caller_location) { clear(&s.leaked_allocations) } +@(require_results) scratch_resize :: proc( s: ^Scratch, old_memory: rawptr, @@ -298,6 +304,7 @@ scratch_resize :: proc( return bytes, err } +@(require_results) scratch_resize_non_zeroed :: proc( s: ^Scratch, old_memory: rawptr, @@ -404,6 +411,7 @@ init_stack :: proc(s: ^Stack, data: []byte) { s.peak_used = 0 } +@(require_results) stack_alloc :: proc( s: ^Stack, size: int, @@ -417,6 +425,7 @@ stack_alloc :: proc( return bytes, err } +@(require_results) stack_alloc_non_zeroed :: proc( s: ^Stack, size: int, @@ -446,6 +455,7 @@ stack_alloc_non_zeroed :: proc( return byte_slice(rawptr(next_addr), size), nil } +@(require_results) stack_free :: proc( s: ^Stack, old_memory: rawptr, @@ -486,6 +496,7 @@ stack_free_all :: proc(s: ^Stack, loc := #caller_location) { s.curr_offset = 0 } +@(require_results) stack_resize :: proc( s: ^Stack, old_memory: rawptr, @@ -505,6 +516,7 @@ stack_resize :: proc( return bytes, err } +@(require_results) stack_resize_non_zeroed :: proc( s: ^Stack, old_memory: rawptr, @@ -626,6 +638,7 @@ small_stack_allocator :: proc(stack: ^Small_Stack) -> Allocator { } } +@(require_results) small_stack_alloc :: proc( s: ^Small_Stack, size: int, @@ -639,6 +652,7 @@ small_stack_alloc :: proc( return bytes, err } +@(require_results) small_stack_alloc_non_zeroed :: proc( s: ^Small_Stack, size: int, @@ -664,6 +678,7 @@ small_stack_alloc_non_zeroed :: proc( return byte_slice(rawptr(next_addr), size), nil } +@(require_results) small_stack_free :: proc( s: ^Small_Stack, old_memory: rawptr, @@ -693,6 +708,7 @@ small_stack_free_all :: proc(s: ^Small_Stack) { s.offset = 0 } +@(require_results) small_stack_resize :: proc( s: ^Small_Stack, old_memory: rawptr, @@ -712,6 +728,7 @@ small_stack_resize :: proc( return bytes, err } +@(require_results) small_stack_resize_non_zeroed :: proc( s: ^Small_Stack, old_memory: rawptr, @@ -932,8 +949,8 @@ dynamic_arena_reset :: proc(a: ^Dynamic_Arena, loc := #caller_location) { append(&a.unused_blocks, block, loc=loc) } clear(&a.used_blocks) - for a in a.out_band_allocations { - free(a, a.block_allocator, loc=loc) + for allocation in a.out_band_allocations { + free(allocation, a.block_allocator, loc=loc) } clear(&a.out_band_allocations) a.bytes_left = 0 // Make new allocations call `_dynamic_arena_cycle_new_block` again. @@ -947,6 +964,7 @@ dynamic_arena_free_all :: proc(a: ^Dynamic_Arena, loc := #caller_location) { clear(&a.unused_blocks) } +@(require_results) dynamic_arena_resize :: proc( a: ^Dynamic_Arena, old_memory: rawptr, @@ -965,6 +983,7 @@ dynamic_arena_resize :: proc( return bytes, err } +@(require_results) dynamic_arena_resize_non_zeroed :: proc( a: ^Dynamic_Arena, old_memory: rawptr, @@ -1014,8 +1033,8 @@ dynamic_arena_allocator_proc :: proc( case .Query_Info: info := (^Allocator_Query_Info)(old_memory) if info != nil && info.pointer != nil { - info.size = pool.block_size - info.alignment = pool.alignment + info.size = arena.block_size + info.alignment = arena.alignment return byte_slice(info, size_of(info^)), nil } return nil, nil @@ -1033,7 +1052,6 @@ panic_allocator_proc :: proc( old_size: int, loc := #caller_location, ) -> ([]byte, Allocator_Error) { - switch mode { case .Alloc: if size > 0 { @@ -1057,7 +1075,6 @@ panic_allocator_proc :: proc( } case .Free_All: panic("mem: panic allocator, .Free_All called", loc=loc) - case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { @@ -1068,7 +1085,6 @@ panic_allocator_proc :: proc( case .Query_Info: panic("mem: panic allocator, .Query_Info called", loc=loc) } - return nil, nil } @@ -1080,6 +1096,8 @@ panic_allocator :: proc() -> Allocator { } } + + Buddy_Block :: struct #align(align_of(uint)) { size: uint, is_free: bool, From c0e17808d46be70b461c020c9c320349e2f99ad9 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 13:26:09 +1100 Subject: [PATCH 13/72] [mem]: Split alloc and alloc_non_zeroed for buddy allocator --- core/mem/allocators.odin | 59 ++++++++++++++-------------------------- 1 file changed, 21 insertions(+), 38 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 1efc60033..45c80e678 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -1133,7 +1133,6 @@ buddy_block_coalescence :: proc(head, tail: ^Buddy_Block) { // Keep looping until there are no more buddies to coalesce block := head buddy := buddy_block_next(block) - no_coalescence := true for block < tail && buddy < tail { // make sure the buddies are within the range if block.is_free && buddy.is_free && block.size == buddy.size { @@ -1156,7 +1155,6 @@ buddy_block_coalescence :: proc(head, tail: ^Buddy_Block) { } } } - if no_coalescence { return } @@ -1166,17 +1164,14 @@ buddy_block_coalescence :: proc(head, tail: ^Buddy_Block) { @(require_results) buddy_block_find_best :: proc(head, tail: ^Buddy_Block, size: uint) -> ^Buddy_Block { assert(size != 0) - best_block: ^Buddy_Block block := head // left buddy := buddy_block_next(block) // right - // The entire memory section between head and tail is free, // just call 'buddy_block_split' to get the allocation if buddy == tail && block.is_free { return buddy_block_split(block, size) } - // Find the block which is the 'best_block' to requested allocation sized for block < tail && buddy < tail { // make sure the buddies are within the range // If both buddies are free, coalesce them together @@ -1187,7 +1182,6 @@ buddy_block_find_best :: proc(head, tail: ^Buddy_Block, size: uint) -> ^Buddy_Bl if size <= block.size && (best_block == nil || block.size <= best_block.size) { best_block = block } - block = buddy_block_next(buddy) if block < tail { // Delay the buddy block for the next iteration @@ -1195,20 +1189,16 @@ buddy_block_find_best :: proc(head, tail: ^Buddy_Block, size: uint) -> ^Buddy_Bl } continue } - - if block.is_free && size <= block.size && (best_block == nil || block.size <= best_block.size) { best_block = block } - if buddy.is_free && size <= buddy.size && (best_block == nil || buddy.size < best_block.size) { // If each buddy are the same size, then it makes more sense // to pick the buddy as it "bounces around" less best_block = buddy } - if (block.size <= buddy.size) { block = buddy_block_next(buddy) if (block < tail) { @@ -1221,12 +1211,10 @@ buddy_block_find_best :: proc(head, tail: ^Buddy_Block, size: uint) -> ^Buddy_Bl buddy = buddy_block_next(buddy) } } - if best_block != nil { // This will handle the case if the 'best_block' is also the perfect fit return buddy_block_split(best_block, size) } - // Maybe out of memory return nil } @@ -1245,26 +1233,20 @@ buddy_allocator :: proc(b: ^Buddy_Allocator) -> Allocator { } } -buddy_allocator_init :: proc(b: ^Buddy_Allocator, data: []byte, alignment: uint) { +buddy_allocator_init :: proc(b: ^Buddy_Allocator, data: []byte, alignment: uint, loc := #caller_location) { assert(data != nil) - assert(is_power_of_two(uintptr(len(data)))) - assert(is_power_of_two(uintptr(alignment))) - + assert(is_power_of_two(uintptr(len(data))), "Size of the backing buffer must be power of two", loc) + assert(is_power_of_two(uintptr(alignment)), "Alignment must be a power of two", loc) alignment := alignment if alignment < size_of(Buddy_Block) { alignment = size_of(Buddy_Block) } - ptr := raw_data(data) - assert(uintptr(ptr) % uintptr(alignment) == 0, "data is not aligned to minimum alignment") - + assert(uintptr(ptr) % uintptr(alignment) == 0, "data is not aligned to minimum alignment", loc) b.head = (^Buddy_Block)(ptr) - b.head.size = len(data) b.head.is_free = true - b.tail = buddy_block_next(b.head) - b.alignment = alignment } @@ -1274,19 +1256,25 @@ buddy_block_size_required :: proc(b: ^Buddy_Allocator, size: uint) -> uint { actual_size := b.alignment size += size_of(Buddy_Block) size = align_forward_uint(size, b.alignment) - for size > actual_size { actual_size <<= 1 } - return actual_size } @(require_results) -buddy_allocator_alloc :: proc(b: ^Buddy_Allocator, size: uint, zeroed: bool) -> ([]byte, Allocator_Error) { +buddy_allocator_alloc :: proc(b: ^Buddy_Allocator, size: uint) -> ([]byte, Allocator_Error) { + bytes, err := buddy_allocator_alloc_non_zeroed(b, size) + if bytes != nil { + zero_slice(bytes) + } + return bytes, err +} + +@(require_results) +buddy_allocator_alloc_non_zeroed :: proc(b: ^Buddy_Allocator, size: uint) -> ([]byte, Allocator_Error) { if size != 0 { actual_size := buddy_block_size_required(b, size) - found := buddy_block_find_best(b.head, b.tail, actual_size) if found != nil { // Try to coalesce all the free buddy blocks and then search again @@ -1297,32 +1285,28 @@ buddy_allocator_alloc :: proc(b: ^Buddy_Allocator, size: uint, zeroed: bool) -> return nil, .Out_Of_Memory } found.is_free = false - data := ([^]byte)(found)[b.alignment:][:size] - if zeroed { - zero_slice(data) - } return data, nil } return nil, nil } +@(require_results) buddy_allocator_free :: proc(b: ^Buddy_Allocator, ptr: rawptr) -> Allocator_Error { if ptr != nil { if !(b.head <= ptr && ptr <= b.tail) { return .Invalid_Pointer } - block := (^Buddy_Block)(([^]byte)(ptr)[-b.alignment:]) block.is_free = true - buddy_block_coalescence(b.head, b.tail) } return nil } buddy_allocator_proc :: proc( - allocator_data: rawptr, mode: Allocator_Mode, + allocator_data: rawptr, + mode: Allocator_Mode, size, alignment: int, old_memory: rawptr, old_size: int, @@ -1330,10 +1314,11 @@ buddy_allocator_proc :: proc( ) -> ([]byte, Allocator_Error) { b := (^Buddy_Allocator)(allocator_data) - switch mode { - case .Alloc, .Alloc_Non_Zeroed: - return buddy_allocator_alloc(b, uint(size), mode == .Alloc) + case .Alloc: + return buddy_allocator_alloc(b, uint(size)) + case .Alloc_Non_Zeroed: + return buddy_allocator_alloc_non_zeroed(b, uint(size)) case .Resize: return default_resize_bytes_align(byte_slice(old_memory, old_size), size, alignment, buddy_allocator(b)) case .Resize_Non_Zeroed: @@ -1341,13 +1326,11 @@ buddy_allocator_proc :: proc( case .Free: return nil, buddy_allocator_free(b, old_memory) case .Free_All: - alignment := b.alignment head := ([^]byte)(b.head) tail := ([^]byte)(b.tail) data := head[:ptr_sub(tail, head)] buddy_allocator_init(b, data, alignment) - case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { From c0112d1c70e369dd4f4704d577c7ff6e8ef17282 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 13:27:17 +1100 Subject: [PATCH 14/72] [mem]: Add free_all for buddy allocator --- core/mem/allocators.odin | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 45c80e678..5fedbd4d6 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -1304,6 +1304,14 @@ buddy_allocator_free :: proc(b: ^Buddy_Allocator, ptr: rawptr) -> Allocator_Erro return nil } +buddy_allocator_free_all :: proc(b: ^Buddy_Allocator) { + alignment := b.alignment + head := ([^]byte)(b.head) + tail := ([^]byte)(b.tail) + data := head[:ptr_sub(tail, head)] + buddy_allocator_init(b, data, alignment) +} + buddy_allocator_proc :: proc( allocator_data: rawptr, mode: Allocator_Mode, @@ -1312,7 +1320,6 @@ buddy_allocator_proc :: proc( old_size: int, loc := #caller_location, ) -> ([]byte, Allocator_Error) { - b := (^Buddy_Allocator)(allocator_data) switch mode { case .Alloc: @@ -1326,18 +1333,13 @@ buddy_allocator_proc :: proc( case .Free: return nil, buddy_allocator_free(b, old_memory) case .Free_All: - alignment := b.alignment - head := ([^]byte)(b.head) - tail := ([^]byte)(b.tail) - data := head[:ptr_sub(tail, head)] - buddy_allocator_init(b, data, alignment) + buddy_allocator_free_all(b) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { set^ = {.Query_Features, .Alloc, .Alloc_Non_Zeroed, .Resize, .Resize_Non_Zeroed, .Free, .Free_All, .Query_Info} } return nil, nil - case .Query_Info: info := (^Allocator_Query_Info)(old_memory) if info != nil && info.pointer != nil { @@ -1345,7 +1347,6 @@ buddy_allocator_proc :: proc( if !(b.head <= ptr && ptr <= b.tail) { return nil, .Invalid_Pointer } - block := (^Buddy_Block)(([^]byte)(ptr)[-b.alignment:]) info.size = int(block.size) info.alignment = int(b.alignment) @@ -1353,6 +1354,5 @@ buddy_allocator_proc :: proc( } return nil, nil } - return nil, nil } From 64814f4199c8d89a3fb0ed7013aa20321a0b34d5 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 14:19:50 +1100 Subject: [PATCH 15/72] [mem]: Document the package --- core/mem/doc.odin | 111 ++++++++++++++++++++++++------- core/mem/tracking_allocator.odin | 31 +++++++++ 2 files changed, 119 insertions(+), 23 deletions(-) diff --git a/core/mem/doc.odin b/core/mem/doc.odin index 44c93f798..b152d0738 100644 --- a/core/mem/doc.odin +++ b/core/mem/doc.odin @@ -1,34 +1,99 @@ /* -package mem implements various types of allocators. +The `mem` package implements various allocators and provides utility functions +for dealing with memory, pointers and slices. +The documentation below describes basic concepts, applicable to the `mem` +package. -An example of how to use the `Tracking_Allocator` to track subsequent allocations -in your program and report leaks and bad frees: +## Pointers, multipointers, and slices -Example: - package foo +A *pointer* is an abstraction of an *address*, a numberic value representing the +location of an object in memory. That object is said to be *pointed to* by the +pointer. To obtain the address of a pointer, cast it to `uintptr`. - import "core:mem" - import "core:fmt" +A multipointer is a pointer that points to multiple objects. Unlike a pointer, +a multipointer can be indexed, but does not have a definite length. A slice is +a pointer that points to multiple objects equipped with the length, specifying +the amount of objects a slice points to. - _main :: proc() { - // do stuff - } +When object's values are read through a pointer, that operation is called a +*load* operation. When memory is read through a pointer, that operation is +called a *store* operation. Both of these operations can be called a *memory +access operation*. - main :: proc() { - track: mem.Tracking_Allocator - mem.tracking_allocator_init(&track, context.allocator) - defer mem.tracking_allocator_destroy(&track) - context.allocator = mem.tracking_allocator(&track) +## Allocators - _main() +In C and C++ memory models, allocations of objects in memory are typically +treated individually with a generic allocator (The `malloc` function). Which in +some scenarios can lead to poor cache utilization, slowdowns on individual +objects' memory management and growing complexity of the code needing to keep +track of the pointers and their lifetimes. - for _, leak in track.allocation_map { - fmt.printf("%v leaked %m\n", leak.location, leak.size) - } - for bad_free in track.bad_free_array { - fmt.printf("%v allocation %p was freed badly\n", bad_free.location, bad_free.memory) - } - } +Using different kinds of *allocators* for different purposes can solve these +problems. The allocators are typically optimized for specific use-cases and +can potentially simplify the memory management code. + +For example, in the context of making a game, having an Arena allocator could +simplify allocations of any temporary memory, because the programmer doesn't +have to keep track of which objects need to be freed every time they are +allocated, because at the end of every frame the whole allocator is reset to +its initial state and all objects are freed at once. + +The allocators have different kinds of restrictions on object lifetimes, sizes, +alignment and can be a significant gain, if used properly. Odin supports +allocators on a language level. + +Operations such as `new`, `free` and `delete` by default will use +`context.allocator`, which can be overridden by the user. When an override +happens all called functions will inherit the new context and use the same +allocator. + +## Alignment + +An address is said to be *aligned to `N` bytes*, if the addresses's numeric +value is divisible by `N`. The number `N` in this case can be referred to as +the *alignment boundary*. Typically an alignment is a power of two integer +value. + +A *natural alignment* of an object is typically equal to its size. For example +a 16 bit integer has a natural alignment of 2 bytes. When an object is not +located on its natural alignment boundary, accesses to that object are +considered *unaligned*. + +Some machines issue a hardware **exception**, or experience **slowdowns** when a +memory access operation occurs from an unaligned address. Examples of such +operations are: + +- SIMD instructions on x86. These instructions require all memory accesses to be + on an address that is aligned to 16 bytes. +- On ARM unaligned loads have an extra cycle penalty. + +As such, many operations that allocate memory in this package allow to +explicitly specify the alignment of allocated pointers/slices. The default +alignment for all operations is specified in a constant `mem.DEFAULT_ALIGNMENT`. + +## Zero by default + +Whenever new memory is allocated, via an allocator, or on the stack, by default +Odin will zero-initialize that memory, even if it wasn't explicitly +initialized. This allows for some convenience in certain scenarios and ease of +debugging, which will not be described in detail here. + +However zero-initialization can be a cause of slowdowns, when allocating large +buffers. For this reason, allocators have `*_non_zeroed` modes of allocation +that allow the user to request for uninitialized memory and will avoid a +relatively expensive zero-filling of the buffer. + +## Naming conventions + +The word `size` is used to denote the **size in bytes**. The word `length` is +used to denote the count of objects. + +Higher-level allocation functions follow the following naming scheme: + +- `new`: Allocates a single object +- `free`: Free a single object (opposite of `new`) +- `make`: Allocate a group of objects +- `delete`: Free a group of objects (opposite of `make`) */ package mem diff --git a/core/mem/tracking_allocator.odin b/core/mem/tracking_allocator.odin index 356180be1..e75844130 100644 --- a/core/mem/tracking_allocator.odin +++ b/core/mem/tracking_allocator.odin @@ -18,6 +18,37 @@ Tracking_Allocator_Bad_Free_Entry :: struct { location: runtime.Source_Code_Location, } +/* +An example of how to use the `Tracking_Allocator` to track subsequent allocations +in your program and report leaks and bad frees: + +Example: + + package foo + + import "core:mem" + import "core:fmt" + + _main :: proc() { + // do stuff + } + + main :: proc() { + track: mem.Tracking_Allocator + mem.tracking_allocator_init(&track, context.allocator) + defer mem.tracking_allocator_destroy(&track) + context.allocator = mem.tracking_allocator(&track) + + _main() + + for _, leak in track.allocation_map { + fmt.printf("%v leaked %m\n", leak.location, leak.size) + } + for bad_free in track.bad_free_array { + fmt.printf("%v allocation %p was freed badly\n", bad_free.location, bad_free.memory) + } + } +*/ Tracking_Allocator :: struct { backing: Allocator, allocation_map: map[rawptr]Tracking_Allocator_Entry, From 2d988bbc5f21fd7e07926c93b01996a392b5a92d Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 14:45:15 +1100 Subject: [PATCH 16/72] [mem]: Rename alloc to alloc_bytes and add alloc --- core/mem/allocators.odin | 295 ++++++++++++++++++++++++++++++++------- 1 file changed, 248 insertions(+), 47 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 5fedbd4d6..acbc202e6 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -57,8 +57,14 @@ init_arena :: proc(a: ^Arena, data: []byte) { } @(require_results) -arena_alloc :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([]byte, Allocator_Error) { - bytes, err := arena_alloc_non_zeroed(a, size, alignment) +arena_alloc :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> (rawptr, Allocator_Error) { + bytes, err := arena_alloc_bytes(a, size, alignment) + return raw_data(bytes), err +} + +@(require_results) +arena_alloc_bytes :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([]byte, Allocator_Error) { + bytes, err := arena_alloc_bytes_non_zeroed(a, size, alignment) if bytes != nil { zero_slice(bytes) } @@ -66,7 +72,13 @@ arena_alloc :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([] } @(require_results) -arena_alloc_non_zeroed :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([]byte, Allocator_Error) { +arena_alloc_non_zeroed :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> (rawptr, Allocator_Error) { + bytes, err := arena_alloc_bytes_non_zeroed(a, size, alignment) + return raw_data(bytes), err +} + +@(require_results) +arena_alloc_bytes_non_zeroed :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([]byte, Allocator_Error) { #no_bounds_check end := &a.data[a.offset] ptr := align_forward(end, uintptr(alignment)) total_size := size + ptr_sub((^byte)(ptr), (^byte)(end)) @@ -94,9 +106,9 @@ arena_allocator_proc :: proc( arena := cast(^Arena)allocator_data switch mode { case .Alloc: - return arena_alloc(arena, size, alignment) + return arena_alloc_bytes(arena, size, alignment) case .Alloc_Non_Zeroed: - return arena_alloc_non_zeroed(arena, size, alignment) + return arena_alloc_bytes_non_zeroed(arena, size, alignment) case .Free: return nil, .Mode_Not_Implemented case .Free_All: @@ -181,8 +193,19 @@ scratch_alloc :: proc( size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := scratch_alloc_bytes(s, size, alignment, loc) + return raw_data(bytes), err +} + +@(require_results) +scratch_alloc_bytes :: proc( + s: ^Scratch, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, ) -> ([]byte, Allocator_Error) { - bytes, err := scratch_alloc_non_zeroed(s, size, alignment, loc) + bytes, err := scratch_alloc_bytes_non_zeroed(s, size, alignment, loc) if bytes != nil { zero_slice(bytes) } @@ -195,6 +218,17 @@ scratch_alloc_non_zeroed :: proc( size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := scratch_alloc_bytes_non_zeroed(s, size, alignment, loc) + return raw_data(bytes), err +} + +@(require_results) +scratch_alloc_bytes_non_zeroed :: proc( + s: ^Scratch, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, ) -> ([]byte, Allocator_Error) { if s.data == nil { DEFAULT_BACKING_SIZE :: 4 * Megabyte @@ -296,8 +330,21 @@ scratch_resize :: proc( size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location +) -> (rawptr, Allocator_Error) { + bytes, err := scratch_resize_bytes(s, old_memory, old_size, size, alignment, loc) + return raw_data(bytes), err +} + +@(require_results) +scratch_resize_bytes :: proc( + s: ^Scratch, + old_memory: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location ) -> ([]byte, Allocator_Error) { - bytes, err := scratch_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) + bytes, err := scratch_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment, loc) if bytes != nil && size > old_size { zero_slice(bytes[size:]) } @@ -312,6 +359,19 @@ scratch_resize_non_zeroed :: proc( size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location +) -> (rawptr, Allocator_Error) { + bytes, err := scratch_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment, loc) + return raw_data(bytes), err +} + +@(require_results) +scratch_resize_bytes_non_zeroed :: proc( + s: ^Scratch, + old_memory: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location ) -> ([]byte, Allocator_Error) { if s.data == nil { DEFAULT_BACKING_SIZE :: 4 * Megabyte @@ -328,7 +388,7 @@ scratch_resize_non_zeroed :: proc( s.curr_offset = int(old_ptr-begin)+size return byte_slice(old_memory, size), nil } - data, err := scratch_alloc_non_zeroed(s, size, alignment, loc) + data, err := scratch_alloc_bytes_non_zeroed(s, size, alignment, loc) if err != nil { return data, err } @@ -350,17 +410,17 @@ scratch_allocator_proc :: proc( size := size switch mode { case .Alloc: - return scratch_alloc(s, size, alignment, loc) + return scratch_alloc_bytes(s, size, alignment, loc) case .Alloc_Non_Zeroed: - return scratch_alloc_non_zeroed(s, size, alignment, loc) + return scratch_alloc_bytes_non_zeroed(s, size, alignment, loc) case .Free: return nil, scratch_free(s, old_memory, loc) case .Free_All: scratch_free_all(s, loc) case .Resize: - return scratch_resize(s, old_memory, old_size, size, alignment, loc) + return scratch_resize_bytes(s, old_memory, old_size, size, alignment, loc) case .Resize_Non_Zeroed: - return scratch_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) + return scratch_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { @@ -417,8 +477,19 @@ stack_alloc :: proc( size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location +) -> (rawptr, Allocator_Error) { + bytes, err := stack_alloc_bytes(s, size, alignment, loc) + return raw_data(bytes), err +} + +@(require_results) +stack_alloc_bytes :: proc( + s: ^Stack, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location ) -> ([]byte, Allocator_Error) { - bytes, err := stack_alloc_non_zeroed(s, size, alignment, loc) + bytes, err := stack_alloc_bytes_non_zeroed(s, size, alignment, loc) if bytes != nil { zero_slice(bytes) } @@ -431,6 +502,17 @@ stack_alloc_non_zeroed :: proc( size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location +) -> (rawptr, Allocator_Error) { + bytes, err := stack_alloc_bytes_non_zeroed(s, size, alignment, loc) + return raw_data(bytes), err +} + +@(require_results) +stack_alloc_bytes_non_zeroed :: proc( + s: ^Stack, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location ) -> ([]byte, Allocator_Error) { if s.data == nil { panic("Stack allocation on an uninitialized stack allocator", loc) @@ -496,6 +578,7 @@ stack_free_all :: proc(s: ^Stack, loc := #caller_location) { s.curr_offset = 0 } + @(require_results) stack_resize :: proc( s: ^Stack, @@ -504,8 +587,21 @@ stack_resize :: proc( size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := stack_resize_bytes(s, old_memory, old_size, size, alignment) + return raw_data(bytes), err +} + +@(require_results) +stack_resize_bytes :: proc( + s: ^Stack, + old_memory: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, ) -> ([]byte, Allocator_Error) { - bytes, err := stack_alloc_non_zeroed(s, size, alignment, loc) + bytes, err := stack_alloc_bytes_non_zeroed(s, size, alignment, loc) if bytes != nil { if old_memory == nil { zero_slice(bytes) @@ -524,12 +620,25 @@ stack_resize_non_zeroed :: proc( size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := stack_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment) + return raw_data(bytes), err +} + +@(require_results) +stack_resize_bytes_non_zeroed :: proc( + s: ^Stack, + old_memory: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, ) -> ([]byte, Allocator_Error) { if s.data == nil { panic("Stack free all on an uninitialized stack allocator", loc) } if old_memory == nil { - return stack_alloc_non_zeroed(s, size, alignment, loc) + return stack_alloc_bytes_non_zeroed(s, size, alignment, loc) } if size == 0 { return nil, nil @@ -550,7 +659,7 @@ stack_resize_non_zeroed :: proc( header := (^Stack_Allocation_Header)(curr_addr - size_of(Stack_Allocation_Header)) old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data))) if old_offset != header.prev_offset { - data, err := stack_alloc_non_zeroed(s, size, alignment, loc) + data, err := stack_alloc_bytes_non_zeroed(s, size, alignment, loc) if err == nil { runtime.copy(data, byte_slice(old_memory, old_size)) } @@ -581,17 +690,17 @@ stack_allocator_proc :: proc( } switch mode { case .Alloc: - return stack_alloc(s, size, alignment, loc) + return stack_alloc_bytes(s, size, alignment, loc) case .Alloc_Non_Zeroed: - return stack_alloc_non_zeroed(s, size, alignment, loc) + return stack_alloc_bytes_non_zeroed(s, size, alignment, loc) case .Free: return nil, stack_free(s, old_memory, loc) case .Free_All: stack_free_all(s, loc) case .Resize: - return stack_resize(s, old_memory, old_size, size, alignment, loc) + return stack_resize_bytes(s, old_memory, old_size, size, alignment, loc) case .Resize_Non_Zeroed: - return stack_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) + return stack_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { @@ -644,8 +753,19 @@ small_stack_alloc :: proc( size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := small_stack_alloc_bytes(s, size, alignment, loc) + return raw_data(bytes), err +} + +@(require_results) +small_stack_alloc_bytes :: proc( + s: ^Small_Stack, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, ) -> ([]byte, Allocator_Error) { - bytes, err := small_stack_alloc_non_zeroed(s, size, alignment, loc) + bytes, err := small_stack_alloc_bytes_non_zeroed(s, size, alignment, loc) if bytes != nil { zero_slice(bytes) } @@ -658,6 +778,17 @@ small_stack_alloc_non_zeroed :: proc( size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := small_stack_alloc_bytes_non_zeroed(s, size, alignment, loc) + return raw_data(bytes), err +} + +@(require_results) +small_stack_alloc_bytes_non_zeroed :: proc( + s: ^Small_Stack, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, ) -> ([]byte, Allocator_Error) { if s.data == nil { return nil, .Invalid_Argument @@ -716,8 +847,21 @@ small_stack_resize :: proc( size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := small_stack_resize_bytes(s, old_memory, old_size, size, alignment, loc) + return raw_data(bytes), err +} + +@(require_results) +small_stack_resize_bytes :: proc( + s: ^Small_Stack, + old_memory: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, ) -> ([]byte, Allocator_Error) { - bytes, err := small_stack_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) + bytes, err := small_stack_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment, loc) if bytes != nil { if old_memory == nil { zero_slice(bytes) @@ -736,11 +880,24 @@ small_stack_resize_non_zeroed :: proc( size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := small_stack_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment, loc) + return raw_data(bytes), err +} + +@(require_results) +small_stack_resize_bytes_non_zeroed :: proc( + s: ^Small_Stack, + old_memory: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, ) -> ([]byte, Allocator_Error) { alignment := alignment alignment = clamp(alignment, 1, 8*size_of(Stack_Allocation_Header{}.padding)/2) if old_memory == nil { - return small_stack_alloc_non_zeroed(s, size, alignment, loc) + return small_stack_alloc_bytes_non_zeroed(s, size, alignment, loc) } if size == 0 { return nil, nil @@ -759,7 +916,7 @@ small_stack_resize_non_zeroed :: proc( if old_size == size { return byte_slice(old_memory, size), nil } - data, err := small_stack_alloc_non_zeroed(s, size, alignment, loc) + data, err := small_stack_alloc_bytes_non_zeroed(s, size, alignment, loc) if err == nil { runtime.copy(data, byte_slice(old_memory, old_size)) } @@ -781,17 +938,17 @@ small_stack_allocator_proc :: proc( } switch mode { case .Alloc: - return small_stack_alloc(s, size, alignment, loc) + return small_stack_alloc_bytes(s, size, alignment, loc) case .Alloc_Non_Zeroed: - return small_stack_alloc_non_zeroed(s, size, alignment, loc) + return small_stack_alloc_bytes_non_zeroed(s, size, alignment, loc) case .Free: return nil, small_stack_free(s, old_memory, loc) case .Free_All: small_stack_free_all(s) case .Resize: - return small_stack_resize(s, old_memory, old_size, size, alignment, loc) + return small_stack_resize_bytes(s, old_memory, old_size, size, alignment, loc) case .Resize_Non_Zeroed: - return small_stack_resize_non_zeroed(s, old_memory, old_size, size, alignment, loc) + return small_stack_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { @@ -805,19 +962,21 @@ small_stack_allocator_proc :: proc( } -/* old stuff */ +/* Preserved for compatibility */ Dynamic_Pool :: Dynamic_Arena DYNAMIC_POOL_BLOCK_SIZE_DEFAULT :: DYNAMIC_ARENA_BLOCK_SIZE_DEFAULT DYNAMIC_POOL_OUT_OF_BAND_SIZE_DEFAULT :: DYNAMIC_ARENA_OUT_OF_BAND_SIZE_DEFAULT dynamic_pool_allocator_proc :: dynamic_arena_allocator_proc dynamic_pool_free_all :: dynamic_arena_free_all dynamic_pool_reset :: dynamic_arena_reset -dynamic_pool_alloc_bytes :: dynamic_arena_alloc -dynamic_pool_alloc :: _dynamic_arena_alloc_ptr +dynamic_pool_alloc_bytes :: dynamic_arena_alloc_bytes +dynamic_pool_alloc :: dynamic_arena_alloc dynamic_pool_init :: dynamic_arena_init dynamic_pool_allocator :: dynamic_arena_allocator dynamic_pool_destroy :: dynamic_arena_destroy + + DYNAMIC_ARENA_BLOCK_SIZE_DEFAULT :: 65536 DYNAMIC_ARENA_OUT_OF_BAND_SIZE_DEFAULT :: 6554 @@ -897,14 +1056,14 @@ _dynamic_arena_cycle_new_block :: proc(p: ^Dynamic_Arena, loc := #caller_locatio } @(private, require_results) -_dynamic_arena_alloc_ptr :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_location) -> (rawptr, Allocator_Error) { - data, err := dynamic_arena_alloc(a, size, loc) +dynamic_arena_alloc :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_location) -> (rawptr, Allocator_Error) { + data, err := dynamic_arena_alloc_bytes(a, size, loc) return raw_data(data), err } @(require_results) -dynamic_arena_alloc :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { - bytes, err := dynamic_arena_alloc_non_zeroed(a, size, loc) +dynamic_arena_alloc_bytes :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { + bytes, err := dynamic_arena_alloc_bytes_non_zeroed(a, size, loc) if bytes != nil { zero_slice(bytes) } @@ -912,7 +1071,13 @@ dynamic_arena_alloc :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_locatio } @(require_results) -dynamic_arena_alloc_non_zeroed :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { +dynamic_arena_alloc_non_zeroed :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_location) -> (rawptr, Allocator_Error) { + data, err := dynamic_arena_alloc_bytes_non_zeroed(a, size, loc) + return raw_data(data), err +} + +@(require_results) +dynamic_arena_alloc_bytes_non_zeroed :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { n := align_formula(size, a.alignment) if n > a.block_size { return nil, .Invalid_Argument @@ -971,8 +1136,20 @@ dynamic_arena_resize :: proc( old_size: int, size: int, loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := dynamic_arena_resize_bytes(a, old_memory, old_size, size, loc) + return raw_data(bytes), err +} + +@(require_results) +dynamic_arena_resize_bytes :: proc( + a: ^Dynamic_Arena, + old_memory: rawptr, + old_size: int, + size: int, + loc := #caller_location, ) -> ([]byte, Allocator_Error) { - bytes, err := dynamic_arena_resize_non_zeroed(a, old_memory, old_size, size, loc) + bytes, err := dynamic_arena_resize_bytes_non_zeroed(a, old_memory, old_size, size, loc) if bytes != nil { if old_memory == nil { zero_slice(bytes) @@ -990,11 +1167,23 @@ dynamic_arena_resize_non_zeroed :: proc( old_size: int, size: int, loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := dynamic_arena_resize_bytes_non_zeroed(a, old_memory, old_size, size, loc) + return raw_data(bytes), err +} + +@(require_results) +dynamic_arena_resize_bytes_non_zeroed :: proc( + a: ^Dynamic_Arena, + old_memory: rawptr, + old_size: int, + size: int, + loc := #caller_location, ) -> ([]byte, Allocator_Error) { if old_size >= size { return byte_slice(old_memory, size), nil } - data, err := dynamic_arena_alloc_non_zeroed(a, size, loc) + data, err := dynamic_arena_alloc_bytes_non_zeroed(a, size, loc) if err == nil { runtime.copy(data, byte_slice(old_memory, old_size)) } @@ -1013,17 +1202,17 @@ dynamic_arena_allocator_proc :: proc( arena := (^Dynamic_Arena)(allocator_data) switch mode { case .Alloc: - return dynamic_arena_alloc(arena, size, loc) + return dynamic_arena_alloc_bytes(arena, size, loc) case .Alloc_Non_Zeroed: - return dynamic_arena_alloc_non_zeroed(arena, size, loc) + return dynamic_arena_alloc_bytes_non_zeroed(arena, size, loc) case .Free: return nil, .Mode_Not_Implemented case .Free_All: dynamic_arena_free_all(arena, loc) case .Resize: - return dynamic_arena_resize(arena, old_memory, old_size, size, loc) + return dynamic_arena_resize_bytes(arena, old_memory, old_size, size, loc) case .Resize_Non_Zeroed: - return dynamic_arena_resize_non_zeroed(arena, old_memory, old_size, size, loc) + return dynamic_arena_resize_bytes_non_zeroed(arena, old_memory, old_size, size, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { @@ -1263,8 +1452,14 @@ buddy_block_size_required :: proc(b: ^Buddy_Allocator, size: uint) -> uint { } @(require_results) -buddy_allocator_alloc :: proc(b: ^Buddy_Allocator, size: uint) -> ([]byte, Allocator_Error) { - bytes, err := buddy_allocator_alloc_non_zeroed(b, size) +buddy_allocator_alloc :: proc(b: ^Buddy_Allocator, size: uint) -> (rawptr, Allocator_Error) { + bytes, err := buddy_allocator_alloc_bytes(b, size) + return raw_data(bytes), err +} + +@(require_results) +buddy_allocator_alloc_bytes :: proc(b: ^Buddy_Allocator, size: uint) -> ([]byte, Allocator_Error) { + bytes, err := buddy_allocator_alloc_bytes_non_zeroed(b, size) if bytes != nil { zero_slice(bytes) } @@ -1272,7 +1467,13 @@ buddy_allocator_alloc :: proc(b: ^Buddy_Allocator, size: uint) -> ([]byte, Alloc } @(require_results) -buddy_allocator_alloc_non_zeroed :: proc(b: ^Buddy_Allocator, size: uint) -> ([]byte, Allocator_Error) { +buddy_allocator_alloc_non_zeroed :: proc(b: ^Buddy_Allocator, size: uint) -> (rawptr, Allocator_Error) { + bytes, err := buddy_allocator_alloc_bytes_non_zeroed(b, size) + return raw_data(bytes), err +} + +@(require_results) +buddy_allocator_alloc_bytes_non_zeroed :: proc(b: ^Buddy_Allocator, size: uint) -> ([]byte, Allocator_Error) { if size != 0 { actual_size := buddy_block_size_required(b, size) found := buddy_block_find_best(b.head, b.tail, actual_size) @@ -1323,9 +1524,9 @@ buddy_allocator_proc :: proc( b := (^Buddy_Allocator)(allocator_data) switch mode { case .Alloc: - return buddy_allocator_alloc(b, uint(size)) + return buddy_allocator_alloc_bytes(b, uint(size)) case .Alloc_Non_Zeroed: - return buddy_allocator_alloc_non_zeroed(b, uint(size)) + return buddy_allocator_alloc_bytes_non_zeroed(b, uint(size)) case .Resize: return default_resize_bytes_align(byte_slice(old_memory, old_size), size, alignment, buddy_allocator(b)) case .Resize_Non_Zeroed: From 6017a20e1cde4c218ab05a754c747b6864e87394 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 15:11:04 +1100 Subject: [PATCH 17/72] [mem]: Make resize_bytes take a slice for the old memory --- core/mem/allocators.odin | 90 ++++++++++++++++++++-------------------- 1 file changed, 45 insertions(+), 45 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index acbc202e6..34b89fcb8 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -331,21 +331,20 @@ scratch_resize :: proc( alignment := DEFAULT_ALIGNMENT, loc := #caller_location ) -> (rawptr, Allocator_Error) { - bytes, err := scratch_resize_bytes(s, old_memory, old_size, size, alignment, loc) + bytes, err := scratch_resize_bytes(s, byte_slice(old_memory, old_size), size, alignment, loc) return raw_data(bytes), err } @(require_results) scratch_resize_bytes :: proc( s: ^Scratch, - old_memory: rawptr, - old_size: int, + old_data: []byte, size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location ) -> ([]byte, Allocator_Error) { - bytes, err := scratch_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment, loc) - if bytes != nil && size > old_size { + bytes, err := scratch_resize_bytes_non_zeroed(s, old_data, size, alignment, loc) + if bytes != nil && size > len(old_data) { zero_slice(bytes[size:]) } return bytes, err @@ -360,19 +359,20 @@ scratch_resize_non_zeroed :: proc( alignment := DEFAULT_ALIGNMENT, loc := #caller_location ) -> (rawptr, Allocator_Error) { - bytes, err := scratch_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment, loc) + bytes, err := scratch_resize_bytes_non_zeroed(s, byte_slice(old_memory, old_size), size, alignment, loc) return raw_data(bytes), err } @(require_results) scratch_resize_bytes_non_zeroed :: proc( s: ^Scratch, - old_memory: rawptr, - old_size: int, + old_data: []byte, size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location ) -> ([]byte, Allocator_Error) { + old_memory := raw_data(old_data) + old_size := len(old_data) if s.data == nil { DEFAULT_BACKING_SIZE :: 4 * Megabyte if !(context.allocator.procedure != scratch_allocator_proc && context.allocator.data != s) { @@ -418,9 +418,9 @@ scratch_allocator_proc :: proc( case .Free_All: scratch_free_all(s, loc) case .Resize: - return scratch_resize_bytes(s, old_memory, old_size, size, alignment, loc) + return scratch_resize_bytes(s, byte_slice(old_memory, old_size), size, alignment, loc) case .Resize_Non_Zeroed: - return scratch_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment, loc) + return scratch_resize_bytes_non_zeroed(s, byte_slice(old_memory, old_size), size, alignment, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { @@ -588,25 +588,24 @@ stack_resize :: proc( alignment := DEFAULT_ALIGNMENT, loc := #caller_location, ) -> (rawptr, Allocator_Error) { - bytes, err := stack_resize_bytes(s, old_memory, old_size, size, alignment) + bytes, err := stack_resize_bytes(s, byte_slice(old_memory, old_size), size, alignment) return raw_data(bytes), err } @(require_results) stack_resize_bytes :: proc( s: ^Stack, - old_memory: rawptr, - old_size: int, + old_data: []byte, size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location, ) -> ([]byte, Allocator_Error) { bytes, err := stack_alloc_bytes_non_zeroed(s, size, alignment, loc) if bytes != nil { - if old_memory == nil { + if old_data == nil { zero_slice(bytes) - } else if size > old_size { - zero_slice(bytes[old_size:]) + } else if size > len(old_data) { + zero_slice(bytes[len(old_data):]) } } return bytes, err @@ -621,19 +620,20 @@ stack_resize_non_zeroed :: proc( alignment := DEFAULT_ALIGNMENT, loc := #caller_location, ) -> (rawptr, Allocator_Error) { - bytes, err := stack_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment) + bytes, err := stack_resize_bytes_non_zeroed(s, byte_slice(old_memory, old_size), size, alignment) return raw_data(bytes), err } @(require_results) stack_resize_bytes_non_zeroed :: proc( s: ^Stack, - old_memory: rawptr, - old_size: int, + old_data: []byte, size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location, ) -> ([]byte, Allocator_Error) { + old_memory := raw_data(old_data) + old_size := len(old_data) if s.data == nil { panic("Stack free all on an uninitialized stack allocator", loc) } @@ -698,9 +698,9 @@ stack_allocator_proc :: proc( case .Free_All: stack_free_all(s, loc) case .Resize: - return stack_resize_bytes(s, old_memory, old_size, size, alignment, loc) + return stack_resize_bytes(s, byte_slice(old_memory, old_size), size, alignment, loc) case .Resize_Non_Zeroed: - return stack_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment, loc) + return stack_resize_bytes_non_zeroed(s, byte_slice(old_memory, old_size), size, alignment, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { @@ -848,25 +848,24 @@ small_stack_resize :: proc( alignment := DEFAULT_ALIGNMENT, loc := #caller_location, ) -> (rawptr, Allocator_Error) { - bytes, err := small_stack_resize_bytes(s, old_memory, old_size, size, alignment, loc) + bytes, err := small_stack_resize_bytes(s, byte_slice(old_memory, old_size), size, alignment, loc) return raw_data(bytes), err } @(require_results) small_stack_resize_bytes :: proc( s: ^Small_Stack, - old_memory: rawptr, - old_size: int, + old_data: []byte, size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location, ) -> ([]byte, Allocator_Error) { - bytes, err := small_stack_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment, loc) + bytes, err := small_stack_resize_bytes_non_zeroed(s, old_data, size, alignment, loc) if bytes != nil { - if old_memory == nil { + if old_data == nil { zero_slice(bytes) - } else if size > old_size { - zero_slice(bytes[old_size:]) + } else if size > len(old_data) { + zero_slice(bytes[len(old_data):]) } } return bytes, err @@ -881,19 +880,20 @@ small_stack_resize_non_zeroed :: proc( alignment := DEFAULT_ALIGNMENT, loc := #caller_location, ) -> (rawptr, Allocator_Error) { - bytes, err := small_stack_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment, loc) + bytes, err := small_stack_resize_bytes_non_zeroed(s, byte_slice(old_memory, old_size), size, alignment, loc) return raw_data(bytes), err } @(require_results) small_stack_resize_bytes_non_zeroed :: proc( s: ^Small_Stack, - old_memory: rawptr, - old_size: int, + old_data: []byte, size: int, alignment := DEFAULT_ALIGNMENT, loc := #caller_location, ) -> ([]byte, Allocator_Error) { + old_memory := raw_data(old_data) + old_size := len(old_data) alignment := alignment alignment = clamp(alignment, 1, 8*size_of(Stack_Allocation_Header{}.padding)/2) if old_memory == nil { @@ -946,9 +946,9 @@ small_stack_allocator_proc :: proc( case .Free_All: small_stack_free_all(s) case .Resize: - return small_stack_resize_bytes(s, old_memory, old_size, size, alignment, loc) + return small_stack_resize_bytes(s, byte_slice(old_memory, old_size), size, alignment, loc) case .Resize_Non_Zeroed: - return small_stack_resize_bytes_non_zeroed(s, old_memory, old_size, size, alignment, loc) + return small_stack_resize_bytes_non_zeroed(s, byte_slice(old_memory, old_size), size, alignment, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { @@ -1137,24 +1137,23 @@ dynamic_arena_resize :: proc( size: int, loc := #caller_location, ) -> (rawptr, Allocator_Error) { - bytes, err := dynamic_arena_resize_bytes(a, old_memory, old_size, size, loc) + bytes, err := dynamic_arena_resize_bytes(a, byte_slice(old_memory, old_size), size, loc) return raw_data(bytes), err } @(require_results) dynamic_arena_resize_bytes :: proc( a: ^Dynamic_Arena, - old_memory: rawptr, - old_size: int, + old_data: []byte, size: int, loc := #caller_location, ) -> ([]byte, Allocator_Error) { - bytes, err := dynamic_arena_resize_bytes_non_zeroed(a, old_memory, old_size, size, loc) + bytes, err := dynamic_arena_resize_bytes_non_zeroed(a, old_data, size, loc) if bytes != nil { - if old_memory == nil { + if old_data == nil { zero_slice(bytes) - } else if size > old_size { - zero_slice(bytes[old_size:]) + } else if size > len(old_data) { + zero_slice(bytes[len(old_data):]) } } return bytes, err @@ -1168,18 +1167,19 @@ dynamic_arena_resize_non_zeroed :: proc( size: int, loc := #caller_location, ) -> (rawptr, Allocator_Error) { - bytes, err := dynamic_arena_resize_bytes_non_zeroed(a, old_memory, old_size, size, loc) + bytes, err := dynamic_arena_resize_bytes_non_zeroed(a, byte_slice(old_memory, old_size), size, loc) return raw_data(bytes), err } @(require_results) dynamic_arena_resize_bytes_non_zeroed :: proc( a: ^Dynamic_Arena, - old_memory: rawptr, - old_size: int, + old_data: []byte, size: int, loc := #caller_location, ) -> ([]byte, Allocator_Error) { + old_memory := raw_data(old_data) + old_size := len(old_data) if old_size >= size { return byte_slice(old_memory, size), nil } @@ -1210,9 +1210,9 @@ dynamic_arena_allocator_proc :: proc( case .Free_All: dynamic_arena_free_all(arena, loc) case .Resize: - return dynamic_arena_resize_bytes(arena, old_memory, old_size, size, loc) + return dynamic_arena_resize_bytes(arena, byte_slice(old_memory, old_size), size, loc) case .Resize_Non_Zeroed: - return dynamic_arena_resize_bytes_non_zeroed(arena, old_memory, old_size, size, loc) + return dynamic_arena_resize_bytes_non_zeroed(arena, byte_slice(old_memory, old_size), size, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { From 7c9d2f61f58f9ccb730da335dbd6573ec6e844b4 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 15:16:20 +1100 Subject: [PATCH 18/72] [mem]: Update package documentation --- core/mem/doc.odin | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/core/mem/doc.odin b/core/mem/doc.odin index b152d0738..5e8bcce6a 100644 --- a/core/mem/doc.odin +++ b/core/mem/doc.odin @@ -1,5 +1,5 @@ /* -The `mem` package implements various allocators and provides utility functions +The `mem` package implements various allocators and provides utility procedures for dealing with memory, pointers and slices. The documentation below describes basic concepts, applicable to the `mem` @@ -24,7 +24,7 @@ access operation*. ## Allocators In C and C++ memory models, allocations of objects in memory are typically -treated individually with a generic allocator (The `malloc` function). Which in +treated individually with a generic allocator (The `malloc` procedure). Which in some scenarios can lead to poor cache utilization, slowdowns on individual objects' memory management and growing complexity of the code needing to keep track of the pointers and their lifetimes. @@ -45,7 +45,7 @@ allocators on a language level. Operations such as `new`, `free` and `delete` by default will use `context.allocator`, which can be overridden by the user. When an override -happens all called functions will inherit the new context and use the same +happens all called procedures will inherit the new context and use the same allocator. ## Alignment @@ -89,7 +89,17 @@ relatively expensive zero-filling of the buffer. The word `size` is used to denote the **size in bytes**. The word `length` is used to denote the count of objects. -Higher-level allocation functions follow the following naming scheme: +The allocation procedures use the following conventions: + +- If the name contains `alloc_bytes` or `resize_bytes`, then the procedure takes + in slice parameters and returns slices. +- If the procedure name contains `alloc` or `resize`, then the procedure takes + in a raw pointer and returns raw pointers. +- If the procedure name contains `free_bytes`, then the procedure takes in a + slice. +- If the procedure name contains `free`, then the procedure takes in a pointer. + +Higher-level allocation procedures follow the following naming scheme: - `new`: Allocates a single object - `free`: Free a single object (opposite of `new`) From 3a351ec407af42aeb82ac4fb51f9b633422f59fb Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 18:01:41 +1100 Subject: [PATCH 19/72] [mem]: Document mem.odin --- core/mem/mem.odin | 458 +++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 409 insertions(+), 49 deletions(-) diff --git a/core/mem/mem.odin b/core/mem/mem.odin index 9e47c9602..c17ab43a9 100644 --- a/core/mem/mem.odin +++ b/core/mem/mem.odin @@ -3,23 +3,99 @@ package mem import "base:runtime" import "base:intrinsics" -Byte :: runtime.Byte -Kilobyte :: runtime.Kilobyte -Megabyte :: runtime.Megabyte -Gigabyte :: runtime.Gigabyte -Terabyte :: runtime.Terabyte -Petabyte :: runtime.Petabyte -Exabyte :: runtime.Exabyte +/* +The size, in bytes, of a single byte. +This constant is equal to the value of `1`. +*/ +Byte :: runtime.Byte + +/* +The size, in bytes, of one kilobyte. + +This constant is equal to the amount of bytes in one kilobyte (also known as +kibibyte), which is equal to 1024 bytes. +*/ +Kilobyte :: runtime.Kilobyte + +/* +The size, in bytes, of one megabyte. + +This constant is equal to the amount of bytes in one megabyte (also known as +mebibyte), which is equal to 1024 kilobyte. +*/ +Megabyte :: runtime.Megabyte + +/* +The size, in bytes, of one gigabyte. + +This constant is equal to the amount of bytes in one gigabyte (also known as +gibiibyte), which is equal to 1024 megabytes. +*/ +Gigabyte :: runtime.Gigabyte + +/* +The size, in bytes, of one terabyte. + +This constant is equal to the amount of bytes in one terabyte (also known as +tebiibyte), which is equal to 1024 gigabytes. +*/ +Terabyte :: runtime.Terabyte + +/* +The size, in bytes, of one petabyte. + +This constant is equal to the amount of bytes in one petabyte (also known as +pebiibyte), which is equal to 1024 terabytes. +*/ +Petabyte :: runtime.Petabyte + +/* +The size, in bytes, of one exabyte. + +This constant is equal to the amount of bytes in one exabyte (also known as +exbibyte), which is equal to 1024 petabytes. +*/ +Exabyte :: runtime.Exabyte + +/* +Set each byte of a memory range to a specific value. + +This procedure copies value specified by the `value` parameter into each of the +`len` bytes of a memory range, located at address `data`. + +This procedure returns the pointer to `data`. +*/ set :: proc "contextless" (data: rawptr, value: byte, len: int) -> rawptr { return runtime.memset(data, i32(value), len) } +/* +Set each byte of a memory range to zero. + +This procedure copies the value `0` into the `len` bytes of a memory range, +starting at address `data`. + +This procedure returns the pointer to `data`. +*/ zero :: proc "contextless" (data: rawptr, len: int) -> rawptr { intrinsics.mem_zero(data, len) return data } +/* +Set each byte of a memory range to zero. + +This procedure copies the value `0` into the `len` bytes of a memory range, +starting at address `data`. + +This procedure returns the pointer to `data`. + +Unlike the `zero()` procedure, which can be optimized away or reordered by the +compiler under certain circumstances, `zero_explicit()` procedure can not be +optimized away or reordered with other memory access operations, and the +compiler assumes volatile semantics of the memory. +*/ zero_explicit :: proc "contextless" (data: rawptr, len: int) -> rawptr { // This routine tries to avoid the compiler optimizing away the call, // so that it is always executed. It is intended to provided @@ -30,26 +106,82 @@ zero_explicit :: proc "contextless" (data: rawptr, len: int) -> rawptr { return data } +/* +Zero-fill the memory of an object. + +This procedure sets each byte of the object pointed to by the pointer `item` +to zero, and returns the pointer to `item`. +*/ zero_item :: proc "contextless" (item: $P/^$T) -> P { intrinsics.mem_zero(item, size_of(T)) return item } +/* +Zero-fill the memory of the slice. + +This procedure sets each byte of the slice pointed to by the slice `data` +to zero, and returns the slice `data`. +*/ zero_slice :: proc "contextless" (data: $T/[]$E) -> T { zero(raw_data(data), size_of(E)*len(data)) return data } +/* +Copy bytes from one memory range to another. + +This procedure copies `len` bytes of data, from the memory range pointed to by +the `src` pointer into the memory range pointed to by the `dst` pointer, and +returns the `dst` pointer. +*/ copy :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr { intrinsics.mem_copy(dst, src, len) return dst } +/* +Copy bytes between two non-overlapping memory ranges. + +This procedure copies `len` bytes of data, from the memory range pointed to by +the `src` pointer into the memory range pointed to by the `dst` pointer, and +returns the `dst` pointer. + +This is a slightly more optimized version of the `copy` procedure that requires +that memory ranges specified by the parameters to this procedure are not +overlapping. If the memory ranges specified by `dst` and `src` pointers overlap, +the behavior of this function may be unpredictable. +*/ copy_non_overlapping :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr { intrinsics.mem_copy_non_overlapping(dst, src, len) return dst } +/* +Compare two memory ranges defined by slices. + +This procedure performs a byte-by-byte comparison between memory ranges +specified by slices `a` and `b`, and returns a value, specifying their relative +ordering. + +If the return value is: +- Equal to `-1`, then `a` is "smaller" than `b`. +- Equal to `+1`, then `a` is "bigger" than `b`. +- Equal to `0`, then `a` and `b` are equal. + +The comparison is performed as follows: +1. Each byte, upto `min(len(a), len(b))` bytes is compared between `a` and `b`. + - If the byte in slice `a` is smaller than a byte in slice `b`, then comparison + stops and this procedure returns `-1`. + - If the byte in slice `a` is bigger than a byte in slice `b`, then comparison + stops and this procedure returns `+1`. + - Otherwise the comparison continues until `min(len(a), len(b))` are compared. +2. If all the bytes in the range are equal, then the lengths of the slices are + compared. + - If the length of slice `a` is smaller than the length of slice `b`, then `-1` is returned. + - If the length of slice `b` is smaller than the length of slice `b`, then `+1` is returned. + - Otherwise `0` is returned. +*/ @(require_results) compare :: proc "contextless" (a, b: []byte) -> int { res := compare_byte_ptrs(raw_data(a), raw_data(b), min(len(a), len(b))) @@ -61,16 +193,89 @@ compare :: proc "contextless" (a, b: []byte) -> int { return res } +/* +Compare two memory ranges defined by byte pointers. + +This procedure performs a byte-by-byte comparison between memory ranges of size +`n` located at addresses `a` and `b`, and returns a value, specifying their relative +ordering. + +If the return value is: +- Equal to `-1`, then `a` is "smaller" than `b`. +- Equal to `+1`, then `a` is "bigger" than `b`. +- Equal to `0`, then `a` and `b` are equal. + +The comparison is performed as follows: +1. Each byte, upto `n` bytes is compared between `a` and `b`. + - If the byte in `a` is smaller than a byte in `b`, then comparison stops + and this procedure returns `-1`. + - If the byte in `a` is bigger than a byte in `b`, then comparison stops + and this procedure returns `+1`. + - Otherwise the comparison continues until `n` bytes are compared. +2. If all the bytes in the range are equal, this procedure returns `0`. +*/ @(require_results) compare_byte_ptrs :: proc "contextless" (a, b: ^byte, n: int) -> int #no_bounds_check { return runtime.memory_compare(a, b, n) } +/* +Compare two memory ranges defined by pointers. + +This procedure performs a byte-by-byte comparison between memory ranges of size +`n` located at addresses `a` and `b`, and returns a value, specifying their relative +ordering. + +If the return value is: +- Equal to `-1`, then `a` is "smaller" than `b`. +- Equal to `+1`, then `a` is "bigger" than `b`. +- Equal to `0`, then `a` and `b` are equal. + +The comparison is performed as follows: +1. Each byte, upto `n` bytes is compared between `a` and `b`. + - If the byte in `a` is smaller than a byte in `b`, then comparison stops + and this procedure returns `-1`. + - If the byte in `a` is bigger than a byte in `b`, then comparison stops + and this procedure returns `+1`. + - Otherwise the comparison continues until `n` bytes are compared. +2. If all the bytes in the range are equal, this procedure returns `0`. +*/ +@(require_results) +compare_ptrs :: proc "contextless" (a, b: rawptr, n: int) -> int { + return compare_byte_ptrs((^byte)(a), (^byte)(b), n) +} + +/* +Check whether two objects are equal on binary level. + +This procedure checks whether the memory ranges occupied by objects `a` and +`b` are equal. See `compare_byte_ptrs()` for how this comparison is done. +*/ +@(require_results) +simple_equal :: proc "contextless" (a, b: $T) -> bool where intrinsics.type_is_simple_compare(T) { + a, b := a, b + return compare_byte_ptrs((^byte)(&a), (^byte)(&b), size_of(T)) == 0 +} + +/* +Check if the memory range defined by a slice is zero-filled. + +This procedure checks whether every byte, pointed to by the slice, specified +by the parameter `data`, is zero. If all bytes of the slice are zero, this +procedure returns `true`. Otherwise this procedure returns `false`. +*/ @(require_results) check_zero :: proc(data: []byte) -> bool { return check_zero_ptr(raw_data(data), len(data)) } +/* +Check if the memory range defined defined by a pointer is zero-filled. + +This procedure checks whether each of the `len` bytes, starting at address +`ptr` is zero. If all bytes of this range are zero, this procedure returns +`true`. Otherwise this procedure returns `false`. +*/ @(require_results) check_zero_ptr :: proc(ptr: rawptr, len: int) -> bool { switch { @@ -85,58 +290,99 @@ check_zero_ptr :: proc(ptr: rawptr, len: int) -> bool { case 4: return intrinsics.unaligned_load((^u32)(ptr)) == 0 case 8: return intrinsics.unaligned_load((^u64)(ptr)) == 0 } - start := uintptr(ptr) start_aligned := align_forward_uintptr(start, align_of(uintptr)) end := start + uintptr(len) end_aligned := align_backward_uintptr(end, align_of(uintptr)) - for b in start.. bool where intrinsics.type_is_simple_compare(T) { - a, b := a, b - return compare_byte_ptrs((^byte)(&a), (^byte)(&b), size_of(T)) == 0 -} +/* +Offset a given pointer by a given amount. -@(require_results) -compare_ptrs :: proc "contextless" (a, b: rawptr, n: int) -> int { - return compare_byte_ptrs((^byte)(a), (^byte)(b), n) -} +This procedure offsets the pointer `ptr` to an object of type `T`, by the amount +of bytes specified by `offset*size_of(T)`, and returns the pointer `ptr`. +**Note**: Prefer to use multipointer types, if possible. +*/ ptr_offset :: intrinsics.ptr_offset +/* +Offset a given pointer by a given amount backwards. + +This procedure offsets the pointer `ptr` to an object of type `T`, by the amount +of bytes specified by `offset*size_of(T)` in the negative direction, and +returns the pointer `ptr`. +*/ ptr_sub :: intrinsics.ptr_sub +/* +Construct a slice from pointer and length. + +This procedure creates a slice, that points to `len` amount of objects located +at an address, specified by `ptr`. +*/ @(require_results) slice_ptr :: proc "contextless" (ptr: ^$T, len: int) -> []T { return ([^]T)(ptr)[:len] } +/* +Construct a byte slice from raw pointer and length. + +This procedure creates a byte slice, that points to `len` amount of bytes +located at an address specified by `data`. +*/ @(require_results) byte_slice :: #force_inline proc "contextless" (data: rawptr, #any_int len: int) -> []byte { return ([^]u8)(data)[:max(len, 0)] } +/* +Create a byte slice from pointer and length. + +This procedure creates a byte slice, pointing to `len` objects, starting from +the address specified by `ptr`. +*/ +@(require_results) +ptr_to_bytes :: proc "contextless" (ptr: ^$T, len := 1) -> []byte { + return transmute([]byte)Raw_Slice{ptr, len*size_of(T)} +} + +/* +Obtain the slice, pointing to the contents of `any`. + +This procedure returns the slice, pointing to the contents of the specified +value of the `any` type. +*/ +@(require_results) +any_to_bytes :: proc "contextless" (val: any) -> []byte { + ti := type_info_of(val.id) + size := ti != nil ? ti.size : 0 + return transmute([]byte)Raw_Slice{val.data, size} +} + +/* +Obtain a byte slice from any slice. + +This procedure returns a slice, that points to the same bytes as the slice, +specified by `slice` and returns the resulting byte slice. +*/ @(require_results) slice_to_bytes :: proc "contextless" (slice: $E/[]$T) -> []byte { s := transmute(Raw_Slice)slice @@ -144,6 +390,15 @@ slice_to_bytes :: proc "contextless" (slice: $E/[]$T) -> []byte { return transmute([]byte)s } +/* +Transmute slice to a different type. + +This procedure performs an operation similar to transmute, returning a slice of +type `T` that points to the same bytes as the slice specified by `slice` +parameter. Unlike plain transmute operation, this procedure adjusts the length +of the resulting slice, such that the resulting slice points to the correct +amount of objects to cover the memory region pointed to by `slice`. +*/ @(require_results) slice_data_cast :: proc "contextless" ($T: typeid/[]$A, slice: $S/[]$B) -> T { when size_of(A) == 0 || size_of(B) == 0 { @@ -155,12 +410,25 @@ slice_data_cast :: proc "contextless" ($T: typeid/[]$A, slice: $S/[]$B) -> T { } } +/* +Obtain data and length of a slice. + +This procedure returns the pointer to the start of the memory region pointed to +by slice `slice` and the length of the slice. +*/ @(require_results) slice_to_components :: proc "contextless" (slice: $E/[]$T) -> (data: ^T, len: int) { s := transmute(Raw_Slice)slice return (^T)(s.data), s.len } +/* +Create a dynamic array from slice. + +This procedure creates a dynamic array, using slice `backing` as the backing +buffer for the dynamic array. The resulting dynamic array can not grow beyond +the size of the specified slice. +*/ @(require_results) buffer_from_slice :: proc "contextless" (backing: $T/[]$E) -> [dynamic]E { return transmute([dynamic]E)Raw_Dynamic_Array{ @@ -174,19 +442,12 @@ buffer_from_slice :: proc "contextless" (backing: $T/[]$E) -> [dynamic]E { } } -@(require_results) -ptr_to_bytes :: proc "contextless" (ptr: ^$T, len := 1) -> []byte { - return transmute([]byte)Raw_Slice{ptr, len*size_of(T)} -} - -@(require_results) -any_to_bytes :: proc "contextless" (val: any) -> []byte { - ti := type_info_of(val.id) - size := ti != nil ? ti.size : 0 - return transmute([]byte)Raw_Slice{val.data, size} -} - +/* +Check whether a number is a power of two. +This procedure checks whether a given pointer-sized unsigned integer contains +a power-of-two value. +*/ @(require_results) is_power_of_two :: proc "contextless" (x: uintptr) -> bool { if x <= 0 { @@ -195,67 +456,156 @@ is_power_of_two :: proc "contextless" (x: uintptr) -> bool { return (x & (x-1)) == 0 } +/* +Align uintptr forward. + +This procedure returns the next address after `ptr`, that is located on the +alignment boundary specified by `align`. If `ptr` is already aligned to `align` +bytes, `ptr` is returned. + +The specified alignment must be a power of 2. +*/ +@(require_results) +align_forward_uintptr :: proc(ptr, align: uintptr) -> uintptr { + assert(is_power_of_two(align)) + return (p + align-1) & ~(align-1) +} + +/* +Align pointer forward. + +This procedure returns the next address after `ptr`, that is located on the +alignment boundary specified by `align`. If `ptr` is already aligned to `align` +bytes, `ptr` is returned. + +The specified alignment must be a power of 2. +*/ @(require_results) align_forward :: proc(ptr: rawptr, align: uintptr) -> rawptr { return rawptr(align_forward_uintptr(uintptr(ptr), align)) } -@(require_results) -align_forward_uintptr :: proc(ptr, align: uintptr) -> uintptr { - assert(is_power_of_two(align)) +/* +Align int forward. - p := ptr - modulo := p & (align-1) - if modulo != 0 { - p += align - modulo - } - return p -} +This procedure returns the next address after `ptr`, that is located on the +alignment boundary specified by `align`. If `ptr` is already aligned to `align` +bytes, `ptr` is returned. +The specified alignment must be a power of 2. +*/ @(require_results) align_forward_int :: proc(ptr, align: int) -> int { return int(align_forward_uintptr(uintptr(ptr), uintptr(align))) } +/* +Align uint forward. + +This procedure returns the next address after `ptr`, that is located on the +alignment boundary specified by `align`. If `ptr` is already aligned to `align` +bytes, `ptr` is returned. + +The specified alignment must be a power of 2. +*/ @(require_results) align_forward_uint :: proc(ptr, align: uint) -> uint { return uint(align_forward_uintptr(uintptr(ptr), uintptr(align))) } +/* +Align uintptr backwards. + +This procedure returns the previous address before `ptr`, that is located on the +alignment boundary specified by `align`. If `ptr` is already aligned to `align` +bytes, `ptr` is returned. + +The specified alignment must be a power of 2. +*/ +@(require_results) +align_backward_uintptr :: proc(ptr, align: uintptr) -> uintptr { + assert(is_power_of_two(align)) + return ptr & ~(align-1) +} + +/* +Align rawptr backwards. + +This procedure returns the previous address before `ptr`, that is located on the +alignment boundary specified by `align`. If `ptr` is already aligned to `align` +bytes, `ptr` is returned. + +The specified alignment must be a power of 2. +*/ @(require_results) align_backward :: proc(ptr: rawptr, align: uintptr) -> rawptr { return rawptr(align_backward_uintptr(uintptr(ptr), align)) } -@(require_results) -align_backward_uintptr :: proc(ptr, align: uintptr) -> uintptr { - return align_forward_uintptr(ptr - align + 1, align) -} +/* +Align int backwards. +This procedure returns the previous address before `ptr`, that is located on the +alignment boundary specified by `align`. If `ptr` is already aligned to `align` +bytes, `ptr` is returned. + +The specified alignment must be a power of 2. +*/ @(require_results) align_backward_int :: proc(ptr, align: int) -> int { return int(align_backward_uintptr(uintptr(ptr), uintptr(align))) } +/* +Align uint backwards. + +This procedure returns the previous address before `ptr`, that is located on the +alignment boundary specified by `align`. If `ptr` is already aligned to `align` +bytes, `ptr` is returned. + +The specified alignment must be a power of 2. +*/ @(require_results) align_backward_uint :: proc(ptr, align: uint) -> uint { return uint(align_backward_uintptr(uintptr(ptr), uintptr(align))) } +/* +Create a context with a given allocator. + +This procedure returns a copy of the current context with the allocator replaced +by the allocator `a`. +*/ @(require_results) context_from_allocator :: proc(a: Allocator) -> type_of(context) { context.allocator = a return context } +/* +Copy the value from a pointer into a value. + +This procedure copies the object of type `T` pointed to by the pointer `ptr` +into a new stack-allocated value and returns that value. +*/ @(require_results) reinterpret_copy :: proc "contextless" ($T: typeid, ptr: rawptr) -> (value: T) { copy(&value, ptr, size_of(T)) return } +/* +Dynamic array with a fixed capacity buffer. + +This type represents dynamic arrays with a fixed-size backing buffer. Upon +allocating memory beyond reaching the maximum capacity, allocations from fixed +byte buffers return `nil` and no error. +*/ Fixed_Byte_Buffer :: distinct [dynamic]byte +/* +Create a fixed byte buffer from a slice. +*/ @(require_results) make_fixed_byte_buffer :: proc "contextless" (backing: []byte) -> Fixed_Byte_Buffer { s := transmute(Raw_Slice)backing @@ -270,12 +620,24 @@ make_fixed_byte_buffer :: proc "contextless" (backing: []byte) -> Fixed_Byte_Buf return transmute(Fixed_Byte_Buffer)d } +/* +General-purpose align formula. + +This procedure is equivalent to `align_forward`, but it does not require the +alignment to be a power of two. +*/ @(require_results) align_formula :: proc "contextless" (size, align: int) -> int { result := size + align-1 return result - result%align } +/* +Calculate the padding after the pointer with a header. + +This procedure returns the next address, following `ptr` and `header_size` +bytes of space that is aligned to a boundary specified by `align`. +*/ @(require_results) calc_padding_with_header :: proc "contextless" (ptr: uintptr, align: uintptr, header_size: int) -> int { p, a := ptr, align @@ -287,14 +649,12 @@ calc_padding_with_header :: proc "contextless" (ptr: uintptr, align: uintptr, he needed_space := uintptr(header_size) if padding < needed_space { needed_space -= padding - if needed_space & (a-1) > 0 { padding += align * (1+(needed_space/align)) } else { padding += align * (needed_space/align) } } - return int(padding) } From f8cd13767e360092fb4b7df02508f2884cf82da5 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 7 Sep 2024 18:08:11 +1100 Subject: [PATCH 20/72] [mem]: Fix the issue with unbranched version of ptr align --- core/mem/mem.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/mem/mem.odin b/core/mem/mem.odin index c17ab43a9..2212ee171 100644 --- a/core/mem/mem.odin +++ b/core/mem/mem.odin @@ -468,7 +468,7 @@ The specified alignment must be a power of 2. @(require_results) align_forward_uintptr :: proc(ptr, align: uintptr) -> uintptr { assert(is_power_of_two(align)) - return (p + align-1) & ~(align-1) + return (ptr + align-1) & ~(align-1) } /* From 1842cd6297ae60fba46b43758d5ffc655ef2e58c Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sun, 8 Sep 2024 00:09:18 +1100 Subject: [PATCH 21/72] Fix typo Co-authored-by: FourteenBrush <74827262+FourteenBrush@users.noreply.github.com> --- core/mem/mem.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/mem/mem.odin b/core/mem/mem.odin index 2212ee171..0554cee23 100644 --- a/core/mem/mem.odin +++ b/core/mem/mem.odin @@ -98,7 +98,7 @@ compiler assumes volatile semantics of the memory. */ zero_explicit :: proc "contextless" (data: rawptr, len: int) -> rawptr { // This routine tries to avoid the compiler optimizing away the call, - // so that it is always executed. It is intended to provided + // so that it is always executed. It is intended to provide // equivalent semantics to those provided by the C11 Annex K 3.7.4.1 // memset_s call. intrinsics.mem_zero_volatile(data, len) // Use the volatile mem_zero From c719a86312813c1eed8793aafe6f98eb5ed1b3e0 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sun, 8 Sep 2024 10:58:40 +1100 Subject: [PATCH 22/72] [mem]: Document alloc.odin --- core/mem/alloc.odin | 577 ++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 530 insertions(+), 47 deletions(-) diff --git a/core/mem/alloc.odin b/core/mem/alloc.odin index 558e810e3..dbf9af9b2 100644 --- a/core/mem/alloc.odin +++ b/core/mem/alloc.odin @@ -2,66 +2,272 @@ package mem import "base:runtime" -// NOTE(bill, 2019-12-31): These are defined in `package runtime` as they are used in the `context`. This is to prevent an import definition cycle. +//NOTE(bill, 2019-12-31): These are defined in `package runtime` as they are used in the `context`. This is to prevent an import definition cycle. + +/* +A request to allocator procedure. + +This type represents a type of allocation request made to an allocator +procedure. There is one allocator procedure per allocator, and this value is +used to discriminate between different functions of the allocator. + +The type is defined as follows: + + Allocator_Mode :: enum byte { + Alloc, + Alloc_Non_Zeroed, + Free, + Free_All, + Resize, + Resize_Non_Zeroed, + Query_Features, + } + +Depending on which value is used, the allocator procedure will perform different +functions: + +- `Alloc`: Allocates a memory region with a given `size` and `alignment`. +- `Alloc_Non_Zeroed`: Same as `Alloc` without explicit zero-initialization of + the memory region. +- `Free`: Free a memory region located at address `ptr` with a given `size`. +- `Free_All`: Free all memory allocated using this allocator. +- `Resize`: Resize a memory region located at address `old_ptr` with size + `old_size` to be `size` bytes in length and have the specified `alignment`, + in case a re-alllocation occurs. +- `Resize_Non_Zeroed`: Same as `Resize`, without explicit zero-initialization. + +*/ Allocator_Mode :: runtime.Allocator_Mode -/* -Allocator_Mode :: enum byte { - Alloc, - Free, - Free_All, - Resize, - Query_Features, - Alloc_Non_Zeroed, - Resize_Non_Zeroed, -} -*/ +/* +A set of allocator features. + +This type represents values that contain a set of features an allocator has. +Currently the type is defined as follows: + + Allocator_Mode_Set :: distinct bit_set[Allocator_Mode]; +*/ Allocator_Mode_Set :: runtime.Allocator_Mode_Set -/* -Allocator_Mode_Set :: distinct bit_set[Allocator_Mode]; -*/ +/* +Allocator information. + +This type represents information about a given allocator at a specific point +in time. Currently the type is defined as follows: + + Allocator_Query_Info :: struct { + pointer: rawptr, + size: Maybe(int), + alignment: Maybe(int), + } + +- `pointer`: Pointer to a backing buffer. +- `size`: Size of the backing buffer. +- `alignment`: The allocator's alignment. + +If not applicable, any of these fields may be `nil`. +*/ Allocator_Query_Info :: runtime.Allocator_Query_Info -/* -Allocator_Query_Info :: struct { - pointer: rawptr, - size: Maybe(int), - alignment: Maybe(int), -} -*/ -Allocator_Error :: runtime.Allocator_Error /* -Allocator_Error :: enum byte { - None = 0, - Out_Of_Memory = 1, - Invalid_Pointer = 2, - Invalid_Argument = 3, - Mode_Not_Implemented = 4, -} +An allocation request error. + +This type represents error values the allocators may return upon requests. + + Allocator_Error :: enum byte { + None = 0, + Out_Of_Memory = 1, + Invalid_Pointer = 2, + Invalid_Argument = 3, + Mode_Not_Implemented = 4, + } + +The meaning of the errors is as follows: + +- `None`: No error. +- `Out_Of_Memory`: Either: + 1. The allocator has ran out of the backing buffer, or the requested + allocation size is too large to fit into a backing buffer. + 2. The operating system error during memory allocation. + 3. The backing allocator was used to allocate a new backing buffer and the + backing allocator returned Out_Of_Memory. +- `Invalid_Pointer`: The pointer referring to a memory region does not belong + to any of the allocators backing buffers or does not point to a valid start + of an allocation made in that allocator. +- `Invalid_Argument`: Can occur if one of the arguments makes it impossible to + satisfy a request (i.e. having alignment larger than the backing buffer + of the allocation). +- `Mode_Not_Implemented`: The allocator does not support the specified + operation. For example, an arena does not support freeing individual + allocations. +*/ +Allocator_Error :: runtime.Allocator_Error + +/* +The allocator procedure. + +This type represents allocation procedures. An allocation procedure is a single +procedure, implementing all allocator functions such as allocating the memory, +freeing the memory, etc. + +Currently the type is defined as follows: + + Allocator_Proc :: #type proc( + allocator_data: rawptr, + mode: Allocator_Mode, + size: int, + alignment: int, + old_memory: rawptr, + old_size: int, + location: Source_Code_Location = #caller_location, + ) -> ([]byte, Allocator_Error); + +The function of this procedure and the meaning of parameters depends on the +value of the `mode` parameter. + +## 1. `.Alloc`, `.Alloc_Non_Zeroed` + +Allocates a memory region of size `size`, aligned on a boundary specified by +`alignment`. + +**Inputs**: +- `allocator_data`: Pointer to the allocator data. +- `mode`: `.Alloc` or `.Alloc_Non_Zeroed`. +- `size`: The desired size of the memory region. +- `alignment`: The desired alignmnet of the allocation. +- `old_memory`: Unused, should be `nil`. +- `old_size`: Unused, should be 0. + +**Returns**: +1. The memory region, if allocated successfully, or `nil` otherwise. +2. An error, if allocation failed. + +**Note**: Some allocators may return `nil`, even if no error is returned. +Always check both the error and the allocated buffer. + +Same as `.Alloc`. + +## 2. `Free` + +Frees a memory region located at the address specified by `old_memory`. If the +allocator does not track sizes of allocations, the size should be specified in +the `old_size` parameter. + +**Inputs**: +- `allocator_data`: Pointer to the allocator data. +- `mode`: `.Free`. +- `size`: Unused, should be 0. +- `alignment`: Unused, should be 0. +- `old_memory`: Pointer to the memory region to free. +- `old_size`: The size of the memory region to free. This parameter is optional + if the allocator keeps track of the sizes of allocations. + +**Returns**: +1. `nil` +2. Error, if freeing failed. + +## 3. `Free_All` + +Frees all allocations, associated with the allocator, making it available for +further allocations using the same backing buffers. + +**Inputs**: +- `allocator_data`: Pointer to the allocator data. +- `mode`: `.Free_All`. +- `size`: Unused, should be 0. +- `alignment`: Unused, should be 0. +- `old_memory`: Unused, should be `nil`. +- `old_size`: Unused, should be `0`. + +**Returns**: +1. `nil`. +2. Error, if freeing failed. + +## 4. `Resize`, `Resize_Non_Zeroed` + +Resizes the memory region, of the size `old_size` located at the address +specified by `old_memory` to have the new size `size`. The slice of the new +memory region is returned from the procedure. The allocator may attempt to +keep the new memory region at the same address as the previous allocation, +however no such guarantee is made. Do not assume the new memory region will +be at the same address as the old memory region. + +If `old_memory` pointer is `nil`, this function acts just like `.Alloc` or +`.Alloc_Non_Zeroed`, using `size` and `alignment` to allocate a new memory +region. + +If `new_size` is `nil`, the procedure acts just like `.Free`, freeing the +memory region `old_size` bytes in length, located at the address specified by +`old_memory`. + +**Inputs**: +- `allocator_data`: Pointer to the allocator data. +- `mode`: `.Resize` or `.Resize_All`. +- `size`: The desired new size of the memory region. +- `alignment`: The alignment of the new memory region, if its allocated +- `old_memory`: The pointer to the memory region to resize. +- `old_size`: The size of the memory region to resize. If the allocator + keeps track of the sizes of allocations, this parameter is optional. + +**Returns**: +1. The slice of the memory region after resize operation, if successfull, + `nil` otherwise. +2. An error, if the resize failed. + +**Note**: Some allocators may return `nil`, even if no error is returned. +Always check both the error and the allocated buffer. */ Allocator_Proc :: runtime.Allocator_Proc -/* -Allocator_Proc :: #type proc(allocator_data: rawptr, mode: Allocator_Mode, - size, alignment: int, - old_memory: rawptr, old_size: int, location: Source_Code_Location = #caller_location) -> ([]byte, Allocator_Error); -*/ +/* +Allocator. + +This type represents generic interface for all allocators. Currently this type +is defined as follows: + + Allocator :: struct { + procedure: Allocator_Proc, + data: rawptr, + } + +- `procedure`: Pointer to the allocation procedure. +- `data`: Pointer to the allocator data. +*/ Allocator :: runtime.Allocator -/* -Allocator :: struct { - procedure: Allocator_Proc, - data: rawptr, -} -*/ +/* +Default alignment. + +This value is the default alignment for all platforms that is used, if the +alignment is not specified explicitly. +*/ DEFAULT_ALIGNMENT :: 2*align_of(rawptr) +/* +Default page size. + +This value is the default page size for the current platform. +*/ DEFAULT_PAGE_SIZE :: 64 * 1024 when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 else 16 * 1024 when ODIN_OS == .Darwin && ODIN_ARCH == .arm64 else 4 * 1024 +/* +Allocate memory. + +This function allocates `size` bytes of memory, aligned to a boundary specified +by `alignment` using the allocator specified by `allocator`. + +**Inputs**: +- `size`: The desired size of the allocated memory region. +- `alignment`: The desired alignment of the allocated memory region. +- `allocator`: The allocator to allocate from. + +**Returns**: +1. Pointer to the allocated memory, or `nil` if allocation failed. +2. Error, if the allocation failed. +*/ @(require_results) alloc :: proc( size: int, @@ -73,6 +279,21 @@ alloc :: proc( return raw_data(data), err } +/* +Allocate memory. + +This function allocates `size` bytes of memory, aligned to a boundary specified +by `alignment` using the allocator specified by `allocator`. + +**Inputs**: +- `size`: The desired size of the allocated memory region. +- `alignment`: The desired alignment of the allocated memory region. +- `allocator`: The allocator to allocate from. + +**Returns**: +1. Slice of the allocated memory region, or `nil` if allocation failed. +2. Error, if the allocation failed. +*/ @(require_results) alloc_bytes :: proc( size: int, @@ -83,6 +304,22 @@ alloc_bytes :: proc( return runtime.mem_alloc(size, alignment, allocator, loc) } +/* +Allocate non-zeroed memory. + +This function allocates `size` bytes of memory, aligned to a boundary specified +by `alignment` using the allocator specified by `allocator`. This procedure +does not explicitly zero-initialize allocated memory region. + +**Inputs**: +- `size`: The desired size of the allocated memory region. +- `alignment`: The desired alignment of the allocated memory region. +- `allocator`: The allocator to allocate from. + +**Returns**: +1. Slice of the allocated memory region, or `nil` if allocation failed. +2. Error, if the allocation failed. +*/ @(require_results) alloc_bytes_non_zeroed :: proc( size: int, @@ -93,6 +330,16 @@ alloc_bytes_non_zeroed :: proc( return runtime.mem_alloc_non_zeroed(size, alignment, allocator, loc) } +/* +Free memory. + +This procedure frees memory region located at the address, specified by `ptr`, +allocated from the allocator specified by `allocator`. + +**Inputs**: +- `ptr`: Pointer to the memory region to free. +- `allocator`: The allocator to free to. +*/ free :: proc( ptr: rawptr, allocator := context.allocator, @@ -101,15 +348,42 @@ free :: proc( return runtime.mem_free(ptr, allocator, loc) } +/* +Free a memory region. + +This procedure frees `size` bytes of memory region located at the address, +specified by `ptr`, allocated from the allocator specified by `allocator`. + +**Inputs**: +- `ptr`: Pointer to the memory region to free. +- `size`: The size of the memory region to free. +- `allocator`: The allocator to free to. + +**Returns**: +- The error, if freeing failed. +*/ free_with_size :: proc( ptr: rawptr, - byte_count: int, + size: int, allocator := context.allocator, loc := #caller_location, ) -> Allocator_Error { - return runtime.mem_free_with_size(ptr, byte_count, allocator, loc) + return runtime.mem_free_with_size(ptr, size, allocator, loc) } +/* +Free a memory region. + +This procedure frees memory region, specified by `bytes`, allocated from the +allocator specified by `allocator`. + +**Inputs**: +- `bytes`: The memory region to free. +- `allocator`: The allocator to free to. + +**Returns**: +- The error, if freeing failed. +*/ free_bytes :: proc( bytes: []byte, allocator := context.allocator, @@ -118,10 +392,45 @@ free_bytes :: proc( return runtime.mem_free_bytes(bytes, allocator, loc) } +/* +Free all allocations. + +This procedure frees all allocations made on the allocator specified by +`allocator` to that allocator, making it available for further allocations. +*/ free_all :: proc(allocator := context.allocator, loc := #caller_location) -> Allocator_Error { return runtime.mem_free_all(allocator, loc) } +/* +Resize a memory region. + +This procedure resizes a memory region, `old_size` bytes in size, located at +the address specified by `ptr`, such that it has a new size, specified by +`new_size` and and is aligned on a boundary specified by `alignment`. + +If the `ptr` parameter is `nil`, `resize()` acts just like `alloc`, allocating +`new_size` bytes, aligned on a boundary specified by `alignment`. + +If the `new_size` parameter is `0`, `resize()` acts just like `free`, freeing +the memory region `old_size` bytes in length, located at the address specified +by `ptr`. + +**Inputs**: +- `ptr`: Pointer to the memory region to resize. +- `old_size`: Size of the memory region to resize. +- `new_size`: The desired size of the resized memory region. +- `alignment`: The desired alignment of the resized memory region. +- `allocator`: The owner of the memory region to resize. + +**Returns**: +1. The pointer to the resized memory region, if successfull, `nil` otherwise. +2. Error, if resize failed. + +**Note**: The `alignment` parameter is used to preserve the original alignment +of the allocation, if `resize()` needs to relocate the memory region. Do not +use `resize()` to change the alignment of the allocated memory region. +*/ @(require_results) resize :: proc( ptr: rawptr, @@ -135,6 +444,33 @@ resize :: proc( return raw_data(data), err } +/* +Resize a memory region. + +This procedure resizes a memory region, specified by `old_data`, such that it +has a new size, specified by `new_size` and and is aligned on a boundary +specified by `alignment`. + +If the `old_data` parameter is `nil`, `resize()` acts just like `alloc`, +allocating `new_size` bytes, aligned on a boundary specified by `alignment`. + +If the `new_size` parameter is `0`, `resize()` acts just like `free`, freeing +the memory region specified by `old_data`. + +**Inputs**: +- `old_data`: Pointer to the memory region to resize. +- `new_size`: The desired size of the resized memory region. +- `alignment`: The desired alignment of the resized memory region. +- `allocator`: The owner of the memory region to resize. + +**Returns**: +1. The resized memory region, if successfull, `nil` otherwise. +2. Error, if resize failed. + +**Note**: The `alignment` parameter is used to preserve the original alignment +of the allocation, if `resize()` needs to relocate the memory region. Do not +use `resize()` to change the alignment of the allocated memory region. +*/ @(require_results) resize_bytes :: proc( old_data: []byte, @@ -146,6 +482,9 @@ resize_bytes :: proc( return runtime.mem_resize(raw_data(old_data), len(old_data), new_size, alignment, allocator, loc) } +/* +Query allocator features. +*/ @(require_results) query_features :: proc(allocator: Allocator, loc := #caller_location) -> (set: Allocator_Mode_Set) { if allocator.procedure != nil { @@ -155,6 +494,9 @@ query_features :: proc(allocator: Allocator, loc := #caller_location) -> (set: A return nil } +/* +Query allocator information. +*/ @(require_results) query_info :: proc( pointer: rawptr, @@ -168,6 +510,9 @@ query_info :: proc( return } +/* +Free a string. +*/ delete_string :: proc( str: string, allocator := context.allocator, @@ -176,6 +521,9 @@ delete_string :: proc( return runtime.delete_string(str, allocator, loc) } +/* +Free a cstring. +*/ delete_cstring :: proc( str: cstring, allocator := context.allocator, @@ -184,6 +532,9 @@ delete_cstring :: proc( return runtime.delete_cstring(str, allocator, loc) } +/* +Free a dynamic array. +*/ delete_dynamic_array :: proc( array: $T/[dynamic]$E, loc := #caller_location, @@ -191,6 +542,9 @@ delete_dynamic_array :: proc( return runtime.delete_dynamic_array(array, loc) } +/* +Free a slice. +*/ delete_slice :: proc( array: $T/[]$E, allocator := context.allocator, @@ -199,6 +553,9 @@ delete_slice :: proc( return runtime.delete_slice(array, allocator, loc) } +/* +Free a map. +*/ delete_map :: proc( m: $T/map[$K]$V, loc := #caller_location, @@ -206,6 +563,9 @@ delete_map :: proc( return runtime.delete_map(m, loc) } +/* +Free. +*/ delete :: proc{ delete_string, delete_cstring, @@ -214,6 +574,13 @@ delete :: proc{ delete_map, } +/* +Allocate a new object. + +This procedure allocates a new object of type `T` using an allocator specified +by `allocator`, and returns a pointer to the allocated object, if allocated +successfully, or `nil` otherwise. +*/ @(require_results) new :: proc( $T: typeid, @@ -223,6 +590,14 @@ new :: proc( return new_aligned(T, align_of(T), allocator, loc) } +/* +Allocate a new object with alignment. + +This procedure allocates a new object of type `T` using an allocator specified +by `allocator`, and returns a pointer, aligned on a boundary specified by +`alignment` to the allocated object, if allocated successfully, or `nil` +otherwise. +*/ @(require_results) new_aligned :: proc( $T: typeid, @@ -233,6 +608,14 @@ new_aligned :: proc( return runtime.new_aligned(T, alignment, allocator, loc) } +/* +Allocate a new object and initialize it with a value. + +This procedure allocates a new object of type `T` using an allocator specified +by `allocator`, and returns a pointer, aligned on a boundary specified by +`alignment` to the allocated object, if allocated successfully, or `nil` +otherwise. The allocated object is initialized with `data`. +*/ @(require_results) new_clone :: proc( data: $T, @@ -242,6 +625,13 @@ new_clone :: proc( return runtime.new_clone(data, allocator, loc) } +/* +Allocate a new slice with alignment. + +This procedure allocates a new slice of type `T` with length `len`, aligned +on a boundary specified by `alignment` from an allocator specified by +`allocator`, and returns the allocated slice. +*/ @(require_results) make_aligned :: proc( $T: typeid/[]$E, @@ -253,6 +643,12 @@ make_aligned :: proc( return runtime.make_aligned(T, len, alignment, allocator, loc) } +/* +Allocate a new slice. + +This procedure allocates a new slice of type `T` with length `len`, from an +allocator specified by `allocator`, and returns the allocated slice. +*/ @(require_results) make_slice :: proc( $T: typeid/[]$E, @@ -263,6 +659,12 @@ make_slice :: proc( return runtime.make_slice(T, len, allocator, loc) } +/* +Allocate a dynamic array. + +This procedure creates a dynamic array of type `T`, with `allocator` as its +backing allocator, and initial length and capacity of `0`. +*/ @(require_results) make_dynamic_array :: proc( $T: typeid/[dynamic]$E, @@ -272,6 +674,13 @@ make_dynamic_array :: proc( return runtime.make_dynamic_array(T, allocator, loc) } +/* +Allocate a dynamic array with initial length. + +This procedure creates a dynamic array of type `T`, with `allocator` as its +backing allocator, and initial capacity of `0`, and initial length specified by +`len`. +*/ @(require_results) make_dynamic_array_len :: proc( $T: typeid/[dynamic]$E, @@ -282,6 +691,13 @@ make_dynamic_array_len :: proc( return runtime.make_dynamic_array_len_cap(T, len, len, allocator, loc) } +/* +Allocate a dynamic array with initial length and capacity. + +This procedure creates a dynamic array of type `T`, with `allocator` as its +backing allocator, and initial capacity specified by `cap`, and initial length +specified by `len`. +*/ @(require_results) make_dynamic_array_len_cap :: proc( $T: typeid/[dynamic]$E, @@ -293,6 +709,13 @@ make_dynamic_array_len_cap :: proc( return runtime.make_dynamic_array_len_cap(T, len, cap, allocator, loc) } +/* +Allocate a map. + +This procedure creates a map of type `T` with initial capacity specified by +`cap`, that is using an allocator specified by `allocator` as its backing +allocator. +*/ @(require_results) make_map :: proc( $T: typeid/map[$K]$E, @@ -303,6 +726,12 @@ make_map :: proc( return runtime.make_map(T, cap, allocator, loc) } +/* +Allocate a multi pointer. + +This procedure allocates a multipointer of type `T` pointing to `len` elements, +from an allocator specified by `allocator`. +*/ @(require_results) make_multi_pointer :: proc( $T: typeid/[^]$E, @@ -313,6 +742,9 @@ make_multi_pointer :: proc( return runtime.make_multi_pointer(T, len, allocator, loc) } +/* +Allocate. +*/ make :: proc{ make_slice, make_dynamic_array, @@ -322,6 +754,23 @@ make :: proc{ make_multi_pointer, } +/* +Default resize procedure. + +When allocator does not support resize operation, but supports `.Alloc` and +`.Free`, this procedure is used to implement allocator's default behavior on +resize. + +The behavior of the function is as follows: + +- If `new_size` is `0`, the function acts like `free()`, freeing the memory + region of `old_size` bytes located at `old_memory`. +- If `old_memory` is `nil`, the function acts like `alloc()`, allocating + `new_size` bytes of memory aligned on a boundary specified by `alignment`. +- Otherwise, a new memory region of size `new_size` is allocated, then the + data from the old memory region is copied and the old memory region is + freed. +*/ @(require_results) default_resize_align :: proc( old_memory: rawptr, @@ -343,6 +792,27 @@ default_resize_align :: proc( return } +/* +Default resize procedure. + +When allocator does not support resize operation, but supports +`.Alloc_Non_Zeroed` and `.Free`, this procedure is used to implement allocator's +default behavior on +resize. + +Unlike `default_resize_align` no new memory is being explicitly +zero-initialized. + +The behavior of the function is as follows: + +- If `new_size` is `0`, the function acts like `free()`, freeing the memory + region of `old_size` bytes located at `old_memory`. +- If `old_memory` is `nil`, the function acts like `alloc()`, allocating + `new_size` bytes of memory aligned on a boundary specified by `alignment`. +- Otherwise, a new memory region of size `new_size` is allocated, then the + data from the old memory region is copied and the old memory region is + freed. +*/ @(require_results) default_resize_bytes_align_non_zeroed :: proc( old_data: []byte, @@ -354,6 +824,23 @@ default_resize_bytes_align_non_zeroed :: proc( return _default_resize_bytes_align(old_data, new_size, alignment, false, allocator, loc) } +/* +Default resize procedure. + +When allocator does not support resize operation, but supports `.Alloc` and +`.Free`, this procedure is used to implement allocator's default behavior on +resize. + +The behavior of the function is as follows: + +- If `new_size` is `0`, the function acts like `free()`, freeing the memory + region specified by `old_data`. +- If `old_data` is `nil`, the function acts like `alloc()`, allocating + `new_size` bytes of memory aligned on a boundary specified by `alignment`. +- Otherwise, a new memory region of size `new_size` is allocated, then the + data from the old memory region is copied and the old memory region is + freed. +*/ @(require_results) default_resize_bytes_align :: proc( old_data: []byte, @@ -383,16 +870,13 @@ _default_resize_bytes_align :: #force_inline proc( return alloc_bytes_non_zeroed(new_size, alignment, allocator, loc) } } - if new_size == 0 { err := free_bytes(old_data, allocator, loc) return nil, err } - if new_size == old_size { return old_data, .None } - new_memory : []byte err : Allocator_Error if should_zero { @@ -403,7 +887,6 @@ _default_resize_bytes_align :: #force_inline proc( if new_memory == nil || err != nil { return nil, err } - runtime.copy(new_memory, old_data) free_bytes(old_data, allocator, loc) return new_memory, err From b78d54601021e4c22a0a62aa7a1cfa69405da455 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sun, 8 Sep 2024 11:02:17 +1100 Subject: [PATCH 23/72] [mem]: Add non_zeroed versions of resize --- core/mem/alloc.odin | 100 +++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 94 insertions(+), 6 deletions(-) diff --git a/core/mem/alloc.odin b/core/mem/alloc.odin index dbf9af9b2..c2e55541c 100644 --- a/core/mem/alloc.odin +++ b/core/mem/alloc.odin @@ -409,10 +409,10 @@ This procedure resizes a memory region, `old_size` bytes in size, located at the address specified by `ptr`, such that it has a new size, specified by `new_size` and and is aligned on a boundary specified by `alignment`. -If the `ptr` parameter is `nil`, `resize()` acts just like `alloc`, allocating +If the `ptr` parameter is `nil`, `resize()` acts just like `alloc()`, allocating `new_size` bytes, aligned on a boundary specified by `alignment`. -If the `new_size` parameter is `0`, `resize()` acts just like `free`, freeing +If the `new_size` parameter is `0`, `resize()` acts just like `free()`, freeing the memory region `old_size` bytes in length, located at the address specified by `ptr`. @@ -444,6 +444,51 @@ resize :: proc( return raw_data(data), err } +/* +Resize a memory region without zero-initialization. + +This procedure resizes a memory region, `old_size` bytes in size, located at +the address specified by `ptr`, such that it has a new size, specified by +`new_size` and and is aligned on a boundary specified by `alignment`. + +If the `ptr` parameter is `nil`, `resize()` acts just like `alloc()`, allocating +`new_size` bytes, aligned on a boundary specified by `alignment`. + +If the `new_size` parameter is `0`, `resize()` acts just like `free()`, freeing +the memory region `old_size` bytes in length, located at the address specified +by `ptr`. + +Unlike `resize()`, this procedure does not explicitly zero-initialize any new +memory. + +**Inputs**: +- `ptr`: Pointer to the memory region to resize. +- `old_size`: Size of the memory region to resize. +- `new_size`: The desired size of the resized memory region. +- `alignment`: The desired alignment of the resized memory region. +- `allocator`: The owner of the memory region to resize. + +**Returns**: +1. The pointer to the resized memory region, if successfull, `nil` otherwise. +2. Error, if resize failed. + +**Note**: The `alignment` parameter is used to preserve the original alignment +of the allocation, if `resize()` needs to relocate the memory region. Do not +use `resize()` to change the alignment of the allocated memory region. +*/ +@(require_results) +resize_non_zeroed :: proc( + ptr: rawptr, + old_size: int, + new_size: int, + alignment: int = DEFAULT_ALIGNMENT, + allocator := context.allocator, + loc := #caller_location, +) -> (rawptr, Allocator_Error) { + data, err := runtime.non_zero_mem_resize(ptr, old_size, new_size, alignment, allocator, loc) + return raw_data(data), err +} + /* Resize a memory region. @@ -451,11 +496,12 @@ This procedure resizes a memory region, specified by `old_data`, such that it has a new size, specified by `new_size` and and is aligned on a boundary specified by `alignment`. -If the `old_data` parameter is `nil`, `resize()` acts just like `alloc`, -allocating `new_size` bytes, aligned on a boundary specified by `alignment`. +If the `old_data` parameter is `nil`, `resize_bytes()` acts just like +`alloc_bytes()`, allocating `new_size` bytes, aligned on a boundary specified +by `alignment`. -If the `new_size` parameter is `0`, `resize()` acts just like `free`, freeing -the memory region specified by `old_data`. +If the `new_size` parameter is `0`, `resize_bytes()` acts just like +`free_bytes()`, freeing the memory region specified by `old_data`. **Inputs**: - `old_data`: Pointer to the memory region to resize. @@ -482,6 +528,48 @@ resize_bytes :: proc( return runtime.mem_resize(raw_data(old_data), len(old_data), new_size, alignment, allocator, loc) } +/* +Resize a memory region. + +This procedure resizes a memory region, specified by `old_data`, such that it +has a new size, specified by `new_size` and and is aligned on a boundary +specified by `alignment`. + +If the `old_data` parameter is `nil`, `resize_bytes()` acts just like +`alloc_bytes()`, allocating `new_size` bytes, aligned on a boundary specified +by `alignment`. + +If the `new_size` parameter is `0`, `resize_bytes()` acts just like +`free_bytes()`, freeing the memory region specified by `old_data`. + +Unlike `resize_bytes()`, this procedure does not explicitly zero-initialize +any new memory. + +**Inputs**: +- `old_data`: Pointer to the memory region to resize. +- `new_size`: The desired size of the resized memory region. +- `alignment`: The desired alignment of the resized memory region. +- `allocator`: The owner of the memory region to resize. + +**Returns**: +1. The resized memory region, if successfull, `nil` otherwise. +2. Error, if resize failed. + +**Note**: The `alignment` parameter is used to preserve the original alignment +of the allocation, if `resize()` needs to relocate the memory region. Do not +use `resize()` to change the alignment of the allocated memory region. +*/ +@(require_results) +resize_bytes_non_zeroed :: proc( + old_data: []byte, + new_size: int, + alignment: int = DEFAULT_ALIGNMENT, + allocator := context.allocator, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + return runtime.non_zero_mem_resize(raw_data(old_data), len(old_data), new_size, alignment, allocator, loc) +} + /* Query allocator features. */ From 6eb80831b5ec9e43f1b70eb305688e8cff60f0ce Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sun, 8 Sep 2024 11:12:28 +1100 Subject: [PATCH 24/72] [mem]: Panic when allocator is not initialized --- core/mem/allocators.odin | 67 +++++++++++++++++++++++++++------------- 1 file changed, 45 insertions(+), 22 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 34b89fcb8..e7b5faa16 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -57,14 +57,24 @@ init_arena :: proc(a: ^Arena, data: []byte) { } @(require_results) -arena_alloc :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> (rawptr, Allocator_Error) { - bytes, err := arena_alloc_bytes(a, size, alignment) +arena_alloc :: proc( + a: ^Arena, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := arena_alloc_bytes(a, size, alignment, loc) return raw_data(bytes), err } @(require_results) -arena_alloc_bytes :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([]byte, Allocator_Error) { - bytes, err := arena_alloc_bytes_non_zeroed(a, size, alignment) +arena_alloc_bytes :: proc( + a: ^Arena, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + bytes, err := arena_alloc_bytes_non_zeroed(a, size, alignment, loc) if bytes != nil { zero_slice(bytes) } @@ -72,13 +82,26 @@ arena_alloc_bytes :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) } @(require_results) -arena_alloc_non_zeroed :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> (rawptr, Allocator_Error) { - bytes, err := arena_alloc_bytes_non_zeroed(a, size, alignment) +arena_alloc_non_zeroed :: proc( + a: ^Arena, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := arena_alloc_bytes_non_zeroed(a, size, alignment, loc) return raw_data(bytes), err } @(require_results) -arena_alloc_bytes_non_zeroed :: proc(a: ^Arena, size: int, alignment := DEFAULT_ALIGNMENT) -> ([]byte, Allocator_Error) { +arena_alloc_bytes_non_zeroed :: proc( + a: ^Arena, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location +) -> ([]byte, Allocator_Error) { + if a.data == nil { + panic("Arena is not initialized", loc) + } #no_bounds_check end := &a.data[a.offset] ptr := align_forward(end, uintptr(alignment)) total_size := size + ptr_sub((^byte)(ptr), (^byte)(end)) @@ -101,22 +124,22 @@ arena_allocator_proc :: proc( alignment: int, old_memory: rawptr, old_size: int, - location := #caller_location, + loc := #caller_location, ) -> ([]byte, Allocator_Error) { arena := cast(^Arena)allocator_data switch mode { case .Alloc: - return arena_alloc_bytes(arena, size, alignment) + return arena_alloc_bytes(arena, size, alignment, loc) case .Alloc_Non_Zeroed: - return arena_alloc_bytes_non_zeroed(arena, size, alignment) + return arena_alloc_bytes_non_zeroed(arena, size, alignment, loc) case .Free: return nil, .Mode_Not_Implemented case .Free_All: arena_free_all(arena) case .Resize: - return default_resize_bytes_align(byte_slice(old_memory, old_size), size, alignment, arena_allocator(arena)) + return default_resize_bytes_align(byte_slice(old_memory, old_size), size, alignment, arena_allocator(arena), loc) case .Resize_Non_Zeroed: - return default_resize_bytes_align_non_zeroed(byte_slice(old_memory, old_size), size, alignment, arena_allocator(arena)) + return default_resize_bytes_align_non_zeroed(byte_slice(old_memory, old_size), size, alignment, arena_allocator(arena), loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { @@ -311,9 +334,6 @@ scratch_free :: proc(s: ^Scratch, ptr: rawptr, loc := #caller_location) -> Alloc } scratch_free_all :: proc(s: ^Scratch, loc := #caller_location) { - if s.data == nil { - panic("free_all called on an unitialized scratch allocator", loc) - } s.curr_offset = 0 s.prev_allocation = nil for ptr in s.leaked_allocations { @@ -571,9 +591,6 @@ stack_free :: proc( } stack_free_all :: proc(s: ^Stack, loc := #caller_location) { - if s.data == nil { - panic("Stack free all on an uninitialized stack allocator", loc) - } s.prev_offset = 0 s.curr_offset = 0 } @@ -791,7 +808,7 @@ small_stack_alloc_bytes_non_zeroed :: proc( loc := #caller_location, ) -> ([]byte, Allocator_Error) { if s.data == nil { - return nil, .Invalid_Argument + panic("Small stack is not initialized", loc) } alignment := alignment alignment = clamp(alignment, 1, 8*size_of(Stack_Allocation_Header{}.padding)/2) @@ -815,6 +832,9 @@ small_stack_free :: proc( old_memory: rawptr, loc := #caller_location, ) -> Allocator_Error { + if s.data == nil { + panic("Small stack is not initialized", loc) + } if old_memory == nil { return nil } @@ -892,6 +912,9 @@ small_stack_resize_bytes_non_zeroed :: proc( alignment := DEFAULT_ALIGNMENT, loc := #caller_location, ) -> ([]byte, Allocator_Error) { + if s.data == nil { + panic("Small stack is not initialized", loc) + } old_memory := raw_data(old_data) old_size := len(old_data) alignment := alignment @@ -1029,7 +1052,7 @@ dynamic_arena_destroy :: proc(pool: ^Dynamic_Arena) { @(private="file") _dynamic_arena_cycle_new_block :: proc(p: ^Dynamic_Arena, loc := #caller_location) -> (err: Allocator_Error) { if p.block_allocator.procedure == nil { - panic("You must call pool_init on a Pool before using it", loc) + panic("You must call arena_init on a Pool before using it", loc) } if p.current_block != nil { append(&p.used_blocks, p.current_block, loc=loc) @@ -1528,9 +1551,9 @@ buddy_allocator_proc :: proc( case .Alloc_Non_Zeroed: return buddy_allocator_alloc_bytes_non_zeroed(b, uint(size)) case .Resize: - return default_resize_bytes_align(byte_slice(old_memory, old_size), size, alignment, buddy_allocator(b)) + return default_resize_bytes_align(byte_slice(old_memory, old_size), size, alignment, buddy_allocator(b), loc) case .Resize_Non_Zeroed: - return default_resize_bytes_align_non_zeroed(byte_slice(old_memory, old_size), size, alignment, buddy_allocator(b)) + return default_resize_bytes_align_non_zeroed(byte_slice(old_memory, old_size), size, alignment, buddy_allocator(b), loc) case .Free: return nil, buddy_allocator_free(b, old_memory) case .Free_All: From f1f5dc614e0451c65d7e036ecb92eb76a7b753bd Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sun, 8 Sep 2024 11:17:27 +1100 Subject: [PATCH 25/72] [mem]: Remove old comments --- core/mem/allocators.odin | 2 -- 1 file changed, 2 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index e7b5faa16..2ee397316 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -402,7 +402,6 @@ scratch_resize_bytes_non_zeroed :: proc( } begin := uintptr(raw_data(s.data)) end := begin + uintptr(len(s.data)) - // TODO(flysand): Doesn't handle old_memory == nil old_ptr := uintptr(old_memory) if begin <= old_ptr && old_ptr < end && old_ptr+uintptr(size) < end { s.curr_offset = int(old_ptr-begin)+size @@ -412,7 +411,6 @@ scratch_resize_bytes_non_zeroed :: proc( if err != nil { return data, err } - // TODO(flysand): OOB access on size < old_size. runtime.copy(data, byte_slice(old_memory, old_size)) err = scratch_free(s, old_memory, loc) return data, err From 3b30bc305c9da737545c96173b566efb1e10b466 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sun, 8 Sep 2024 14:13:03 +1100 Subject: [PATCH 26/72] [mem]: Document raw.odin --- core/mem/raw.odin | 74 ++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 60 insertions(+), 14 deletions(-) diff --git a/core/mem/raw.odin b/core/mem/raw.odin index 7fda3229d..ab1148cea 100644 --- a/core/mem/raw.odin +++ b/core/mem/raw.odin @@ -3,40 +3,86 @@ package mem import "base:builtin" import "base:runtime" +/* +Mamory layout of the `any` type. +*/ Raw_Any :: runtime.Raw_Any +/* +Mamory layout of the `string` type. +*/ Raw_String :: runtime.Raw_String - +/* +Mamory layout of the `cstring` type. +*/ Raw_Cstring :: runtime.Raw_Cstring - +/* +Mamory layout of `[]T` types. +*/ Raw_Slice :: runtime.Raw_Slice - +/* +Mamory layout of `[dynamic]T` types. +*/ Raw_Dynamic_Array :: runtime.Raw_Dynamic_Array - +/* +Mamory layout of `map[K]V` types. +*/ Raw_Map :: runtime.Raw_Map - +/* +Mamory layout of `#soa []T` types. +*/ Raw_Soa_Pointer :: runtime.Raw_Soa_Pointer - +/* +Mamory layout of the `complex32` type. +*/ Raw_Complex32 :: runtime.Raw_Complex32 - +/* +Mamory layout of the `complex64` type. +*/ Raw_Complex64 :: runtime.Raw_Complex64 - +/* +Mamory layout of the `complex128` type. +*/ Raw_Complex128 :: runtime.Raw_Complex128 - +/* +Mamory layout of the `quaternion64` type. +*/ Raw_Quaternion64 :: runtime.Raw_Quaternion64 - +/* +Mamory layout of the `quaternion128` type. +*/ Raw_Quaternion128 :: runtime.Raw_Quaternion128 - +/* +Mamory layout of the `quaternion256` type. +*/ Raw_Quaternion256 :: runtime.Raw_Quaternion256 - +/* +Mamory layout of the `quaternion64` type. +*/ Raw_Quaternion64_Vector_Scalar :: runtime.Raw_Quaternion64_Vector_Scalar - +/* +Mamory layout of the `quaternion128` type. +*/ Raw_Quaternion128_Vector_Scalar :: runtime.Raw_Quaternion128_Vector_Scalar - +/* +Mamory layout of the `quaternion256` type. +*/ Raw_Quaternion256_Vector_Scalar :: runtime.Raw_Quaternion256_Vector_Scalar +/* +Create a value of the any type. + +This procedure creates a value with type `any` that points to an object with +typeid `id` located at an address specified by `data`. +*/ make_any :: proc "contextless" (data: rawptr, id: typeid) -> any { return transmute(any)Raw_Any{data, id} } +/* +Obtain pointer to the data. + +This procedure returns the pointer to the data of a slice, string, or a dynamic +array. +*/ raw_data :: builtin.raw_data From 299accb717ff376bbb063cde7585d582b658d405 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sun, 8 Sep 2024 14:17:32 +1100 Subject: [PATCH 27/72] [mem]: Put panic allocator after nil allocator, adjust @require_results --- core/mem/allocators.odin | 115 +++++++++++++++++++-------------------- 1 file changed, 57 insertions(+), 58 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 2ee397316..649d5466a 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -3,6 +3,7 @@ package mem import "base:intrinsics" import "base:runtime" +@(require_results) nil_allocator :: proc() -> Allocator { return Allocator{ procedure = nil_allocator_proc, @@ -21,6 +22,62 @@ nil_allocator_proc :: proc( return nil, nil } + + +@(require_results) +panic_allocator :: proc() -> Allocator { + return Allocator{ + procedure = panic_allocator_proc, + data = nil, + } +} + +panic_allocator_proc :: proc( + allocator_data: rawptr, + mode: Allocator_Mode, + size, alignment: int, + old_memory: rawptr, + old_size: int, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + switch mode { + case .Alloc: + if size > 0 { + panic("mem: panic allocator, .Alloc called", loc=loc) + } + case .Alloc_Non_Zeroed: + if size > 0 { + panic("mem: panic allocator, .Alloc_Non_Zeroed called", loc=loc) + } + case .Resize: + if size > 0 { + panic("mem: panic allocator, .Resize called", loc=loc) + } + case .Resize_Non_Zeroed: + if size > 0 { + panic("mem: panic allocator, .Resize_Non_Zeroed called", loc=loc) + } + case .Free: + if old_memory != nil { + panic("mem: panic allocator, .Free called", loc=loc) + } + case .Free_All: + panic("mem: panic allocator, .Free_All called", loc=loc) + case .Query_Features: + set := (^Allocator_Mode_Set)(old_memory) + if set != nil { + set^ = {.Query_Features} + } + return nil, nil + + case .Query_Info: + panic("mem: panic allocator, .Query_Info called", loc=loc) + } + return nil, nil +} + + + Arena :: struct { data: []byte, offset: int, @@ -300,7 +357,6 @@ scratch_alloc_bytes_non_zeroed :: proc( return ptr, err } -@(require_results) scratch_free :: proc(s: ^Scratch, ptr: rawptr, loc := #caller_location) -> Allocator_Error { if s.data == nil { panic("Free on an uninitialized scratch allocator", loc) @@ -555,7 +611,6 @@ stack_alloc_bytes_non_zeroed :: proc( return byte_slice(rawptr(next_addr), size), nil } -@(require_results) stack_free :: proc( s: ^Stack, old_memory: rawptr, @@ -824,7 +879,6 @@ small_stack_alloc_bytes_non_zeroed :: proc( return byte_slice(rawptr(next_addr), size), nil } -@(require_results) small_stack_free :: proc( s: ^Small_Stack, old_memory: rawptr, @@ -1254,60 +1308,6 @@ dynamic_arena_allocator_proc :: proc( -panic_allocator_proc :: proc( - allocator_data: rawptr, - mode: Allocator_Mode, - size, alignment: int, - old_memory: rawptr, - old_size: int, - loc := #caller_location, -) -> ([]byte, Allocator_Error) { - switch mode { - case .Alloc: - if size > 0 { - panic("mem: panic allocator, .Alloc called", loc=loc) - } - case .Alloc_Non_Zeroed: - if size > 0 { - panic("mem: panic allocator, .Alloc_Non_Zeroed called", loc=loc) - } - case .Resize: - if size > 0 { - panic("mem: panic allocator, .Resize called", loc=loc) - } - case .Resize_Non_Zeroed: - if size > 0 { - panic("mem: panic allocator, .Resize_Non_Zeroed called", loc=loc) - } - case .Free: - if old_memory != nil { - panic("mem: panic allocator, .Free called", loc=loc) - } - case .Free_All: - panic("mem: panic allocator, .Free_All called", loc=loc) - case .Query_Features: - set := (^Allocator_Mode_Set)(old_memory) - if set != nil { - set^ = {.Query_Features} - } - return nil, nil - - case .Query_Info: - panic("mem: panic allocator, .Query_Info called", loc=loc) - } - return nil, nil -} - -@(require_results) -panic_allocator :: proc() -> Allocator { - return Allocator{ - procedure = panic_allocator_proc, - data = nil, - } -} - - - Buddy_Block :: struct #align(align_of(uint)) { size: uint, is_free: bool, @@ -1513,7 +1513,6 @@ buddy_allocator_alloc_bytes_non_zeroed :: proc(b: ^Buddy_Allocator, size: uint) return nil, nil } -@(require_results) buddy_allocator_free :: proc(b: ^Buddy_Allocator, ptr: rawptr) -> Allocator_Error { if ptr != nil { if !(b.head <= ptr && ptr <= b.tail) { From 05df34f99c97eefc6957786150e19010cb84c230 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sun, 8 Sep 2024 18:44:33 +1100 Subject: [PATCH 28/72] [mem]: Start documenting allocators.odin --- core/mem/allocators.odin | 663 ++++++++++++++++++++++++++++++++++----- 1 file changed, 592 insertions(+), 71 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 649d5466a..972031a21 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -3,6 +3,13 @@ package mem import "base:intrinsics" import "base:runtime" +/* +Nil allocator. + +The `nil` allocator returns `nil` on every allocation attempt. This type of +allocator can be used in scenarios where memory doesn't need to be allocated, +but an attempt to allocate memory is not an error. +*/ @(require_results) nil_allocator :: proc() -> Allocator { return Allocator{ @@ -23,7 +30,13 @@ nil_allocator_proc :: proc( } +/* +Panic allocator. +The panic allocator is a type of allocator that panics on any allocation +attempt. This type of allocator can be used in scenarios where memory should +not be allocated, and an attempt to allocate memory is an error. +*/ @(require_results) panic_allocator :: proc() -> Allocator { return Allocator{ @@ -77,7 +90,9 @@ panic_allocator_proc :: proc( } - +/* +Arena allocator data. +*/ Arena :: struct { data: []byte, offset: int, @@ -85,11 +100,19 @@ Arena :: struct { temp_count: int, } -Arena_Temp_Memory :: struct { - arena: ^Arena, - prev_offset: int, -} +/* +Arena allocator. +The arena allocator (also known as a linear allocator, bump allocator, +region allocator) is an allocator that uses a single backing buffer for +allocations. + +The buffer is being used contiguously, from start by end. Each subsequent +allocation occupies the next adjacent region of memory in the buffer. Since +arena allocator does not keep track of any metadata associated with the +allocations and their locations, it is impossible to free individual +allocations. +*/ @(require_results) arena_allocator :: proc(arena: ^Arena) -> Allocator { return Allocator{ @@ -98,6 +121,12 @@ arena_allocator :: proc(arena: ^Arena) -> Allocator { } } +/* +Initialize an arena. + +This procedure initializes the arena `a` with memory region `data` as it's +backing buffer. +*/ arena_init :: proc(a: ^Arena, data: []byte) { a.data = data a.offset = 0 @@ -113,6 +142,13 @@ init_arena :: proc(a: ^Arena, data: []byte) { a.temp_count = 0 } +/* +Allocate memory from an arena. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment` from an arena `a`. The allocated memory is zero-initialized. +This procedure returns a pointer to the newly allocated memory region. +*/ @(require_results) arena_alloc :: proc( a: ^Arena, @@ -124,6 +160,13 @@ arena_alloc :: proc( return raw_data(bytes), err } +/* +Allocate memory from an arena. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment` from an arena `a`. The allocated memory is zero-initialized. +This procedure returns a slice of the newly allocated memory region. +*/ @(require_results) arena_alloc_bytes :: proc( a: ^Arena, @@ -138,6 +181,14 @@ arena_alloc_bytes :: proc( return bytes, err } +/* +Allocate non-initialized memory from an arena. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment` from an arena `a`. The allocated memory is not explicitly +zero-initialized. This procedure returns a pointer to the newly allocated +memory region. +*/ @(require_results) arena_alloc_non_zeroed :: proc( a: ^Arena, @@ -149,6 +200,14 @@ arena_alloc_non_zeroed :: proc( return raw_data(bytes), err } +/* +Allocate non-initialized memory from an arena. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment` from an arena `a`. The allocated memory is not explicitly +zero-initialized. This procedure returns a slice of the newly allocated +memory region. +*/ @(require_results) arena_alloc_bytes_non_zeroed :: proc( a: ^Arena, @@ -170,6 +229,9 @@ arena_alloc_bytes_non_zeroed :: proc( return byte_slice(ptr, size), nil } +/* +Free all memory to an arena. +*/ arena_free_all :: proc(a: ^Arena) { a.offset = 0 } @@ -209,6 +271,28 @@ arena_allocator_proc :: proc( return nil, nil } +/* +Temporary memory region of arena. + +Temporary memory regions of arena act as "savepoints" for arena. When one is +created, the subsequent allocations are done inside the temporary memory +region. When `end_arena_temp_memory` is called, the arena is rolled back, and +all of the memory that was allocated from the arena will be freed. + +Multiple temporary memory regions can exist at the same time for an arena. +*/ +Arena_Temp_Memory :: struct { + arena: ^Arena, + prev_offset: int, +} + +/* +Start a temporary memory region. + +This procedure creates a temporary memory region. After a temporary memory +region is created, all allocations are said to be *inside* the temporary memory +region, until `end_arena_temp_memory` is called. +*/ @(require_results) begin_arena_temp_memory :: proc(a: ^Arena) -> Arena_Temp_Memory { tmp: Arena_Temp_Memory @@ -218,6 +302,12 @@ begin_arena_temp_memory :: proc(a: ^Arena) -> Arena_Temp_Memory { return tmp } +/* +End a temporary memory region. + +This procedure ends the temporary memory region for an arena. All of the +allocations *inside* the temporary memory region will be freed to the arena. +*/ end_arena_temp_memory :: proc(tmp: Arena_Temp_Memory) { assert(tmp.arena.offset >= tmp.prev_offset) assert(tmp.arena.temp_count > 0) @@ -225,11 +315,14 @@ end_arena_temp_memory :: proc(tmp: Arena_Temp_Memory) { tmp.arena.temp_count -= 1 } -/* old procedures */ +/* Preserved for compatibility */ Scratch_Allocator :: Scratch scratch_allocator_init :: scratch_init scratch_allocator_destroy :: scratch_destroy +/* +Scratch allocator data. +*/ Scratch :: struct { data: []byte, curr_offset: int, @@ -238,6 +331,23 @@ Scratch :: struct { leaked_allocations: [dynamic][]byte, } +/* +Scratch allocator. + +The scratch allocator works in a similar way to the `Arena` allocator. The +scratch allocator has a backing buffer, that is being allocated in +contiguous regions, from start to end. + +Each subsequent allocation will be the next adjacent region of memory in the +backing buffer. If the allocation doesn't fit into the remaining space of the +backing buffer, this allocation is put at the start of the buffer, and all +previous allocations will become invalidated. If the allocation doesn't fit +into the backing buffer as a whole, it will be allocated using a backing +allocator, and pointer to the allocated memory region will be put into the +`leaked_allocations` array. + +The `leaked_allocations` array is managed by the `context` allocator. +*/ @(require_results) scratch_allocator :: proc(allocator: ^Scratch) -> Allocator { return Allocator{ @@ -246,6 +356,9 @@ scratch_allocator :: proc(allocator: ^Scratch) -> Allocator { } } +/* +Initialize scratch allocator. +*/ scratch_init :: proc(s: ^Scratch, size: int, backup_allocator := context.allocator) -> Allocator_Error { s.data = make_aligned([]byte, size, 2*align_of(rawptr), backup_allocator) or_return s.curr_offset = 0 @@ -255,6 +368,9 @@ scratch_init :: proc(s: ^Scratch, size: int, backup_allocator := context.allocat return nil } +/* +Free all data associated with a scratch allocator. +*/ scratch_destroy :: proc(s: ^Scratch) { if s == nil { return @@ -267,6 +383,13 @@ scratch_destroy :: proc(s: ^Scratch) { s^ = {} } +/* +Allocate memory from scratch allocator. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment`. The allocated memory region is zero-initialized. This procedure +returns a pointer to the allocated memory region. +*/ @(require_results) scratch_alloc :: proc( s: ^Scratch, @@ -278,6 +401,13 @@ scratch_alloc :: proc( return raw_data(bytes), err } +/* +Allocate memory from scratch allocator. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment`. The allocated memory region is zero-initialized. This procedure +returns a slice of the allocated memory region. +*/ @(require_results) scratch_alloc_bytes :: proc( s: ^Scratch, @@ -292,6 +422,13 @@ scratch_alloc_bytes :: proc( return bytes, err } +/* +Allocate memory from scratch allocator. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment`. The allocated memory region is not explicitly zero-initialized. +This procedure returns a pointer to the allocated memory region. +*/ @(require_results) scratch_alloc_non_zeroed :: proc( s: ^Scratch, @@ -303,6 +440,13 @@ scratch_alloc_non_zeroed :: proc( return raw_data(bytes), err } +/* +Allocate memory from scratch allocator. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment`. The allocated memory region is not explicitly zero-initialized. +This procedure returns a slice of the allocated memory region. +*/ @(require_results) scratch_alloc_bytes_non_zeroed :: proc( s: ^Scratch, @@ -319,44 +463,49 @@ scratch_alloc_bytes_non_zeroed :: proc( } size := size size = align_forward_int(size, alignment) - switch { - case s.curr_offset+size <= len(s.data): + if size <= len(s.data) { + offset := uintptr(0) + if s.curr_offset+size <= len(s.data) { + offset = uintptr(s.curr_offset) + } else { + offset = 0 + } start := uintptr(raw_data(s.data)) - ptr := start + uintptr(s.curr_offset) - ptr = align_forward_uintptr(ptr, uintptr(alignment)) + ptr := align_forward_uintptr(offset+start, uintptr(alignment)) s.prev_allocation = rawptr(ptr) - offset := int(ptr - start) - s.curr_offset = offset + size + s.curr_offset = int(offset) + size return byte_slice(rawptr(ptr), size), nil - case size <= len(s.data): - start := uintptr(raw_data(s.data)) - ptr := align_forward_uintptr(start, uintptr(alignment)) - s.prev_allocation = rawptr(ptr) - offset := int(ptr - start) - s.curr_offset = offset + size - return byte_slice(rawptr(ptr), size), nil - } - a := s.backup_allocator - if a.procedure == nil { - a = context.allocator - s.backup_allocator = a - } - ptr, err := alloc_bytes_non_zeroed(size, alignment, a, loc) - if err != nil { + } else { + a := s.backup_allocator + if a.procedure == nil { + a = context.allocator + s.backup_allocator = a + } + ptr, err := alloc_bytes_non_zeroed(size, alignment, a, loc) + if err != nil { + return ptr, err + } + if s.leaked_allocations == nil { + s.leaked_allocations, err = make([dynamic][]byte, a) + } + append(&s.leaked_allocations, ptr) + if logger := context.logger; logger.lowest_level <= .Warning { + if logger.procedure != nil { + logger.procedure(logger.data, .Warning, "mem.Scratch resorted to backup_allocator" , logger.options, loc) + } + } return ptr, err } - if s.leaked_allocations == nil { - s.leaked_allocations, err = make([dynamic][]byte, a) - } - append(&s.leaked_allocations, ptr) - if logger := context.logger; logger.lowest_level <= .Warning { - if logger.procedure != nil { - logger.procedure(logger.data, .Warning, "mem.Scratch resorted to backup_allocator" , logger.options, loc) - } - } - return ptr, err } +/* +Free memory to scratch allocator. + +This procedure frees the memory region allocated at pointer `ptr`. + +If `ptr` is not the latest allocation and is not a leaked allocation, this +operation is a no-op. +*/ scratch_free :: proc(s: ^Scratch, ptr: rawptr, loc := #caller_location) -> Allocator_Error { if s.data == nil { panic("Free on an uninitialized scratch allocator", loc) @@ -389,6 +538,9 @@ scratch_free :: proc(s: ^Scratch, ptr: rawptr, loc := #caller_location) -> Alloc return .Invalid_Pointer } +/* +Free all memory to the scratch allocator. +*/ scratch_free_all :: proc(s: ^Scratch, loc := #caller_location) { s.curr_offset = 0 s.prev_allocation = nil @@ -398,6 +550,22 @@ scratch_free_all :: proc(s: ^Scratch, loc := #caller_location) { clear(&s.leaked_allocations) } +/* +Resize an allocation. + +This procedure resizes a memory region, defined by its location, `old_memory`, +and its size, `old_size` to have a size `size` and alignment `alignment`. The +newly allocated memory, if any is zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `scratch_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `scratch_free()`, freeing the +memory region located at an address specified by `old_memory`. + +This procedure returns the pointer to the resized memory region. +*/ @(require_results) scratch_resize :: proc( s: ^Scratch, @@ -411,6 +579,22 @@ scratch_resize :: proc( return raw_data(bytes), err } +/* +Resize an allocation. + +This procedure resizes a memory region, specified by `old_data`, to have a size +`size` and alignment `alignment`. The newly allocated memory, if any is +zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `scratch_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `scratch_free()`, freeing the +memory region located at an address specified by `old_memory`. + +This procedure returns the slice of the resized memory region. +*/ @(require_results) scratch_resize_bytes :: proc( s: ^Scratch, @@ -426,6 +610,22 @@ scratch_resize_bytes :: proc( return bytes, err } +/* +Resize an allocation without zero-initialization. + +This procedure resizes a memory region, defined by its location, `old_memory`, +and its size, `old_size` to have a size `size` and alignment `alignment`. The +newly allocated memory, if any is not explicitly zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `scratch_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `scratch_free()`, freeing the +memory region located at an address specified by `old_memory`. + +This procedure returns the pointer to the resized memory region. +*/ @(require_results) scratch_resize_non_zeroed :: proc( s: ^Scratch, @@ -439,6 +639,22 @@ scratch_resize_non_zeroed :: proc( return raw_data(bytes), err } +/* +Resize an allocation. + +This procedure resizes a memory region, specified by `old_data`, to have a size +`size` and alignment `alignment`. The newly allocated memory, if any is not +explicitly zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `scratch_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `scratch_free()`, freeing the +memory region located at an address specified by `old_memory`. + +This procedure returns the slice of the resized memory region. +*/ @(require_results) scratch_resize_bytes_non_zeroed :: proc( s: ^Scratch, @@ -509,7 +725,9 @@ scratch_allocator_proc :: proc( -// Stack is a stack-like allocator which has a strict memory freeing order +/* +Stack allocator data. +*/ Stack :: struct { data: []byte, prev_offset: int, @@ -517,11 +735,30 @@ Stack :: struct { peak_used: int, } +/* +Header of a stack allocation. +*/ Stack_Allocation_Header :: struct { prev_offset: int, padding: int, } +/* +Stack allocator. + +The stack allocator is an allocator that allocates data in the backing buffer +linearly, from start to end. Each subsequent allocation will get the next +adjacent memory region. + +Unlike arena allocator, the stack allocator saves allocation metadata and has +a strict freeing order. Only the last allocated element can be freed. After the +last allocated element is freed, the next previous allocated element becomes +available for freeing. + +The metadata is stored in the allocation headers, that are located before the +start of each allocated memory region. Each header points to the start of the +previous allocation header. +*/ @(require_results) stack_allocator :: proc(stack: ^Stack) -> Allocator { return Allocator{ @@ -530,6 +767,12 @@ stack_allocator :: proc(stack: ^Stack) -> Allocator { } } +/* +Initialize the stack allocator. + +This procedure initializes the stack allocator with a backing buffer specified +by `data` parameter. +*/ stack_init :: proc(s: ^Stack, data: []byte) { s.data = data s.prev_offset = 0 @@ -545,6 +788,13 @@ init_stack :: proc(s: ^Stack, data: []byte) { s.peak_used = 0 } +/* +Allocate memory from stack. + +This procedure allocates `size` bytes of memory, aligned to the boundary +specified by `alignment`. The allocated memory is zero-initialized. This +procedure returns the pointer to the allocated memory. +*/ @(require_results) stack_alloc :: proc( s: ^Stack, @@ -556,6 +806,13 @@ stack_alloc :: proc( return raw_data(bytes), err } +/* +Allocate memory from stack. + +This procedure allocates `size` bytes of memory, aligned to the boundary +specified by `alignment`. The allocated memory is zero-initialized. This +procedure returns the slice of the allocated memory. +*/ @(require_results) stack_alloc_bytes :: proc( s: ^Stack, @@ -570,6 +827,13 @@ stack_alloc_bytes :: proc( return bytes, err } +/* +Allocate memory from stack. + +This procedure allocates `size` bytes of memory, aligned to the boundary +specified by `alignment`. The allocated memory is not explicitly +zero-initialized. This procedure returns the pointer to the allocated memory. +*/ @(require_results) stack_alloc_non_zeroed :: proc( s: ^Stack, @@ -581,6 +845,13 @@ stack_alloc_non_zeroed :: proc( return raw_data(bytes), err } +/* +Allocate memory from stack. + +This procedure allocates `size` bytes of memory, aligned to the boundary +specified by `alignment`. The allocated memory is not explicitly +zero-initialized. This procedure returns the slice of the allocated memory. +*/ @(require_results) stack_alloc_bytes_non_zeroed :: proc( s: ^Stack, @@ -611,6 +882,13 @@ stack_alloc_bytes_non_zeroed :: proc( return byte_slice(rawptr(next_addr), size), nil } +/* +Free memory to the stack. + +This procedure frees the memory region starting at `old_memory` to the stack. +If the freeing does is an out of order freeing, the `.Invalid_Pointer` error +is returned. +*/ stack_free :: proc( s: ^Stack, old_memory: rawptr, @@ -643,12 +921,30 @@ stack_free :: proc( return nil } +/* +Free all allocations to the stack. +*/ stack_free_all :: proc(s: ^Stack, loc := #caller_location) { s.prev_offset = 0 s.curr_offset = 0 } +/* +Resize an allocation. +This procedure resizes a memory region, defined by its location, `old_memory`, +and its size, `old_size` to have a size `size` and alignment `alignment`. The +newly allocated memory, if any is zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `stack_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `stack_free()`, freeing the +memory region located at an address specified by `old_memory`. + +This procedure returns the pointer to the resized memory region. +*/ @(require_results) stack_resize :: proc( s: ^Stack, @@ -662,6 +958,22 @@ stack_resize :: proc( return raw_data(bytes), err } +/* +Resize an allocation. + +This procedure resizes a memory region, specified by the `old_data` parameter +to have a size `size` and alignment `alignment`. The newly allocated memory, +if any is zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `stack_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `stack_free()`, freeing the +memory region located at an address specified by `old_memory`. + +This procedure returns the slice of the resized memory region. +*/ @(require_results) stack_resize_bytes :: proc( s: ^Stack, @@ -681,6 +993,22 @@ stack_resize_bytes :: proc( return bytes, err } +/* +Resize an allocation without zero-initialization. + +This procedure resizes a memory region, defined by its location, `old_memory`, +and its size, `old_size` to have a size `size` and alignment `alignment`. The +newly allocated memory, if any is not explicitly zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `stack_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `stack_free()`, freeing the +memory region located at an address specified by `old_memory`. + +This procedure returns the pointer to the resized memory region. +*/ @(require_results) stack_resize_non_zeroed :: proc( s: ^Stack, @@ -694,6 +1022,22 @@ stack_resize_non_zeroed :: proc( return raw_data(bytes), err } +/* +Resize an allocation without zero-initialization. + +This procedure resizes a memory region, specified by the `old_data` parameter +to have a size `size` and alignment `alignment`. The newly allocated memory, +if any is not explicitly zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `stack_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `stack_free()`, freeing the +memory region located at an address specified by `old_memory`. + +This procedure returns the slice of the resized memory region. +*/ @(require_results) stack_resize_bytes_non_zeroed :: proc( s: ^Stack, @@ -784,18 +1128,28 @@ stack_allocator_proc :: proc( } - +/* +Allocation header of the small stack allocator. +*/ Small_Stack_Allocation_Header :: struct { padding: u8, } -// Small_Stack is a stack-like allocator which uses the smallest possible header but at the cost of non-strict memory freeing order +/* +Small stack allocator data. +*/ Small_Stack :: struct { data: []byte, offset: int, peak_used: int, } +/* +Initialize small stack. + +This procedure initializes the small stack allocator with `data` as its backing +buffer. +*/ small_stack_init :: proc(s: ^Small_Stack, data: []byte) { s.data = data s.offset = 0 @@ -809,6 +1163,28 @@ init_small_stack :: proc(s: ^Small_Stack, data: []byte) { s.peak_used = 0 } +/* +Small stack allocator. + +The small stack allocator is just like a stack allocator, with the only +difference being an extremely small header size. Unlike the stack allocator, +small stack allows out-of order freeing of memory. + +The memory is allocated in the backing buffer linearly, from start to end. +Each subsequent allocation will get the next adjacent memory region. + +The metadata is stored in the allocation headers, that are located before the +start of each allocated memory region. Each header contains the amount of +padding bytes between that header and end of the previous allocation. + +## Properties + +**Performance characteristics**: TODO + +**Has a backing allocator**: No + +**Saves metadata**: Allocation header before each allocation. +*/ @(require_results) small_stack_allocator :: proc(stack: ^Small_Stack) -> Allocator { return Allocator{ @@ -817,6 +1193,13 @@ small_stack_allocator :: proc(stack: ^Small_Stack) -> Allocator { } } +/* +Allocate memory from small stack. + +This procedure allocates `size` bytes of memory aligned to a boundary specified +by `alignment`. The allocated memory is zero-initialized. This procedure +returns a pointer to the allocated memory region. +*/ @(require_results) small_stack_alloc :: proc( s: ^Small_Stack, @@ -828,6 +1211,13 @@ small_stack_alloc :: proc( return raw_data(bytes), err } +/* +Allocate memory from small stack. + +This procedure allocates `size` bytes of memory aligned to a boundary specified +by `alignment`. The allocated memory is zero-initialized. This procedure +returns a slice of the allocated memory region. +*/ @(require_results) small_stack_alloc_bytes :: proc( s: ^Small_Stack, @@ -842,6 +1232,13 @@ small_stack_alloc_bytes :: proc( return bytes, err } +/* +Allocate memory from small stack. + +This procedure allocates `size` bytes of memory aligned to a boundary specified +by `alignment`. The allocated memory is not explicitly zero-initialized. This +procedure returns a pointer to the allocated memory region. +*/ @(require_results) small_stack_alloc_non_zeroed :: proc( s: ^Small_Stack, @@ -853,6 +1250,13 @@ small_stack_alloc_non_zeroed :: proc( return raw_data(bytes), err } +/* +Allocate memory from small stack. + +This procedure allocates `size` bytes of memory aligned to a boundary specified +by `alignment`. The allocated memory is not explicitly zero-initialized. This +procedure returns a slice of the allocated memory region. +*/ @(require_results) small_stack_alloc_bytes_non_zeroed :: proc( s: ^Small_Stack, @@ -879,6 +1283,13 @@ small_stack_alloc_bytes_non_zeroed :: proc( return byte_slice(rawptr(next_addr), size), nil } +/* +Allocate memory from small stack. + +This procedure allocates `size` bytes of memory aligned to a boundary specified +by `alignment`. The allocated memory is not explicitly zero-initialized. This +procedure returns a slice of the allocated memory region. +*/ small_stack_free :: proc( s: ^Small_Stack, old_memory: rawptr, @@ -907,10 +1318,29 @@ small_stack_free :: proc( return nil } +/* +Free all memory to small stack. +*/ small_stack_free_all :: proc(s: ^Small_Stack) { s.offset = 0 } +/* +Resize an allocation. + +This procedure resizes a memory region, defined by its location, `old_memory`, +and its size, `old_size` to have a size `size` and alignment `alignment`. The +newly allocated memory, if any is zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `small_stack_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `small_stack_free()`, freeing the +memory region located at an address specified by `old_memory`. + +This procedure returns the pointer to the resized memory region. +*/ @(require_results) small_stack_resize :: proc( s: ^Small_Stack, @@ -924,6 +1354,22 @@ small_stack_resize :: proc( return raw_data(bytes), err } +/* +Resize an allocation. + +This procedure resizes a memory region, specified by the `old_data` parameter +to have a size `size` and alignment `alignment`. The newly allocated memory, +if any is zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `small_stack_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `small_stack_free()`, freeing the +memory region located at an address specified by `old_memory`. + +This procedure returns the slice of the resized memory region. +*/ @(require_results) small_stack_resize_bytes :: proc( s: ^Small_Stack, @@ -943,6 +1389,22 @@ small_stack_resize_bytes :: proc( return bytes, err } +/* +Resize an allocation without zero-initialization. + +This procedure resizes a memory region, defined by its location, `old_memory`, +and its size, `old_size` to have a size `size` and alignment `alignment`. The +newly allocated memory, if any is not explicitly zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `small_stack_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `small_stack_free()`, freeing the +memory region located at an address specified by `old_memory`. + +This procedure returns the pointer to the resized memory region. +*/ @(require_results) small_stack_resize_non_zeroed :: proc( s: ^Small_Stack, @@ -956,6 +1418,22 @@ small_stack_resize_non_zeroed :: proc( return raw_data(bytes), err } +/* +Resize an allocation without zero-initialization. + +This procedure resizes a memory region, specified by the `old_data` parameter +to have a size `size` and alignment `alignment`. The newly allocated memory, +if any is not explicitly zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `small_stack_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `small_stack_free()`, freeing the +memory region located at an address specified by `old_memory`. + +This procedure returns the slice of the resized memory region. +*/ @(require_results) small_stack_resize_bytes_non_zeroed :: proc( s: ^Small_Stack, @@ -1050,11 +1528,19 @@ dynamic_pool_init :: dynamic_arena_init dynamic_pool_allocator :: dynamic_arena_allocator dynamic_pool_destroy :: dynamic_arena_destroy - - +/* +Default block size for dynamic arena. +*/ DYNAMIC_ARENA_BLOCK_SIZE_DEFAULT :: 65536 + +/* +Default out-band size of the dynamic arena. +*/ DYNAMIC_ARENA_OUT_OF_BAND_SIZE_DEFAULT :: 6554 +/* +Dynamic arena allocator data. +*/ Dynamic_Arena :: struct { block_size: int, out_band_size: int, @@ -1068,65 +1554,95 @@ Dynamic_Arena :: struct { block_allocator: Allocator, } +/* +Initialize a dynamic arena. + +This procedure initializes a dynamic arena. The specified `block_allocator` +will be used to allocate arena blocks, and `array_allocator` to allocate +arrays of blocks and out-band blocks. The blocks have the default size of +`block_size` and out-band threshold will be `out_band_size`. All allocations +will be aligned to a boundary specified by `alignment`. +*/ dynamic_arena_init :: proc( - pool: ^Dynamic_Arena, + a: ^Dynamic_Arena, block_allocator := context.allocator, array_allocator := context.allocator, block_size := DYNAMIC_ARENA_BLOCK_SIZE_DEFAULT, out_band_size := DYNAMIC_ARENA_OUT_OF_BAND_SIZE_DEFAULT, alignment := DEFAULT_ALIGNMENT, ) { - pool.block_size = block_size - pool.out_band_size = out_band_size - pool.alignment = alignment - pool.block_allocator = block_allocator - pool.out_band_allocations.allocator = array_allocator - pool.unused_blocks.allocator = array_allocator - pool.used_blocks.allocator = array_allocator + a.block_size = block_size + a.out_band_size = out_band_size + a.alignment = alignment + a.block_allocator = block_allocator + a.out_band_allocations.allocator = array_allocator + a.unused_blocks.allocator = array_allocator + a.used_blocks.allocator = array_allocator } +/* +Dynamic arena allocator. + +The dynamic arena allocator uses blocks of a specific size, allocated on-demand +using the block allocator. This allocator acts similarly to arena. All +allocations in a block happen contiguously, from start to end. If an allocation +does not fit into the remaining space of the block, and its size is smaller +than the specified out-band size, a new block is allocated using the +`block_allocator` and the allocation is performed from a newly-allocated block. + +If an allocation has bigger size than the specified out-band size, a new block +is allocated such that the allocation fits into this new block. This is referred +to as an *out-band allocation*. The out-band blocks are kept separately from +normal blocks. + +Just like arena, the dynamic arena does not support freeing of individual +objects. +*/ @(require_results) -dynamic_arena_allocator :: proc(pool: ^Dynamic_Arena) -> Allocator { +dynamic_arena_allocator :: proc(a: ^Dynamic_Arena) -> Allocator { return Allocator{ procedure = dynamic_arena_allocator_proc, - data = pool, + data = a, } } -dynamic_arena_destroy :: proc(pool: ^Dynamic_Arena) { - dynamic_arena_free_all(pool) - delete(pool.unused_blocks) - delete(pool.used_blocks) - delete(pool.out_band_allocations) - zero(pool, size_of(pool^)) +/* +Destroy a dynamic arena. +*/ +dynamic_arena_destroy :: proc(a: ^Dynamic_Arena) { + dynamic_arena_free_all(a) + delete(a.unused_blocks) + delete(a.used_blocks) + delete(a.out_band_allocations) + zero(a, size_of(a^)) } @(private="file") -_dynamic_arena_cycle_new_block :: proc(p: ^Dynamic_Arena, loc := #caller_location) -> (err: Allocator_Error) { - if p.block_allocator.procedure == nil { +_dynamic_arena_cycle_new_block :: proc(a: ^Dynamic_Arena, loc := #caller_location) -> (err: Allocator_Error) { + if a.block_allocator.procedure == nil { panic("You must call arena_init on a Pool before using it", loc) } - if p.current_block != nil { - append(&p.used_blocks, p.current_block, loc=loc) + if a.current_block != nil { + append(&a.used_blocks, a.current_block, loc=loc) } new_block: rawptr - if len(p.unused_blocks) > 0 { - new_block = pop(&p.unused_blocks) + if len(a.unused_blocks) > 0 { + new_block = pop(&a.unused_blocks) } else { data: []byte - data, err = p.block_allocator.procedure( - p.block_allocator.data, + data, err = a.block_allocator.procedure( + a.block_allocator.data, Allocator_Mode.Alloc, - p.block_size, - p.alignment, + a.block_size, + a.alignment, nil, 0, ) new_block = raw_data(data) } - p.bytes_left = p.block_size - p.current_pos = new_block - p.current_block = new_block + a.bytes_left = a.block_size + a.current_pos = new_block + a.current_block = new_block return } @@ -1435,6 +1951,11 @@ Buddy_Allocator :: struct { alignment: uint, } +/* +Buddy allocator. + +TODO +*/ @(require_results) buddy_allocator :: proc(b: ^Buddy_Allocator) -> Allocator { return Allocator{ From 167ced8ad161e0c8a84fd7b4fc3c94afff27236e Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sun, 8 Sep 2024 18:50:44 +1100 Subject: [PATCH 29/72] [mem]: Don't use named params for dynamic pool in tests --- core/mem/allocators.odin | 16 ++++++++-------- tests/core/mem/test_mem_dynamic_pool.odin | 4 ++-- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 972031a21..f1e45d1a1 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -1564,20 +1564,20 @@ arrays of blocks and out-band blocks. The blocks have the default size of will be aligned to a boundary specified by `alignment`. */ dynamic_arena_init :: proc( - a: ^Dynamic_Arena, + pool: ^Dynamic_Arena, block_allocator := context.allocator, array_allocator := context.allocator, block_size := DYNAMIC_ARENA_BLOCK_SIZE_DEFAULT, out_band_size := DYNAMIC_ARENA_OUT_OF_BAND_SIZE_DEFAULT, alignment := DEFAULT_ALIGNMENT, ) { - a.block_size = block_size - a.out_band_size = out_band_size - a.alignment = alignment - a.block_allocator = block_allocator - a.out_band_allocations.allocator = array_allocator - a.unused_blocks.allocator = array_allocator - a.used_blocks.allocator = array_allocator + pool.block_size = block_size + pool.out_band_size = out_band_size + pool.alignment = alignment + pool.block_allocator = block_allocator + pool.out_band_allocations.allocator = array_allocator + pool.unused_blocks.allocator = array_allocator + pool.used_blocks.allocator = array_allocator } /* diff --git a/tests/core/mem/test_mem_dynamic_pool.odin b/tests/core/mem/test_mem_dynamic_pool.odin index d1086cfe6..fa204d3b1 100644 --- a/tests/core/mem/test_mem_dynamic_pool.odin +++ b/tests/core/mem/test_mem_dynamic_pool.odin @@ -6,7 +6,7 @@ import "core:mem" expect_pool_allocation :: proc(t: ^testing.T, expected_used_bytes, num_bytes, alignment: int) { pool: mem.Dynamic_Pool - mem.dynamic_pool_init(pool = &pool, alignment = alignment) + mem.dynamic_pool_init(&pool, alignment = alignment) pool_allocator := mem.dynamic_pool_allocator(&pool) element, err := mem.alloc(num_bytes, alignment, pool_allocator) @@ -48,7 +48,7 @@ expect_pool_allocation_out_of_band :: proc(t: ^testing.T, num_bytes, out_band_si testing.expect(t, num_bytes >= out_band_size, "Sanity check failed, your test call is flawed! Make sure that num_bytes >= out_band_size!") pool: mem.Dynamic_Pool - mem.dynamic_pool_init(pool = &pool, out_band_size = out_band_size) + mem.dynamic_pool_init(&pool, out_band_size = out_band_size) pool_allocator := mem.dynamic_pool_allocator(&pool) element, err := mem.alloc(num_bytes, allocator = pool_allocator) From 5ae27c6ebce707aa6a153cf01ab658c6b1cbdabf Mon Sep 17 00:00:00 2001 From: Laytan Laats Date: Thu, 5 Sep 2024 18:00:35 +0200 Subject: [PATCH 30/72] wasm: support more vendor libraries Adds support for: - box2d - cgltf - stb image - stb rect pack --- core/bytes/bytes.odin | 4 +- core/mem/allocators.odin | 78 + core/os/os_js.odin | 89 +- core/strings/strings.odin | 14 +- vendor/box2d/box2d.odin | 22 +- vendor/box2d/box2d_wasm.odin | 4 + vendor/box2d/build_box2d.sh | 2 + vendor/box2d/lib/box2d_wasm.o | Bin 0 -> 433031 bytes vendor/box2d/lib/box2d_wasm_simd.o | Bin 0 -> 405135 bytes vendor/box2d/wasm.Makefile | 32 + vendor/cgltf/cgltf.odin | 5 + vendor/cgltf/cgltf_wasm.odin | 4 + vendor/cgltf/lib/cgltf_wasm.o | Bin 0 -> 112327 bytes vendor/cgltf/src/Makefile | 4 + vendor/libc/README.md | 12 + vendor/libc/assert.odin | 15 + vendor/libc/include/assert.h | 16 + vendor/libc/include/math.h | 21 + vendor/libc/include/stdio.h | 47 + vendor/libc/include/stdlib.h | 19 + vendor/libc/include/string.h | 21 + vendor/libc/libc.odin | 25 + vendor/libc/math.odin | 100 + vendor/libc/stdio.odin | 106 + vendor/libc/stdlib.odin | 119 ++ vendor/libc/string.odin | 111 + vendor/stb/image/stb_image.odin | 57 +- vendor/stb/image/stb_image_resize.odin | 5 + vendor/stb/image/stb_image_wasm.odin | 4 + vendor/stb/image/stb_image_write.odin | 22 +- vendor/stb/lib/stb_image_resize_wasm.o | Bin 0 -> 27646 bytes vendor/stb/lib/stb_image_wasm.o | Bin 0 -> 78144 bytes vendor/stb/lib/stb_image_write_wasm.o | Bin 0 -> 24259 bytes vendor/stb/lib/stb_rect_pack_wasm.o | Bin 0 -> 3683 bytes vendor/stb/lib/stb_sprintf_wasm.o | Bin 0 -> 13793 bytes vendor/stb/lib/stb_truetype_wasm.o | Bin 41425 -> 46482 bytes vendor/stb/rect_pack/stb_rect_pack.odin | 5 + vendor/stb/rect_pack/stb_rect_pack_wasm.odin | 4 + vendor/stb/sprintf/stb_sprintf.odin | 37 + vendor/stb/src/Makefile | 14 +- vendor/stb/src/stb_sprintf.c | 2 + vendor/stb/src/stb_sprintf.h | 1906 ++++++++++++++++++ vendor/stb/src/stb_truetype_wasm.c | 46 - vendor/stb/truetype/stb_truetype.odin | 7 +- vendor/stb/truetype/stb_truetype_wasm.odin | 80 +- 45 files changed, 2828 insertions(+), 231 deletions(-) create mode 100644 vendor/box2d/box2d_wasm.odin create mode 100755 vendor/box2d/lib/box2d_wasm.o create mode 100755 vendor/box2d/lib/box2d_wasm_simd.o create mode 100644 vendor/box2d/wasm.Makefile create mode 100644 vendor/cgltf/cgltf_wasm.odin create mode 100644 vendor/cgltf/lib/cgltf_wasm.o create mode 100644 vendor/libc/README.md create mode 100644 vendor/libc/assert.odin create mode 100644 vendor/libc/include/assert.h create mode 100644 vendor/libc/include/math.h create mode 100644 vendor/libc/include/stdio.h create mode 100644 vendor/libc/include/stdlib.h create mode 100644 vendor/libc/include/string.h create mode 100644 vendor/libc/libc.odin create mode 100644 vendor/libc/math.odin create mode 100644 vendor/libc/stdio.odin create mode 100644 vendor/libc/stdlib.odin create mode 100644 vendor/libc/string.odin create mode 100644 vendor/stb/image/stb_image_wasm.odin create mode 100644 vendor/stb/lib/stb_image_resize_wasm.o create mode 100644 vendor/stb/lib/stb_image_wasm.o create mode 100644 vendor/stb/lib/stb_image_write_wasm.o create mode 100644 vendor/stb/lib/stb_rect_pack_wasm.o create mode 100644 vendor/stb/lib/stb_sprintf_wasm.o create mode 100644 vendor/stb/rect_pack/stb_rect_pack_wasm.odin create mode 100644 vendor/stb/sprintf/stb_sprintf.odin create mode 100644 vendor/stb/src/stb_sprintf.c create mode 100644 vendor/stb/src/stb_sprintf.h delete mode 100644 vendor/stb/src/stb_truetype_wasm.c diff --git a/core/bytes/bytes.odin b/core/bytes/bytes.odin index 45eb44307..c0d25bcce 100644 --- a/core/bytes/bytes.odin +++ b/core/bytes/bytes.odin @@ -334,7 +334,7 @@ Inputs: Returns: - index: The index of the byte `c`, or -1 if it was not found. */ -index_byte :: proc(s: []byte, c: byte) -> (index: int) #no_bounds_check { +index_byte :: proc "contextless" (s: []byte, c: byte) -> (index: int) #no_bounds_check { i, l := 0, len(s) // Guard against small strings. On modern systems, it is ALWAYS @@ -469,7 +469,7 @@ Inputs: Returns: - index: The index of the byte `c`, or -1 if it was not found. */ -last_index_byte :: proc(s: []byte, c: byte) -> int #no_bounds_check { +last_index_byte :: proc "contextless" (s: []byte, c: byte) -> int #no_bounds_check { i := len(s) // Guard against small strings. On modern systems, it is ALWAYS diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index a5b93ad05..cbed5fbe3 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -1137,3 +1137,81 @@ buddy_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, return nil, nil } + +// An allocator that keeps track of allocation sizes and passes it along to resizes. +// This is useful if you are using a library that needs an equivalent of `realloc` but want to use +// the Odin allocator interface. +// +// You want to wrap your allocator into this one if you are trying to use any allocator that relies +// on the old size to work. +// +// The overhead of this allocator is an extra max(alignment, size_of(Header)) bytes allocated for each allocation, these bytes are +// used to store the size and original pointer. +Compat_Allocator :: struct { + parent: Allocator, +} + +compat_allocator_init :: proc(rra: ^Compat_Allocator, allocator := context.allocator) { + rra.parent = allocator +} + +compat_allocator :: proc(rra: ^Compat_Allocator) -> Allocator { + return Allocator{ + data = rra, + procedure = compat_allocator_proc, + } +} + +compat_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, + size, alignment: int, + old_memory: rawptr, old_size: int, + location := #caller_location) -> (data: []byte, err: Allocator_Error) { + size, old_size := size, old_size + + Header :: struct { + size: int, + ptr: rawptr, + } + + rra := (^Compat_Allocator)(allocator_data) + switch mode { + case .Alloc, .Alloc_Non_Zeroed: + a := max(alignment, size_of(Header)) + size += a + assert(size >= 0, "overflow") + + allocation := rra.parent.procedure(rra.parent.data, mode, size, alignment, old_memory, old_size, location) or_return + #no_bounds_check data = allocation[a:] + + ([^]Header)(raw_data(data))[-1] = { + size = size, + ptr = raw_data(allocation), + } + return + + case .Free: + header := ([^]Header)(old_memory)[-1] + return rra.parent.procedure(rra.parent.data, mode, size, alignment, header.ptr, header.size, location) + + case .Resize, .Resize_Non_Zeroed: + header := ([^]Header)(old_memory)[-1] + + a := max(alignment, size_of(header)) + size += a + assert(size >= 0, "overflow") + + allocation := rra.parent.procedure(rra.parent.data, mode, size, alignment, header.ptr, header.size, location) or_return + #no_bounds_check data = allocation[a:] + + ([^]Header)(raw_data(data))[-1] = { + size = size, + ptr = raw_data(allocation), + } + return + + case .Free_All, .Query_Info, .Query_Features: + return rra.parent.procedure(rra.parent.data, mode, size, alignment, old_memory, old_size, location) + + case: unreachable() + } +} diff --git a/core/os/os_js.odin b/core/os/os_js.odin index eb434c727..02821c3e3 100644 --- a/core/os/os_js.odin +++ b/core/os/os_js.odin @@ -3,33 +3,38 @@ package os import "base:runtime" +foreign import "odin_env" + @(require_results) is_path_separator :: proc(c: byte) -> bool { return c == '/' || c == '\\' } +Handle :: distinct u32 + +stdout: Handle = 1 +stderr: Handle = 2 + @(require_results) open :: proc(path: string, mode: int = O_RDONLY, perm: int = 0) -> (Handle, Error) { unimplemented("core:os procedure not supported on JS target") } close :: proc(fd: Handle) -> Error { - unimplemented("core:os procedure not supported on JS target") + return nil } flush :: proc(fd: Handle) -> (err: Error) { - unimplemented("core:os procedure not supported on JS target") + return nil } - - write :: proc(fd: Handle, data: []byte) -> (int, Error) { - unimplemented("core:os procedure not supported on JS target") -} - -@(private="file") -read_console :: proc(handle: Handle, b: []byte) -> (n: int, err: Error) { - unimplemented("core:os procedure not supported on JS target") + foreign odin_env { + @(link_name="write") + _write :: proc "contextless" (fd: Handle, p: []byte) --- + } + _write(fd, data) + return len(data), nil } read :: proc(fd: Handle, data: []byte) -> (int, Error) { @@ -45,19 +50,6 @@ file_size :: proc(fd: Handle) -> (i64, Error) { unimplemented("core:os procedure not supported on JS target") } - -@(private) -MAX_RW :: 1<<30 - -@(private) -pread :: proc(fd: Handle, data: []byte, offset: i64) -> (int, Error) { - unimplemented("core:os procedure not supported on JS target") -} -@(private) -pwrite :: proc(fd: Handle, data: []byte, offset: i64) -> (int, Error) { - unimplemented("core:os procedure not supported on JS target") -} - read_at :: proc(fd: Handle, data: []byte, offset: i64) -> (n: int, err: Error) { unimplemented("core:os procedure not supported on JS target") } @@ -65,16 +57,6 @@ write_at :: proc(fd: Handle, data: []byte, offset: i64) -> (n: int, err: Error) unimplemented("core:os procedure not supported on JS target") } -stdout: Handle = 1 -stderr: Handle = 2 - -@(require_results) -get_std_handle :: proc "contextless" (h: uint) -> Handle { - context = runtime.default_context() - unimplemented("core:os procedure not supported on JS target") -} - - @(require_results) exists :: proc(path: string) -> bool { unimplemented("core:os procedure not supported on JS target") @@ -90,9 +72,6 @@ is_dir :: proc(path: string) -> bool { unimplemented("core:os procedure not supported on JS target") } -// NOTE(tetra): GetCurrentDirectory is not thread safe with SetCurrentDirectory and GetFullPathName -//@private cwd_lock := win32.SRWLOCK{} // zero is initialized - @(require_results) get_current_directory :: proc(allocator := context.allocator) -> string { unimplemented("core:os procedure not supported on JS target") @@ -118,18 +97,6 @@ remove_directory :: proc(path: string) -> (err: Error) { } - -@(private, require_results) -is_abs :: proc(path: string) -> bool { - unimplemented("core:os procedure not supported on JS target") -} - -@(private, require_results) -fix_long_path :: proc(path: string) -> string { - unimplemented("core:os procedure not supported on JS target") -} - - link :: proc(old_name, new_name: string) -> (err: Error) { unimplemented("core:os procedure not supported on JS target") } @@ -169,7 +136,6 @@ read_dir :: proc(fd: Handle, n: int, allocator := context.allocator) -> (fi: []F unimplemented("core:os procedure not supported on JS target") } -Handle :: distinct uintptr File_Time :: distinct u64 _Platform_Error :: enum i32 { @@ -254,12 +220,7 @@ WSAECONNRESET :: Platform_Error.WSAECONNRESET ERROR_FILE_IS_PIPE :: General_Error.File_Is_Pipe ERROR_FILE_IS_NOT_DIR :: General_Error.Not_Dir -// "Argv" arguments converted to Odin strings -args := _alloc_command_line_arguments() - - - - +args: []string @(require_results) last_write_time :: proc(fd: Handle) -> (File_Time, Error) { @@ -279,26 +240,14 @@ get_page_size :: proc() -> int { @(private, require_results) _processor_core_count :: proc() -> int { - unimplemented("core:os procedure not supported on JS target") + return 1 } exit :: proc "contextless" (code: int) -> ! { - context = runtime.default_context() - unimplemented("core:os procedure not supported on JS target") + unimplemented_contextless("core:os procedure not supported on JS target") } - - @(require_results) current_thread_id :: proc "contextless" () -> int { - context = runtime.default_context() - unimplemented("core:os procedure not supported on JS target") + return 0 } - - - -@(require_results) -_alloc_command_line_arguments :: proc() -> []string { - return nil -} - diff --git a/core/strings/strings.odin b/core/strings/strings.odin index b69c4a0e0..dbc84f8b7 100644 --- a/core/strings/strings.odin +++ b/core/strings/strings.odin @@ -93,7 +93,7 @@ Inputs: Returns: - res: A string created from the null-terminated byte pointer and length */ -string_from_null_terminated_ptr :: proc(ptr: [^]byte, len: int) -> (res: string) { +string_from_null_terminated_ptr :: proc "contextless" (ptr: [^]byte, len: int) -> (res: string) { s := string(ptr[:len]) s = truncate_to_byte(s, 0) return s @@ -139,7 +139,7 @@ NOTE: Failure to find the byte results in returning the entire string. Returns: - res: The truncated string */ -truncate_to_byte :: proc(str: string, b: byte) -> (res: string) { +truncate_to_byte :: proc "contextless" (str: string, b: byte) -> (res: string) { n := index_byte(str, b) if n < 0 { n = len(str) @@ -261,7 +261,7 @@ Inputs: Returns: - result: `-1` if `lhs` comes first, `1` if `rhs` comes first, or `0` if they are equal */ -compare :: proc(lhs, rhs: string) -> (result: int) { +compare :: proc "contextless" (lhs, rhs: string) -> (result: int) { return mem.compare(transmute([]byte)lhs, transmute([]byte)rhs) } /* @@ -1447,7 +1447,7 @@ Output: -1 */ -index_byte :: proc(s: string, c: byte) -> (res: int) { +index_byte :: proc "contextless" (s: string, c: byte) -> (res: int) { return #force_inline bytes.index_byte(transmute([]u8)s, c) } /* @@ -1482,7 +1482,7 @@ Output: -1 */ -last_index_byte :: proc(s: string, c: byte) -> (res: int) { +last_index_byte :: proc "contextless" (s: string, c: byte) -> (res: int) { return #force_inline bytes.last_index_byte(transmute([]u8)s, c) } /* @@ -1576,8 +1576,8 @@ Output: -1 */ -index :: proc(s, substr: string) -> (res: int) { - hash_str_rabin_karp :: proc(s: string) -> (hash: u32 = 0, pow: u32 = 1) { +index :: proc "contextless" (s, substr: string) -> (res: int) { + hash_str_rabin_karp :: proc "contextless" (s: string) -> (hash: u32 = 0, pow: u32 = 1) { for i := 0; i < len(s); i += 1 { hash = hash*PRIME_RABIN_KARP + u32(s[i]) } diff --git a/vendor/box2d/box2d.odin b/vendor/box2d/box2d.odin index 081e0861b..c1d789273 100644 --- a/vendor/box2d/box2d.odin +++ b/vendor/box2d/box2d.odin @@ -3,7 +3,11 @@ package vendor_box2d import "base:intrinsics" import "core:c" -@(private) VECTOR_EXT :: "avx2" when #config(VENDOR_BOX2D_ENABLE_AVX2, intrinsics.has_target_feature("avx2")) else "sse2" +when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 { + @(private) VECTOR_EXT :: "_simd" when #config(VENDOR_BOX2D_ENABLE_SIMD128, intrinsics.has_target_feature("simd128")) else "" +} else { + @(private) VECTOR_EXT :: "avx2" when #config(VENDOR_BOX2D_ENABLE_AVX2, intrinsics.has_target_feature("avx2")) else "sse2" +} when ODIN_OS == .Windows { @(private) LIB_PATH :: "lib/box2d_windows_amd64_" + VECTOR_EXT + ".lib" @@ -13,6 +17,8 @@ when ODIN_OS == .Windows { @(private) LIB_PATH :: "lib/box2d_darwin_amd64_" + VECTOR_EXT + ".a" } else when ODIN_ARCH == .amd64 { @(private) LIB_PATH :: "lib/box2d_other_amd64_" + VECTOR_EXT + ".a" +} else when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 { + @(private) LIB_PATH :: "lib/box2d_wasm" + VECTOR_EXT + ".o" } else { @(private) LIB_PATH :: "lib/box2d_other.a" } @@ -21,8 +27,16 @@ when !#exists(LIB_PATH) { #panic("Could not find the compiled box2d libraries at \"" + LIB_PATH + "\", they can be compiled by running the `build.sh` script at `" + ODIN_ROOT + "vendor/box2d/build_box2d.sh\"`") } -foreign import lib { - LIB_PATH, +when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 { + when VECTOR_EXT == "_simd" { + foreign import lib "lib/box2d_wasm_simd.o" + } else { + foreign import lib "lib/box2d_wasm.o" + } +} else { + foreign import lib { + LIB_PATH, + } } @@ -1520,4 +1534,4 @@ IsValid :: proc{ Joint_IsValid, IsValidRay, -} \ No newline at end of file +} diff --git a/vendor/box2d/box2d_wasm.odin b/vendor/box2d/box2d_wasm.odin new file mode 100644 index 000000000..eab369a0d --- /dev/null +++ b/vendor/box2d/box2d_wasm.odin @@ -0,0 +1,4 @@ +//+build wasm32, wasm64p32 +package vendor_box2d + +@(require) import _ "vendor:libc" diff --git a/vendor/box2d/build_box2d.sh b/vendor/box2d/build_box2d.sh index 4fa64faa0..9513d3113 100755 --- a/vendor/box2d/build_box2d.sh +++ b/vendor/box2d/build_box2d.sh @@ -68,5 +68,7 @@ esac cd .. +make -f wasm.Makefile + rm -rf v3.0.0.tar.gz rm -rf box2d-3.0.0 diff --git a/vendor/box2d/lib/box2d_wasm.o b/vendor/box2d/lib/box2d_wasm.o new file mode 100755 index 0000000000000000000000000000000000000000..15d71c5a141c1667db29fedc403421da7946346c GIT binary patch literal 433031 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 literal 0 HcmV?d00001 diff --git a/vendor/box2d/lib/box2d_wasm_simd.o b/vendor/box2d/lib/box2d_wasm_simd.o new file mode 100755 index 0000000000000000000000000000000000000000..568900bd982f488dadb09abd2068e1bc1eaa870b GIT binary patch literal 405135 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
    l)9jQ7;?A0Fj^)RniiX1@}&k=L&Z85(*fEfus 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

    3#-fWtlU(;`eg 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 S+VgSZQ+6-@j{V&8ul@&oWZ1_5 literal 0 HcmV?d00001 diff --git a/vendor/box2d/wasm.Makefile b/vendor/box2d/wasm.Makefile new file mode 100644 index 000000000..929b61aea --- /dev/null +++ b/vendor/box2d/wasm.Makefile @@ -0,0 +1,32 @@ +# Custom Makefile to build box2d for Odin's WASM targets. +# I tried to make a cmake toolchain file for this / use cmake but this is far easier. +# NOTE: We are pretending to be emscripten to box2d so it takes WASM code paths, but we don't actually use emscripten. + +# CC = $(shell brew --prefix llvm)/bin/clang +# LD = $(shell brew --prefix llvm)/bin/wasm-ld + +VERSION = 3.0.0 +SRCS = $(wildcard box2d-$(VERSION)/src/*.c) +OBJS_SIMD = $(SRCS:.c=_simd.o) +OBJS = $(SRCS:.c=.o) +SYSROOT = $(shell odin root)/vendor/libc +CFLAGS = -Ibox2d-$(VERSION)/include -Ibox2d-$(VERSION)/Extern/simde --target=wasm32 -D__EMSCRIPTEN__ -DNDEBUG -O3 --sysroot=$(SYSROOT) + +all: lib/box2d_wasm.o lib/box2d_wasm_simd.o clean + +%.o: %.c + $(CC) -c $(CFLAGS) $< -o $@ + +%_simd.o: %.c + $(CC) -c $(CFLAGS) -msimd128 $< -o $@ + +lib/box2d_wasm.o: $(OBJS) + $(LD) -r -o lib/box2d_wasm.o $(OBJS) + +lib/box2d_wasm_simd.o: $(OBJS_SIMD) + $(LD) -r -o lib/box2d_wasm_simd.o $(OBJS_SIMD) + +clean: + rm -rf $(OBJS) $(OBJS_SIMD) + +.PHONY: clean diff --git a/vendor/cgltf/cgltf.odin b/vendor/cgltf/cgltf.odin index f4518360d..a24c36d64 100644 --- a/vendor/cgltf/cgltf.odin +++ b/vendor/cgltf/cgltf.odin @@ -5,6 +5,7 @@ LIB :: ( "lib/cgltf.lib" when ODIN_OS == .Windows else "lib/cgltf.a" when ODIN_OS == .Linux else "lib/darwin/cgltf.a" when ODIN_OS == .Darwin + else "lib/cgltf_wasm.o" when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 else "" ) @@ -13,7 +14,11 @@ when LIB != "" { // Windows library is shipped with the compiler, so a Windows specific message should not be needed. #panic("Could not find the compiled cgltf library, it can be compiled by running `make -C \"" + ODIN_ROOT + "vendor/cgltf/src\"`") } +} +when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 { + foreign import lib "lib/cgltf_wasm.o" +} else when LIB != "" { foreign import lib { LIB } } else { foreign import lib "system:cgltf" diff --git a/vendor/cgltf/cgltf_wasm.odin b/vendor/cgltf/cgltf_wasm.odin new file mode 100644 index 000000000..f2da86a2c --- /dev/null +++ b/vendor/cgltf/cgltf_wasm.odin @@ -0,0 +1,4 @@ +//+build wasm32, wasm64p32 +package cgltf + +@(require) import _ "vendor:libc" diff --git a/vendor/cgltf/lib/cgltf_wasm.o b/vendor/cgltf/lib/cgltf_wasm.o new file mode 100644 index 0000000000000000000000000000000000000000..54346d176c8e8c1335d00f418d7f554fe690e3f0 GIT binary patch literal 112327 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 ! { + context = g_ctx + loc := runtime.Source_Code_Location{ + file_path = string(file), + line = line, + column = 0, + procedure = string(func), + } + context.assertion_failure_proc("runtime assertion", string(expr), loc) +} diff --git a/vendor/libc/include/assert.h b/vendor/libc/include/assert.h new file mode 100644 index 000000000..a6fb6c696 --- /dev/null +++ b/vendor/libc/include/assert.h @@ -0,0 +1,16 @@ +#ifdef NDEBUG +#define assert(e) ((void)0) +#else + +#ifdef __FILE_NAME__ +#define __ASSERT_FILE_NAME __FILE_NAME__ +#else /* __FILE_NAME__ */ +#define __ASSERT_FILE_NAME __FILE__ +#endif /* __FILE_NAME__ */ + +void __odin_libc_assert_fail(const char *, const char *, int, const char *); + +#define assert(e) \ + (__builtin_expect(!(e), 0) ? __odin_libc_assert_fail(__func__, __ASSERT_FILE_NAME, __LINE__, #e) : (void)0) + +#endif /* NDEBUG */ diff --git a/vendor/libc/include/math.h b/vendor/libc/include/math.h new file mode 100644 index 000000000..3f60d698f --- /dev/null +++ b/vendor/libc/include/math.h @@ -0,0 +1,21 @@ +#include + +float sqrtf(float); +float cosf(float); +float sinf(float); +float atan2f(float, float); +bool isnan(float); +bool isinf(float); +double floor(double x); +double ceil(double x); +double sqrt(double x); +double pow(double x, double y); +double fmod(double x, double y); +double cos(double x); +double acos(double x); +double fabs(double x); +int abs(int); +double ldexp(double, int); +double exp(double); +float log(float); +float sin(float); diff --git a/vendor/libc/include/stdio.h b/vendor/libc/include/stdio.h new file mode 100644 index 000000000..807437f3c --- /dev/null +++ b/vendor/libc/include/stdio.h @@ -0,0 +1,47 @@ +#include +#include + +#pragma once + +typedef struct {} FILE; + +#define SEEK_SET 0 +#define SEEK_CUR 1 +#define SEEK_END 2 + +#define stdout ((FILE *)2) +#define stderr ((FILE *)3) + +FILE *fopen(const char *, char *); +int fclose(FILE *); +int fseek(FILE *, long, int); +long ftell(FILE *); +size_t fread(void *, size_t, size_t, FILE *); +size_t fwrite(const void *, size_t, size_t, FILE *); + +int vfprintf(FILE *, const char *, va_list); +int vsnprintf(char *, size_t, const char *, va_list); + +static inline int snprintf(char *buf, size_t size, const char *fmt, ...) { + va_list args; + va_start(args, fmt); + int result = vsnprintf(buf, size, fmt, args); + va_end(args); + return result; +} + +static inline int fprintf(FILE *f, const char *fmt, ...) { + va_list args; + va_start(args, fmt); + int result = vfprintf(f, fmt, args); + va_end(args); + return result; +} + +static inline int printf(const char *fmt, ...) { + va_list args; + va_start(args, fmt); + int result = vfprintf(stdout, fmt, args); + va_end(args); + return result; +} diff --git a/vendor/libc/include/stdlib.h b/vendor/libc/include/stdlib.h new file mode 100644 index 000000000..22cfc528b --- /dev/null +++ b/vendor/libc/include/stdlib.h @@ -0,0 +1,19 @@ +#include + +void *malloc(size_t size); + +void *aligned_alloc(size_t alignment, size_t size); + +void free(void *); + +void *realloc(void *, size_t); + +void qsort(void* base, size_t num, size_t size, int (*compare)(const void*, const void*)); + +int atoi(const char *); +long atol(const char *); +long long atoll(const char *); + +double atof(const char *); + +long strtol(const char *, char **, int); diff --git a/vendor/libc/include/string.h b/vendor/libc/include/string.h new file mode 100644 index 000000000..4571f9454 --- /dev/null +++ b/vendor/libc/include/string.h @@ -0,0 +1,21 @@ +#include + +void *memcpy(void *, const void *, size_t); +void *memset(void *, int, size_t); +void *memmove(void *, void *, size_t); +int memcmp(const void *, const void *, size_t); + +unsigned long strlen(const char *str); + +char *strchr(const char *, int); +char *strrchr(const char *, int); + +char *strncpy(char *, const char *, size_t); +char *strcpy(char *, const char *); + +size_t strcspn(const char *, const char *); + +int strcmp(const char *, const char *); +int strncmp(const char *, const char *, size_t); + +char *strstr(const char *, const char *); diff --git a/vendor/libc/libc.odin b/vendor/libc/libc.odin new file mode 100644 index 000000000..00d687109 --- /dev/null +++ b/vendor/libc/libc.odin @@ -0,0 +1,25 @@ +package odin_libc + +import "base:runtime" + +import "core:mem" + +@(private) +g_ctx: runtime.Context +@(private) +g_allocator: mem.Compat_Allocator + +@(init) +init_context :: proc() { + g_ctx = context + + // Wrapping the allocator with the mem.Compat_Allocator so we can + // mimic the realloc semantics. + mem.compat_allocator_init(&g_allocator, g_ctx.allocator) + g_ctx.allocator = mem.compat_allocator(&g_allocator) +} + +// NOTE: the allocator must respect an `old_size` of `-1` on resizes! +set_context :: proc(ctx := context) { + g_ctx = ctx +} diff --git a/vendor/libc/math.odin b/vendor/libc/math.odin new file mode 100644 index 000000000..59f42dd67 --- /dev/null +++ b/vendor/libc/math.odin @@ -0,0 +1,100 @@ +package odin_libc + +import "base:builtin" + +import "core:math" + +@(require, linkage="strong", link_name="sqrtf") +sqrtf :: proc "c" (v: f32) -> f32 { + return math.sqrt(v) +} + +@(require, linkage="strong", link_name="cosf") +cosf :: proc "c" (v: f32) -> f32 { + return math.cos(v) +} + +@(require, linkage="strong", link_name="sinf") +sinf :: proc "c" (v: f32) -> f32 { + return math.sin(v) +} + +@(require, linkage="strong", link_name="atan2f") +atan2f :: proc "c" (v: f32, v2: f32) -> f32 { + return math.atan2(v, v2) +} + +@(require, linkage="strong", link_name="isnan") +isnan :: proc "c" (v: f32) -> bool { + return math.is_nan(v) +} + +@(require, linkage="strong", link_name="isinf") +isinf :: proc "c" (v: f32) -> bool { + return math.is_inf(v) +} + +@(require, linkage="strong", link_name="sqrt") +sqrt :: proc "c" (x: f64) -> f64 { + return math.sqrt(x) +} + +@(require, linkage="strong", link_name="floor") +floor :: proc "c" (x: f64) -> f64 { + return math.floor(x) +} + +@(require, linkage="strong", link_name="ceil") +ceil :: proc "c" (x: f64) -> f64 { + return math.ceil(x) +} + +@(require, linkage="strong", link_name="pow") +pow :: proc "c" (x, y: f64) -> f64 { + return math.pow(x, y) +} + +@(require, linkage="strong", link_name="fmod") +fmod :: proc "c" (x, y: f64) -> f64 { + return math.mod(x, y) +} + +@(require, linkage="strong", link_name="cos") +cos :: proc "c" (x: f64) -> f64 { + return math.cos(x) +} + +@(require, linkage="strong", link_name="acos") +acos :: proc "c" (x: f64) -> f64 { + return math.acos(x) +} + +@(require, linkage="strong", link_name="fabs") +fabs :: proc "c" (x: f64) -> f64 { + return math.abs(x) +} + +@(require, linkage="strong", link_name="abs") +abs :: proc "c" (x: i32) -> i32 { + return builtin.abs(x) +} + +@(require, linkage="strong", link_name="ldexp") +ldexp :: proc "c" (x: f64, y: i32) -> f64{ + return math.ldexp(x, int(y)) +} + +@(require, linkage="strong", link_name="exp") +exp :: proc "c" (x: f64) -> f64 { + return math.exp(x) +} + +@(require, linkage="strong", link_name="log") +log :: proc "c" (x: f32) -> f32 { + return math.ln(x) +} + +@(require, linkage="strong", link_name="sin") +sin :: proc "c" (x: f32) -> f32 { + return math.sin(x) +} diff --git a/vendor/libc/stdio.odin b/vendor/libc/stdio.odin new file mode 100644 index 000000000..10b95b96b --- /dev/null +++ b/vendor/libc/stdio.odin @@ -0,0 +1,106 @@ +package odin_libc + +import "core:c" +import "core:io" +import "core:os" + +import stb "vendor:stb/sprintf" + +FILE :: uintptr + +@(require, linkage="strong", link_name="fopen") +fopen :: proc "c" (path: cstring, mode: cstring) -> FILE { + context = g_ctx + unimplemented("odin_libc.fopen") +} + +@(require, linkage="strong", link_name="fseek") +fseek :: proc "c" (file: FILE, offset: c.long, whence: i32) -> i32 { + context = g_ctx + handle := os.Handle(file-1) + _, err := os.seek(handle, i64(offset), int(whence)) + if err != nil { + return -1 + } + return 0 +} + +@(require, linkage="strong", link_name="ftell") +ftell :: proc "c" (file: FILE) -> c.long { + context = g_ctx + handle := os.Handle(file-1) + off, err := os.seek(handle, 0, os.SEEK_CUR) + if err != nil { + return -1 + } + return c.long(off) +} + +@(require, linkage="strong", link_name="fclose") +fclose :: proc "c" (file: FILE) -> i32 { + context = g_ctx + handle := os.Handle(file-1) + if os.close(handle) != nil { + return -1 + } + return 0 +} + +@(require, linkage="strong", link_name="fread") +fread :: proc "c" (buffer: [^]byte, size: uint, count: uint, file: FILE) -> uint { + context = g_ctx + handle := os.Handle(file-1) + n, _ := os.read(handle, buffer[:min(size, count)]) + return uint(max(0, n)) +} + +@(require, linkage="strong", link_name="fwrite") +fwrite :: proc "c" (buffer: [^]byte, size: uint, count: uint, file: FILE) -> uint { + context = g_ctx + handle := os.Handle(file-1) + n, _ := os.write(handle, buffer[:min(size, count)]) + return uint(max(0, n)) +} + +@(require, linkage="strong", link_name="vsnprintf") +vsnprintf :: proc "c" (buf: [^]byte, count: uint, fmt: cstring, args: ^c.va_list) -> i32 { + i32_count := i32(count) + assert_contextless(i32_count >= 0) + return stb.vsnprintf(buf, i32_count, fmt, args) +} + +@(require, linkage="strong", link_name="vfprintf") +vfprintf :: proc "c" (file: FILE, fmt: cstring, args: ^c.va_list) -> i32 { + context = g_ctx + + handle := os.Handle(file-1) + + MAX_STACK :: 4096 + + buf: []byte + stack_buf: [MAX_STACK]byte = --- + { + n := stb.vsnprintf(&stack_buf[0], MAX_STACK, fmt, args) + if n <= 0 { + return n + } + + if n >= MAX_STACK { + buf = make([]byte, n) + n2 := stb.vsnprintf(raw_data(buf), i32(len(buf)), fmt, args) + assert(n == n2) + } else { + buf = stack_buf[:n] + } + } + defer if len(buf) > MAX_STACK { + delete(buf) + } + + _, err := io.write_full(os.stream_from_handle(handle), buf) + if err != nil { + return -1 + } + + return i32(len(buf)) +} diff --git a/vendor/libc/stdlib.odin b/vendor/libc/stdlib.odin new file mode 100644 index 000000000..f898de619 --- /dev/null +++ b/vendor/libc/stdlib.odin @@ -0,0 +1,119 @@ +package odin_libc + +import "base:runtime" + +import "core:c" +import "core:slice" +import "core:sort" +import "core:strconv" +import "core:strings" + +@(require, linkage="strong", link_name="malloc") +malloc :: proc "c" (size: uint) -> rawptr { + context = g_ctx + ptr, err := runtime.mem_alloc_non_zeroed(int(size)) + assert(err == nil, "allocation failure") + return raw_data(ptr) +} + +@(require, linkage="strong", link_name="aligned_alloc") +aligned_alloc :: proc "c" (alignment: uint, size: uint) -> rawptr { + context = g_ctx + ptr, err := runtime.mem_alloc_non_zeroed(int(size), int(alignment)) + assert(err == nil, "allocation failure") + return raw_data(ptr) +} + +@(require, linkage="strong", link_name="free") +free :: proc "c" (ptr: rawptr) { + context = g_ctx + runtime.mem_free(ptr) +} + +@(require, linkage="strong", link_name="realloc") +realloc :: proc "c" (ptr: rawptr, new_size: uint) -> rawptr { + context = g_ctx + // -1 for the old_size, assumed to be wrapped with the mem.Compat_Allocator to get the right size. + // Note that realloc does not actually care about alignment and is allowed to just align it to something + // else than the original allocation. + ptr, err := runtime.non_zero_mem_resize(ptr, -1, int(new_size)) + assert(err != nil, "realloc failure") + return raw_data(ptr) +} + +@(require, linkage="strong", link_name="qsort") +qsort :: proc "c" (base: rawptr, num: uint, size: uint, cmp: proc "c" (a, b: rawptr) -> i32) { + context = g_ctx + + Inputs :: struct { + base: rawptr, + num: uint, + size: uint, + cmp: proc "c" (a, b: rawptr) -> i32, + } + + sort.sort({ + collection = &Inputs{base, num, size, cmp}, + len = proc(it: sort.Interface) -> int { + inputs := (^Inputs)(it.collection) + return int(inputs.num) + }, + less = proc(it: sort.Interface, i, j: int) -> bool { + inputs := (^Inputs)(it.collection) + a := rawptr(uintptr(inputs.base) + (uintptr(i) * uintptr(inputs.size))) + b := rawptr(uintptr(inputs.base) + (uintptr(j) * uintptr(inputs.size))) + return inputs.cmp(a, b) < 0 + }, + swap = proc(it: sort.Interface, i, j: int) { + inputs := (^Inputs)(it.collection) + + a := rawptr(uintptr(inputs.base) + (uintptr(i) * uintptr(inputs.size))) + b := rawptr(uintptr(inputs.base) + (uintptr(j) * uintptr(inputs.size))) + + slice.ptr_swap_non_overlapping(a, b, int(inputs.size)) + }, + }) +} + +@(require, linkage="strong", link_name="atoi") +atoi :: proc "c" (str: cstring) -> i32 { + return i32(atoll(str)) +} + +@(require, linkage="strong", link_name="atol") +atol :: proc "c" (str: cstring) -> c.long { + return c.long(atoll(str)) +} + +@(require, linkage="strong", link_name="atoll") +atoll :: proc "c" (str: cstring) -> c.longlong { + context = g_ctx + + sstr := string(str) + sstr = strings.trim_left_space(sstr) + i, _ := strconv.parse_i64_of_base(sstr, 10) + return c.longlong(i) +} + +@(require, linkage="strong", link_name="atof") +atof :: proc "c" (str: cstring) -> f64 { + context = g_ctx + + sstr := string(str) + sstr = strings.trim_left_space(sstr) + f, _ := strconv.parse_f64(sstr) + return f +} + +@(require, linkage="strong", link_name="strtol") +strtol :: proc "c" (str: cstring, str_end: ^cstring, base: i32) -> c.long { + context = g_ctx + + sstr := string(str) + sstr = strings.trim_left_space(sstr) + + n: int + i, _ := strconv.parse_i64_of_base(sstr, int(base), &n) + str_end ^= cstring(raw_data(sstr)[n:]) + return c.long(clamp(i, i64(min(c.long)), i64(max(c.long)))) +} diff --git a/vendor/libc/string.odin b/vendor/libc/string.odin new file mode 100644 index 000000000..1ab0803da --- /dev/null +++ b/vendor/libc/string.odin @@ -0,0 +1,111 @@ +package odin_libc + +import "base:intrinsics" + +import "core:c" +import "core:strings" +import "core:mem" + +// NOTE: already defined by Odin. +// void *memcpy(void *, const void *, size_t); +// void *memset(void *, int, size_t); + +@(require, linkage="strong", link_name="memcmp") +memcmp :: proc "c" (lhs: [^]byte, rhs: [^]byte, count: uint) -> i32 { + icount := int(count) + assert_contextless(icount >= 0) + return i32(mem.compare(lhs[:icount], rhs[:icount])) +} + +@(require, linkage="strong", link_name="strlen") +strlen :: proc "c" (str: cstring) -> c.ulong { + return c.ulong(len(str)) +} + +@(require, linkage="strong", link_name="strchr") +strchr :: proc "c" (str: cstring, ch: i32) -> cstring { + bch := u8(ch) + sstr := string(str) + if bch == 0 { + return cstring(raw_data(sstr)[len(sstr):]) + } + + idx := strings.index_byte(sstr, bch) + if idx < 0 { + return nil + } + + return cstring(raw_data(sstr)[idx:]) +} + +@(require, linkage="strong", link_name="strrchr") +strrchr :: proc "c" (str: cstring, ch: i32) -> cstring { + bch := u8(ch) + sstr := string(str) + if bch == 0 { + return cstring(raw_data(sstr)[len(sstr):]) + } + + idx := strings.last_index_byte(sstr, bch) + if idx < 0 { + return nil + } + + return cstring(raw_data(sstr)[idx:]) +} + +@(require, linkage="strong", link_name="strncpy") +strncpy :: proc "c" (dst: [^]byte, src: cstring, count: uint) -> cstring { + icount := int(count) + assert_contextless(icount >= 0) + cnt := min(len(src), icount) + intrinsics.mem_copy_non_overlapping(dst, rawptr(src), cnt) + intrinsics.mem_zero(dst, icount-cnt) + return cstring(dst) +} + +@(require, linkage="strong", link_name="strcpy") +strcpy :: proc "c" (dst: [^]byte, src: cstring) -> cstring { + intrinsics.mem_copy_non_overlapping(dst, rawptr(src), len(src)+1) + return cstring(dst) +} + +@(require, linkage="strong", link_name="strcspn") +strcspn :: proc "c" (dst: cstring, src: cstring) -> uint { + context = g_ctx + sdst := string(dst) + idx := strings.index_any(sdst, string(src)) + if idx == -1 { + return len(sdst) + } + return uint(idx) +} + +@(require, linkage="strong", link_name="strncmp") +strncmp :: proc "c" (lhs: cstring, rhs: cstring, count: uint) -> i32 { + icount := int(count) + assert_contextless(icount >= 0) + lhss := strings.string_from_null_terminated_ptr(([^]byte)(lhs), icount) + rhss := strings.string_from_null_terminated_ptr(([^]byte)(rhs), icount) + return i32(strings.compare(lhss, rhss)) +} + +@(require, linkage="strong", link_name="strcmp") +strcmp :: proc "c" (lhs: cstring, rhs: cstring) -> i32 { + return i32(strings.compare(string(lhs), string(rhs))) +} + +@(require, linkage="strong", link_name="strstr") +strstr :: proc "c" (str: cstring, substr: cstring) -> cstring { + if substr == "" { + return str + } + + idx := strings.index(string(str), string(substr)) + if idx < 0 { + return nil + } + + return cstring(([^]byte)(str)[idx:]) +} + diff --git a/vendor/stb/image/stb_image.odin b/vendor/stb/image/stb_image.odin index 828a1c2bd..85d612354 100644 --- a/vendor/stb/image/stb_image.odin +++ b/vendor/stb/image/stb_image.odin @@ -7,6 +7,7 @@ LIB :: ( "../lib/stb_image.lib" when ODIN_OS == .Windows else "../lib/stb_image.a" when ODIN_OS == .Linux else "../lib/darwin/stb_image.a" when ODIN_OS == .Darwin + else "../lib/stb_image_wasm.o" when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 else "" ) @@ -15,12 +16,19 @@ when LIB != "" { // The STB libraries are shipped with the compiler on Windows so a Windows specific message should not be needed. #panic("Could not find the compiled STB libraries, they can be compiled by running `make -C \"" + ODIN_ROOT + "vendor/stb/src\"`") } +} +when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 { + foreign import stbi "../lib/stb_image_wasm.o" + foreign import stbi { LIB } +} else when LIB != "" { foreign import stbi { LIB } } else { foreign import stbi "system:stb_image" } +NO_STDIO :: ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 + #assert(size_of(c.int) == size_of(b32)) #assert(size_of(b32) == size_of(c.int)) @@ -33,14 +41,48 @@ Io_Callbacks :: struct { eof: proc "c" (user: rawptr) -> c.int, // returns nonzero if we are at end of file/data } +when !NO_STDIO { + @(default_calling_convention="c", link_prefix="stbi_") + foreign stbi { + //////////////////////////////////// + // + // 8-bits-per-channel interface + // + load :: proc(filename: cstring, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]byte --- + load_from_file :: proc(f: ^c.FILE, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]byte --- + + //////////////////////////////////// + // + // 16-bits-per-channel interface + // + load_16 :: proc(filename: cstring, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]u16 --- + load_16_from_file :: proc(f: ^c.FILE, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]u16 --- + + //////////////////////////////////// + // + // float-per-channel interface + // + loadf :: proc(filename: cstring, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]f32 --- + loadf_from_file :: proc(f: ^c.FILE, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]f32 --- + + is_hdr :: proc(filename: cstring) -> c.int --- + is_hdr_from_file :: proc(f: ^c.FILE) -> c.int --- + + // get image dimensions & components without fully decoding + info :: proc(filename: cstring, x, y, comp: ^c.int) -> c.int --- + info_from_file :: proc(f: ^c.FILE, x, y, comp: ^c.int) -> c.int --- + + is_16_bit :: proc(filename: cstring) -> b32 --- + is_16_bit_from_file :: proc(f: ^c.FILE) -> b32 --- + } +} + @(default_calling_convention="c", link_prefix="stbi_") foreign stbi { //////////////////////////////////// // // 8-bits-per-channel interface // - load :: proc(filename: cstring, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]byte --- - load_from_file :: proc(f: ^c.FILE, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]byte --- load_from_memory :: proc(buffer: [^]byte, len: c.int, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]byte --- load_from_callbacks :: proc(clbk: ^Io_Callbacks, user: rawptr, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]byte --- @@ -50,8 +92,6 @@ foreign stbi { // // 16-bits-per-channel interface // - load_16 :: proc(filename: cstring, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]u16 --- - load_16_from_file :: proc(f: ^c.FILE, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]u16 --- load_16_from_memory :: proc(buffer: [^]byte, len: c.int, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]u16 --- load_16_from_callbacks :: proc(clbk: ^Io_Callbacks, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]u16 --- @@ -59,8 +99,6 @@ foreign stbi { // // float-per-channel interface // - loadf :: proc(filename: cstring, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]f32 --- - loadf_from_file :: proc(f: ^c.FILE, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]f32 --- loadf_from_memory :: proc(buffer: [^]byte, len: c.int, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]f32 --- loadf_from_callbacks :: proc(clbk: ^Io_Callbacks, user: rawptr, x, y, channels_in_file: ^c.int, desired_channels: c.int) -> [^]f32 --- @@ -73,9 +111,6 @@ foreign stbi { is_hdr_from_callbacks :: proc(clbk: ^Io_Callbacks, user: rawptr) -> c.int --- is_hdr_from_memory :: proc(buffer: [^]byte, len: c.int) -> c.int --- - is_hdr :: proc(filename: cstring) -> c.int --- - is_hdr_from_file :: proc(f: ^c.FILE) -> c.int --- - // get a VERY brief reason for failure // NOT THREADSAFE failure_reason :: proc() -> cstring --- @@ -84,13 +119,9 @@ foreign stbi { image_free :: proc(retval_from_load: rawptr) --- // get image dimensions & components without fully decoding - info :: proc(filename: cstring, x, y, comp: ^c.int) -> c.int --- - info_from_file :: proc(f: ^c.FILE, x, y, comp: ^c.int) -> c.int --- info_from_memory :: proc(buffer: [^]byte, len: c.int, x, y, comp: ^c.int) -> c.int --- info_from_callbacks :: proc(clbk: ^Io_Callbacks, user: rawptr, x, y, comp: ^c.int) -> c.int --- - is_16_bit :: proc(filename: cstring) -> b32 --- - is_16_bit_from_file :: proc(f: ^c.FILE) -> b32 --- is_16_bit_from_memory :: proc(buffer: [^]byte, len: c.int) -> c.int --- // for image formats that explicitly notate that they have premultiplied alpha, diff --git a/vendor/stb/image/stb_image_resize.odin b/vendor/stb/image/stb_image_resize.odin index e22b587b2..a37c2e243 100644 --- a/vendor/stb/image/stb_image_resize.odin +++ b/vendor/stb/image/stb_image_resize.odin @@ -7,6 +7,7 @@ RESIZE_LIB :: ( "../lib/stb_image_resize.lib" when ODIN_OS == .Windows else "../lib/stb_image_resize.a" when ODIN_OS == .Linux else "../lib/darwin/stb_image_resize.a" when ODIN_OS == .Darwin + else "../lib/stb_image_resize_wasm.o" when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 else "" ) @@ -15,7 +16,11 @@ when RESIZE_LIB != "" { // The STB libraries are shipped with the compiler on Windows so a Windows specific message should not be needed. #panic("Could not find the compiled STB libraries, they can be compiled by running `make -C \"" + ODIN_ROOT + "vendor/stb/src\"`") } +} +when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 { + foreign import lib "../lib/stb_image_resize_wasm.o" +} else when RESIZE_LIB != "" { foreign import lib { RESIZE_LIB } } else { foreign import lib "system:stb_image_resize" diff --git a/vendor/stb/image/stb_image_wasm.odin b/vendor/stb/image/stb_image_wasm.odin new file mode 100644 index 000000000..77bb44f02 --- /dev/null +++ b/vendor/stb/image/stb_image_wasm.odin @@ -0,0 +1,4 @@ +//+build wasm32, wasm64p32 +package stb_image + +@(require) import _ "vendor:libc" diff --git a/vendor/stb/image/stb_image_write.odin b/vendor/stb/image/stb_image_write.odin index f030f1e28..a0c0b57a0 100644 --- a/vendor/stb/image/stb_image_write.odin +++ b/vendor/stb/image/stb_image_write.odin @@ -7,6 +7,7 @@ WRITE_LIB :: ( "../lib/stb_image_write.lib" when ODIN_OS == .Windows else "../lib/stb_image_write.a" when ODIN_OS == .Linux else "../lib/darwin/stb_image_write.a" when ODIN_OS == .Darwin + else "../lib/stb_image_write_wasm.o" when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 else "" ) @@ -15,7 +16,11 @@ when WRITE_LIB != "" { // The STB libraries are shipped with the compiler on Windows so a Windows specific message should not be needed. #panic("Could not find the compiled STB libraries, they can be compiled by running `make -C \"" + ODIN_ROOT + "vendor/stb/src\"`") } +} +when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 { + foreign import stbiw "../lib/stb_image_write_wasm.o" +} else when WRITE_LIB != "" { foreign import stbiw { WRITE_LIB } } else { foreign import stbiw "system:stb_image_write" @@ -25,12 +30,6 @@ write_func :: proc "c" (ctx: rawptr, data: rawptr, size: c.int) @(default_calling_convention="c", link_prefix="stbi_") foreign stbiw { - write_png :: proc(filename: cstring, w, h, comp: c.int, data: rawptr, stride_in_bytes: c.int) -> c.int --- - write_bmp :: proc(filename: cstring, w, h, comp: c.int, data: rawptr) -> c.int --- - write_tga :: proc(filename: cstring, w, h, comp: c.int, data: rawptr) -> c.int --- - write_hdr :: proc(filename: cstring, w, h, comp: c.int, data: [^]f32) -> c.int --- - write_jpg :: proc(filename: cstring, w, h, comp: c.int, data: rawptr, quality: c.int /*0..=100*/) -> c.int --- - write_png_to_func :: proc(func: write_func, ctx: rawptr, w, h, comp: c.int, data: rawptr, stride_in_bytes: c.int) -> c.int --- write_bmp_to_func :: proc(func: write_func, ctx: rawptr, w, h, comp: c.int, data: rawptr) -> c.int --- write_tga_to_func :: proc(func: write_func, ctx: rawptr, w, h, comp: c.int, data: rawptr) -> c.int --- @@ -39,3 +38,14 @@ foreign stbiw { flip_vertically_on_write :: proc(flip_boolean: b32) --- } + +when !NO_STDIO { + @(default_calling_convention="c", link_prefix="stbi_") + foreign stbiw { + write_png :: proc(filename: cstring, w, h, comp: c.int, data: rawptr, stride_in_bytes: c.int) -> c.int --- + write_bmp :: proc(filename: cstring, w, h, comp: c.int, data: rawptr) -> c.int --- + write_tga :: proc(filename: cstring, w, h, comp: c.int, data: rawptr) -> c.int --- + write_hdr :: proc(filename: cstring, w, h, comp: c.int, data: [^]f32) -> c.int --- + write_jpg :: proc(filename: cstring, w, h, comp: c.int, data: rawptr, quality: c.int /*0..=100*/) -> c.int --- + } +} diff --git a/vendor/stb/lib/stb_image_resize_wasm.o b/vendor/stb/lib/stb_image_resize_wasm.o new file mode 100644 index 0000000000000000000000000000000000000000..1bf91266bf948e08986d6d402f30216ca3f829f5 GIT binary patch literal 27646 zcmd6Q34B!5759D1tZ(+LWYISRVgiCdAO^|Iq2pwHo zd~~3O1~Bwv3pMIy{z0QB^_fb%`>pSyDwIR0-msrx=+QAfRwF6#nvX80sqAux4CdGtGch@QwqRJ78 zL~G~b)}CYw#;xdV>1*xkO!PG`>PSl6%%xmA035?ilI;$sleyfQrg^+xn@{}p`2&9Z z397D(sh`9QNpqEymX(jFsI02?fW84X)qUytX9GqP)0r;mvaaZ=Zqx0$V+JJ5QvVFZ z@o6A#Fx_eN8_fJG8Ir*Q=Mfz3E=`vD<#i+RGQf;|QhTIy6#uN3>fU;JCJKAKT!q3` zFPEc`>tzoLsa|%X&>G|kDBKP55hz>@at#V+gFH%ZlACnTFk$qMuju%ra}$7 zs9<5IN78ir9g#BKHKc30Yiq|e zM*kelu$_h(mvI4X3K_fUHNd58PR_eNz>dr5yE$a+Ez}nX&5r~Pdv5>1kntEzB487O z=(!+b%kQ}rJ;{u+upnf>J=@nnm5mov11Nq&>CyeV&tS77-pUAG&oGo(UWO(w$zS(< z%`0hHWL_0AUdx~k<L{S zh@tcucdo~DZ8b6r0+|8EA}-xExH;n5h+*vOr;(<+c7!G1XP|vxb(oZf%w&U<1-uDL zu4AlFz=%=_W)=dk=^DUm7Vug@@E1TG^`PzyTtH~m%bVyO>YsYwlGSd=%Ok*PNXm2x zJ1`(rFE2ykKzqG>84ZDx=;OK_@wU~=tEmsY?vdIEKnLFORvz&|xed9mUcQbGqRNNR z#ZxbLqYFGmjr5BQUcOTTOC;hwDa~ZvtNQ{Mk`O?)gZN9;a8EVlFl*#0(a6a)r7wtv+xZ?1OS_qk z^rjh7I0W|?fZpK^Q|^=6M&UEyhqR4$Medi@$^AO3fu1u=Bm@ot!a<>OK2%ahsP-~RKtc@J z2JCbdDqk-{C@^G0f__~m3F{Lm4nw>qo|PP}LKYHMFdDG8NfDWYdr07jp)ef9VmQhU zj-zRpHcpam6KcCBGjU@?$(?xq!6q)I*_$F9Py{@Bnp0K}H3edvY?WJ4o0w@YZ>BNV zNgeg_a|gkeWMX2=1t9CHfbkdxafU=xXed_(GjO~TG;Si@5H6ed0n5=_74F^I_tju- zAOKSH^FaPSXxwsk7RdPr1i23&GkryPBmGM&8)5}Cj0~LEM7At^B@5$~s)=i4^ITEL z&(Q0=QX3WUC{)0aPyzp;tNas8SC`tfpGp!;p@~=nuH1yckP4?C+KtEQRd9vtsbGh- z(?9LT^O;W2jx3>v8HX&?J$SqdI0Rh0cK{xX55je8TXl6%SB8H!6E*m=FTQC?`IWbIyXtu0&vyq!>xN0H>E6lBP0yi2cUPNbJm z-oQ`EBoNWvg0wCY8OBY`$kI9tJ@vfxEz(JX@On(=9Xz3%3tPsJzT3g1bglo|cuaxtxY zFznNv;c`tcM`PHDgqe6A3C;F0ja1S1vzbrsr9bb)7w1rRyVLj}i!$9e|5=0NAjtRZG z{a7#a$f)MF6Uf*O^bir>jF3)*oKV`9NK+6=DFw2%MMjWef%C8w2sDr~tO{M-6h_t? zc9Dgd)|G~6oV8r{q{Io!E!qmZgw=eOt(9eTw@lbtk?w$zW{o|7t$8zJy&CkctUX+u zLl-E^5E@aTrkf+G#d_3STPywyTg&ndI&z;ZTf36<#0*i7IgN)bY6JZ(6SjtRrV6}( zFWH)P$dkFYrWXrMa|nh&#kkI4txDRC#UWBhS4X6hl%j%+EvT27Di<(KOLs#OdeAg3 zz_BP{xoJ{R8PdZ_fF;u`!@unWvY2M!8f;Zc$}9^grO@b68 z|Aew(26E!z0JnCFoCA zuv-IkC%A{zJh`SwxnO~N#*!sV;-}LJ@fM`PDP{S@X}mzMreg+n?zAtm_WRUnypi1x zGzt&o9_H4`sr{0)7UX+2tyz>tg7Ex7)3Y6bU?&j|K@0LpN?a&dri6=?Cj1L64r9B9 z>sfg||33##K}-QK6du5DEKeW{#J`lQElDZwDWv8MT8;1sl$@jsUId{?z+f27=2Y_N zg7plVRP4$G+6D5cm|aQwC4%s0X=)b7NYS8Q9%zUc%7JVK%Esq%a_9jx1!h-<;m&n$ zyUtaHA|$uP_OO?@198IS=8@I{+-FUnoq{-ZZyPug>>#}~?ZN_~pnB&*;KOOxi`XQX zETULB4@BIyX~zg5pIkj>qbNZcX4Oi)XOFf6P2YK?b49UAt&#kejH7@M%jv=|rQz$huoNxD1~ zR-lHe8PU{Kz6fWvm0(Ve*eJ8j3S{=2q|v@J?8vwTbH7WWlsJ1V1+oHTX=gBn^;A$-5#h>Vw>jhGNH(Ht=ZqtUCf%QLaV_7M}wXIuXpE zrvjL0&a?qDxPNrrAVJnBw@U~PC_DJt7#k)qI7BxT$StU$3Yw2%2hgYTHVJti$~&d7 zpUT}5_Hj@KVDKoelMwk(E<}=pVlMI)6f=nD#5g65Pff@B|OfaqZ6{^1Hx0mx8xS=fbP zBAd=9*}*-&NwOo0WNJ#2oNjW0R?y|9f+z=hE-QK1lp=0bL;F2yiZ1#86S{~Xjy#Ib zLS9KBFA3zih$#HPs!~F!hEPbgu%I}IMmiyLY@3=Id2peaOC3_jf*3l8y$;<+?4=b8 zR~uSZArGq-h*qYxht6d9$}vo-Lj@2$xarU~Z$%nW4DkV3;R;KH>vw>A8W1ZvkWw8G ze}`V(2LA)iXoGw55g9%a@@O^2Eu(@eEA%RIoa8af5c9n7C2cU>5-byoXt5P)3tUZp z6iyJm`Iclkca_@RZabY*DR`u{LB8!-9){PZI4F}FD;x%~M@Yvr_-9Cpfa^ARm5i%{ zc^Z4RWqjSI0pnGA%_N;R1GuzD>^Pl3njsI9LXdOAu@$@}?V>2UV=Gx6piYiBw`N5} zS58!P?d037W@Mx7IY7cvW{?0_#!^%)FxH)kif)QDZlFe_iKu8L*Y>MP8Kn;{F`or;en>wsvdi9};MKq4@@sk(#y8Ip8691zb}Rf>=v z9R>Ebs1c!&YfNrvM2O`vajgi62#q`@Hi?+nEn;FZ-yX_VjhBdp=Hm55f0k-Mbv?97 za#I+@nG;!P87x$7M^G$=Ap}Ic8lihBkwOS7*VRZxn;z=YOH-k21pK*|7FiTu!b&P= za;+%hfm2pg2F7yxRAI7Yo3#8y3?cIfQbD1NR>Nw_zpE7OfP)$B&{UjhLbRhM;rg?i z5babniD+j9=%#4rMy88!fYl|BXdER4C>85LLP>5S3#NoCfUZ7BqKHQ{$T=53)BO>e z=%x`=jXMP_4Qags&p~e3Oq@$nu_lPlCBy-mM&?W)lKDnJhCU9{N1(wY0__IEsn08YH%X3_v8^NPWj0RRg^ zuJI)SU;*hN0J`_f0g%2b0OiXA01JV*6Gq?%5G=+`63&vO{*myZa7ftA&D_x_Y2eo} ziW?B+;D;Jy6-9`W-p?U*bUna)FvC(<{U|=89?&M|!NVqe5j^~X>Fe*K0F_|5h#@FtKUftFS&2JyMJ@~Kl`Dm6~eKwRtM z$4%6Qh#83U!+$VnNT>IvCW5tR&ma{8O@s8(H0;+a~9 z8Rn=kLsS*>vL>yyz`PiQ&Gz)r0#OCRIBdm7iFtzyO%1!l@j zvcsTJfnNv;Ij&obgHXt)+P8-fn$8Dxi?M7v(TTBQ)|r?Uvq-6g1er!y<`vhG;)f+! z@NOVZ=Wx7%=N^7aJ*0q0Jzfr}c5Id4AZ@K_F9W#LQ!9~$c;KdOSdgn` zNc0n)KA5o&@q{*-DLLk`$&c8Cj;WXmpYG9Jw1N~{54yx%IZp+E6YY!RoPm-or2J=u z{dnUi4@wj7;>R>L-G|E%8uCeOSYXrIH%)?RQlN0bA}}u{Hxv6u-`<3xa2!h!s(3M7YR@djd*8NjX!=` zg81N_apLZI#!#3}DReJSl(+BP`BFTvfuy@@M$~;i)bZA1o9`P8sAVN8`)3T9Dsft+Wi=29<}3z+ zJHuHCJtcKVGoqHSLj9yCSqg$%0Jts#Lb1`02t)Gpa6JJLCKUpGE-KniNQ;WNl@=A} z8y6E~G-Ln%ep2s1TC0h;se*#3r&nS>*vtEzUU@IJg*_{c{n8oe4Uz3$+h&AT8Xxax zXBgXw!*q0jKKu78XV7&x$4X=1EI!1TDve-(Rgp)T&o+rl~ z3o^tn%3*(I$pkNfor*Ty4_w5mG{ru9ihVc^gXx5ALKny*@MAr$4_{Od_V*wA<@JC} zH?8&gdH@9=J%GQ+)&tsV;+Crj%O$5ldt10 zFdj_!ZXtXWSuO>$IgEkS#Y61_NpjuP;^FC{LJE%CrF8N`vtq9*bIOA|?l|QEMPl!9M@TM0N=e-o zP(n%=bMUJLm0Ki1U6UYA6~rwR#LX4Nc?5B%lA9n1&cO9Nr{!lm*uXM47F(o16Uk;;; z7l*Cpt{!26-3%$c1;h88k;Llm4%+YG+XVuK$C@gpKJz>i5V8_SjuY;~>k1h>G8ybq z;f@}*+*AmSa%T!`eeIaRB`_}%cOG!|4Vn6JlExVW?89DAT?~@l;u;1pb%8oN9sd#z zxp=DLHn9JH|6A9Ldtmn zmf+G7#fzeBmhkmY5$6Yl4hCBI0b-6f4xpFE25QJb`oYDX@=u?c=GNE3e?&lGo z_Jj@^?g1MaLmC+64fxs$aw{`$5Wsk_ zpT$TK`2_g9Sfor%5xy$o*&xKi$>0}P1|;mtr3A4W_bw0~1tLIbUleBQ{*8R^b@!Ks>}RIncHAV$x{D9Dg{-^@Xl2!r3tV!R_)a zJm1oc8!k=bN%!yV=&Y9v=^>Q-iVbFG7TFMjsO$-+7SWOkLTbBF^c}A zIizk}b4X=?M2I9Df`s{zDj|Ul3{ze4{Y@ykQ@DdNxJmL<96yL3H^M1X1~z42HE;&t z1L*Mw*$80>?aN>yFAylE{EKV>_DX6^NRpaoBMDsTTd=@2NFEO-VAzb~w^yK_dMVO> zRC=k>3+}+3(-tn41_52>ZQ2Dc*=H^$;s4+t`-Eduv6kd(OY<9LzzAMrwOC6INMbR$ zOvI_hV*lNG6T{eQxwChn$GC@HO?QWtEYPNt0Xy7imanjZlC-@;e`bKz=VHpGutU za{M^r#0{=yoKVrkoh5dVGfiM8W+a-BXc0}=#^p5mh$eH#j?+YrhSMYqVfrCVA2$)4 z&m5R0a!47PNSHpNiJ~hPAHLH1`NWqe4sgA&IQ)dVIGWNq>g0kr>a>!A9@2@1*F>Fv zjVn@656M+!qwXctsoI{#ng=aXx*U}|0B*2htd+@ly#hD#OdL1*0z7b|6F6}|fQxz= zwu*2c@e3RA@uj*Ks)tMS9lBj0C3BJ>Gx9z%#3}q1j@`Y$#sM9&S#>DaND5+%Q%3SS zcHMt0+L6Q(?TqUP_J-(wo_S_Oj7GAyMZ%o|*do5peY3`EBE6Yp%_r< zr_@W_Kcf%2Oer3KwbL;WdZD0x7)35P0;-Ju-Zu2Wr#To+tz8^6UGatom8nrdi}9jm zYv&Dz@owfc5eLUKQq%6=4pvOXgj#uT-=fx@M53j+qh&=$b6?W@F%rg%a;*rBiPq)K zOOuJ7WN+)4$??ljKUS-5?Of6|F1D$Kn1n~h zqu^2T*znl#IPf^l(q)#o=%S=m!la@QC;QueUzh3Y-sW(RTiKtkwY9mad zdslRKcj0$vto^sCnhG;e@oNQY8m>^K1phf3C>+7vt!l+WNG;2nJ3Esdy?RWj(q2_7 z$!WpV^^-B^HC3C^+|j+PIbjasWAxFZ_3YY4JsSXqUSiW~`;yDM@k2QYQZ*=FV$qtu zB%fCN8V@x7j1~BW976AYn|7YW)i%*rTeG6Gw{>Y}a5`o-U5k^6 zMJtvpN%qw0V@)iws`=!#dNeAG0?jT6)?Qy~)I~Wb4vpeW?ymJ5!Wo6eOR!H0^|xB7llc`UxznE~M+m z>J!P!h{=UXSrxW(#qtD{tfw{E3#eN>+5kB-Heu1#Q%ep#^yqOd+5m@O&h)Q z?rFEzKQisAMbA$=q5hB4j`-<^)86V)8uu>rG(K`eN#k=f4{fZC*ESA*zpin5Q>?M! zYsWR-uxozfcg|Yac>WC?jbo2o)2O-EH$H#sg^eGcyQT4j&6hT^N3Uu;WXcVVtABk< zW77?HHJ*CYeU1Cye7Nyn^Pg%w{i7Ee=RE!U#_L~syYam6-y5I1{J)LO*UQnW%N@~* z9iHeZ&jzFKl$S;Kezz+6$$!Gpb(b6-J$~M}=$esr(GQEKMxPuRk4h&T6aD_>UyGix z{~OUqH!O&Dj7~(?yqS!?|4>KtsRw$arLUYBZPCt-cHO-pTHkv?bW&_n^sVwO(FMv- z^qfyFjlOQ*7Cl?v9$hr&y67kCcSOJWMsI)l z(dch4-5WI)KNJ0P(+kmk<6n;cVBEgwm5qOlzIp1Oqi0?8Ui8~fe-Kqh{U^Heg8k9T zemRzyZi{X9Ib+RlxMPPr;Ely^48-PKQWT3{R2r+kctq^l%c^3*n+}cL{75AB?w=2f zomO5OyKCMNv1u0_8Qb~7q}Z&Q`j~J1)R_8KV{G*Nrr3&K&WQc(xMO2iJUb_L$KrXh zY3#(<``4WmEBWThv7PSIVjWK`jJ-CzIQB^EvRLJ@9kG$)yJJ@#(idA_zB*Q2wKle^ zcpz4Irbg@k7ExC?X%?gP0uLtPZPGd{5O02(GAY{sg>^dwRdXq%TDmd6Yu%r zA8iT5<5NQMlYdtfA9-F${8y98;?rI)k1rdlh_5=XDt@eVNc_d09U7mrCLF(b>d5$Y zACHP}{Ke?_%#AhiC%-i&KJ~C8;urjLT>R2s9vQ#vnu+m_@7Be`3#P>HIqIl*q+)9P zto=vF?|rK=zW3Q!{8xLL;t$>ztnWuAlbBfArzX`0aIT;!pN{H~zcb>*Cnxj>8QUYh|XlTAbwJ zH|0*?BW^6#CWa#?b+&iHN$Y)Ux|2t?baiy~^maG5;A1NBXz5zMsI`+kYv=d~hP_y< zm6|YD5 zyro2QiBQ!^(P>wSHmP$0MXqsH4`>-{re`9-T;ANXw6zoC-llOp;(f7kSCneAFkfSq zzisX8MzmUmWaJCsu#aHDd1sCKlCW+l(}I@3m0DrkU8apR`P#gAaRRAa-eTs9OGZ zkt8oE{*$z%%v>a{PqbY|l(Q$+ly%!*=3P53A2l z-KZYbxIkSS8>8-MlGOXAU*`D5%tIU(&E93NntPgk<<|rD>rdQkyZNMxZG#I=ww-*+ zNVn(o0asPaKbB=vZO1)H_@3PW*X~p>Ww29zA{??8xPj#*QfGO|L9{tQ@~#I({zNdn5+kaf;958~m)81*A;H)Br2VyiHPAGV?as z##$uVWe%Mbuu85rn%+m8s zE@tOQOm?NSeOK(gbc*uCxo0wbb0!W{V^P3R6AVQd`o|)r=pI^_p_A$}-X0 zvvd(teWnM^Yf4Z6T#ltLQ~ebJudF^xlby+)))uA)Osp-f6YCS{=3w?j5f6+^Ev8K@>~NX0^uWD$br#f~3}a2*Bkf6P%tV=0XWr^mRw>Cf`5IVQ zx^{L*X6zIP^JL!YooqgnOH3qzx7b8EGuhL{t<=>b=SeXVQdfh98 zG!2%_J4FSPM;<1eONJqqZW%P0JSvsy9VATKEwJ6 zY_tWdx`|{rdOnb}O!$KFFjkrwG-=9ciXjE$lw%HcB&X1l?z%}N3zAF&NziKj*CS+jcCTE31 zV?LBA`Bn8y(o=v<4K>3tkJfe?c(%94#`Etw)giI<=^)?YoC#URS zh(N2dGSqxp8}h5BGAWpvEuDoHsDqU9`aw*2b&%8447^-9Wi+N>;4AzlIl%%z3J7cx1Xh~@{F&ZZ zW$C{8N}J>F3(OBis7cM0KR(-e6&Mb=*B^LzAqRR8UKCK6Nd**U5)>v^i6#{=kh%gw zgPWG792nt)#Ekqo>ma*^1H&pr{K2%g4q~7DIl$#*QWk9~AVF~inc4?nQblTt{BWYO zgZOT%J|C0}XjHCr>OQBMq)D?*zm|9_wdc|ixeAEZ>E19R_siDLUAzlIR$4zFDWkdZ&dXWRSl?a#?Dh+>NP5=Zd6fq zo2oIk3sp~0)iYG}lIme>AF6J)q3RABs(ywquCWJfF7-vKdX=i)viTVMtIfqew)xe+ z*aNElL%U7=r2`+HbJ*A>XOL~fb2Fa%ok8_HHwJEUW8knm#MqT?m-;)ZdY!8N;x1zB zZ*CX+zE;d`#q*d}!d}oy*&nnr$KN!WZT1A&wRoPxbBQ;ozT?F-|Mc3_KlZs=6ltBJW4lGgS2(s@fMA$=I8y`h=?12T`>t2)YM@ zE_En0im6wGQ1!#mVT}DKQdjPs&}dCqtYpieNyVO|Gvzp{-PY!kCmhP zneuwZepBvJ|4dcyQ`NuAk78^;s_v`^sO+JNp#A9zoBGcRY#v=w8MN=Hvf1ycvZ>cp zH$bS>7;sxPj&gTZyVU2X>LsdrqZ+gQsoG_~_Yfa@=+L13wL@+8zv?#isqoRzl`y)z z5}wA`8)29FPpbNus?LoxGW?Q;%l_L4dXKc(Hy&oQe{ZzSzIU`uy|4x}Z>_PZH`PR$ zdV3A}|FkB?*q$1Is72MswFF`ejwd#baj}hKo7m2=P3musFfi89 zhGW@l*wH$7>TEVR^*FY3>KyjVsdLmvSTFm@ndS4`m19A=EY;iF!t&( zE_KJOBba*YEL7b+3sv{cax4^{o5_aw$1L)Dv9^$t~i*!wNU{)?)Y`%v{-AFBS`_ie`B?{leltVGrB zm8g1PC8{1>=~CZag{lu$q3V-Ws9L|;r4Ft^)n#i?bkCto#pUocxh8UjDCgq`Y65 zAg@;^%IB*S=PTtPaNOCZl*#0J{(KYU8rPp-wK38d8~i=3jW_rja%B$wWztHcdV1{(u_;4 G?)yIx)!R(~ literal 0 HcmV?d00001 diff --git a/vendor/stb/lib/stb_image_wasm.o b/vendor/stb/lib/stb_image_wasm.o new file mode 100644 index 0000000000000000000000000000000000000000..cd7fa31cebc2c011bd3c2185c41d7fb42cab5264 GIT binary patch literal 78144 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%0AIBK9ErKP%v9o@A-s7 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 literal 0 HcmV?d00001 diff --git a/vendor/stb/lib/stb_rect_pack_wasm.o b/vendor/stb/lib/stb_rect_pack_wasm.o new file mode 100644 index 0000000000000000000000000000000000000000..fdd6d95d609945116972f99d96a240939a58ca55 GIT binary patch literal 3683 zcma)9O>7&-6`q-$f8 z^Ku-w(soko##_l&r+Z5}_~jz)c_gkBSp=RtEc%^!e$J!!XyY5A(oFM3;g{7RrZ0GO zADZ`>PIEqpcpyk)k&y-SmxJduBh&TnqqnSn^5ulA=q_)Y3jE;e(g|;K!2yH;1G>5>k2)RTu%`;QLVH?aj zC_pxbs=0QeW35K$&I=jlFTo0SZdfRCrCo~8^8orqohJm`P*UJ7LhgK5M(O_uQh5xy#glvD^mx&W;i`q6;0Hjct0EBbg01w;bG z0uS2kprXCd1O*bQ_DGFC48|Cz!y$F=S<#a*b>yV>4G``S2%tBXU*vO`W;gJ_jWcEf z&?!;2u~4>sJ#~=n3bO47Q^-0po&{_|EmB36p*lp@4Z*{DB2;vN=n(+5snS!_4M1yA zNEjp#LYo4E4d6={q8`8<*nmhY;-1p^2C_la(7ObW44aQ6AweWtxmpx(lMI@Mrj|RA z6@-s;?&q(_JPWY6%m2mCzv*H62DM-ZQe{rLlry8#0IMrd2oYVzAjAUiJ*6G$VMmLx zF8<}Hi!lwotdqt5C;%nvWH`0kfcl86JFf#i9@tcXUW78j+&j3t9NKdMY#o^&)Yf7c z2tPVM_D9MQXQ&bV#!2c_fU1@;grk9(*vOb0TAI^B4F_)o#;XMS(ZB#1A_f{cdHukIp`9>P(xz5Z%78 zbgjRszpLvDOSM+I(Iy8;{9~>PyI|8x+4%`q^X<-Bvar-ncKZuUyLw5R`%|ZMM&H#x zxL`<-{)($-pJsduUthOy|Bg`Q^|aeFib#x1zAM!9gbBKMU#QZ!4bZ-R8(26NVVUIrF)2vwii9U@7z2i14Dt1e4Z@ zaW%D8t8+8%?DXT#I(>68DJ$81+D`lUMC@)PeI{+H4ipZRhAEPs@EH@iX;Uzp2Kcz% z+1jpk6ZpWz_a@waI+&6@H*)YL8>tY^@yym?0RzB@^=yt6MyHn@HqV5cdDH2p8)>`N ziaXu4q|3$0|Kp0$?6PM^>dxg^d2~8oVAG@1D~gru4`_IJ^VM!=t=6wqCk!0zFJ2n4 z5>AZ!hY8g)lcX0J|Ne;UND&-P&OvKT=zVEY@7YPx%Zxw&4NYZ@Fk$E1q|)<~q*oYc zpU{jibdy%6UVZgPuU)bi;% z-j6?#pGumM85Q<8T*$f<-H#6Z0iaBR9jnEy~Rr_ovmcGo7~j(R;|5}J9EBzrh1YsdU;wy@Fatkzn+({2v~ZUN)#f5C??=Kufz literal 0 HcmV?d00001 diff --git a/vendor/stb/lib/stb_sprintf_wasm.o b/vendor/stb/lib/stb_sprintf_wasm.o new file mode 100644 index 0000000000000000000000000000000000000000..4c8e140e5dafae0d1dfceb1b455cbb438bec1307 GIT binary patch literal 13793 zcmd5@dwf*Yoj><6b7$selF4KyGh_msJ77g6aq>=h<^~8L^3YOWpV|;Y1STPGXmF7P z5JbiLet{nisKxrItX2iV6>uwRSBumt)@=o)1sAt#tJFue?Du!hoxDJ|b@z{*Fmuj5 z_nh;4zs|j|+V&+1V@!FdyStmY=BZs>Y@Vx&K1$a-H?=FMr^x}G29z%KcQjkq>YJ8j z)YLRCZmO?st65UNq`7Um$`og~y`#3Sp{AvIaZ^Wqo7N?U-I&x~-@!DRGo+?wanpju zZS{2>HCHTcs_R(X+*H$1JHN4BX<@2%9l`K2Mb&f-|GewzT4Ax0!LN$n5n|l#(Hr8fk+Q$%$xswx6i&_Q|jQ`okm-+Fk8-_o~%b zceci}S}{G7s|_~63u%=+3-`smR==uNaz^`wY<-$vHMz=zr7E@`rRr7?qbslkK(SKe zDm9q!O|Y<+Y0~~mt9`~)Ley51RuB|rX_dBWX??Wx^$6c&JPeZJA$wjjJyS6ZRW}UH zFbuE348!F%ZN<{kJf^LqF-+To27|j9T9;{eV`rX)2F%gzZfMKe?Q4{~C9wy#a^}(ExMqd>w)RaI4AZTMX?I!CL8#;d6|OmQ1}Lxx z*ePHtkRYZ;`*!lq5NJmMJ~|M5l;|cjgAzQ+)uBv)CkQ5wSh`RrAuk>w`gBq=6$>Lo zU$mD|DJ-Epf@N{d{+OKyRD;$KjA`~=UCDHp=5cv+1_iZWW>bMQLAQnoT(DqfGF^9j zFoh<30y$`Czn~WCV-0~&u|OqNR`3J-?PIJuhV>Au4p~B~07W;j*@svM=mJ1$rI^ZT zChaJ1L4H`F+QkwdSS{@*CP5#9wwB}qLDeoKSSBAr3ZtEd@IDrNeGdddpCGe`zz)mI za6Xzx^}7r`!%x@gUSCFrLVXjg3fa$Ns-YU`>3X`BZbFh>^gS(+1gI%hJ<>vS?t%6KIS^4T z^nMSkhTZ74k+k8Qa?jFOd}vki`mOfKj8-dT=SdGiQdZjFsfJdu@5bVE1xjr$tX!w= zIhF?4K};l@hxA-r8^eacO$1Hb&7(XF)3>(~tL&Qu!y+*tFtqBV{1|Jjp(HvU0+)cY zy}FYRofC_PfV*@KtKf=5SU~O{AJ5g+Q0NHeMw8^Q?QI_^V;RDk4Jyv_Bd{(2Aw#MPyD(Vc>z+yJ{NXYCPwBsQ&;>583<3SCY#B zkn=H%I0yta1Smu>(gR>0o&k#hI+z9(q0NF^Bc(z^N|ly@a7Xiaa9Rv^Fanp9vdnMd zY|!DX!_n{nc7mos*#2B#3nWRfq?!HP2|R+-x;`I3M(_B50rn3S8-m5i>Y@~g;g@6< zgT@0#*L_H-_Ggm4O8X;2BMwpeGtkOlOvDr+=v?Afh=*s=ED`< z4^59b5!NDYhPeqS#CljCI4X@0HiqqlfL%N%kEO%-usXNFp)z8NKJgc~WwMjv=M_;rShJEd|6$y4EmK1aiH;G;goSLiS#` zcgPDjJt9wa*{ct+u_8F^W%heu2i#50Ky?kqEJ#O#=DW~OHWvLa+vS$1M`7{zI44Ox?jQO+9j zRSlQ`j|#^j01KT2d&#Lw_d_AvGdBk24&7l5lhpummlz)Er4~eVBZz60Rm|ep35)i= zb?#iSWvJ8dj&m`#5?Go%gR-q$h`>o$a{LT(GAO!HkUqkiAhIK@vB6e4>^CWlB+pgY zScOPH;YbeQ2%Dbr_>c=U7-XQ6s`w};LlCw#;#G*;2Mk|CF&PgfARoc;0Sv`j$k0h1 zDA=W@!QvR46-6Z?8BnDE5pyUr;B%0Db89Ft&qb8_yAiMx*jZ)>-vmzLoaDKv2Tg+0 zn@;io&urjol1fftL3$dP(3@c*kNBnx6R9QW$--CI4%+NqUnFdgYz=`9f}JV~X2jrD z(EBYzisU_N2Fd}uQ5!W-vWSQbQ33*FB^fTbf;=?j5JIsi2dc>Ei?~WP8}uOxyFoz< z^+!TF9I4G@CO$V+%1-5tWJgrO#;uK3T;vkNxK&3=F^tC-kUiu2e(8y^-*g~`1;|vX z#ze78+(ze{L-sI{EK_=p%tz)s2+%193KHO60^gEjV2y~qp!bjh27wW&po}VwJcaNU zFhZGkLY?M0QCaBzsZkjv3gx9T{hAhwBY0ElL}wz@;?zS!!IesJQ1K!`qdJE|GsRMr zzL=Kap#b;Q(2^kwUV(OG_CW;I23u=EEs?@exK)IEq5+lqa3q+NrsFc=bYcDw zuB}q0lnW?0_aI;}_K5J|A?hMiB~&RXfUAYpC>a?F2X+ z0r9QaY6Ooq0PA>!$9M#+BnXmoIbh@nJ{+0`&w{xinCDK95gHLJvSKFkR-MwLn7smp z9U83_(jUxzOalheWL98KX0~E=jK?<-Sx)jw-O!zb^2~x%d>fn^IM-KUX z!C@hES}YeK&w$X}9Nb2JEA|nR66ra#=ya0mix?6K08gzIB7)VEh$1Nw$tv5i0}>0N zMNB^(LSh;`H0Frp6KQ1w&ylGo%5$8N!Qs$d6beYyK%0|mqOy@tWwAl1MI0p)x6x`_gK4y8|Fq3u|OlR)?~bP&yKV_FQ#kc1FnNH`OchD7Irr`i%> z7L>Flcu*>e0N6_q@TS@WB@5*i1U?=~kwgn|5CO>e0;-_RB?vE;2&$+f=67 zzGV&KFibcp;fgUA<&gcF@EsBn(nuP6soxlFooI#crl24;BmCo`r2PSdXy9CV2pCZ7 z)Uc3bRFtgH)DVmvo1&oPQF0wZB_ohp7;Jz^Q8EDbhoM2@3{o5bBfPi666LY3bMygy+bC0*+=;P)}_DATTR@UJSB_kBgAE#IYw>MkhR?6QJ`Q1a{&=F80Bf z!X}1tp-7m5GzLBfnM&_E3{e5=_>tV+^KNoaTtoGm%NfpgNEcMc)2U9hpu4rFt zSCJQ?!au1=5P>8f2xM}EILS}|5~WW(LhK=JicxxGv?g(;t|VI;aB_t?h(oh*-z8{-jsx3hA7w)KKvWb&QK-WL zu^mhs@)Or0>$|4~MW4eE0xOz=jlMg&u^^G3eW;2gAue zv78TYaGs-xJsg2M;wGKMlaYitiy$GkRS))9|Ay+LOiXLp;-eg3e8Z;!R!HFs0cCpX(gTv3ZE9_ zy*>?l5B6yylcI<)1%;__?R2`0(+fB>Akfdh2XR3N3jgl-RQZJTYgmI_C2O)$tl|Ax z1OHA>!-&eS&4Y0InA(CAMKZYmE@C;D1ithBdC(yL{`c{M{5w??vHa0{n!3k#of zs_^^aHXuj)M{zTxCFT%rIRZC4dx5*7hqK){b#u-rQIc|v9>S3th{wVZBI$z)g+Yu% zbb>x0w)E*ksGmO2$u_f8d^1H74-F%0rKksUBqvDf2PZ3iAwhxY=)o7(;5Nl;0SC59 zq4aCij`nlmX@7F0s1P`wz9)g5dD8F2`vCN2K$mNUY}J*df_;Bne=hD$J-~_^By|JN zvgiRLjs*_kSsCNZeqc4KO}mGFxx4QX)SMV@+nVLUv+Ta{lPB4lIexv0aKT5ny!NV2 zyh`Bi9a%%idQ>?YFbjhUA%lCXl=X2hcVj8>+Q1rm|G=>SW}HXQ$9(n&dLweuC6+;4 z@!79?amkku{|sb%8@Ub$c-kf(bJ#&{G{k*&HclpRM}LlhSFU+JZf=gJVYSv_??)!W zk~j>G`?B|7kk8wZhdXK%hku<_584W73AU?X_zTT4(=z`cx7wBO1_H_;btR&<}tI@v@2F0FmkE`sU3*<=8bTIQo_zjP|icu&zI5r{xv) zad<_{k`JFxOZ6!fW&?UQxR?2Dq$9|+$b5Wugt9A;Ek%`y0&t+T!4u*`I#IlZr}Ok) z>FcB&gJ>4&V3JJG!$MjCbx847@OCz-sBZZQ;y@m6#|u8E@c5-`{||W#nnAUnDAMnq z%*5x=q&hNXeVgS4N-4wZ?(VX@ayp^u-@F;W-W|~FxIi0P00yLE7!>wEe@?d{y|vSS zLlJFUl;%!sg)!0@GWV{C2jM1e-1+RAkA397C>hV1^WB1O5@*4Djjb2$oV0PJ!DD^~r=(CYZH;D5D z?gN|#0RVWAl{e7p5PS;{u0ZJ)>W2T#LQ>_uEQw=69F}{*yC8gyU}8`Z7Pu6w3kuF@ z#9EvsR2?(A<6iu(ysC;_;M}GlA)Vou>>_eu*xMlQg*D!-al<}lw1`xLdQI{gQX%j5 z7~}vSKY(c7om~(bHSo7MS|%YGHl6XS_&v=Tzl+ZLNE~=F2Pdq8IQT8>DjYY*yJ8I% z&VF$uK?3pMoh2YoZ?4EY5K$++nZz^g&Lna-dTbpxWbKgy*bpOD2XK?>LTWNafHe>w z?F8fs2Zf;E0RqyyBPdZI!aGuE$i^5~DfB3qqtOc;xE9B1CRaEfmQj?NxPGfSR_T2g z4vt!L!Xv^h%6@1dLL26*0VrHI!ZfxDB%L{`c~nu<)QfaC;YB)K-XYP52(183&`mq7 zqV?jy0Y5l(C=XkUc zvK}|(nC7pphbZZWspJD?QyI;_{O6((a%KRq4xlK)0?h9Z<}iND42hPL~~2UgxdK=w5MdEE%K*InK@r4B$AY<=?SLw;;8O+4ZBpfl{d?jPSMuC`YN@&rbn$p z3q;GP-Ev#b610`SzbCN;?M=h}b=R9{i@$TCA#D=tK2)~+1$z?fIk@)X;$@TAOS2X( z+4IOGHvZ;$M=m)$sdB?pokJfFPoDE%@4a~>XU61Pem&Fu%a6JzWN?e!14U$b=jI^QoRsU)(lf+T*)6 z{`svdCyd#Uc<)Ecr%bs0&F>sD^D`&xeD1Bc-(B&}_}dpOKiu`zgX1&*BX8B+ceajS zy=?lTy=ROYzv-OK>o#5O9-n>D(R&})4vgD%?ZG>rIB?InJKw0TK9Rm~+@q5YyncCG z;kZW+JU#p6HD8S#QFTk&=6m*yoxLgD_p|qJ8T*GHL;}3x2VL;HaeZ#x;bA4^kK0IpXKkfQ->X>!M{_@e8U7uIn{%+5M%U^wM z$IJ3b;u-&rKW=Dpk9zT~?Z)_fhdp`W zb>*eMKltF(xeLpG@XVoS?prpoeDT&_ynV&eFP_0WXNI}xf+vENPv(spTl>AyBVU_5 zzf{*gUQoAbQ^7O2pFa8NJ8z6mOz<4NW^Kl(5qnyy&whRCh|4ee(tiJMtA-umFI>K} zVCRtMHn+YK-|$K3ox5&cb0qEDz(Wh>v}wy0nk?|d3GLafANZU?48rPZvXx#fBi-Nwe8=p9dF+F*_*$LU*Wr9ZMky%SaN)DWb2fx zwlznu?D*bm2bOlMF6!vYdT-qFZJ*v<@l~$25(?lm7fHbL?8@W*m#UsRKE?O+!#ldi z9($!R`^wkj`S<@aJ(_=$yY#|0uF0=n{Y>*&Z)ff|N8f(Q$G>fyasRTc4O`!Pcg)By z7cX6P^v4h1`B43>mw(tZqV|k5*O1m9?`wSP?#MeQ%5yHR_*>SNFW3PpYYe=^->|r8 zq3YRqH7L5VyDD(?zbf{E*xs2% z9=h^5VCFY>m~1;}bm*yRs$Yn)`nEPd+t!bCIh-cO`c3U<22a{D*rGlrVJ1e?`wz)k znKYDwi=jaODJ{)E?5J<@u^#YNclhnFmg%mH6f2t~x0&jWIRw--FKz0mscWoV(o$1b z+t@fC|0jc~hQs{9H*`zlRHP;)`QU(2p&^Xr z=C?KXo1EIHZazs>SB8Gm?WMYsp1LnZ$&|prf&79~hYFbzP0eyp?9~k@M(UQM97U&Y zP|TEYYF3IyAp)HR2aQ7=bT)Xh)CZjn#-dk!PP+tBKkX8!Ag6*B^9O@YO=cTOP`GNwX(Uab2c)6{dw$W{lR2a$SGP>tg!Hrkm-Xn+DUK^{b3M8Sv=8&BW0AnFeF4 zvpo9sS-8463ln;A$94cN9PCqPY8T4mQ6l7Yh1Cu2*IE$35E9Be3HQ zBYj%W846?jzT;yX&h%+J&&0&l$WygfMxl4>S(xJ35WAoe3XX zRp4WH75Loy3N-gug&O;Lv5#F_f*nc}=3ZN>xp$Ol?zI&f>mK8CZyKwyP2+s*FutFS z^SQT<*VtF%eeAXgKKBa~H1{JDHTNx*n(;uTuK%^t&-7JxI@9+frP2>i3UulxCuMf( z2POwQ^`n!sI`uzJ!Hs{Z#?RAJL!J6BriMH9W7D&l{=4%*-JY2~WBV-Kcwv^#eltrm zj-r18-&M19W#jB2?5DFe<%T&q?A|$=v44(k+;gFBY`sutyDp3xFQfh4g&KRDGH-7S zjALnCJv?g~x^?yK?ez=t<}X*$r!_CBpWjyhLk{C@TIen)&o9U?XOGgNjE>s2g>cJP n)Yo<_ZL4or&&gP_RQ$)OyoHU;^J^R1&+)V`Uf7gZ-`Vlsu7e`i literal 0 HcmV?d00001 diff --git a/vendor/stb/lib/stb_truetype_wasm.o b/vendor/stb/lib/stb_truetype_wasm.o index d3380e8a2441184569d910562ff374d9d621d4f0..e545ef8e7f2ae4527168f2c970ef30248bb5fb44 100644 GIT binary patch literal 46482 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 literal 41425 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 a?wfDjd*J3BduPwB% i32 --- + snprintf :: proc(buf: [^]byte, count: i32, fmt: cstring, #c_vararg args: ..any) -> i32 --- + vsprintf :: proc(buf: [^]byte, fmt: cstring, va: c.va_list) -> i32 --- + vsnprintf :: proc(buf: [^]byte, count: i32, fmt: cstring, va: ^c.va_list) -> i32 --- + vsprintfcb :: proc(callback: SPRINTFCB, user: rawptr, buf: [^]byte, fmt: cstring, va: ^c.va_list) -> i32 --- +} + +SPRINTFCB :: #type proc "c" (buf: [^]byte, user: rawptr, len: i32) -> cstring diff --git a/vendor/stb/src/Makefile b/vendor/stb/src/Makefile index b7217d528..194ea5e75 100644 --- a/vendor/stb/src/Makefile +++ b/vendor/stb/src/Makefile @@ -8,17 +8,24 @@ endif wasm: mkdir -p ../lib - $(CC) -c -Os --target=wasm32 -nostdlib stb_truetype_wasm.c -o ../lib/stb_truetype_wasm.o + $(CC) -c -Os --target=wasm32 --sysroot=$(shell odin root)/vendor/libc stb_image.c -o ../lib/stb_image_wasm.o -DSTBI_NO_STDIO + $(CC) -c -Os --target=wasm32 --sysroot=$(shell odin root)/vendor/libc stb_image_write.c -o ../lib/stb_image_write_wasm.o -DSTBI_WRITE_NO_STDIO + $(CC) -c -Os --target=wasm32 --sysroot=$(shell odin root)/vendor/libc stb_image_resize.c -o ../lib/stb_image_resize_wasm.o + $(CC) -c -Os --target=wasm32 --sysroot=$(shell odin root)/vendor/libc stb_truetype.c -o ../lib/stb_truetype_wasm.o + # $(CC) -c -Os --target=wasm32 --sysroot=$(shell odin root)/vendor/libc stb_vorbis.c -o ../lib/stb_vorbis_wasm.o -DSTB_VORBIS_NO_STDIO + $(CC) -c -Os --target=wasm32 --sysroot=$(shell odin root)/vendor/libc stb_rect_pack.c -o ../lib/stb_rect_pack_wasm.o + $(CC) -c -Os --target=wasm32 stb_sprintf.c -o ../lib/stb_sprintf_wasm.o unix: mkdir -p ../lib - $(CC) -c -O2 -Os -fPIC stb_image.c stb_image_write.c stb_image_resize.c stb_truetype.c stb_rect_pack.c stb_vorbis.c + $(CC) -c -O2 -Os -fPIC stb_image.c stb_image_write.c stb_image_resize.c stb_truetype.c stb_rect_pack.c stb_vorbis.c stb_sprintf.c $(AR) rcs ../lib/stb_image.a stb_image.o $(AR) rcs ../lib/stb_image_write.a stb_image_write.o $(AR) rcs ../lib/stb_image_resize.a stb_image_resize.o $(AR) rcs ../lib/stb_truetype.a stb_truetype.o $(AR) rcs ../lib/stb_rect_pack.a stb_rect_pack.o $(AR) rcs ../lib/stb_vorbis.a stb_vorbis.o + $(AR) rcs ../lib/stb_sprintf.a stb_sprintf.o #$(CC) -fPIC -shared -Wl,-soname=stb_image.so -o ../lib/stb_image.so stb_image.o #$(CC) -fPIC -shared -Wl,-soname=stb_image_write.so -o ../lib/stb_image_write.so stb_image_write.o #$(CC) -fPIC -shared -Wl,-soname=stb_image_resize.so -o ../lib/stb_image_resize.so stb_image_resize.o @@ -47,4 +54,7 @@ darwin: $(CC) -arch x86_64 -c -O2 -Os -fPIC stb_vorbis.c -o stb_vorbis-x86_64.o -mmacosx-version-min=10.12 $(CC) -arch arm64 -c -O2 -Os -fPIC stb_vorbis.c -o stb_vorbis-arm64.o -mmacosx-version-min=10.12 lipo -create stb_vorbis-x86_64.o stb_vorbis-arm64.o -output ../lib/darwin/stb_vorbis.a + $(CC) -arch x86_64 -c -O2 -Os -fPIC stb_sprintf.c -o stb_sprintf-x86_64.o -mmacosx-version-min=10.12 + $(CC) -arch arm64 -c -O2 -Os -fPIC stb_sprintf.c -o stb_sprintf-arm64.o -mmacosx-version-min=10.12 + lipo -create stb_sprintf-x86_64.o stb_sprintf-arm64.o -output ../lib/darwin/stb_sprintf.a rm *.o diff --git a/vendor/stb/src/stb_sprintf.c b/vendor/stb/src/stb_sprintf.c new file mode 100644 index 000000000..d60a91bae --- /dev/null +++ b/vendor/stb/src/stb_sprintf.c @@ -0,0 +1,2 @@ +#define STB_SPRINTF_IMPLEMENTATION +#include "stb_sprintf.h" diff --git a/vendor/stb/src/stb_sprintf.h b/vendor/stb/src/stb_sprintf.h new file mode 100644 index 000000000..ca432a6bc --- /dev/null +++ b/vendor/stb/src/stb_sprintf.h @@ -0,0 +1,1906 @@ +// stb_sprintf - v1.10 - public domain snprintf() implementation +// originally by Jeff Roberts / RAD Game Tools, 2015/10/20 +// http://github.com/nothings/stb +// +// allowed types: sc uidBboXx p AaGgEef n +// lengths : hh h ll j z t I64 I32 I +// +// Contributors: +// Fabian "ryg" Giesen (reformatting) +// github:aganm (attribute format) +// +// Contributors (bugfixes): +// github:d26435 +// github:trex78 +// github:account-login +// Jari Komppa (SI suffixes) +// Rohit Nirmal +// Marcin Wojdyr +// Leonard Ritter +// Stefano Zanotti +// Adam Allison +// Arvid Gerstmann +// Markus Kolb +// +// LICENSE: +// +// See end of file for license information. + +#ifndef STB_SPRINTF_H_INCLUDE +#define STB_SPRINTF_H_INCLUDE + +/* +Single file sprintf replacement. + +Originally written by Jeff Roberts at RAD Game Tools - 2015/10/20. +Hereby placed in public domain. + +This is a full sprintf replacement that supports everything that +the C runtime sprintfs support, including float/double, 64-bit integers, +hex floats, field parameters (%*.*d stuff), length reads backs, etc. + +Why would you need this if sprintf already exists? Well, first off, +it's *much* faster (see below). It's also much smaller than the CRT +versions code-space-wise. We've also added some simple improvements +that are super handy (commas in thousands, callbacks at buffer full, +for example). Finally, the format strings for MSVC and GCC differ +for 64-bit integers (among other small things), so this lets you use +the same format strings in cross platform code. + +It uses the standard single file trick of being both the header file +and the source itself. If you just include it normally, you just get +the header file function definitions. To get the code, you include +it from a C or C++ file and define STB_SPRINTF_IMPLEMENTATION first. + +It only uses va_args macros from the C runtime to do it's work. It +does cast doubles to S64s and shifts and divides U64s, which does +drag in CRT code on most platforms. + +It compiles to roughly 8K with float support, and 4K without. +As a comparison, when using MSVC static libs, calling sprintf drags +in 16K. + +API: +==== +int stbsp_sprintf( char * buf, char const * fmt, ... ) +int stbsp_snprintf( char * buf, int count, char const * fmt, ... ) + Convert an arg list into a buffer. stbsp_snprintf always returns + a zero-terminated string (unlike regular snprintf). + +int stbsp_vsprintf( char * buf, char const * fmt, va_list va ) +int stbsp_vsnprintf( char * buf, int count, char const * fmt, va_list va ) + Convert a va_list arg list into a buffer. stbsp_vsnprintf always returns + a zero-terminated string (unlike regular snprintf). + +int stbsp_vsprintfcb( STBSP_SPRINTFCB * callback, void * user, char * buf, char const * fmt, va_list va ) + typedef char * STBSP_SPRINTFCB( char const * buf, void * user, int len ); + Convert into a buffer, calling back every STB_SPRINTF_MIN chars. + Your callback can then copy the chars out, print them or whatever. + This function is actually the workhorse for everything else. + The buffer you pass in must hold at least STB_SPRINTF_MIN characters. + // you return the next buffer to use or 0 to stop converting + +void stbsp_set_separators( char comma, char period ) + Set the comma and period characters to use. + +FLOATS/DOUBLES: +=============== +This code uses a internal float->ascii conversion method that uses +doubles with error correction (double-doubles, for ~105 bits of +precision). This conversion is round-trip perfect - that is, an atof +of the values output here will give you the bit-exact double back. + +One difference is that our insignificant digits will be different than +with MSVC or GCC (but they don't match each other either). We also +don't attempt to find the minimum length matching float (pre-MSVC15 +doesn't either). + +If you don't need float or doubles at all, define STB_SPRINTF_NOFLOAT +and you'll save 4K of code space. + +64-BIT INTS: +============ +This library also supports 64-bit integers and you can use MSVC style or +GCC style indicators (%I64d or %lld). It supports the C99 specifiers +for size_t and ptr_diff_t (%jd %zd) as well. + +EXTRAS: +======= +Like some GCCs, for integers and floats, you can use a ' (single quote) +specifier and commas will be inserted on the thousands: "%'d" on 12345 +would print 12,345. + +For integers and floats, you can use a "$" specifier and the number +will be converted to float and then divided to get kilo, mega, giga or +tera and then printed, so "%$d" 1000 is "1.0 k", "%$.2d" 2536000 is +"2.53 M", etc. For byte values, use two $:s, like "%$$d" to turn +2536000 to "2.42 Mi". If you prefer JEDEC suffixes to SI ones, use three +$:s: "%$$$d" -> "2.42 M". To remove the space between the number and the +suffix, add "_" specifier: "%_$d" -> "2.53M". + +In addition to octal and hexadecimal conversions, you can print +integers in binary: "%b" for 256 would print 100. + +PERFORMANCE vs MSVC 2008 32-/64-bit (GCC is even slower than MSVC): +=================================================================== +"%d" across all 32-bit ints (4.8x/4.0x faster than 32-/64-bit MSVC) +"%24d" across all 32-bit ints (4.5x/4.2x faster) +"%x" across all 32-bit ints (4.5x/3.8x faster) +"%08x" across all 32-bit ints (4.3x/3.8x faster) +"%f" across e-10 to e+10 floats (7.3x/6.0x faster) +"%e" across e-10 to e+10 floats (8.1x/6.0x faster) +"%g" across e-10 to e+10 floats (10.0x/7.1x faster) +"%f" for values near e-300 (7.9x/6.5x faster) +"%f" for values near e+300 (10.0x/9.1x faster) +"%e" for values near e-300 (10.1x/7.0x faster) +"%e" for values near e+300 (9.2x/6.0x faster) +"%.320f" for values near e-300 (12.6x/11.2x faster) +"%a" for random values (8.6x/4.3x faster) +"%I64d" for 64-bits with 32-bit values (4.8x/3.4x faster) +"%I64d" for 64-bits > 32-bit values (4.9x/5.5x faster) +"%s%s%s" for 64 char strings (7.1x/7.3x faster) +"...512 char string..." ( 35.0x/32.5x faster!) +*/ + +#if defined(__clang__) + #if defined(__has_feature) && defined(__has_attribute) + #if __has_feature(address_sanitizer) + #if __has_attribute(__no_sanitize__) + #define STBSP__ASAN __attribute__((__no_sanitize__("address"))) + #elif __has_attribute(__no_sanitize_address__) + #define STBSP__ASAN __attribute__((__no_sanitize_address__)) + #elif __has_attribute(__no_address_safety_analysis__) + #define STBSP__ASAN __attribute__((__no_address_safety_analysis__)) + #endif + #endif + #endif +#elif defined(__GNUC__) && (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)) + #if defined(__SANITIZE_ADDRESS__) && __SANITIZE_ADDRESS__ + #define STBSP__ASAN __attribute__((__no_sanitize_address__)) + #endif +#endif + +#ifndef STBSP__ASAN +#define STBSP__ASAN +#endif + +#ifdef STB_SPRINTF_STATIC +#define STBSP__PUBLICDEC static +#define STBSP__PUBLICDEF static STBSP__ASAN +#else +#ifdef __cplusplus +#define STBSP__PUBLICDEC extern "C" +#define STBSP__PUBLICDEF extern "C" STBSP__ASAN +#else +#define STBSP__PUBLICDEC extern +#define STBSP__PUBLICDEF STBSP__ASAN +#endif +#endif + +#if defined(__has_attribute) + #if __has_attribute(format) + #define STBSP__ATTRIBUTE_FORMAT(fmt,va) __attribute__((format(printf,fmt,va))) + #endif +#endif + +#ifndef STBSP__ATTRIBUTE_FORMAT +#define STBSP__ATTRIBUTE_FORMAT(fmt,va) +#endif + +#ifdef _MSC_VER +#define STBSP__NOTUSED(v) (void)(v) +#else +#define STBSP__NOTUSED(v) (void)sizeof(v) +#endif + +#include // for va_arg(), va_list() +#include // size_t, ptrdiff_t + +#ifndef STB_SPRINTF_MIN +#define STB_SPRINTF_MIN 512 // how many characters per callback +#endif +typedef char *STBSP_SPRINTFCB(const char *buf, void *user, int len); + +#ifndef STB_SPRINTF_DECORATE +#define STB_SPRINTF_DECORATE(name) stbsp_##name // define this before including if you want to change the names +#endif + +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va); +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsnprintf)(char *buf, int count, char const *fmt, va_list va); +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(2,3); +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(3,4); + +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va); +STBSP__PUBLICDEC void STB_SPRINTF_DECORATE(set_separators)(char comma, char period); + +#endif // STB_SPRINTF_H_INCLUDE + +#ifdef STB_SPRINTF_IMPLEMENTATION + +#define stbsp__uint32 unsigned int +#define stbsp__int32 signed int + +#ifdef _MSC_VER +#define stbsp__uint64 unsigned __int64 +#define stbsp__int64 signed __int64 +#else +#define stbsp__uint64 unsigned long long +#define stbsp__int64 signed long long +#endif +#define stbsp__uint16 unsigned short + +#ifndef stbsp__uintptr +#if defined(__ppc64__) || defined(__powerpc64__) || defined(__aarch64__) || defined(_M_X64) || defined(__x86_64__) || defined(__x86_64) || defined(__s390x__) +#define stbsp__uintptr stbsp__uint64 +#else +#define stbsp__uintptr stbsp__uint32 +#endif +#endif + +#ifndef STB_SPRINTF_MSVC_MODE // used for MSVC2013 and earlier (MSVC2015 matches GCC) +#if defined(_MSC_VER) && (_MSC_VER < 1900) +#define STB_SPRINTF_MSVC_MODE +#endif +#endif + +#ifdef STB_SPRINTF_NOUNALIGNED // define this before inclusion to force stbsp_sprintf to always use aligned accesses +#define STBSP__UNALIGNED(code) +#else +#define STBSP__UNALIGNED(code) code +#endif + +#ifndef STB_SPRINTF_NOFLOAT +// internal float utility functions +static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits); +static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value); +#define STBSP__SPECIAL 0x7000 +#endif + +static char stbsp__period = '.'; +static char stbsp__comma = ','; +static struct +{ + short temp; // force next field to be 2-byte aligned + char pair[201]; +} stbsp__digitpair = +{ + 0, + "00010203040506070809101112131415161718192021222324" + "25262728293031323334353637383940414243444546474849" + "50515253545556575859606162636465666768697071727374" + "75767778798081828384858687888990919293949596979899" +}; + +STBSP__PUBLICDEF void STB_SPRINTF_DECORATE(set_separators)(char pcomma, char pperiod) +{ + stbsp__period = pperiod; + stbsp__comma = pcomma; +} + +#define STBSP__LEFTJUST 1 +#define STBSP__LEADINGPLUS 2 +#define STBSP__LEADINGSPACE 4 +#define STBSP__LEADING_0X 8 +#define STBSP__LEADINGZERO 16 +#define STBSP__INTMAX 32 +#define STBSP__TRIPLET_COMMA 64 +#define STBSP__NEGATIVE 128 +#define STBSP__METRIC_SUFFIX 256 +#define STBSP__HALFWIDTH 512 +#define STBSP__METRIC_NOSPACE 1024 +#define STBSP__METRIC_1024 2048 +#define STBSP__METRIC_JEDEC 4096 + +static void stbsp__lead_sign(stbsp__uint32 fl, char *sign) +{ + sign[0] = 0; + if (fl & STBSP__NEGATIVE) { + sign[0] = 1; + sign[1] = '-'; + } else if (fl & STBSP__LEADINGSPACE) { + sign[0] = 1; + sign[1] = ' '; + } else if (fl & STBSP__LEADINGPLUS) { + sign[0] = 1; + sign[1] = '+'; + } +} + +static STBSP__ASAN stbsp__uint32 stbsp__strlen_limited(char const *s, stbsp__uint32 limit) +{ + char const * sn = s; + + // get up to 4-byte alignment + for (;;) { + if (((stbsp__uintptr)sn & 3) == 0) + break; + + if (!limit || *sn == 0) + return (stbsp__uint32)(sn - s); + + ++sn; + --limit; + } + + // scan over 4 bytes at a time to find terminating 0 + // this will intentionally scan up to 3 bytes past the end of buffers, + // but becase it works 4B aligned, it will never cross page boundaries + // (hence the STBSP__ASAN markup; the over-read here is intentional + // and harmless) + while (limit >= 4) { + stbsp__uint32 v = *(stbsp__uint32 *)sn; + // bit hack to find if there's a 0 byte in there + if ((v - 0x01010101) & (~v) & 0x80808080UL) + break; + + sn += 4; + limit -= 4; + } + + // handle the last few characters to find actual size + while (limit && *sn) { + ++sn; + --limit; + } + + return (stbsp__uint32)(sn - s); +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va) +{ + static char hex[] = "0123456789abcdefxp"; + static char hexu[] = "0123456789ABCDEFXP"; + char *bf; + char const *f; + int tlen = 0; + + bf = buf; + f = fmt; + for (;;) { + stbsp__int32 fw, pr, tz; + stbsp__uint32 fl; + + // macros for the callback buffer stuff + #define stbsp__chk_cb_bufL(bytes) \ + { \ + int len = (int)(bf - buf); \ + if ((len + (bytes)) >= STB_SPRINTF_MIN) { \ + tlen += len; \ + if (0 == (bf = buf = callback(buf, user, len))) \ + goto done; \ + } \ + } + #define stbsp__chk_cb_buf(bytes) \ + { \ + if (callback) { \ + stbsp__chk_cb_bufL(bytes); \ + } \ + } + #define stbsp__flush_cb() \ + { \ + stbsp__chk_cb_bufL(STB_SPRINTF_MIN - 1); \ + } // flush if there is even one byte in the buffer + #define stbsp__cb_buf_clamp(cl, v) \ + cl = v; \ + if (callback) { \ + int lg = STB_SPRINTF_MIN - (int)(bf - buf); \ + if (cl > lg) \ + cl = lg; \ + } + + // fast copy everything up to the next % (or end of string) + for (;;) { + while (((stbsp__uintptr)f) & 3) { + schk1: + if (f[0] == '%') + goto scandd; + schk2: + if (f[0] == 0) + goto endfmt; + stbsp__chk_cb_buf(1); + *bf++ = f[0]; + ++f; + } + for (;;) { + // Check if the next 4 bytes contain %(0x25) or end of string. + // Using the 'hasless' trick: + // https://graphics.stanford.edu/~seander/bithacks.html#HasLessInWord + stbsp__uint32 v, c; + v = *(stbsp__uint32 *)f; + c = (~v) & 0x80808080; + if (((v ^ 0x25252525) - 0x01010101) & c) + goto schk1; + if ((v - 0x01010101) & c) + goto schk2; + if (callback) + if ((STB_SPRINTF_MIN - (int)(bf - buf)) < 4) + goto schk1; + #ifdef STB_SPRINTF_NOUNALIGNED + if(((stbsp__uintptr)bf) & 3) { + bf[0] = f[0]; + bf[1] = f[1]; + bf[2] = f[2]; + bf[3] = f[3]; + } else + #endif + { + *(stbsp__uint32 *)bf = v; + } + bf += 4; + f += 4; + } + } + scandd: + + ++f; + + // ok, we have a percent, read the modifiers first + fw = 0; + pr = -1; + fl = 0; + tz = 0; + + // flags + for (;;) { + switch (f[0]) { + // if we have left justify + case '-': + fl |= STBSP__LEFTJUST; + ++f; + continue; + // if we have leading plus + case '+': + fl |= STBSP__LEADINGPLUS; + ++f; + continue; + // if we have leading space + case ' ': + fl |= STBSP__LEADINGSPACE; + ++f; + continue; + // if we have leading 0x + case '#': + fl |= STBSP__LEADING_0X; + ++f; + continue; + // if we have thousand commas + case '\'': + fl |= STBSP__TRIPLET_COMMA; + ++f; + continue; + // if we have kilo marker (none->kilo->kibi->jedec) + case '$': + if (fl & STBSP__METRIC_SUFFIX) { + if (fl & STBSP__METRIC_1024) { + fl |= STBSP__METRIC_JEDEC; + } else { + fl |= STBSP__METRIC_1024; + } + } else { + fl |= STBSP__METRIC_SUFFIX; + } + ++f; + continue; + // if we don't want space between metric suffix and number + case '_': + fl |= STBSP__METRIC_NOSPACE; + ++f; + continue; + // if we have leading zero + case '0': + fl |= STBSP__LEADINGZERO; + ++f; + goto flags_done; + default: goto flags_done; + } + } + flags_done: + + // get the field width + if (f[0] == '*') { + fw = va_arg(va, stbsp__uint32); + ++f; + } else { + while ((f[0] >= '0') && (f[0] <= '9')) { + fw = fw * 10 + f[0] - '0'; + f++; + } + } + // get the precision + if (f[0] == '.') { + ++f; + if (f[0] == '*') { + pr = va_arg(va, stbsp__uint32); + ++f; + } else { + pr = 0; + while ((f[0] >= '0') && (f[0] <= '9')) { + pr = pr * 10 + f[0] - '0'; + f++; + } + } + } + + // handle integer size overrides + switch (f[0]) { + // are we halfwidth? + case 'h': + fl |= STBSP__HALFWIDTH; + ++f; + if (f[0] == 'h') + ++f; // QUARTERWIDTH + break; + // are we 64-bit (unix style) + case 'l': + fl |= ((sizeof(long) == 8) ? STBSP__INTMAX : 0); + ++f; + if (f[0] == 'l') { + fl |= STBSP__INTMAX; + ++f; + } + break; + // are we 64-bit on intmax? (c99) + case 'j': + fl |= (sizeof(size_t) == 8) ? STBSP__INTMAX : 0; + ++f; + break; + // are we 64-bit on size_t or ptrdiff_t? (c99) + case 'z': + fl |= (sizeof(ptrdiff_t) == 8) ? STBSP__INTMAX : 0; + ++f; + break; + case 't': + fl |= (sizeof(ptrdiff_t) == 8) ? STBSP__INTMAX : 0; + ++f; + break; + // are we 64-bit (msft style) + case 'I': + if ((f[1] == '6') && (f[2] == '4')) { + fl |= STBSP__INTMAX; + f += 3; + } else if ((f[1] == '3') && (f[2] == '2')) { + f += 3; + } else { + fl |= ((sizeof(void *) == 8) ? STBSP__INTMAX : 0); + ++f; + } + break; + default: break; + } + + // handle each replacement + switch (f[0]) { + #define STBSP__NUMSZ 512 // big enough for e308 (with commas) or e-307 + char num[STBSP__NUMSZ]; + char lead[8]; + char tail[8]; + char *s; + char const *h; + stbsp__uint32 l, n, cs; + stbsp__uint64 n64; +#ifndef STB_SPRINTF_NOFLOAT + double fv; +#endif + stbsp__int32 dp; + char const *sn; + + case 's': + // get the string + s = va_arg(va, char *); + if (s == 0) + s = (char *)"null"; + // get the length, limited to desired precision + // always limit to ~0u chars since our counts are 32b + l = stbsp__strlen_limited(s, (pr >= 0) ? pr : ~0u); + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + // copy the string in + goto scopy; + + case 'c': // char + // get the character + s = num + STBSP__NUMSZ - 1; + *s = (char)va_arg(va, int); + l = 1; + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + goto scopy; + + case 'n': // weird write-bytes specifier + { + int *d = va_arg(va, int *); + *d = tlen + (int)(bf - buf); + } break; + +#ifdef STB_SPRINTF_NOFLOAT + case 'A': // float + case 'a': // hex float + case 'G': // float + case 'g': // float + case 'E': // float + case 'e': // float + case 'f': // float + va_arg(va, double); // eat it + s = (char *)"No float"; + l = 8; + lead[0] = 0; + tail[0] = 0; + pr = 0; + cs = 0; + STBSP__NOTUSED(dp); + goto scopy; +#else + case 'A': // hex float + case 'a': // hex float + h = (f[0] == 'A') ? hexu : hex; + fv = va_arg(va, double); + if (pr == -1) + pr = 6; // default is 6 + // read the double into a string + if (stbsp__real_to_parts((stbsp__int64 *)&n64, &dp, fv)) + fl |= STBSP__NEGATIVE; + + s = num + 64; + + stbsp__lead_sign(fl, lead); + + if (dp == -1023) + dp = (n64) ? -1022 : 0; + else + n64 |= (((stbsp__uint64)1) << 52); + n64 <<= (64 - 56); + if (pr < 15) + n64 += ((((stbsp__uint64)8) << 56) >> (pr * 4)); +// add leading chars + +#ifdef STB_SPRINTF_MSVC_MODE + *s++ = '0'; + *s++ = 'x'; +#else + lead[1 + lead[0]] = '0'; + lead[2 + lead[0]] = 'x'; + lead[0] += 2; +#endif + *s++ = h[(n64 >> 60) & 15]; + n64 <<= 4; + if (pr) + *s++ = stbsp__period; + sn = s; + + // print the bits + n = pr; + if (n > 13) + n = 13; + if (pr > (stbsp__int32)n) + tz = pr - n; + pr = 0; + while (n--) { + *s++ = h[(n64 >> 60) & 15]; + n64 <<= 4; + } + + // print the expo + tail[1] = h[17]; + if (dp < 0) { + tail[2] = '-'; + dp = -dp; + } else + tail[2] = '+'; + n = (dp >= 1000) ? 6 : ((dp >= 100) ? 5 : ((dp >= 10) ? 4 : 3)); + tail[0] = (char)n; + for (;;) { + tail[n] = '0' + dp % 10; + if (n <= 3) + break; + --n; + dp /= 10; + } + + dp = (int)(s - sn); + l = (int)(s - (num + 64)); + s = num + 64; + cs = 1 + (3 << 24); + goto scopy; + + case 'G': // float + case 'g': // float + h = (f[0] == 'G') ? hexu : hex; + fv = va_arg(va, double); + if (pr == -1) + pr = 6; + else if (pr == 0) + pr = 1; // default is 6 + // read the double into a string + if (stbsp__real_to_str(&sn, &l, num, &dp, fv, (pr - 1) | 0x80000000)) + fl |= STBSP__NEGATIVE; + + // clamp the precision and delete extra zeros after clamp + n = pr; + if (l > (stbsp__uint32)pr) + l = pr; + while ((l > 1) && (pr) && (sn[l - 1] == '0')) { + --pr; + --l; + } + + // should we use %e + if ((dp <= -4) || (dp > (stbsp__int32)n)) { + if (pr > (stbsp__int32)l) + pr = l - 1; + else if (pr) + --pr; // when using %e, there is one digit before the decimal + goto doexpfromg; + } + // this is the insane action to get the pr to match %g semantics for %f + if (dp > 0) { + pr = (dp < (stbsp__int32)l) ? l - dp : 0; + } else { + pr = -dp + ((pr > (stbsp__int32)l) ? (stbsp__int32) l : pr); + } + goto dofloatfromg; + + case 'E': // float + case 'e': // float + h = (f[0] == 'E') ? hexu : hex; + fv = va_arg(va, double); + if (pr == -1) + pr = 6; // default is 6 + // read the double into a string + if (stbsp__real_to_str(&sn, &l, num, &dp, fv, pr | 0x80000000)) + fl |= STBSP__NEGATIVE; + doexpfromg: + tail[0] = 0; + stbsp__lead_sign(fl, lead); + if (dp == STBSP__SPECIAL) { + s = (char *)sn; + cs = 0; + pr = 0; + goto scopy; + } + s = num + 64; + // handle leading chars + *s++ = sn[0]; + + if (pr) + *s++ = stbsp__period; + + // handle after decimal + if ((l - 1) > (stbsp__uint32)pr) + l = pr + 1; + for (n = 1; n < l; n++) + *s++ = sn[n]; + // trailing zeros + tz = pr - (l - 1); + pr = 0; + // dump expo + tail[1] = h[0xe]; + dp -= 1; + if (dp < 0) { + tail[2] = '-'; + dp = -dp; + } else + tail[2] = '+'; +#ifdef STB_SPRINTF_MSVC_MODE + n = 5; +#else + n = (dp >= 100) ? 5 : 4; +#endif + tail[0] = (char)n; + for (;;) { + tail[n] = '0' + dp % 10; + if (n <= 3) + break; + --n; + dp /= 10; + } + cs = 1 + (3 << 24); // how many tens + goto flt_lead; + + case 'f': // float + fv = va_arg(va, double); + doafloat: + // do kilos + if (fl & STBSP__METRIC_SUFFIX) { + double divisor; + divisor = 1000.0f; + if (fl & STBSP__METRIC_1024) + divisor = 1024.0; + while (fl < 0x4000000) { + if ((fv < divisor) && (fv > -divisor)) + break; + fv /= divisor; + fl += 0x1000000; + } + } + if (pr == -1) + pr = 6; // default is 6 + // read the double into a string + if (stbsp__real_to_str(&sn, &l, num, &dp, fv, pr)) + fl |= STBSP__NEGATIVE; + dofloatfromg: + tail[0] = 0; + stbsp__lead_sign(fl, lead); + if (dp == STBSP__SPECIAL) { + s = (char *)sn; + cs = 0; + pr = 0; + goto scopy; + } + s = num + 64; + + // handle the three decimal varieties + if (dp <= 0) { + stbsp__int32 i; + // handle 0.000*000xxxx + *s++ = '0'; + if (pr) + *s++ = stbsp__period; + n = -dp; + if ((stbsp__int32)n > pr) + n = pr; + i = n; + while (i) { + if ((((stbsp__uintptr)s) & 3) == 0) + break; + *s++ = '0'; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)s = 0x30303030; + s += 4; + i -= 4; + } + while (i) { + *s++ = '0'; + --i; + } + if ((stbsp__int32)(l + n) > pr) + l = pr - n; + i = l; + while (i) { + *s++ = *sn++; + --i; + } + tz = pr - (n + l); + cs = 1 + (3 << 24); // how many tens did we write (for commas below) + } else { + cs = (fl & STBSP__TRIPLET_COMMA) ? ((600 - (stbsp__uint32)dp) % 3) : 0; + if ((stbsp__uint32)dp >= l) { + // handle xxxx000*000.0 + n = 0; + for (;;) { + if ((fl & STBSP__TRIPLET_COMMA) && (++cs == 4)) { + cs = 0; + *s++ = stbsp__comma; + } else { + *s++ = sn[n]; + ++n; + if (n >= l) + break; + } + } + if (n < (stbsp__uint32)dp) { + n = dp - n; + if ((fl & STBSP__TRIPLET_COMMA) == 0) { + while (n) { + if ((((stbsp__uintptr)s) & 3) == 0) + break; + *s++ = '0'; + --n; + } + while (n >= 4) { + *(stbsp__uint32 *)s = 0x30303030; + s += 4; + n -= 4; + } + } + while (n) { + if ((fl & STBSP__TRIPLET_COMMA) && (++cs == 4)) { + cs = 0; + *s++ = stbsp__comma; + } else { + *s++ = '0'; + --n; + } + } + } + cs = (int)(s - (num + 64)) + (3 << 24); // cs is how many tens + if (pr) { + *s++ = stbsp__period; + tz = pr; + } + } else { + // handle xxxxx.xxxx000*000 + n = 0; + for (;;) { + if ((fl & STBSP__TRIPLET_COMMA) && (++cs == 4)) { + cs = 0; + *s++ = stbsp__comma; + } else { + *s++ = sn[n]; + ++n; + if (n >= (stbsp__uint32)dp) + break; + } + } + cs = (int)(s - (num + 64)) + (3 << 24); // cs is how many tens + if (pr) + *s++ = stbsp__period; + if ((l - dp) > (stbsp__uint32)pr) + l = pr + dp; + while (n < l) { + *s++ = sn[n]; + ++n; + } + tz = pr - (l - dp); + } + } + pr = 0; + + // handle k,m,g,t + if (fl & STBSP__METRIC_SUFFIX) { + char idx; + idx = 1; + if (fl & STBSP__METRIC_NOSPACE) + idx = 0; + tail[0] = idx; + tail[1] = ' '; + { + if (fl >> 24) { // SI kilo is 'k', JEDEC and SI kibits are 'K'. + if (fl & STBSP__METRIC_1024) + tail[idx + 1] = "_KMGT"[fl >> 24]; + else + tail[idx + 1] = "_kMGT"[fl >> 24]; + idx++; + // If printing kibits and not in jedec, add the 'i'. + if (fl & STBSP__METRIC_1024 && !(fl & STBSP__METRIC_JEDEC)) { + tail[idx + 1] = 'i'; + idx++; + } + tail[0] = idx; + } + } + }; + + flt_lead: + // get the length that we copied + l = (stbsp__uint32)(s - (num + 64)); + s = num + 64; + goto scopy; +#endif + + case 'B': // upper binary + case 'b': // lower binary + h = (f[0] == 'B') ? hexu : hex; + lead[0] = 0; + if (fl & STBSP__LEADING_0X) { + lead[0] = 2; + lead[1] = '0'; + lead[2] = h[0xb]; + } + l = (8 << 4) | (1 << 8); + goto radixnum; + + case 'o': // octal + h = hexu; + lead[0] = 0; + if (fl & STBSP__LEADING_0X) { + lead[0] = 1; + lead[1] = '0'; + } + l = (3 << 4) | (3 << 8); + goto radixnum; + + case 'p': // pointer + fl |= (sizeof(void *) == 8) ? STBSP__INTMAX : 0; + pr = sizeof(void *) * 2; + fl &= ~STBSP__LEADINGZERO; // 'p' only prints the pointer with zeros + // fall through - to X + + case 'X': // upper hex + case 'x': // lower hex + h = (f[0] == 'X') ? hexu : hex; + l = (4 << 4) | (4 << 8); + lead[0] = 0; + if (fl & STBSP__LEADING_0X) { + lead[0] = 2; + lead[1] = '0'; + lead[2] = h[16]; + } + radixnum: + // get the number + if (fl & STBSP__INTMAX) + n64 = va_arg(va, stbsp__uint64); + else + n64 = va_arg(va, stbsp__uint32); + + s = num + STBSP__NUMSZ; + dp = 0; + // clear tail, and clear leading if value is zero + tail[0] = 0; + if (n64 == 0) { + lead[0] = 0; + if (pr == 0) { + l = 0; + cs = 0; + goto scopy; + } + } + // convert to string + for (;;) { + *--s = h[n64 & ((1 << (l >> 8)) - 1)]; + n64 >>= (l >> 8); + if (!((n64) || ((stbsp__int32)((num + STBSP__NUMSZ) - s) < pr))) + break; + if (fl & STBSP__TRIPLET_COMMA) { + ++l; + if ((l & 15) == ((l >> 4) & 15)) { + l &= ~15; + *--s = stbsp__comma; + } + } + }; + // get the tens and the comma pos + cs = (stbsp__uint32)((num + STBSP__NUMSZ) - s) + ((((l >> 4) & 15)) << 24); + // get the length that we copied + l = (stbsp__uint32)((num + STBSP__NUMSZ) - s); + // copy it + goto scopy; + + case 'u': // unsigned + case 'i': + case 'd': // integer + // get the integer and abs it + if (fl & STBSP__INTMAX) { + stbsp__int64 i64 = va_arg(va, stbsp__int64); + n64 = (stbsp__uint64)i64; + if ((f[0] != 'u') && (i64 < 0)) { + n64 = (stbsp__uint64)-i64; + fl |= STBSP__NEGATIVE; + } + } else { + stbsp__int32 i = va_arg(va, stbsp__int32); + n64 = (stbsp__uint32)i; + if ((f[0] != 'u') && (i < 0)) { + n64 = (stbsp__uint32)-i; + fl |= STBSP__NEGATIVE; + } + } + +#ifndef STB_SPRINTF_NOFLOAT + if (fl & STBSP__METRIC_SUFFIX) { + if (n64 < 1024) + pr = 0; + else if (pr == -1) + pr = 1; + fv = (double)(stbsp__int64)n64; + goto doafloat; + } +#endif + + // convert to string + s = num + STBSP__NUMSZ; + l = 0; + + for (;;) { + // do in 32-bit chunks (avoid lots of 64-bit divides even with constant denominators) + char *o = s - 8; + if (n64 >= 100000000) { + n = (stbsp__uint32)(n64 % 100000000); + n64 /= 100000000; + } else { + n = (stbsp__uint32)n64; + n64 = 0; + } + if ((fl & STBSP__TRIPLET_COMMA) == 0) { + do { + s -= 2; + *(stbsp__uint16 *)s = *(stbsp__uint16 *)&stbsp__digitpair.pair[(n % 100) * 2]; + n /= 100; + } while (n); + } + while (n) { + if ((fl & STBSP__TRIPLET_COMMA) && (l++ == 3)) { + l = 0; + *--s = stbsp__comma; + --o; + } else { + *--s = (char)(n % 10) + '0'; + n /= 10; + } + } + if (n64 == 0) { + if ((s[0] == '0') && (s != (num + STBSP__NUMSZ))) + ++s; + break; + } + while (s != o) + if ((fl & STBSP__TRIPLET_COMMA) && (l++ == 3)) { + l = 0; + *--s = stbsp__comma; + --o; + } else { + *--s = '0'; + } + } + + tail[0] = 0; + stbsp__lead_sign(fl, lead); + + // get the length that we copied + l = (stbsp__uint32)((num + STBSP__NUMSZ) - s); + if (l == 0) { + *--s = '0'; + l = 1; + } + cs = l + (3 << 24); + if (pr < 0) + pr = 0; + + scopy: + // get fw=leading/trailing space, pr=leading zeros + if (pr < (stbsp__int32)l) + pr = l; + n = pr + lead[0] + tail[0] + tz; + if (fw < (stbsp__int32)n) + fw = n; + fw -= n; + pr -= l; + + // handle right justify and leading zeros + if ((fl & STBSP__LEFTJUST) == 0) { + if (fl & STBSP__LEADINGZERO) // if leading zeros, everything is in pr + { + pr = (fw > pr) ? fw : pr; + fw = 0; + } else { + fl &= ~STBSP__TRIPLET_COMMA; // if no leading zeros, then no commas + } + } + + // copy the spaces and/or zeros + if (fw + pr) { + stbsp__int32 i; + stbsp__uint32 c; + + // copy leading spaces (or when doing %8.4d stuff) + if ((fl & STBSP__LEFTJUST) == 0) + while (fw > 0) { + stbsp__cb_buf_clamp(i, fw); + fw -= i; + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = ' '; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x20202020; + bf += 4; + i -= 4; + } + while (i) { + *bf++ = ' '; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy leader + sn = lead + 1; + while (lead[0]) { + stbsp__cb_buf_clamp(i, lead[0]); + lead[0] -= (char)i; + while (i) { + *bf++ = *sn++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy leading zeros + c = cs >> 24; + cs &= 0xffffff; + cs = (fl & STBSP__TRIPLET_COMMA) ? ((stbsp__uint32)(c - ((pr + cs) % (c + 1)))) : 0; + while (pr > 0) { + stbsp__cb_buf_clamp(i, pr); + pr -= i; + if ((fl & STBSP__TRIPLET_COMMA) == 0) { + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = '0'; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x30303030; + bf += 4; + i -= 4; + } + } + while (i) { + if ((fl & STBSP__TRIPLET_COMMA) && (cs++ == c)) { + cs = 0; + *bf++ = stbsp__comma; + } else + *bf++ = '0'; + --i; + } + stbsp__chk_cb_buf(1); + } + } + + // copy leader if there is still one + sn = lead + 1; + while (lead[0]) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, lead[0]); + lead[0] -= (char)i; + while (i) { + *bf++ = *sn++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy the string + n = l; + while (n) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, n); + n -= i; + STBSP__UNALIGNED(while (i >= 4) { + *(stbsp__uint32 volatile *)bf = *(stbsp__uint32 volatile *)s; + bf += 4; + s += 4; + i -= 4; + }) + while (i) { + *bf++ = *s++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy trailing zeros + while (tz) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, tz); + tz -= i; + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = '0'; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x30303030; + bf += 4; + i -= 4; + } + while (i) { + *bf++ = '0'; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy tail if there is one + sn = tail + 1; + while (tail[0]) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, tail[0]); + tail[0] -= (char)i; + while (i) { + *bf++ = *sn++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // handle the left justify + if (fl & STBSP__LEFTJUST) + if (fw > 0) { + while (fw) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, fw); + fw -= i; + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = ' '; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x20202020; + bf += 4; + i -= 4; + } + while (i--) + *bf++ = ' '; + stbsp__chk_cb_buf(1); + } + } + break; + + default: // unknown, just copy code + s = num + STBSP__NUMSZ - 1; + *s = f[0]; + l = 1; + fw = fl = 0; + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + goto scopy; + } + ++f; + } +endfmt: + + if (!callback) + *bf = 0; + else + stbsp__flush_cb(); + +done: + return tlen + (int)(bf - buf); +} + +// cleanup +#undef STBSP__LEFTJUST +#undef STBSP__LEADINGPLUS +#undef STBSP__LEADINGSPACE +#undef STBSP__LEADING_0X +#undef STBSP__LEADINGZERO +#undef STBSP__INTMAX +#undef STBSP__TRIPLET_COMMA +#undef STBSP__NEGATIVE +#undef STBSP__METRIC_SUFFIX +#undef STBSP__NUMSZ +#undef stbsp__chk_cb_bufL +#undef stbsp__chk_cb_buf +#undef stbsp__flush_cb +#undef stbsp__cb_buf_clamp + +// ============================================================================ +// wrapper functions + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...) +{ + int result; + va_list va; + va_start(va, fmt); + result = STB_SPRINTF_DECORATE(vsprintfcb)(0, 0, buf, fmt, va); + va_end(va); + return result; +} + +typedef struct stbsp__context { + char *buf; + int count; + int length; + char tmp[STB_SPRINTF_MIN]; +} stbsp__context; + +static char *stbsp__clamp_callback(const char *buf, void *user, int len) +{ + stbsp__context *c = (stbsp__context *)user; + c->length += len; + + if (len > c->count) + len = c->count; + + if (len) { + if (buf != c->buf) { + const char *s, *se; + char *d; + d = c->buf; + s = buf; + se = buf + len; + do { + *d++ = *s++; + } while (s < se); + } + c->buf += len; + c->count -= len; + } + + if (c->count <= 0) + return c->tmp; + return (c->count >= STB_SPRINTF_MIN) ? c->buf : c->tmp; // go direct into buffer if you can +} + +static char * stbsp__count_clamp_callback( const char * buf, void * user, int len ) +{ + stbsp__context * c = (stbsp__context*)user; + (void) sizeof(buf); + + c->length += len; + return c->tmp; // go direct into buffer if you can +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsnprintf )( char * buf, int count, char const * fmt, va_list va ) +{ + stbsp__context c; + + if ( (count == 0) && !buf ) + { + c.length = 0; + + STB_SPRINTF_DECORATE( vsprintfcb )( stbsp__count_clamp_callback, &c, c.tmp, fmt, va ); + } + else + { + int l; + + c.buf = buf; + c.count = count; + c.length = 0; + + STB_SPRINTF_DECORATE( vsprintfcb )( stbsp__clamp_callback, &c, stbsp__clamp_callback(0,&c,0), fmt, va ); + + // zero-terminate + l = (int)( c.buf - buf ); + if ( l >= count ) // should never be greater, only equal (or less) than count + l = count - 1; + buf[l] = 0; + } + + return c.length; +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...) +{ + int result; + va_list va; + va_start(va, fmt); + + result = STB_SPRINTF_DECORATE(vsnprintf)(buf, count, fmt, va); + va_end(va); + + return result; +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va) +{ + return STB_SPRINTF_DECORATE(vsprintfcb)(0, 0, buf, fmt, va); +} + +// ======================================================================= +// low level float utility functions + +#ifndef STB_SPRINTF_NOFLOAT + +// copies d to bits w/ strict aliasing (this compiles to nothing on /Ox) +#define STBSP__COPYFP(dest, src) \ + { \ + int cn; \ + for (cn = 0; cn < 8; cn++) \ + ((char *)&dest)[cn] = ((char *)&src)[cn]; \ + } + +// get float info +static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value) +{ + double d; + stbsp__int64 b = 0; + + // load value and round at the frac_digits + d = value; + + STBSP__COPYFP(b, d); + + *bits = b & ((((stbsp__uint64)1) << 52) - 1); + *expo = (stbsp__int32)(((b >> 52) & 2047) - 1023); + + return (stbsp__int32)((stbsp__uint64) b >> 63); +} + +static double const stbsp__bot[23] = { + 1e+000, 1e+001, 1e+002, 1e+003, 1e+004, 1e+005, 1e+006, 1e+007, 1e+008, 1e+009, 1e+010, 1e+011, + 1e+012, 1e+013, 1e+014, 1e+015, 1e+016, 1e+017, 1e+018, 1e+019, 1e+020, 1e+021, 1e+022 +}; +static double const stbsp__negbot[22] = { + 1e-001, 1e-002, 1e-003, 1e-004, 1e-005, 1e-006, 1e-007, 1e-008, 1e-009, 1e-010, 1e-011, + 1e-012, 1e-013, 1e-014, 1e-015, 1e-016, 1e-017, 1e-018, 1e-019, 1e-020, 1e-021, 1e-022 +}; +static double const stbsp__negboterr[22] = { + -5.551115123125783e-018, -2.0816681711721684e-019, -2.0816681711721686e-020, -4.7921736023859299e-021, -8.1803053914031305e-022, 4.5251888174113741e-023, + 4.5251888174113739e-024, -2.0922560830128471e-025, -6.2281591457779853e-026, -3.6432197315497743e-027, 6.0503030718060191e-028, 2.0113352370744385e-029, + -3.0373745563400371e-030, 1.1806906454401013e-032, -7.7705399876661076e-032, 2.0902213275965398e-033, -7.1542424054621921e-034, -7.1542424054621926e-035, + 2.4754073164739869e-036, 5.4846728545790429e-037, 9.2462547772103625e-038, -4.8596774326570872e-039 +}; +static double const stbsp__top[13] = { + 1e+023, 1e+046, 1e+069, 1e+092, 1e+115, 1e+138, 1e+161, 1e+184, 1e+207, 1e+230, 1e+253, 1e+276, 1e+299 +}; +static double const stbsp__negtop[13] = { + 1e-023, 1e-046, 1e-069, 1e-092, 1e-115, 1e-138, 1e-161, 1e-184, 1e-207, 1e-230, 1e-253, 1e-276, 1e-299 +}; +static double const stbsp__toperr[13] = { + 8388608, + 6.8601809640529717e+028, + -7.253143638152921e+052, + -4.3377296974619174e+075, + -1.5559416129466825e+098, + -3.2841562489204913e+121, + -3.7745893248228135e+144, + -1.7356668416969134e+167, + -3.8893577551088374e+190, + -9.9566444326005119e+213, + 6.3641293062232429e+236, + -5.2069140800249813e+259, + -5.2504760255204387e+282 +}; +static double const stbsp__negtoperr[13] = { + 3.9565301985100693e-040, -2.299904345391321e-063, 3.6506201437945798e-086, 1.1875228833981544e-109, + -5.0644902316928607e-132, -6.7156837247865426e-155, -2.812077463003139e-178, -5.7778912386589953e-201, + 7.4997100559334532e-224, -4.6439668915134491e-247, -6.3691100762962136e-270, -9.436808465446358e-293, + 8.0970921678014997e-317 +}; + +#if defined(_MSC_VER) && (_MSC_VER <= 1200) +static stbsp__uint64 const stbsp__powten[20] = { + 1, + 10, + 100, + 1000, + 10000, + 100000, + 1000000, + 10000000, + 100000000, + 1000000000, + 10000000000, + 100000000000, + 1000000000000, + 10000000000000, + 100000000000000, + 1000000000000000, + 10000000000000000, + 100000000000000000, + 1000000000000000000, + 10000000000000000000U +}; +#define stbsp__tento19th ((stbsp__uint64)1000000000000000000) +#else +static stbsp__uint64 const stbsp__powten[20] = { + 1, + 10, + 100, + 1000, + 10000, + 100000, + 1000000, + 10000000, + 100000000, + 1000000000, + 10000000000ULL, + 100000000000ULL, + 1000000000000ULL, + 10000000000000ULL, + 100000000000000ULL, + 1000000000000000ULL, + 10000000000000000ULL, + 100000000000000000ULL, + 1000000000000000000ULL, + 10000000000000000000ULL +}; +#define stbsp__tento19th (1000000000000000000ULL) +#endif + +#define stbsp__ddmulthi(oh, ol, xh, yh) \ + { \ + double ahi = 0, alo, bhi = 0, blo; \ + stbsp__int64 bt; \ + oh = xh * yh; \ + STBSP__COPYFP(bt, xh); \ + bt &= ((~(stbsp__uint64)0) << 27); \ + STBSP__COPYFP(ahi, bt); \ + alo = xh - ahi; \ + STBSP__COPYFP(bt, yh); \ + bt &= ((~(stbsp__uint64)0) << 27); \ + STBSP__COPYFP(bhi, bt); \ + blo = yh - bhi; \ + ol = ((ahi * bhi - oh) + ahi * blo + alo * bhi) + alo * blo; \ + } + +#define stbsp__ddtoS64(ob, xh, xl) \ + { \ + double ahi = 0, alo, vh, t; \ + ob = (stbsp__int64)xh; \ + vh = (double)ob; \ + ahi = (xh - vh); \ + t = (ahi - xh); \ + alo = (xh - (ahi - t)) - (vh + t); \ + ob += (stbsp__int64)(ahi + alo + xl); \ + } + +#define stbsp__ddrenorm(oh, ol) \ + { \ + double s; \ + s = oh + ol; \ + ol = ol - (s - oh); \ + oh = s; \ + } + +#define stbsp__ddmultlo(oh, ol, xh, xl, yh, yl) ol = ol + (xh * yl + xl * yh); + +#define stbsp__ddmultlos(oh, ol, xh, yl) ol = ol + (xh * yl); + +static void stbsp__raise_to_power10(double *ohi, double *olo, double d, stbsp__int32 power) // power can be -323 to +350 +{ + double ph, pl; + if ((power >= 0) && (power <= 22)) { + stbsp__ddmulthi(ph, pl, d, stbsp__bot[power]); + } else { + stbsp__int32 e, et, eb; + double p2h, p2l; + + e = power; + if (power < 0) + e = -e; + et = (e * 0x2c9) >> 14; /* %23 */ + if (et > 13) + et = 13; + eb = e - (et * 23); + + ph = d; + pl = 0.0; + if (power < 0) { + if (eb) { + --eb; + stbsp__ddmulthi(ph, pl, d, stbsp__negbot[eb]); + stbsp__ddmultlos(ph, pl, d, stbsp__negboterr[eb]); + } + if (et) { + stbsp__ddrenorm(ph, pl); + --et; + stbsp__ddmulthi(p2h, p2l, ph, stbsp__negtop[et]); + stbsp__ddmultlo(p2h, p2l, ph, pl, stbsp__negtop[et], stbsp__negtoperr[et]); + ph = p2h; + pl = p2l; + } + } else { + if (eb) { + e = eb; + if (eb > 22) + eb = 22; + e -= eb; + stbsp__ddmulthi(ph, pl, d, stbsp__bot[eb]); + if (e) { + stbsp__ddrenorm(ph, pl); + stbsp__ddmulthi(p2h, p2l, ph, stbsp__bot[e]); + stbsp__ddmultlos(p2h, p2l, stbsp__bot[e], pl); + ph = p2h; + pl = p2l; + } + } + if (et) { + stbsp__ddrenorm(ph, pl); + --et; + stbsp__ddmulthi(p2h, p2l, ph, stbsp__top[et]); + stbsp__ddmultlo(p2h, p2l, ph, pl, stbsp__top[et], stbsp__toperr[et]); + ph = p2h; + pl = p2l; + } + } + } + stbsp__ddrenorm(ph, pl); + *ohi = ph; + *olo = pl; +} + +// given a float value, returns the significant bits in bits, and the position of the +// decimal point in decimal_pos. +/-INF and NAN are specified by special values +// returned in the decimal_pos parameter. +// frac_digits is absolute normally, but if you want from first significant digits (got %g and %e), or in 0x80000000 +static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits) +{ + double d; + stbsp__int64 bits = 0; + stbsp__int32 expo, e, ng, tens; + + d = value; + STBSP__COPYFP(bits, d); + expo = (stbsp__int32)((bits >> 52) & 2047); + ng = (stbsp__int32)((stbsp__uint64) bits >> 63); + if (ng) + d = -d; + + if (expo == 2047) // is nan or inf? + { + *start = (bits & ((((stbsp__uint64)1) << 52) - 1)) ? "NaN" : "Inf"; + *decimal_pos = STBSP__SPECIAL; + *len = 3; + return ng; + } + + if (expo == 0) // is zero or denormal + { + if (((stbsp__uint64) bits << 1) == 0) // do zero + { + *decimal_pos = 1; + *start = out; + out[0] = '0'; + *len = 1; + return ng; + } + // find the right expo for denormals + { + stbsp__int64 v = ((stbsp__uint64)1) << 51; + while ((bits & v) == 0) { + --expo; + v >>= 1; + } + } + } + + // find the decimal exponent as well as the decimal bits of the value + { + double ph, pl; + + // log10 estimate - very specifically tweaked to hit or undershoot by no more than 1 of log10 of all expos 1..2046 + tens = expo - 1023; + tens = (tens < 0) ? ((tens * 617) / 2048) : (((tens * 1233) / 4096) + 1); + + // move the significant bits into position and stick them into an int + stbsp__raise_to_power10(&ph, &pl, d, 18 - tens); + + // get full as much precision from double-double as possible + stbsp__ddtoS64(bits, ph, pl); + + // check if we undershot + if (((stbsp__uint64)bits) >= stbsp__tento19th) + ++tens; + } + + // now do the rounding in integer land + frac_digits = (frac_digits & 0x80000000) ? ((frac_digits & 0x7ffffff) + 1) : (tens + frac_digits); + if ((frac_digits < 24)) { + stbsp__uint32 dg = 1; + if ((stbsp__uint64)bits >= stbsp__powten[9]) + dg = 10; + while ((stbsp__uint64)bits >= stbsp__powten[dg]) { + ++dg; + if (dg == 20) + goto noround; + } + if (frac_digits < dg) { + stbsp__uint64 r; + // add 0.5 at the right position and round + e = dg - frac_digits; + if ((stbsp__uint32)e >= 24) + goto noround; + r = stbsp__powten[e]; + bits = bits + (r / 2); + if ((stbsp__uint64)bits >= stbsp__powten[dg]) + ++tens; + bits /= r; + } + noround:; + } + + // kill long trailing runs of zeros + if (bits) { + stbsp__uint32 n; + for (;;) { + if (bits <= 0xffffffff) + break; + if (bits % 1000) + goto donez; + bits /= 1000; + } + n = (stbsp__uint32)bits; + while ((n % 1000) == 0) + n /= 1000; + bits = n; + donez:; + } + + // convert to string + out += 64; + e = 0; + for (;;) { + stbsp__uint32 n; + char *o = out - 8; + // do the conversion in chunks of U32s (avoid most 64-bit divides, worth it, constant denomiators be damned) + if (bits >= 100000000) { + n = (stbsp__uint32)(bits % 100000000); + bits /= 100000000; + } else { + n = (stbsp__uint32)bits; + bits = 0; + } + while (n) { + out -= 2; + *(stbsp__uint16 *)out = *(stbsp__uint16 *)&stbsp__digitpair.pair[(n % 100) * 2]; + n /= 100; + e += 2; + } + if (bits == 0) { + if ((e) && (out[0] == '0')) { + ++out; + --e; + } + break; + } + while (out != o) { + *--out = '0'; + ++e; + } + } + + *decimal_pos = tens; + *start = out; + *len = e; + return ng; +} + +#undef stbsp__ddmulthi +#undef stbsp__ddrenorm +#undef stbsp__ddmultlo +#undef stbsp__ddmultlos +#undef STBSP__SPECIAL +#undef STBSP__COPYFP + +#endif // STB_SPRINTF_NOFLOAT + +// clean up +#undef stbsp__uint16 +#undef stbsp__uint32 +#undef stbsp__int32 +#undef stbsp__uint64 +#undef stbsp__int64 +#undef STBSP__UNALIGNED + +#endif // STB_SPRINTF_IMPLEMENTATION + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/vendor/stb/src/stb_truetype_wasm.c b/vendor/stb/src/stb_truetype_wasm.c deleted file mode 100644 index e0b1fdc77..000000000 --- a/vendor/stb/src/stb_truetype_wasm.c +++ /dev/null @@ -1,46 +0,0 @@ -#include - -void *stbtt_malloc(size_t size); -void stbtt_free(void *ptr); - -void stbtt_qsort(void* base, size_t num, size_t size, int (*compare)(const void*, const void*)); - -double stbtt_floor(double x); -double stbtt_ceil(double x); -double stbtt_sqrt(double x); -double stbtt_pow(double x, double y); -double stbtt_fmod(double x, double y); -double stbtt_cos(double x); -double stbtt_acos(double x); -double stbtt_fabs(double x); - -unsigned long stbtt_strlen(const char *str); - -void *memcpy(void *dst, const void *src, size_t count); -void *memset(void *dst, int x, size_t count); - -#define STBRP_SORT stbtt_qsort -#define STBRP_ASSERT(condition) ((void)0) - -#define STBTT_malloc(x,u) ((void)(u),stbtt_malloc(x)) -#define STBTT_free(x,u) ((void)(u),stbtt_free(x)) - -#define STBTT_assert(condition) ((void)0) - -#define STBTT_ifloor(x) ((int) stbtt_floor(x)) -#define STBTT_iceil(x) ((int) stbtt_ceil(x)) -#define STBTT_sqrt(x) stbtt_sqrt(x) -#define STBTT_pow(x,y) stbtt_pow(x,y) -#define STBTT_fmod(x,y) stbtt_fmod(x,y) -#define STBTT_cos(x) stbtt_cos(x) -#define STBTT_acos(x) stbtt_acos(x) -#define STBTT_fabs(x) stbtt_fabs(x) -#define STBTT_strlen(x) stbtt_strlen(x) -#define STBTT_memcpy memcpy -#define STBTT_memset memset - -#define STB_RECT_PACK_IMPLEMENTATION -#include "stb_rect_pack.h" - -#define STB_TRUETYPE_IMPLEMENTATION -#include "stb_truetype.h" diff --git a/vendor/stb/truetype/stb_truetype.odin b/vendor/stb/truetype/stb_truetype.odin index e6defff5f..f1dcdf2a2 100644 --- a/vendor/stb/truetype/stb_truetype.odin +++ b/vendor/stb/truetype/stb_truetype.odin @@ -8,6 +8,7 @@ LIB :: ( "../lib/stb_truetype.lib" when ODIN_OS == .Windows else "../lib/stb_truetype.a" when ODIN_OS == .Linux else "../lib/darwin/stb_truetype.a" when ODIN_OS == .Darwin + else "../lib/stb_truetype_wasm.o" when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 else "" ) @@ -15,10 +16,12 @@ when LIB != "" { when !#exists(LIB) { #panic("Could not find the compiled STB libraries, they can be compiled by running `make -C \"" + ODIN_ROOT + "vendor/stb/src\"`") } +} - foreign import stbtt { LIB } -} else when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 { +when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 { foreign import stbtt "../lib/stb_truetype_wasm.o" +} else when LIB != "" { + foreign import stbtt { LIB } } else { foreign import stbtt "system:stb_truetype" } diff --git a/vendor/stb/truetype/stb_truetype_wasm.odin b/vendor/stb/truetype/stb_truetype_wasm.odin index 472419ccb..d15f29f18 100644 --- a/vendor/stb/truetype/stb_truetype_wasm.odin +++ b/vendor/stb/truetype/stb_truetype_wasm.odin @@ -1,82 +1,4 @@ //+build wasm32, wasm64p32 package stb_truetype -import "base:builtin" -import "base:intrinsics" -import "base:runtime" - -import "core:c" -import "core:math" -import "core:slice" -import "core:sort" - -@(require, linkage="strong", link_name="stbtt_malloc") -malloc :: proc "c" (size: uint) -> rawptr { - context = runtime.default_context() - ptr, _ := runtime.mem_alloc_non_zeroed(int(size)) - return raw_data(ptr) -} - -@(require, linkage="strong", link_name="stbtt_free") -free :: proc "c" (ptr: rawptr) { - context = runtime.default_context() - builtin.free(ptr) -} - -@(require, linkage="strong", link_name="stbtt_qsort") -qsort :: proc "c" (base: rawptr, num: uint, size: uint, cmp: proc "c" (a, b: rawptr) -> i32) { - context = runtime.default_context() - - Inputs :: struct { - base: rawptr, - num: uint, - size: uint, - cmp: proc "c" (a, b: rawptr) -> i32, - } - - sort.sort({ - collection = &Inputs{base, num, size, cmp}, - len = proc(it: sort.Interface) -> int { - inputs := (^Inputs)(it.collection) - return int(inputs.num) - }, - less = proc(it: sort.Interface, i, j: int) -> bool { - inputs := (^Inputs)(it.collection) - a := rawptr(uintptr(inputs.base) + (uintptr(i) * uintptr(inputs.size))) - b := rawptr(uintptr(inputs.base) + (uintptr(j) * uintptr(inputs.size))) - return inputs.cmp(a, b) < 0 - }, - swap = proc(it: sort.Interface, i, j: int) { - inputs := (^Inputs)(it.collection) - - a := rawptr(uintptr(inputs.base) + (uintptr(i) * uintptr(inputs.size))) - b := rawptr(uintptr(inputs.base) + (uintptr(j) * uintptr(inputs.size))) - - slice.ptr_swap_non_overlapping(a, b, int(inputs.size)) - }, - }) -} - -@(require, linkage="strong", link_name="stbtt_floor") -floor :: proc "c" (x: f64) -> f64 { return math.floor(x) } -@(require, linkage="strong", link_name="stbtt_ceil") -ceil :: proc "c" (x: f64) -> f64 { return math.ceil(x) } -@(require, linkage="strong", link_name="stbtt_sqrt") -sqrt :: proc "c" (x: f64) -> f64 { return math.sqrt(x) } -@(require, linkage="strong", link_name="stbtt_pow") -pow :: proc "c" (x, y: f64) -> f64 { return math.pow(x, y) } -@(require, linkage="strong", link_name="stbtt_fmod") -fmod :: proc "c" (x, y: f64) -> f64 { return math.mod(x, y) } -@(require, linkage="strong", link_name="stbtt_cos") -cos :: proc "c" (x: f64) -> f64 { return math.cos(x) } -@(require, linkage="strong", link_name="stbtt_acos") -acos :: proc "c" (x: f64) -> f64 { return math.acos(x) } -@(require, linkage="strong", link_name="stbtt_fabs") -fabs :: proc "c" (x: f64) -> f64 { return math.abs(x) } - -@(require, linkage="strong", link_name="stbtt_strlen") -strlen :: proc "c" (str: cstring) -> c.ulong { return c.ulong(len(str)) } - -// NOTE: defined in runtime. -// void *memcpy(void *dst, const void *src, size_t count); -// void *memset(void *dst, int x, size_t count); +@(require) import _ "vendor:libc" From 9d6f71fd2ed0a290781e547c7573e86010ff660f Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Sun, 8 Sep 2024 15:27:28 -0400 Subject: [PATCH 31/72] Fix `sync.Benaphore` The calls to `atomic_add*` return the value before adding, not after, so the previous code was causing the occasional data race. --- core/sync/extended.odin | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/core/sync/extended.odin b/core/sync/extended.odin index b446fefa0..ffba40ef8 100644 --- a/core/sync/extended.odin +++ b/core/sync/extended.odin @@ -355,7 +355,7 @@ from entering any critical sections associated with the same benaphore, until until the lock is released. */ benaphore_lock :: proc "contextless" (b: ^Benaphore) { - if atomic_add_explicit(&b.counter, 1, .Acquire) > 1 { + if atomic_add_explicit(&b.counter, 1, .Acquire) > 0 { sema_wait(&b.sema) } } @@ -384,7 +384,7 @@ are waiting on the lock, exactly one thread is allowed into a critical section associated with the same banaphore. */ benaphore_unlock :: proc "contextless" (b: ^Benaphore) { - if atomic_sub_explicit(&b.counter, 1, .Release) > 0 { + if atomic_sub_explicit(&b.counter, 1, .Release) > 1 { sema_post(&b.sema) } } @@ -740,4 +740,4 @@ Make event available. one_shot_event_signal :: proc "contextless" (e: ^One_Shot_Event) { atomic_store_explicit(&e.state, 1, .Release) futex_broadcast(&e.state) -} \ No newline at end of file +} From 74b28f1ff91d4776475f4009fa2bcda71c655cd5 Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Sun, 8 Sep 2024 17:25:48 -0400 Subject: [PATCH 32/72] Fix rare double-join possibility in POSIX `thread._join` This was occuring about 1/100 times with the test runner's thread pool. --- core/thread/thread_unix.odin | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/core/thread/thread_unix.odin b/core/thread/thread_unix.odin index ddc47244c..d165560ac 100644 --- a/core/thread/thread_unix.odin +++ b/core/thread/thread_unix.odin @@ -9,8 +9,6 @@ import "core:time" _IS_SUPPORTED :: true -CAS :: sync.atomic_compare_exchange_strong - // NOTE(tetra): Aligned here because of core/unix/pthread_linux.odin/pthread_t. // Also see core/sys/darwin/mach_darwin.odin/semaphore_t. Thread_Os_Specific :: struct #align(16) { @@ -140,24 +138,18 @@ _is_done :: proc(t: ^Thread) -> bool { } _join :: proc(t: ^Thread) { - // sync.guard(&t.mutex) - if unix.pthread_equal(unix.pthread_self(), t.unix_thread) { return } - // Preserve other flags besides `.Joined`, like `.Started`. - unjoined := sync.atomic_load(&t.flags) - {.Joined} - joined := unjoined + {.Joined} - - // Try to set `t.flags` from unjoined to joined. If it returns joined, - // it means the previous value had that flag set and we can return. - if res, ok := CAS(&t.flags, unjoined, joined); res == joined && !ok { + // If the previous value was already `Joined`, then we can return. + if .Joined in sync.atomic_or(&t.flags, {.Joined}) { return } + // Prevent non-started threads from blocking main thread with initial wait // condition. - if .Started not_in unjoined { + if .Started not_in sync.atomic_load(&t.flags) { _start(t) } unix.pthread_join(t.unix_thread, nil) From cbd4d5e765646ef07c4133ab65e06652a87a1916 Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Sun, 8 Sep 2024 17:54:45 -0400 Subject: [PATCH 33/72] Fix data race in `atomic_sema_wait_with_timeout` --- core/sync/primitives_atomic.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sync/primitives_atomic.odin b/core/sync/primitives_atomic.odin index 1d8e423db..076a74b20 100644 --- a/core/sync/primitives_atomic.odin +++ b/core/sync/primitives_atomic.odin @@ -361,7 +361,7 @@ atomic_sema_wait_with_timeout :: proc "contextless" (s: ^Atomic_Sema, duration: if !futex_wait_with_timeout(&s.count, u32(original_count), remaining) { return false } - original_count = s.count + original_count = atomic_load_explicit(&s.count, .Relaxed) } if original_count == atomic_compare_exchange_strong_explicit(&s.count, original_count, original_count-1, .Acquire, .Acquire) { return true From 4d14b4257e7570216826c5cbcee94aa51116e3b3 Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Sun, 8 Sep 2024 18:05:34 -0400 Subject: [PATCH 34/72] Convert POSIX `Thread` to use semaphore instead One less value to store, and it should be less of a hack too. Semaphores will not wait around if they have the go-ahead; they depend on an internal value being non-zero, instead of whatever was loaded when they started waiting, which is the case with a `Cond`. --- core/thread/thread_unix.odin | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/core/thread/thread_unix.odin b/core/thread/thread_unix.odin index d165560ac..3d3b419b0 100644 --- a/core/thread/thread_unix.odin +++ b/core/thread/thread_unix.odin @@ -5,7 +5,6 @@ package thread import "base:runtime" import "core:sync" import "core:sys/unix" -import "core:time" _IS_SUPPORTED :: true @@ -13,8 +12,7 @@ _IS_SUPPORTED :: true // Also see core/sys/darwin/mach_darwin.odin/semaphore_t. Thread_Os_Specific :: struct #align(16) { unix_thread: unix.pthread_t, // NOTE: very large on Darwin, small on Linux. - cond: sync.Cond, - mutex: sync.Mutex, + start_ok: sync.Sema, } // // Creates a thread which will run the given procedure. @@ -27,14 +25,10 @@ _create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread { // We need to give the thread a moment to start up before we enable cancellation. can_set_thread_cancel_state := unix.pthread_setcancelstate(unix.PTHREAD_CANCEL_ENABLE, nil) == 0 - sync.lock(&t.mutex) - t.id = sync.current_thread_id() - for (.Started not_in sync.atomic_load(&t.flags)) { - // HACK: use a timeout so in the event that the condition is signalled at THIS comment's exact point - // (after checking flags, before starting the wait) it gets itself out of that deadlock after a ms. - sync.wait_with_timeout(&t.cond, &t.mutex, time.Millisecond) + if .Started not_in sync.atomic_load(&t.flags) { + sync.wait(&t.start_ok) } if .Joined in sync.atomic_load(&t.flags) { @@ -64,8 +58,6 @@ _create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread { sync.atomic_or(&t.flags, { .Done }) - sync.unlock(&t.mutex) - if .Self_Cleanup in sync.atomic_load(&t.flags) { res := unix.pthread_detach(t.unix_thread) assert_contextless(res == 0) @@ -130,7 +122,7 @@ _create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread { _start :: proc(t: ^Thread) { sync.atomic_or(&t.flags, { .Started }) - sync.signal(&t.cond) + sync.post(&t.start_ok) } _is_done :: proc(t: ^Thread) -> bool { From 45da0093774276223e3724a89e5b0a9f8ef7c9f7 Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Sun, 8 Sep 2024 18:21:55 -0400 Subject: [PATCH 35/72] Use more atomic handling of thread flags This can prevent a data race on Linux with `Self_Cleanup`. --- core/thread/thread.odin | 12 ++++++------ core/thread/thread_windows.odin | 6 +++--- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/core/thread/thread.odin b/core/thread/thread.odin index 17ba1a0a2..c1cbceb42 100644 --- a/core/thread/thread.odin +++ b/core/thread/thread.odin @@ -272,7 +272,7 @@ create_and_start :: proc(fn: proc(), init_context: Maybe(runtime.Context) = nil, t := create(thread_proc, priority) t.data = rawptr(fn) if self_cleanup { - t.flags += {.Self_Cleanup} + intrinsics.atomic_or(&t.flags, {.Self_Cleanup}) } t.init_context = init_context start(t) @@ -307,7 +307,7 @@ create_and_start_with_data :: proc(data: rawptr, fn: proc(data: rawptr), init_co t.user_index = 1 t.user_args[0] = data if self_cleanup { - t.flags += {.Self_Cleanup} + intrinsics.atomic_or(&t.flags, {.Self_Cleanup}) } t.init_context = init_context start(t) @@ -347,7 +347,7 @@ create_and_start_with_poly_data :: proc(data: $T, fn: proc(data: T), init_contex mem.copy(&t.user_args[0], &data, size_of(T)) if self_cleanup { - t.flags += {.Self_Cleanup} + intrinsics.atomic_or(&t.flags, {.Self_Cleanup}) } t.init_context = init_context @@ -394,7 +394,7 @@ create_and_start_with_poly_data2 :: proc(arg1: $T1, arg2: $T2, fn: proc(T1, T2), _ = copy(user_args[n:], mem.ptr_to_bytes(&arg2)) if self_cleanup { - t.flags += {.Self_Cleanup} + intrinsics.atomic_or(&t.flags, {.Self_Cleanup}) } t.init_context = init_context @@ -443,7 +443,7 @@ create_and_start_with_poly_data3 :: proc(arg1: $T1, arg2: $T2, arg3: $T3, fn: pr _ = copy(user_args[n:], mem.ptr_to_bytes(&arg3)) if self_cleanup { - t.flags += {.Self_Cleanup} + intrinsics.atomic_or(&t.flags, {.Self_Cleanup}) } t.init_context = init_context @@ -494,7 +494,7 @@ create_and_start_with_poly_data4 :: proc(arg1: $T1, arg2: $T2, arg3: $T3, arg4: _ = copy(user_args[n:], mem.ptr_to_bytes(&arg4)) if self_cleanup { - t.flags += {.Self_Cleanup} + intrinsics.atomic_or(&t.flags, {.Self_Cleanup}) } t.init_context = init_context diff --git a/core/thread/thread_windows.odin b/core/thread/thread_windows.odin index 50a4e5fbc..22c3eae65 100644 --- a/core/thread/thread_windows.odin +++ b/core/thread/thread_windows.odin @@ -27,7 +27,7 @@ _create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread { __windows_thread_entry_proc :: proc "system" (t_: rawptr) -> win32.DWORD { t := (^Thread)(t_) - if .Joined in t.flags { + if .Joined in sync.atomic_load(&t.flags) { return 0 } @@ -48,9 +48,9 @@ _create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread { t.procedure(t) } - intrinsics.atomic_store(&t.flags, t.flags + {.Done}) + intrinsics.atomic_or(&t.flags, {.Done}) - if .Self_Cleanup in t.flags { + if .Self_Cleanup in sync.atomic_load(&t.flags) { win32.CloseHandle(t.win32_thread) t.win32_thread = win32.INVALID_HANDLE // NOTE(ftphikari): It doesn't matter which context 'free' received, right? From dbb783fbf20df1bba899b7a2bcbd65f71eb32fef Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Sun, 8 Sep 2024 18:59:55 -0400 Subject: [PATCH 36/72] Fix atomic memory order for `sync.ticket_mutex_unlock` --- core/sync/extended.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sync/extended.odin b/core/sync/extended.odin index ffba40ef8..fd2bda08a 100644 --- a/core/sync/extended.odin +++ b/core/sync/extended.odin @@ -297,7 +297,7 @@ waiting to acquire the lock, exactly one of those threads is unblocked and allowed into the critical section. */ ticket_mutex_unlock :: #force_inline proc "contextless" (m: ^Ticket_Mutex) { - atomic_add_explicit(&m.serving, 1, .Relaxed) + atomic_add_explicit(&m.serving, 1, .Release) } /* From c3f363cfbcee453c7d90b37429c92115e91216af Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Sun, 8 Sep 2024 21:59:55 -0400 Subject: [PATCH 37/72] Fix data race when `pool_stop_task` is called --- core/thread/thread_pool.odin | 1 + 1 file changed, 1 insertion(+) diff --git a/core/thread/thread_pool.odin b/core/thread/thread_pool.odin index 9bcc42968..d9166b450 100644 --- a/core/thread/thread_pool.odin +++ b/core/thread/thread_pool.odin @@ -60,6 +60,7 @@ pool_thread_runner :: proc(t: ^Thread) { if task, ok := pool_pop_waiting(pool); ok { data.task = task pool_do_work(pool, task) + sync.guard(&pool.mutex) data.task = {} } } From fdd488256896ab40025ebd394735d5a6a30bd8ee Mon Sep 17 00:00:00 2001 From: flysand7 Date: Tue, 10 Sep 2024 19:51:20 +1100 Subject: [PATCH 38/72] [mem]: Adjust docs for alloc --- core/mem/alloc.odin | 166 +++++++++++++++++++++++++++++++++++++++----- 1 file changed, 150 insertions(+), 16 deletions(-) diff --git a/core/mem/alloc.odin b/core/mem/alloc.odin index c2e55541c..1ede92837 100644 --- a/core/mem/alloc.odin +++ b/core/mem/alloc.odin @@ -35,7 +35,6 @@ functions: `old_size` to be `size` bytes in length and have the specified `alignment`, in case a re-alllocation occurs. - `Resize_Non_Zeroed`: Same as `Resize`, without explicit zero-initialization. - */ Allocator_Mode :: runtime.Allocator_Mode @@ -123,7 +122,11 @@ Currently the type is defined as follows: ) -> ([]byte, Allocator_Error); The function of this procedure and the meaning of parameters depends on the -value of the `mode` parameter. +value of the `mode` parameter. For any operation the following constraints +apply: + +- The `alignment` must be a power of two. +- The `size` must be a positive integer. ## 1. `.Alloc`, `.Alloc_Non_Zeroed` @@ -142,10 +145,11 @@ Allocates a memory region of size `size`, aligned on a boundary specified by 1. The memory region, if allocated successfully, or `nil` otherwise. 2. An error, if allocation failed. -**Note**: Some allocators may return `nil`, even if no error is returned. +**Note**: The nil allocator may return `nil`, even if no error is returned. Always check both the error and the allocated buffer. -Same as `.Alloc`. +**Note**: The `.Alloc` mode is required to be implemented for an allocator +and can not return a `.Mode_Not_Implemented` error. ## 2. `Free` @@ -200,6 +204,10 @@ If `new_size` is `nil`, the procedure acts just like `.Free`, freeing the memory region `old_size` bytes in length, located at the address specified by `old_memory`. +If the `old_memory` pointer is not aligned to the boundary specified by +`alignment`, the procedure relocates the buffer such that the reallocated +buffer is aligned to the boundary specified by `alignment`. + **Inputs**: - `allocator_data`: Pointer to the allocator data. - `mode`: `.Resize` or `.Resize_All`. @@ -216,6 +224,9 @@ memory region `old_size` bytes in length, located at the address specified by **Note**: Some allocators may return `nil`, even if no error is returned. Always check both the error and the allocated buffer. + +**Note**: if `old_size` is `0` and `old_memory` is `nil`, this operation is a +no-op, and should not return errors. */ Allocator_Proc :: runtime.Allocator_Proc @@ -259,6 +270,8 @@ Allocate memory. This function allocates `size` bytes of memory, aligned to a boundary specified by `alignment` using the allocator specified by `allocator`. +If the `size` parameter is `0`, the operation is a no-op. + **Inputs**: - `size`: The desired size of the allocated memory region. - `alignment`: The desired alignment of the allocated memory region. @@ -267,6 +280,14 @@ by `alignment` using the allocator specified by `allocator`. **Returns**: 1. Pointer to the allocated memory, or `nil` if allocation failed. 2. Error, if the allocation failed. + +**Errors**: +- `None`: If no error occurred. +- `Out_Of_Memory`: Occurs when the allocator runs out of space in any of its + backing buffers, the backing allocator has ran out of space, or an operating + system failure occurred. +- `Invalid_Argument`: If the supplied `size` is negative, alignment is not a + power of two. */ @(require_results) alloc :: proc( @@ -293,6 +314,14 @@ by `alignment` using the allocator specified by `allocator`. **Returns**: 1. Slice of the allocated memory region, or `nil` if allocation failed. 2. Error, if the allocation failed. + +**Errors**: +- `None`: If no error occurred. +- `Out_Of_Memory`: Occurs when the allocator runs out of space in any of its + backing buffers, the backing allocator has ran out of space, or an operating + system failure occurred. +- `Invalid_Argument`: If the supplied `size` is negative, alignment is not a + power of two. */ @(require_results) alloc_bytes :: proc( @@ -319,6 +348,14 @@ does not explicitly zero-initialize allocated memory region. **Returns**: 1. Slice of the allocated memory region, or `nil` if allocation failed. 2. Error, if the allocation failed. + +**Errors**: +- `None`: If no error occurred. +- `Out_Of_Memory`: Occurs when the allocator runs out of space in any of its + backing buffers, the backing allocator has ran out of space, or an operating + system failure occurred. +- `Invalid_Argument`: If the supplied `size` is negative, alignment is not a + power of two. */ @(require_results) alloc_bytes_non_zeroed :: proc( @@ -339,6 +376,16 @@ allocated from the allocator specified by `allocator`. **Inputs**: - `ptr`: Pointer to the memory region to free. - `allocator`: The allocator to free to. + +**Returns**: +- The error, if freeing failed. + +**Errors**: +- `None`: When no error has occurred. +- `Invalid_Pointer`: The specified pointer is not owned by the specified allocator, + or does not point to a valid allocation. +- `Mode_Not_Implemented`: If the specified allocator does not support the `.Free` +mode. */ free :: proc( ptr: rawptr, @@ -354,6 +401,8 @@ Free a memory region. This procedure frees `size` bytes of memory region located at the address, specified by `ptr`, allocated from the allocator specified by `allocator`. +If the `size` parameter is `0`, this call is equivalent to `free()`. + **Inputs**: - `ptr`: Pointer to the memory region to free. - `size`: The size of the memory region to free. @@ -361,6 +410,13 @@ specified by `ptr`, allocated from the allocator specified by `allocator`. **Returns**: - The error, if freeing failed. + +**Errors**: +- `None`: When no error has occurred. +- `Invalid_Pointer`: The specified pointer is not owned by the specified allocator, + or does not point to a valid allocation. +- `Mode_Not_Implemented`: If the specified allocator does not support the `.Free` +mode. */ free_with_size :: proc( ptr: rawptr, @@ -377,12 +433,22 @@ Free a memory region. This procedure frees memory region, specified by `bytes`, allocated from the allocator specified by `allocator`. +If the length of the specified slice is zero, the `.Invalid_Argument` error +is returned. + **Inputs**: - `bytes`: The memory region to free. - `allocator`: The allocator to free to. **Returns**: - The error, if freeing failed. + +**Errors**: +- `None`: When no error has occurred. +- `Invalid_Pointer`: The specified pointer is not owned by the specified allocator, + or does not point to a valid allocation. +- `Mode_Not_Implemented`: If the specified allocator does not support the `.Free` +mode. */ free_bytes :: proc( bytes: []byte, @@ -397,6 +463,14 @@ Free all allocations. This procedure frees all allocations made on the allocator specified by `allocator` to that allocator, making it available for further allocations. + +**Inputs**: +- `allocator`: The allocator to free to. + +**Errors**: +- `None`: When no error has occurred. +- `Mode_Not_Implemented`: If the specified allocator does not support the `.Free` +mode. */ free_all :: proc(allocator := context.allocator, loc := #caller_location) -> Allocator_Error { return runtime.mem_free_all(allocator, loc) @@ -416,6 +490,10 @@ If the `new_size` parameter is `0`, `resize()` acts just like `free()`, freeing the memory region `old_size` bytes in length, located at the address specified by `ptr`. +If the `old_memory` pointer is not aligned to the boundary specified by +`alignment`, the procedure relocates the buffer such that the reallocated +buffer is aligned to the boundary specified by `alignment`. + **Inputs**: - `ptr`: Pointer to the memory region to resize. - `old_size`: Size of the memory region to resize. @@ -427,9 +505,20 @@ by `ptr`. 1. The pointer to the resized memory region, if successfull, `nil` otherwise. 2. Error, if resize failed. -**Note**: The `alignment` parameter is used to preserve the original alignment -of the allocation, if `resize()` needs to relocate the memory region. Do not -use `resize()` to change the alignment of the allocated memory region. +**Errors**: +- `None`: No error. +- `Out_Of_Memory`: When the allocator's backing buffer or it's backing + allocator does not have enough space to fit in an allocation with the new + size, or an operating system failure occurs. +- `Invalid_Pointer`: The pointer referring to a memory region does not belong + to any of the allocators backing buffers or does not point to a valid start + of an allocation made in that allocator. +- `Invalid_Argument`: When `size` is negative, alignment is not a power of two, + or the `old_size` argument is incorrect. +- `Mode_Not_Implemented`: The allocator does not support the `.Realloc` mode. + +**Note**: if `old_size` is `0` and `old_memory` is `nil`, this operation is a +no-op, and should not return errors. */ @(require_results) resize :: proc( @@ -458,6 +547,10 @@ If the `new_size` parameter is `0`, `resize()` acts just like `free()`, freeing the memory region `old_size` bytes in length, located at the address specified by `ptr`. +If the `old_memory` pointer is not aligned to the boundary specified by +`alignment`, the procedure relocates the buffer such that the reallocated +buffer is aligned to the boundary specified by `alignment`. + Unlike `resize()`, this procedure does not explicitly zero-initialize any new memory. @@ -472,9 +565,20 @@ memory. 1. The pointer to the resized memory region, if successfull, `nil` otherwise. 2. Error, if resize failed. -**Note**: The `alignment` parameter is used to preserve the original alignment -of the allocation, if `resize()` needs to relocate the memory region. Do not -use `resize()` to change the alignment of the allocated memory region. +**Errors**: +- `None`: No error. +- `Out_Of_Memory`: When the allocator's backing buffer or it's backing + allocator does not have enough space to fit in an allocation with the new + size, or an operating system failure occurs. +- `Invalid_Pointer`: The pointer referring to a memory region does not belong + to any of the allocators backing buffers or does not point to a valid start + of an allocation made in that allocator. +- `Invalid_Argument`: When `size` is negative, alignment is not a power of two, + or the `old_size` argument is incorrect. +- `Mode_Not_Implemented`: The allocator does not support the `.Realloc` mode. + +**Note**: if `old_size` is `0` and `old_memory` is `nil`, this operation is a +no-op, and should not return errors. */ @(require_results) resize_non_zeroed :: proc( @@ -503,6 +607,10 @@ by `alignment`. If the `new_size` parameter is `0`, `resize_bytes()` acts just like `free_bytes()`, freeing the memory region specified by `old_data`. +If the `old_memory` pointer is not aligned to the boundary specified by +`alignment`, the procedure relocates the buffer such that the reallocated +buffer is aligned to the boundary specified by `alignment`. + **Inputs**: - `old_data`: Pointer to the memory region to resize. - `new_size`: The desired size of the resized memory region. @@ -513,9 +621,20 @@ If the `new_size` parameter is `0`, `resize_bytes()` acts just like 1. The resized memory region, if successfull, `nil` otherwise. 2. Error, if resize failed. -**Note**: The `alignment` parameter is used to preserve the original alignment -of the allocation, if `resize()` needs to relocate the memory region. Do not -use `resize()` to change the alignment of the allocated memory region. +**Errors**: +- `None`: No error. +- `Out_Of_Memory`: When the allocator's backing buffer or it's backing + allocator does not have enough space to fit in an allocation with the new + size, or an operating system failure occurs. +- `Invalid_Pointer`: The pointer referring to a memory region does not belong + to any of the allocators backing buffers or does not point to a valid start + of an allocation made in that allocator. +- `Invalid_Argument`: When `size` is negative, alignment is not a power of two, + or the `old_size` argument is incorrect. +- `Mode_Not_Implemented`: The allocator does not support the `.Realloc` mode. + +**Note**: if `old_size` is `0` and `old_memory` is `nil`, this operation is a +no-op, and should not return errors. */ @(require_results) resize_bytes :: proc( @@ -542,6 +661,10 @@ by `alignment`. If the `new_size` parameter is `0`, `resize_bytes()` acts just like `free_bytes()`, freeing the memory region specified by `old_data`. +If the `old_memory` pointer is not aligned to the boundary specified by +`alignment`, the procedure relocates the buffer such that the reallocated +buffer is aligned to the boundary specified by `alignment`. + Unlike `resize_bytes()`, this procedure does not explicitly zero-initialize any new memory. @@ -555,9 +678,20 @@ any new memory. 1. The resized memory region, if successfull, `nil` otherwise. 2. Error, if resize failed. -**Note**: The `alignment` parameter is used to preserve the original alignment -of the allocation, if `resize()` needs to relocate the memory region. Do not -use `resize()` to change the alignment of the allocated memory region. +**Errors**: +- `None`: No error. +- `Out_Of_Memory`: When the allocator's backing buffer or it's backing + allocator does not have enough space to fit in an allocation with the new + size, or an operating system failure occurs. +- `Invalid_Pointer`: The pointer referring to a memory region does not belong + to any of the allocators backing buffers or does not point to a valid start + of an allocation made in that allocator. +- `Invalid_Argument`: When `size` is negative, alignment is not a power of two, + or the `old_size` argument is incorrect. +- `Mode_Not_Implemented`: The allocator does not support the `.Realloc` mode. + +**Note**: if `old_size` is `0` and `old_memory` is `nil`, this operation is a +no-op, and should not return errors. */ @(require_results) resize_bytes_non_zeroed :: proc( From 0a594147afbfdacece1d221d2dee744e612362c6 Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Mon, 9 Sep 2024 00:23:30 -0400 Subject: [PATCH 39/72] Use `contextless` procs in `core:sync` instead --- core/sync/extended.odin | 10 +++++----- core/sync/futex_darwin.odin | 12 ++++++------ core/sync/futex_freebsd.odin | 8 ++++---- core/sync/futex_linux.odin | 8 ++++---- core/sync/futex_netbsd.odin | 8 ++++---- core/sync/futex_openbsd.odin | 8 ++++---- core/sync/futex_wasm.odin | 8 ++++---- core/sync/primitives.odin | 18 +----------------- core/sync/primitives_atomic.odin | 2 +- 9 files changed, 33 insertions(+), 49 deletions(-) diff --git a/core/sync/extended.odin b/core/sync/extended.odin index fd2bda08a..83cc648b4 100644 --- a/core/sync/extended.odin +++ b/core/sync/extended.odin @@ -48,12 +48,12 @@ wait_group_add :: proc "contextless" (wg: ^Wait_Group, delta: int) { atomic_add(&wg.counter, delta) if wg.counter < 0 { - _panic("sync.Wait_Group negative counter") + panic_contextless("sync.Wait_Group negative counter") } if wg.counter == 0 { cond_broadcast(&wg.cond) if wg.counter != 0 { - _panic("sync.Wait_Group misuse: sync.wait_group_add called concurrently with sync.wait_group_wait") + panic_contextless("sync.Wait_Group misuse: sync.wait_group_add called concurrently with sync.wait_group_wait") } } } @@ -81,7 +81,7 @@ wait_group_wait :: proc "contextless" (wg: ^Wait_Group) { if wg.counter != 0 { cond_wait(&wg.cond, &wg.mutex) if wg.counter != 0 { - _panic("sync.Wait_Group misuse: sync.wait_group_add called concurrently with sync.wait_group_wait") + panic_contextless("sync.Wait_Group misuse: sync.wait_group_add called concurrently with sync.wait_group_wait") } } } @@ -105,7 +105,7 @@ wait_group_wait_with_timeout :: proc "contextless" (wg: ^Wait_Group, duration: t return false } if wg.counter != 0 { - _panic("sync.Wait_Group misuse: sync.wait_group_add called concurrently with sync.wait_group_wait") + panic_contextless("sync.Wait_Group misuse: sync.wait_group_add called concurrently with sync.wait_group_wait") } } return true @@ -494,7 +494,7 @@ for other threads for entering. */ recursive_benaphore_unlock :: proc "contextless" (b: ^Recursive_Benaphore) { tid := current_thread_id() - _assert(tid == b.owner, "tid != b.owner") + assert_contextless(tid == b.owner, "tid != b.owner") b.recursion -= 1 recursion := b.recursion if recursion == 0 { diff --git a/core/sync/futex_darwin.odin b/core/sync/futex_darwin.odin index fca9aadfe..daefd6699 100644 --- a/core/sync/futex_darwin.odin +++ b/core/sync/futex_darwin.odin @@ -48,7 +48,7 @@ _futex_wait_with_timeout :: proc "contextless" (f: ^Futex, expected: u32, durati case -ETIMEDOUT: return false case: - _panic("darwin.os_sync_wait_on_address_with_timeout failure") + panic_contextless("darwin.os_sync_wait_on_address_with_timeout failure") } } else { @@ -63,7 +63,7 @@ _futex_wait_with_timeout :: proc "contextless" (f: ^Futex, expected: u32, durati case ETIMEDOUT: return false case: - _panic("futex_wait failure") + panic_contextless("futex_wait failure") } return true @@ -83,7 +83,7 @@ _futex_signal :: proc "contextless" (f: ^Futex) { case -ENOENT: return case: - _panic("darwin.os_sync_wake_by_address_any failure") + panic_contextless("darwin.os_sync_wake_by_address_any failure") } } } else { @@ -99,7 +99,7 @@ _futex_signal :: proc "contextless" (f: ^Futex) { case ENOENT: return case: - _panic("futex_wake_single failure") + panic_contextless("futex_wake_single failure") } } @@ -119,7 +119,7 @@ _futex_broadcast :: proc "contextless" (f: ^Futex) { case -ENOENT: return case: - _panic("darwin.os_sync_wake_by_address_all failure") + panic_contextless("darwin.os_sync_wake_by_address_all failure") } } } else { @@ -135,7 +135,7 @@ _futex_broadcast :: proc "contextless" (f: ^Futex) { case ENOENT: return case: - _panic("futex_wake_all failure") + panic_contextless("futex_wake_all failure") } } diff --git a/core/sync/futex_freebsd.odin b/core/sync/futex_freebsd.odin index ac6e2400a..82021a71a 100644 --- a/core/sync/futex_freebsd.odin +++ b/core/sync/futex_freebsd.odin @@ -21,7 +21,7 @@ _futex_wait :: proc "contextless" (f: ^Futex, expected: u32) -> bool { continue } - _panic("_futex_wait failure") + panic_contextless("_futex_wait failure") } unreachable() @@ -44,14 +44,14 @@ _futex_wait_with_timeout :: proc "contextless" (f: ^Futex, expected: u32, durati return false } - _panic("_futex_wait_with_timeout failure") + panic_contextless("_futex_wait_with_timeout failure") } _futex_signal :: proc "contextless" (f: ^Futex) { errno := freebsd._umtx_op(f, .WAKE, 1, nil, nil) if errno != nil { - _panic("_futex_signal failure") + panic_contextless("_futex_signal failure") } } @@ -59,6 +59,6 @@ _futex_broadcast :: proc "contextless" (f: ^Futex) { errno := freebsd._umtx_op(f, .WAKE, cast(c.ulong)max(i32), nil, nil) if errno != nil { - _panic("_futex_broadcast failure") + panic_contextless("_futex_broadcast failure") } } diff --git a/core/sync/futex_linux.odin b/core/sync/futex_linux.odin index fe57c12ed..4d9101b9f 100644 --- a/core/sync/futex_linux.odin +++ b/core/sync/futex_linux.odin @@ -15,7 +15,7 @@ _futex_wait :: proc "contextless" (futex: ^Futex, expected: u32) -> bool { return true case: // TODO(flysand): More descriptive panic messages based on the vlaue of `errno` - _panic("futex_wait failure") + panic_contextless("futex_wait failure") } } @@ -34,7 +34,7 @@ _futex_wait_with_timeout :: proc "contextless" (futex: ^Futex, expected: u32, du case .NONE, .EINTR, .EAGAIN: return true case: - _panic("futex_wait_with_timeout failure") + panic_contextless("futex_wait_with_timeout failure") } } @@ -44,7 +44,7 @@ _futex_signal :: proc "contextless" (futex: ^Futex) { case .NONE: return case: - _panic("futex_wake_single failure") + panic_contextless("futex_wake_single failure") } } @@ -57,6 +57,6 @@ _futex_broadcast :: proc "contextless" (futex: ^Futex) { case .NONE: return case: - _panic("_futex_wake_all failure") + panic_contextless("_futex_wake_all failure") } } diff --git a/core/sync/futex_netbsd.odin b/core/sync/futex_netbsd.odin index d12409f32..f81a12675 100644 --- a/core/sync/futex_netbsd.odin +++ b/core/sync/futex_netbsd.odin @@ -35,7 +35,7 @@ _futex_wait :: proc "contextless" (futex: ^Futex, expected: u32) -> bool { case EINTR, EAGAIN: return true case: - _panic("futex_wait failure") + panic_contextless("futex_wait failure") } } return true @@ -55,7 +55,7 @@ _futex_wait_with_timeout :: proc "contextless" (futex: ^Futex, expected: u32, du case ETIMEDOUT: return false case: - _panic("futex_wait_with_timeout failure") + panic_contextless("futex_wait_with_timeout failure") } } return true @@ -63,12 +63,12 @@ _futex_wait_with_timeout :: proc "contextless" (futex: ^Futex, expected: u32, du _futex_signal :: proc "contextless" (futex: ^Futex) { if _, ok := intrinsics.syscall_bsd(unix.SYS___futex, uintptr(futex), FUTEX_WAKE_PRIVATE, 1, 0, 0, 0); !ok { - _panic("futex_wake_single failure") + panic_contextless("futex_wake_single failure") } } _futex_broadcast :: proc "contextless" (futex: ^Futex) { if _, ok := intrinsics.syscall_bsd(unix.SYS___futex, uintptr(futex), FUTEX_WAKE_PRIVATE, uintptr(max(i32)), 0, 0, 0); !ok { - _panic("_futex_wake_all failure") + panic_contextless("_futex_wake_all failure") } } diff --git a/core/sync/futex_openbsd.odin b/core/sync/futex_openbsd.odin index 4883a0841..1ffe4a9a5 100644 --- a/core/sync/futex_openbsd.odin +++ b/core/sync/futex_openbsd.odin @@ -36,7 +36,7 @@ _futex_wait :: proc "contextless" (f: ^Futex, expected: u32) -> bool { return false } - _panic("futex_wait failure") + panic_contextless("futex_wait failure") } _futex_wait_with_timeout :: proc "contextless" (f: ^Futex, expected: u32, duration: time.Duration) -> bool { @@ -62,14 +62,14 @@ _futex_wait_with_timeout :: proc "contextless" (f: ^Futex, expected: u32, durati return false } - _panic("futex_wait_with_timeout failure") + panic_contextless("futex_wait_with_timeout failure") } _futex_signal :: proc "contextless" (f: ^Futex) { res := _unix_futex(f, FUTEX_WAKE_PRIVATE, 1, nil) if res == -1 { - _panic("futex_wake_single failure") + panic_contextless("futex_wake_single failure") } } @@ -77,6 +77,6 @@ _futex_broadcast :: proc "contextless" (f: ^Futex) { res := _unix_futex(f, FUTEX_WAKE_PRIVATE, u32(max(i32)), nil) if res == -1 { - _panic("_futex_wake_all failure") + panic_contextless("_futex_wake_all failure") } } diff --git a/core/sync/futex_wasm.odin b/core/sync/futex_wasm.odin index de88e8198..27532587c 100644 --- a/core/sync/futex_wasm.odin +++ b/core/sync/futex_wasm.odin @@ -10,7 +10,7 @@ import "core:time" _futex_wait :: proc "contextless" (f: ^Futex, expected: u32) -> bool { when !intrinsics.has_target_feature("atomics") { - _panic("usage of `core:sync` requires the `-target-feature:\"atomics\"` or a `-microarch` that supports it") + panic_contextless("usage of `core:sync` requires the `-target-feature:\"atomics\"` or a `-microarch` that supports it") } else { s := intrinsics.wasm_memory_atomic_wait32((^u32)(f), expected, -1) return s != 0 @@ -19,7 +19,7 @@ _futex_wait :: proc "contextless" (f: ^Futex, expected: u32) -> bool { _futex_wait_with_timeout :: proc "contextless" (f: ^Futex, expected: u32, duration: time.Duration) -> bool { when !intrinsics.has_target_feature("atomics") { - _panic("usage of `core:sync` requires the `-target-feature:\"atomics\"` or a `-microarch` that supports it") + panic_contextless("usage of `core:sync` requires the `-target-feature:\"atomics\"` or a `-microarch` that supports it") } else { s := intrinsics.wasm_memory_atomic_wait32((^u32)(f), expected, i64(duration)) return s != 0 @@ -28,7 +28,7 @@ _futex_wait_with_timeout :: proc "contextless" (f: ^Futex, expected: u32, durati _futex_signal :: proc "contextless" (f: ^Futex) { when !intrinsics.has_target_feature("atomics") { - _panic("usage of `core:sync` requires the `-target-feature:\"atomics\"` or a `-microarch` that supports it") + panic_contextless("usage of `core:sync` requires the `-target-feature:\"atomics\"` or a `-microarch` that supports it") } else { loop: for { s := intrinsics.wasm_memory_atomic_notify32((^u32)(f), 1) @@ -41,7 +41,7 @@ _futex_signal :: proc "contextless" (f: ^Futex) { _futex_broadcast :: proc "contextless" (f: ^Futex) { when !intrinsics.has_target_feature("atomics") { - _panic("usage of `core:sync` requires the `-target-feature:\"atomics\"` or a `-microarch` that supports it") + panic_contextless("usage of `core:sync` requires the `-target-feature:\"atomics\"` or a `-microarch` that supports it") } else { loop: for { s := intrinsics.wasm_memory_atomic_notify32((^u32)(f), ~u32(0)) diff --git a/core/sync/primitives.odin b/core/sync/primitives.odin index a22824481..8187c904b 100644 --- a/core/sync/primitives.odin +++ b/core/sync/primitives.odin @@ -1,6 +1,5 @@ package sync -import "base:runtime" import "core:time" /* @@ -560,7 +559,7 @@ futex_wait :: proc "contextless" (f: ^Futex, expected: u32) { return } ok := _futex_wait(f, expected) - _assert(ok, "futex_wait failure") + assert_contextless(ok, "futex_wait failure") } /* @@ -597,18 +596,3 @@ Wake up multiple threads waiting on a futex. futex_broadcast :: proc "contextless" (f: ^Futex) { _futex_broadcast(f) } - - -@(private) -_assert :: proc "contextless" (cond: bool, msg: string) { - if !cond { - _panic(msg) - } -} - -@(private) -_panic :: proc "contextless" (msg: string) -> ! { - runtime.print_string(msg) - runtime.print_byte('\n') - runtime.trap() -} diff --git a/core/sync/primitives_atomic.odin b/core/sync/primitives_atomic.odin index 076a74b20..3c4324eb7 100644 --- a/core/sync/primitives_atomic.odin +++ b/core/sync/primitives_atomic.odin @@ -240,7 +240,7 @@ atomic_recursive_mutex_lock :: proc "contextless" (m: ^Atomic_Recursive_Mutex) { atomic_recursive_mutex_unlock :: proc "contextless" (m: ^Atomic_Recursive_Mutex) { tid := current_thread_id() - _assert(tid == m.owner, "tid != m.owner") + assert_contextless(tid == m.owner, "tid != m.owner") m.recursion -= 1 recursion := m.recursion if recursion == 0 { From 73f5ab473c4129ae209838d7967286684ac3f462 Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Mon, 9 Sep 2024 14:18:01 -0400 Subject: [PATCH 40/72] Keep `chan.can_recv` from deadlocking --- core/sync/chan/chan.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sync/chan/chan.odin b/core/sync/chan/chan.odin index 53a3bff4b..aca08d82e 100644 --- a/core/sync/chan/chan.odin +++ b/core/sync/chan/chan.odin @@ -423,7 +423,7 @@ raw_queue_pop :: proc "contextless" (q: ^Raw_Queue) -> (data: rawptr) { can_recv :: proc "contextless" (c: ^Raw_Chan) -> bool { sync.guard(&c.mutex) if is_buffered(c) { - return len(c) > 0 + return c.queue.len > 0 } return sync.atomic_load(&c.w_waiting) > 0 } From 026aef69e3a42021c5d9666737c7401dc75dc89a Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Mon, 9 Sep 2024 14:42:50 -0400 Subject: [PATCH 41/72] Fix deadlock on sending to full, buffered, closed `Chan` This will also keep messages from being sent to closed, buffered channels in general. --- core/sync/chan/chan.odin | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/core/sync/chan/chan.odin b/core/sync/chan/chan.odin index aca08d82e..cb299f23f 100644 --- a/core/sync/chan/chan.odin +++ b/core/sync/chan/chan.odin @@ -164,12 +164,17 @@ send_raw :: proc "contextless" (c: ^Raw_Chan, msg_in: rawptr) -> (ok: bool) { } if c.queue != nil { // buffered sync.guard(&c.mutex) - for c.queue.len == c.queue.cap { + for !sync.atomic_load(&c.closed) && + c.queue.len == c.queue.cap { sync.atomic_add(&c.w_waiting, 1) sync.wait(&c.w_cond, &c.mutex) sync.atomic_sub(&c.w_waiting, 1) } + if sync.atomic_load(&c.closed) { + return false + } + ok = raw_queue_push(c.queue, msg_in) if sync.atomic_load(&c.r_waiting) > 0 { sync.signal(&c.r_cond) From e9a6a344809daf5c0a3b725dd52e1527382d8c41 Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Mon, 9 Sep 2024 16:04:18 -0400 Subject: [PATCH 42/72] Forbid `chan.try_send` on closed buffered channels --- core/sync/chan/chan.odin | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/core/sync/chan/chan.odin b/core/sync/chan/chan.odin index cb299f23f..f0b04f3b4 100644 --- a/core/sync/chan/chan.odin +++ b/core/sync/chan/chan.odin @@ -260,6 +260,10 @@ try_send_raw :: proc "contextless" (c: ^Raw_Chan, msg_in: rawptr) -> (ok: bool) return false } + if sync.atomic_load(&c.closed) { + return false + } + ok = raw_queue_push(c.queue, msg_in) if sync.atomic_load(&c.r_waiting) > 0 { sync.signal(&c.r_cond) From 8a14a656fbd8843628b61e5a20877b40b772482c Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Mon, 9 Sep 2024 16:05:29 -0400 Subject: [PATCH 43/72] Fix `chan.can_send` for unbuffered channels `w_waiting` is the signal that says a caller is waiting to be able to send something. It is incremented upon send and - in the case of an unbuffered channel - it can only hold one message. Therefore, check that `w_waiting` is zero instead. --- core/sync/chan/chan.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sync/chan/chan.odin b/core/sync/chan/chan.odin index f0b04f3b4..5b9a764b4 100644 --- a/core/sync/chan/chan.odin +++ b/core/sync/chan/chan.odin @@ -444,7 +444,7 @@ can_send :: proc "contextless" (c: ^Raw_Chan) -> bool { if is_buffered(c) { return c.queue.len < c.queue.cap } - return sync.atomic_load(&c.r_waiting) > 0 + return sync.atomic_load(&c.w_waiting) == 0 } From 074314b8874886f8956e9a7e9a773ac059051030 Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Mon, 9 Sep 2024 18:38:29 -0400 Subject: [PATCH 44/72] Fix data race in `test_core_flags` --- tests/core/flags/test_core_flags.odin | 33 ++++++++++++++++----------- 1 file changed, 20 insertions(+), 13 deletions(-) diff --git a/tests/core/flags/test_core_flags.odin b/tests/core/flags/test_core_flags.odin index f8305f2ea..8fcd6a8a7 100644 --- a/tests/core/flags/test_core_flags.odin +++ b/tests/core/flags/test_core_flags.odin @@ -12,6 +12,26 @@ import "core:strings" import "core:testing" import "core:time/datetime" +Custom_Data :: struct { + a: int, +} + +@(init) +init_custom_type_setter :: proc() { + // NOTE: This is done here so it can be out of the flow of the + // multi-threaded test runner, to prevent any data races that could be + // reported by using `-sanitize:thread`. + // + // Do mind that this means every test here acknowledges the `Custom_Data` type. + flags.register_type_setter(proc (data: rawptr, data_type: typeid, _, _: string) -> (string, bool, runtime.Allocator_Error) { + if data_type == Custom_Data { + (cast(^Custom_Data)data).a = 32 + return "", true, nil + } + return "", false, nil + }) +} + @(test) test_no_args :: proc(t: ^testing.T) { S :: struct { @@ -1230,9 +1250,6 @@ test_net :: proc(t: ^testing.T) { @(test) test_custom_type_setter :: proc(t: ^testing.T) { Custom_Bool :: distinct bool - Custom_Data :: struct { - a: int, - } S :: struct { a: Custom_Data, @@ -1240,16 +1257,6 @@ test_custom_type_setter :: proc(t: ^testing.T) { } s: S - // NOTE: Mind that this setter is global state, and the test runner is multi-threaded. - // It should be fine so long as all type setter tests are in this one test proc. - flags.register_type_setter(proc (data: rawptr, data_type: typeid, _, _: string) -> (string, bool, runtime.Allocator_Error) { - if data_type == Custom_Data { - (cast(^Custom_Data)data).a = 32 - return "", true, nil - } - return "", false, nil - }) - defer flags.register_type_setter(nil) args := [?]string { "-a:hellope", "-b:true" } result := flags.parse(&s, args[:]) testing.expect_value(t, result, nil) From 3a6010918033e1548e84d57a07074cdbf802ff9b Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Mon, 9 Sep 2024 19:09:16 -0400 Subject: [PATCH 45/72] Fix signalling test child threads crashing test 0 A thread made inside a test does not share the test index of its parent, so any time one of those threads failed an assert, it would tell the runner to shutdown test index zero. --- core/testing/signal_handler_libc.odin | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/core/testing/signal_handler_libc.odin b/core/testing/signal_handler_libc.odin index 27d1a0735..e2d170595 100644 --- a/core/testing/signal_handler_libc.odin +++ b/core/testing/signal_handler_libc.odin @@ -26,6 +26,8 @@ import "core:os" @(private="file", thread_local) local_test_index: libc.sig_atomic_t +@(private="file", thread_local) +local_test_index_set: bool // Windows does not appear to have a SIGTRAP, so this is defined here, instead // of in the libc package, just so there's no confusion about it being @@ -45,6 +47,13 @@ stop_runner_callback :: proc "c" (sig: libc.int) { @(private="file") stop_test_callback :: proc "c" (sig: libc.int) { + if !local_test_index_set { + // We're a thread created by a test thread. + // + // There's nothing we can do to inform the test runner about who + // signalled, so hopefully the test will handle their own sub-threads. + return + } if local_test_index == -1 { // We're the test runner, and we ourselves have caught a signal from // which there is no recovery. @@ -114,6 +123,7 @@ This is a dire bug and should be reported to the Odin developers. _setup_signal_handler :: proc() { local_test_index = -1 + local_test_index_set = true // Catch user interrupt / CTRL-C. libc.signal(libc.SIGINT, stop_runner_callback) @@ -135,6 +145,7 @@ _setup_signal_handler :: proc() { _setup_task_signal_handler :: proc(test_index: int) { local_test_index = cast(libc.sig_atomic_t)test_index + local_test_index_set = true } _should_stop_runner :: proc() -> bool { From b2c2235e587bb8902dbf35ef84373bb5f616a814 Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Mon, 9 Sep 2024 19:11:44 -0400 Subject: [PATCH 46/72] Fix `recursive_benaphore_try_lock` Previously, if the owner called this, it would fail. --- core/sync/extended.odin | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/core/sync/extended.odin b/core/sync/extended.odin index 83cc648b4..d5521935a 100644 --- a/core/sync/extended.odin +++ b/core/sync/extended.odin @@ -474,10 +474,10 @@ recursive_benaphore_try_lock :: proc "contextless" (b: ^Recursive_Benaphore) -> tid := current_thread_id() if b.owner == tid { atomic_add_explicit(&b.counter, 1, .Acquire) - } - - if v, _ := atomic_compare_exchange_strong_explicit(&b.counter, 0, 1, .Acquire, .Acquire); v != 0 { - return false + } else { + if v, _ := atomic_compare_exchange_strong_explicit(&b.counter, 0, 1, .Acquire, .Acquire); v != 0 { + return false + } } // inside the lock b.owner = tid From f16ed256eaf90fb0fed1e795f6c62cd356180422 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Wed, 11 Sep 2024 08:00:27 +1100 Subject: [PATCH 47/72] [mem]: Fix handling of default resize to check alignment --- base/runtime/internal.odin | 11 +++++++---- core/mem/alloc.odin | 2 +- core/mem/mem.odin | 11 +++++++++++ 3 files changed, 19 insertions(+), 5 deletions(-) diff --git a/base/runtime/internal.odin b/base/runtime/internal.odin index ff60cf547..a0bda9d40 100644 --- a/base/runtime/internal.odin +++ b/base/runtime/internal.odin @@ -118,16 +118,15 @@ mem_copy_non_overlapping :: proc "contextless" (dst, src: rawptr, len: int) -> r DEFAULT_ALIGNMENT :: 2*align_of(rawptr) mem_alloc_bytes :: #force_inline proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) { - if size == 0 { - return nil, nil - } - if allocator.procedure == nil { + assert(is_power_of_two_int(alignment), "Alignment must be a power of two", loc) + if size == 0 || allocator.procedure == nil{ return nil, nil } return allocator.procedure(allocator.data, .Alloc, size, alignment, nil, 0, loc) } mem_alloc :: #force_inline proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) { + assert(is_power_of_two_int(alignment), "Alignment must be a power of two", loc) if size == 0 || allocator.procedure == nil { return nil, nil } @@ -135,6 +134,7 @@ mem_alloc :: #force_inline proc(size: int, alignment: int = DEFAULT_ALIGNMENT, a } mem_alloc_non_zeroed :: #force_inline proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) { + assert(is_power_of_two_int(alignment), "Alignment must be a power of two", loc) if size == 0 || allocator.procedure == nil { return nil, nil } @@ -174,6 +174,7 @@ mem_free_all :: #force_inline proc(allocator := context.allocator, loc := #calle } _mem_resize :: #force_inline proc(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, should_zero: bool, loc := #caller_location) -> (data: []byte, err: Allocator_Error) { + assert(is_power_of_two_int(alignment), "Alignment must be a power of two", loc) if allocator.procedure == nil { return nil, nil } @@ -215,9 +216,11 @@ _mem_resize :: #force_inline proc(ptr: rawptr, old_size, new_size: int, alignmen } mem_resize :: proc(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> (data: []byte, err: Allocator_Error) { + assert(is_power_of_two_int(alignment), "Alignment must be a power of two", loc) return _mem_resize(ptr, old_size, new_size, alignment, allocator, true, loc) } non_zero_mem_resize :: proc(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> (data: []byte, err: Allocator_Error) { + assert(is_power_of_two_int(alignment), "Alignment must be a power of two", loc) return _mem_resize(ptr, old_size, new_size, alignment, allocator, false, loc) } diff --git a/core/mem/alloc.odin b/core/mem/alloc.odin index 1ede92837..5f65e9ebc 100644 --- a/core/mem/alloc.odin +++ b/core/mem/alloc.odin @@ -1096,7 +1096,7 @@ _default_resize_bytes_align :: #force_inline proc( err := free_bytes(old_data, allocator, loc) return nil, err } - if new_size == old_size { + if new_size == old_size && is_aligned(old_memory, alignment) { return old_data, .None } new_memory : []byte diff --git a/core/mem/mem.odin b/core/mem/mem.odin index 0554cee23..b57b18ffc 100644 --- a/core/mem/mem.odin +++ b/core/mem/mem.odin @@ -456,6 +456,17 @@ is_power_of_two :: proc "contextless" (x: uintptr) -> bool { return (x & (x-1)) == 0 } +/* +Check if a pointer is aligned. + +This procedure checks whether a pointer `x` is aligned to a boundary specified +by `align`, and returns `true` if the pointer is aligned, and false otherwise. +*/ +is_aligned :: proc "contextless" (x: rawptr, align: int) -> bool { + p := uintptr(x) + return (p & (1< Date: Mon, 9 Sep 2024 19:15:06 -0400 Subject: [PATCH 48/72] Fix data races in `sync.Recursive_Benaphore` --- core/sync/extended.odin | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/core/sync/extended.odin b/core/sync/extended.odin index d5521935a..924ba92a6 100644 --- a/core/sync/extended.odin +++ b/core/sync/extended.odin @@ -449,13 +449,15 @@ recursive benaphore, until the lock is released. */ recursive_benaphore_lock :: proc "contextless" (b: ^Recursive_Benaphore) { tid := current_thread_id() - if atomic_add_explicit(&b.counter, 1, .Acquire) > 1 { - if tid != b.owner { - sema_wait(&b.sema) + check_owner: if tid != atomic_load_explicit(&b.owner, .Acquire) { + atomic_add_explicit(&b.counter, 1, .Relaxed) + if _, ok := atomic_compare_exchange_strong_explicit(&b.owner, 0, tid, .Release, .Relaxed); ok { + break check_owner } + sema_wait(&b.sema) + atomic_store_explicit(&b.owner, tid, .Release) } // inside the lock - b.owner = tid b.recursion += 1 } @@ -472,15 +474,14 @@ benaphore, until the lock is released. */ recursive_benaphore_try_lock :: proc "contextless" (b: ^Recursive_Benaphore) -> bool { tid := current_thread_id() - if b.owner == tid { - atomic_add_explicit(&b.counter, 1, .Acquire) - } else { - if v, _ := atomic_compare_exchange_strong_explicit(&b.counter, 0, 1, .Acquire, .Acquire); v != 0 { - return false + check_owner: if tid != atomic_load_explicit(&b.owner, .Acquire) { + if _, ok := atomic_compare_exchange_strong_explicit(&b.owner, 0, tid, .Release, .Relaxed); ok { + atomic_add_explicit(&b.counter, 1, .Relaxed) + break check_owner } + return false } // inside the lock - b.owner = tid b.recursion += 1 return true } @@ -494,14 +495,14 @@ for other threads for entering. */ recursive_benaphore_unlock :: proc "contextless" (b: ^Recursive_Benaphore) { tid := current_thread_id() - assert_contextless(tid == b.owner, "tid != b.owner") + assert_contextless(tid == atomic_load_explicit(&b.owner, .Relaxed), "tid != b.owner") b.recursion -= 1 recursion := b.recursion + if recursion == 0 { - b.owner = 0 - } - if atomic_sub_explicit(&b.counter, 1, .Release) > 0 { - if recursion == 0 { + if atomic_sub_explicit(&b.counter, 1, .Relaxed) == 1 { + atomic_store_explicit(&b.owner, 0, .Release) + } else { sema_post(&b.sema) } } From a1435a6a904b2eb2b154a463c5d60f6c1f55abbc Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Tue, 10 Sep 2024 14:51:00 -0400 Subject: [PATCH 49/72] Fix deadlock in `Auto_Reset_Event` --- core/sync/extended.odin | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/core/sync/extended.odin b/core/sync/extended.odin index 924ba92a6..0971516a3 100644 --- a/core/sync/extended.odin +++ b/core/sync/extended.odin @@ -228,15 +228,14 @@ thread. */ auto_reset_event_signal :: proc "contextless" (e: ^Auto_Reset_Event) { old_status := atomic_load_explicit(&e.status, .Relaxed) + new_status := old_status + 1 if old_status < 1 else 1 for { - new_status := old_status + 1 if old_status < 1 else 1 if _, ok := atomic_compare_exchange_weak_explicit(&e.status, old_status, new_status, .Release, .Relaxed); ok { break } - - if old_status < 0 { - sema_post(&e.sema) - } + } + if old_status < 0 { + sema_post(&e.sema) } } From b1db33b519bf52e2d0e6e42ca9daccc7470d6b8b Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Tue, 10 Sep 2024 19:04:44 -0400 Subject: [PATCH 50/72] Add `cpu_relax` to `sync.auto_reset_event_signal` --- core/sync/extended.odin | 1 + 1 file changed, 1 insertion(+) diff --git a/core/sync/extended.odin b/core/sync/extended.odin index 0971516a3..0b1f79df2 100644 --- a/core/sync/extended.odin +++ b/core/sync/extended.odin @@ -233,6 +233,7 @@ auto_reset_event_signal :: proc "contextless" (e: ^Auto_Reset_Event) { if _, ok := atomic_compare_exchange_weak_explicit(&e.status, old_status, new_status, .Release, .Relaxed); ok { break } + cpu_relax() } if old_status < 0 { sema_post(&e.sema) From 2938655a3d8801d1327b0076812edcf357d760df Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Wed, 11 Sep 2024 07:07:09 -0400 Subject: [PATCH 51/72] Fix CPU count detection in FreeBSD & NetBSD --- core/os/os_freebsd.odin | 2 +- core/os/os_netbsd.odin | 2 +- src/gb/gb.h | 12 ++++++++++-- 3 files changed, 12 insertions(+), 4 deletions(-) diff --git a/core/os/os_freebsd.odin b/core/os/os_freebsd.odin index c05a06129..241f42c0b 100644 --- a/core/os/os_freebsd.odin +++ b/core/os/os_freebsd.odin @@ -920,7 +920,7 @@ get_page_size :: proc() -> int { _processor_core_count :: proc() -> int { count : int = 0 count_size := size_of(count) - if _sysctlbyname("hw.logicalcpu", &count, &count_size, nil, 0) == 0 { + if _sysctlbyname("hw.ncpu", &count, &count_size, nil, 0) == 0 { if count > 0 { return count } diff --git a/core/os/os_netbsd.odin b/core/os/os_netbsd.odin index a56c0b784..ba9b40fc3 100644 --- a/core/os/os_netbsd.odin +++ b/core/os/os_netbsd.odin @@ -978,7 +978,7 @@ get_page_size :: proc() -> int { _processor_core_count :: proc() -> int { count : int = 0 count_size := size_of(count) - if _sysctlbyname("hw.logicalcpu", &count, &count_size, nil, 0) == 0 { + if _sysctlbyname("hw.ncpu", &count, &count_size, nil, 0) == 0 { if count > 0 { return count } diff --git a/src/gb/gb.h b/src/gb/gb.h index 0e65696e2..1fef4b4f5 100644 --- a/src/gb/gb.h +++ b/src/gb/gb.h @@ -3195,11 +3195,11 @@ void gb_affinity_init(gbAffinity *a) { a->core_count = 1; a->threads_per_core = 1; - if (sysctlbyname("hw.logicalcpu", &count, &count_size, NULL, 0) == 0) { + if (sysctlbyname("kern.smp.cpus", &count, &count_size, NULL, 0) == 0) { if (count > 0) { a->thread_count = count; // Get # of physical cores - if (sysctlbyname("hw.physicalcpu", &count, &count_size, NULL, 0) == 0) { + if (sysctlbyname("kern.smp.cores", &count, &count_size, NULL, 0) == 0) { if (count > 0) { a->core_count = count; a->threads_per_core = a->thread_count / count; @@ -3210,6 +3210,14 @@ void gb_affinity_init(gbAffinity *a) { } } } + } else if (sysctlbyname("hw.ncpu", &count, &count_size, NULL, 0) == 0) { + // SMP disabled or unavailable. + if (count > 0) { + a->is_accurate = true; + a->thread_count = count; + a->core_count = count; + a->threads_per_core = 1; + } } } From 16cd16b91e9cabfba2d12e271712ca55cb16fa7d Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Sun, 8 Sep 2024 18:23:28 -0400 Subject: [PATCH 52/72] Fix comments --- core/sync/extended.odin | 18 +++++++++--------- core/sync/primitives.odin | 2 +- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/core/sync/extended.odin b/core/sync/extended.odin index 0b1f79df2..30b1b2770 100644 --- a/core/sync/extended.odin +++ b/core/sync/extended.odin @@ -8,7 +8,7 @@ _ :: vg Wait group. Wait group is a synchronization primitive used by the waiting thread to wait, -until a all working threads finish work. +until all working threads finish work. The waiting thread first sets the number of working threads it will expect to wait for using `wait_group_add` call, and start waiting using `wait_group_wait` @@ -35,7 +35,7 @@ Wait_Group :: struct #no_copy { /* Increment an internal counter of a wait group. -This procedure atomicaly increments a number to the specified wait group's +This procedure atomically increments a number to the specified wait group's internal counter by a specified amount. This operation can be done on any thread. */ @@ -121,7 +121,7 @@ When `barrier_wait` procedure is called by any thread, that thread will block the execution, until all threads associated with the barrier reach the same point of execution and also call `barrier_wait`. -when barrier is initialized, a `thread_count` parameter is passed, signifying +When a barrier is initialized, a `thread_count` parameter is passed, signifying the amount of participant threads of the barrier. The barrier also keeps track of an internal atomic counter. When a thread calls `barrier_wait`, the internal counter is incremented. When the internal counter reaches `thread_count`, it is @@ -208,7 +208,7 @@ Represents a thread synchronization primitive that, when signalled, releases one single waiting thread and then resets automatically to a state where it can be signalled again. -When a thread calls `auto_reset_event_wait`, it's execution will be blocked, +When a thread calls `auto_reset_event_wait`, its execution will be blocked, until the event is signalled by another thread. The call to `auto_reset_event_signal` wakes up exactly one thread waiting for the event. */ @@ -331,8 +331,8 @@ Benaphore. A benaphore is a combination of an atomic variable and a semaphore that can improve locking efficiency in a no-contention system. Acquiring a benaphore -lock doesn't call into an internal semaphore, if no other thread in a middle of -a critical section. +lock doesn't call into an internal semaphore, if no other thread is in the +middle of a critical section. Once a lock on a benaphore is acquired by a thread, no other thread is allowed into any critical sections, associted with the same benaphore, until the lock @@ -381,7 +381,7 @@ Release a lock on a benaphore. This procedure releases a lock on the specified benaphore. If any of the threads are waiting on the lock, exactly one thread is allowed into a critical section -associated with the same banaphore. +associated with the same benaphore. */ benaphore_unlock :: proc "contextless" (b: ^Benaphore) { if atomic_sub_explicit(&b.counter, 1, .Release) > 1 { @@ -418,8 +418,8 @@ benaphore_guard :: proc "contextless" (m: ^Benaphore) -> bool { /* Recursive benaphore. -Recurisve benaphore is just like a plain benaphore, except it allows reentrancy -into the critical section. +A recursive benaphore is just like a plain benaphore, except it allows +reentrancy into the critical section. When a lock is acquired on a benaphore, all other threads attempting to acquire a lock on the same benaphore will be blocked from any critical sections, diff --git a/core/sync/primitives.odin b/core/sync/primitives.odin index 8187c904b..f091de045 100644 --- a/core/sync/primitives.odin +++ b/core/sync/primitives.odin @@ -389,7 +389,7 @@ recursive_mutex_guard :: proc "contextless" (m: ^Recursive_Mutex) -> bool { A condition variable. `Cond` implements a condition variable, a rendezvous point for threads waiting -for signalling the occurence of an event. Condition variables are used on +for signalling the occurence of an event. Condition variables are used in conjuction with mutexes to provide a shared access to one or more shared variable. From 7f7cfebc91cc319918bc0042789b0c7a931e56e2 Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Mon, 9 Sep 2024 16:17:08 -0400 Subject: [PATCH 53/72] Add tests for `core:sync` and `core:sync/chan` --- tests/core/normal.odin | 2 + tests/core/sync/chan/test_core_sync_chan.odin | 274 +++++++ tests/core/sync/test_core_sync.odin | 718 ++++++++++++++++++ 3 files changed, 994 insertions(+) create mode 100644 tests/core/sync/chan/test_core_sync_chan.odin create mode 100644 tests/core/sync/test_core_sync.odin diff --git a/tests/core/normal.odin b/tests/core/normal.odin index 6174f2d5c..0670842ac 100644 --- a/tests/core/normal.odin +++ b/tests/core/normal.odin @@ -39,6 +39,8 @@ download_assets :: proc() { @(require) import "slice" @(require) import "strconv" @(require) import "strings" +@(require) import "sync" +@(require) import "sync/chan" @(require) import "sys/posix" @(require) import "sys/windows" @(require) import "text/i18n" diff --git a/tests/core/sync/chan/test_core_sync_chan.odin b/tests/core/sync/chan/test_core_sync_chan.odin new file mode 100644 index 000000000..9b8d9b354 --- /dev/null +++ b/tests/core/sync/chan/test_core_sync_chan.odin @@ -0,0 +1,274 @@ +package test_core_sync_chan + +import "base:runtime" +import "base:intrinsics" +import "core:log" +import "core:math/rand" +import "core:sync/chan" +import "core:testing" +import "core:thread" +import "core:time" + + +Message_Type :: enum i32 { + Result, + Add, + Multiply, + Subtract, + Divide, + End, +} + +Message :: struct { + type: Message_Type, + i: i64, +} + +Comm :: struct { + host: chan.Chan(Message), + client: chan.Chan(Message), + manual_buffering: bool, +} + +BUFFER_SIZE :: 8 +MAX_RAND :: 32 +FAIL_TIME :: 1 * time.Second +SLEEP_TIME :: 1 * time.Millisecond + +comm_client :: proc(th: ^thread.Thread) { + data := cast(^Comm)th.data + manual_buffering := data.manual_buffering + + n: i64 + + for manual_buffering && !chan.can_recv(data.host) { + thread.yield() + } + + recv_loop: for msg in chan.recv(data.host) { + #partial switch msg.type { + case .Add: n += msg.i + case .Multiply: n *= msg.i + case .Subtract: n -= msg.i + case .Divide: n /= msg.i + case .End: + break recv_loop + case: + panic("Unknown message type for client.") + } + + for manual_buffering && !chan.can_recv(data.host) { + thread.yield() + } + } + + for manual_buffering && !chan.can_send(data.host) { + thread.yield() + } + + chan.send(data.client, Message{.Result, n}) + chan.close(data.client) +} + +send_messages :: proc(t: ^testing.T, host: chan.Chan(Message), manual_buffering: bool = false) -> (expected: i64) { + expected = 1 + for manual_buffering && !chan.can_send(host) { + thread.yield() + } + chan.send(host, Message{.Add, 1}) + log.debug(Message{.Add, 1}) + + for _ in 0..<1+2*BUFFER_SIZE { + msg: Message + msg.i = 1 + rand.int63_max(MAX_RAND) + switch rand.int_max(4) { + case 0: + msg.type = .Add + expected += msg.i + case 1: + msg.type = .Multiply + expected *= msg.i + case 2: + msg.type = .Subtract + expected -= msg.i + case 3: + msg.type = .Divide + expected /= msg.i + } + + for manual_buffering && !chan.can_send(host) { + thread.yield() + } + if manual_buffering { + testing.expect(t, chan.len(host) == 0) + } + + chan.send(host, msg) + log.debug(msg) + } + + for manual_buffering && !chan.can_send(host) { + thread.yield() + } + chan.send(host, Message{.End, 0}) + log.debug(Message{.End, 0}) + chan.close(host) + + return +} + +@test +test_chan_buffered :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + comm: Comm + alloc_err: runtime.Allocator_Error + comm.host, alloc_err = chan.create_buffered(chan.Chan(Message), BUFFER_SIZE, context.allocator) + assert(alloc_err == nil, "allocation failed") + comm.client, alloc_err = chan.create_buffered(chan.Chan(Message), BUFFER_SIZE, context.allocator) + assert(alloc_err == nil, "allocation failed") + defer { + chan.destroy(comm.host) + chan.destroy(comm.client) + } + + testing.expect(t, chan.is_buffered(comm.host)) + testing.expect(t, chan.is_buffered(comm.client)) + testing.expect(t, !chan.is_unbuffered(comm.host)) + testing.expect(t, !chan.is_unbuffered(comm.client)) + testing.expect_value(t, chan.len(comm.host), 0) + testing.expect_value(t, chan.len(comm.client), 0) + testing.expect_value(t, chan.cap(comm.host), BUFFER_SIZE) + testing.expect_value(t, chan.cap(comm.client), BUFFER_SIZE) + + reckoner := thread.create(comm_client) + defer thread.destroy(reckoner) + reckoner.data = &comm + thread.start(reckoner) + + expected := send_messages(t, comm.host, manual_buffering = false) + + // Sleep so we can give the other thread enough time to buffer its message. + time.sleep(SLEEP_TIME) + + testing.expect_value(t, chan.len(comm.client), 1) + result, ok := chan.try_recv(comm.client) + + // One more sleep to ensure it has enough time to close. + time.sleep(SLEEP_TIME) + + testing.expect_value(t, chan.is_closed(comm.client), true) + testing.expect_value(t, ok, true) + testing.expect_value(t, result.i, expected) + log.debug(result, expected) + + // Make sure sending to closed channels fails. + testing.expect_value(t, chan.send(comm.host, Message{.End, 0}), false) + testing.expect_value(t, chan.send(comm.client, Message{.End, 0}), false) + testing.expect_value(t, chan.try_send(comm.host, Message{.End, 0}), false) + testing.expect_value(t, chan.try_send(comm.client, Message{.End, 0}), false) + _, ok = chan.recv(comm.host); testing.expect_value(t, ok, false) + _, ok = chan.recv(comm.client); testing.expect_value(t, ok, false) + _, ok = chan.try_recv(comm.host); testing.expect_value(t, ok, false) + _, ok = chan.try_recv(comm.client); testing.expect_value(t, ok, false) +} + +@test +test_chan_unbuffered :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + comm: Comm + comm.manual_buffering = true + alloc_err: runtime.Allocator_Error + comm.host, alloc_err = chan.create_unbuffered(chan.Chan(Message), context.allocator) + assert(alloc_err == nil, "allocation failed") + comm.client, alloc_err = chan.create_unbuffered(chan.Chan(Message), context.allocator) + assert(alloc_err == nil, "allocation failed") + defer { + chan.destroy(comm.host) + chan.destroy(comm.client) + } + + testing.expect(t, !chan.is_buffered(comm.host)) + testing.expect(t, !chan.is_buffered(comm.client)) + testing.expect(t, chan.is_unbuffered(comm.host)) + testing.expect(t, chan.is_unbuffered(comm.client)) + testing.expect_value(t, chan.len(comm.host), 0) + testing.expect_value(t, chan.len(comm.client), 0) + testing.expect_value(t, chan.cap(comm.host), 0) + testing.expect_value(t, chan.cap(comm.client), 0) + + reckoner := thread.create(comm_client) + defer thread.destroy(reckoner) + reckoner.data = &comm + thread.start(reckoner) + + for !chan.can_send(comm.client) { + thread.yield() + } + + expected := send_messages(t, comm.host) + testing.expect_value(t, chan.is_closed(comm.host), true) + + for !chan.can_recv(comm.client) { + thread.yield() + } + + result, ok := chan.try_recv(comm.client) + testing.expect_value(t, ok, true) + testing.expect_value(t, result.i, expected) + log.debug(result, expected) + + // Sleep so we can give the other thread enough time to close its side + // after we've received its message. + time.sleep(SLEEP_TIME) + + testing.expect_value(t, chan.is_closed(comm.client), true) + + // Make sure sending and receiving on closed channels fails. + testing.expect_value(t, chan.send(comm.host, Message{.End, 0}), false) + testing.expect_value(t, chan.send(comm.client, Message{.End, 0}), false) + testing.expect_value(t, chan.try_send(comm.host, Message{.End, 0}), false) + testing.expect_value(t, chan.try_send(comm.client, Message{.End, 0}), false) + _, ok = chan.recv(comm.host); testing.expect_value(t, ok, false) + _, ok = chan.recv(comm.client); testing.expect_value(t, ok, false) + _, ok = chan.try_recv(comm.host); testing.expect_value(t, ok, false) + _, ok = chan.try_recv(comm.client); testing.expect_value(t, ok, false) +} + +@test +test_full_buffered_closed_chan_deadlock :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + ch, alloc_err := chan.create_buffered(chan.Chan(int), 1, context.allocator) + assert(alloc_err == nil, "allocation failed") + defer chan.destroy(ch) + + testing.expect(t, chan.can_send(ch)) + testing.expect(t, chan.send(ch, 32)) + testing.expect(t, chan.close(ch)) + testing.expect(t, !chan.send(ch, 32)) +} + +// This test guarantees a buffered channel's messages can still be received +// even after closing. This is currently how the API works. If that changes, +// this test will need to change. +@test +test_accept_message_from_closed_buffered_chan :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + ch, alloc_err := chan.create_buffered(chan.Chan(int), 2, context.allocator) + assert(alloc_err == nil, "allocation failed") + defer chan.destroy(ch) + + testing.expect(t, chan.can_send(ch)) + testing.expect(t, chan.send(ch, 32)) + testing.expect(t, chan.send(ch, 64)) + testing.expect(t, chan.close(ch)) + result, ok := chan.recv(ch) + testing.expect_value(t, result, 32) + testing.expect(t, ok) + result, ok = chan.try_recv(ch) + testing.expect_value(t, result, 64) + testing.expect(t, ok) +} diff --git a/tests/core/sync/test_core_sync.odin b/tests/core/sync/test_core_sync.odin new file mode 100644 index 000000000..32c08f935 --- /dev/null +++ b/tests/core/sync/test_core_sync.odin @@ -0,0 +1,718 @@ +// NOTE(Feoramund): These tests should be run a few hundred times, with and +// without `-sanitize:thread` enabled, to ensure maximum safety. +// +// Keep in mind that running with the debug logs uncommented can result in +// failures disappearing due to the delay of sending the log message causing +// different synchronization patterns. +// +// These tests are temporarily disabled on Darwin, as there is currently a +// stall occurring which I cannot debug. + +//+build !darwin +package test_core_sync + +import "base:intrinsics" +// import "core:log" +import "core:sync" +import "core:testing" +import "core:thread" +import "core:time" + +FAIL_TIME :: 1 * time.Second +SLEEP_TIME :: 1 * time.Millisecond +SMALL_SLEEP_TIME :: 10 * time.Microsecond + +// This needs to be high enough to cause a data race if any of the +// synchronization primitives fail. +THREADS :: 8 + +// Manually wait on all threads to finish. +// +// This reduces a dependency on a `Wait_Group` or similar primitives. +// +// It's also important that we wait for every thread to finish, as it's +// possible for a thread to finish after the test if we don't check, despite +// joining it to the test thread. +wait_for :: proc(threads: []^thread.Thread) { + wait_loop: for { + count := len(threads) + for v in threads { + if thread.is_done(v) { + count -= 1 + } + } + if count == 0 { + break wait_loop + } + thread.yield() + } + for t in threads { + thread.join(t) + thread.destroy(t) + } +} + +// +// core:sync/primitives.odin +// + +@test +test_mutex :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + m: sync.Mutex, + number: int, + } + + p :: proc(th: ^thread.Thread) { + data := cast(^Data)th.data + + // log.debugf("MUTEX-%v> locking", th.id) + sync.mutex_lock(&data.m) + data.number += 1 + // log.debugf("MUTEX-%v> unlocking", th.id) + sync.mutex_unlock(&data.m) + // log.debugf("MUTEX-%v> leaving", th.id) + } + + data: Data + threads: [THREADS]^thread.Thread + + for &v in threads { + v = thread.create(p) + v.data = &data + v.init_context = context + thread.start(v) + } + + wait_for(threads[:]) + + testing.expect_value(t, data.number, THREADS) +} + +@test +test_rw_mutex :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + m1: sync.RW_Mutex, + m2: sync.RW_Mutex, + number1: int, + number2: int, + } + + p :: proc(th: ^thread.Thread) { + data := cast(^Data)th.data + + sync.rw_mutex_shared_lock(&data.m1) + n := data.number1 + sync.rw_mutex_shared_unlock(&data.m1) + + sync.rw_mutex_lock(&data.m2) + data.number2 += n + sync.rw_mutex_unlock(&data.m2) + } + + data: Data + threads: [THREADS]^thread.Thread + + sync.rw_mutex_lock(&data.m1) + + for &v in threads { + v = thread.create(p) + v.data = &data + v.init_context = context + thread.start(v) + } + + data.number1 = 1 + sync.rw_mutex_unlock(&data.m1) + + wait_for(threads[:]) + + testing.expect_value(t, data.number2, THREADS) +} + +@test +test_recursive_mutex :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + m: sync.Recursive_Mutex, + number: int, + } + + p :: proc(th: ^thread.Thread) { + data := cast(^Data)th.data + + // log.debugf("REC_MUTEX-%v> locking", th.id) + tried1 := sync.recursive_mutex_try_lock(&data.m) + for _ in 0..<3 { + sync.recursive_mutex_lock(&data.m) + } + tried2 := sync.recursive_mutex_try_lock(&data.m) + // log.debugf("REC_MUTEX-%v> locked", th.id) + data.number += 1 + // log.debugf("REC_MUTEX-%v> unlocking", th.id) + for _ in 0..<3 { + sync.recursive_mutex_unlock(&data.m) + } + if tried1 { sync.recursive_mutex_unlock(&data.m) } + if tried2 { sync.recursive_mutex_unlock(&data.m) } + // log.debugf("REC_MUTEX-%v> leaving", th.id) + } + + data: Data + threads: [THREADS]^thread.Thread + + for &v in threads { + v = thread.create(p) + v.data = &data + v.init_context = context + thread.start(v) + } + + wait_for(threads[:]) + + testing.expect_value(t, data.number, THREADS) +} + +@test +test_cond :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + c: sync.Cond, + m: sync.Mutex, + i: int, + number: int, + } + + p :: proc(th: ^thread.Thread) { + data := cast(^Data)th.data + + sync.mutex_lock(&data.m) + + for intrinsics.atomic_load(&data.i) != 1 { + sync.cond_wait(&data.c, &data.m) + } + + data.number += intrinsics.atomic_load(&data.i) + + sync.mutex_unlock(&data.m) + } + + data: Data + threads: [THREADS]^thread.Thread + data.i = -1 + + sync.mutex_lock(&data.m) + + for &v in threads { + v = thread.create(p) + v.data = &data + v.init_context = context + thread.start(v) + } + + time.sleep(SLEEP_TIME) + data.i = 1 + sync.mutex_unlock(&data.m) + sync.cond_broadcast(&data.c) + + wait_for(threads[:]) + + testing.expect_value(t, data.number, THREADS) +} + +@test +test_cond_with_timeout :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + c: sync.Cond + m: sync.Mutex + sync.mutex_lock(&m) + sync.cond_wait_with_timeout(&c, &m, SLEEP_TIME) +} + +@test +test_semaphore :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + s: sync.Sema, + number: int, + } + + p :: proc(th: ^thread.Thread) { + data := cast(^Data)th.data + + // log.debugf("SEM-%v> waiting", th.id) + sync.sema_wait(&data.s) + data.number += 1 + // log.debugf("SEM-%v> posting", th.id) + sync.sema_post(&data.s) + // log.debugf("SEM-%v> leaving", th.id) + } + + data: Data + threads: [THREADS]^thread.Thread + + for &v in threads { + v = thread.create(p) + v.data = &data + v.init_context = context + thread.start(v) + } + sync.sema_post(&data.s) + + wait_for(threads[:]) + + testing.expect_value(t, data.number, THREADS) +} + +@test +test_semaphore_with_timeout :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + s: sync.Sema + sync.sema_wait_with_timeout(&s, SLEEP_TIME) +} + +@test +test_futex :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + f: sync.Futex, + i: int, + number: int, + } + + p :: proc(th: ^thread.Thread) { + data := cast(^Data)th.data + + // log.debugf("FUTEX-%v> waiting", th.id) + sync.futex_wait(&data.f, 3) + // log.debugf("FUTEX-%v> done", th.id) + + n := data.i + intrinsics.atomic_add(&data.number, n) + } + + data: Data + data.i = -1 + data.f = 3 + threads: [THREADS]^thread.Thread + + for &v in threads { + v = thread.create(p) + v.data = &data + v.init_context = context + thread.start(v) + } + + data.i = 1 + // Change the futex variable to keep late-starters from stalling. + data.f = 0 + sync.futex_broadcast(&data.f) + + wait_for(threads[:]) + + testing.expect_value(t, data.number, THREADS) +} + +@test +test_futex_with_timeout :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + f: sync.Futex = 1 + sync.futex_wait_with_timeout(&f, 1, SLEEP_TIME) +} + +// +// core:sync/extended.odin +// + +@test +test_wait_group :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + step1: sync.Wait_Group, + step2: sync.Wait_Group, + i: int, + number: int, + } + + p :: proc(th: ^thread.Thread) { + data := cast(^Data)th.data + + sync.wait_group_wait(&data.step1) + + n := data.i + intrinsics.atomic_add(&data.number, n) + + sync.wait_group_done(&data.step2) + } + + data: Data + data.i = -1 + threads: [THREADS]^thread.Thread + + sync.wait_group_add(&data.step1, 1) + sync.wait_group_add(&data.step2, THREADS) + + for &v in threads { + v = thread.create(p) + v.data = &data + v.init_context = context + thread.start(v) + } + + time.sleep(SMALL_SLEEP_TIME) + data.i = 1 + sync.wait_group_done(&data.step1) + + sync.wait_group_wait(&data.step2) + + wait_for(threads[:]) + + testing.expect_value(t, data.step1.counter, 0) + testing.expect_value(t, data.step2.counter, 0) + testing.expect_value(t, data.number, THREADS) +} + +@test +test_wait_group_with_timeout :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + wg: sync.Wait_Group + sync.wait_group_wait_with_timeout(&wg, SLEEP_TIME) +} + +@test +test_barrier :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + b: sync.Barrier, + i: int, + number: int, + + } + + p :: proc(th: ^thread.Thread) { + data := cast(^Data)th.data + + sync.barrier_wait(&data.b) + + intrinsics.atomic_add(&data.number, data.i) + } + + data: Data + data.i = -1 + threads: [THREADS]^thread.Thread + + sync.barrier_init(&data.b, THREADS + 1) // +1 for this thread, of course. + + for &v in threads { + v = thread.create(p) + v.data = &data + v.init_context = context + thread.start(v) + } + time.sleep(SMALL_SLEEP_TIME) + data.i = 1 + sync.barrier_wait(&data.b) + + wait_for(threads[:]) + + testing.expect_value(t, data.b.index, 0) + testing.expect_value(t, data.b.generation_id, 1) + testing.expect_value(t, data.b.thread_count, THREADS + 1) + testing.expect_value(t, data.number, THREADS) +} + +@test +test_auto_reset :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + a: sync.Auto_Reset_Event, + number: int, + } + + p :: proc(th: ^thread.Thread) { + data := cast(^Data)th.data + + // log.debugf("AUR-%v> entering", th.id) + sync.auto_reset_event_wait(&data.a) + // log.debugf("AUR-%v> adding", th.id) + data.number += 1 + // log.debugf("AUR-%v> signalling", th.id) + sync.auto_reset_event_signal(&data.a) + // log.debugf("AUR-%v> leaving", th.id) + } + + data: Data + threads: [THREADS]^thread.Thread + + for &v in threads { + v = thread.create(p) + v.data = &data + v.init_context = context + thread.start(v) + } + + // There is a chance that this test can stall if a signal is sent before + // all threads are queued, because it's possible for some number of threads + // to get to the waiting state, the signal to fire, all of the waited + // threads to pass successfully, then the other threads come in with no-one + // to run a signal. + // + // So we'll just test a fully-waited queue of cascading threads. + for { + status := intrinsics.atomic_load(&data.a.status) + if status == -THREADS { + // log.debug("All Auto_Reset_Event threads have queued.") + break + } + intrinsics.cpu_relax() + } + + sync.auto_reset_event_signal(&data.a) + + wait_for(threads[:]) + + // The last thread should leave this primitive in a signalled state. + testing.expect_value(t, data.a.status, 1) + testing.expect_value(t, data.number, THREADS) +} + +@test +test_auto_reset_already_signalled :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + a: sync.Auto_Reset_Event + sync.auto_reset_event_signal(&a) + sync.auto_reset_event_wait(&a) + testing.expect_value(t, a.status, 0) +} + +@test +test_ticket_mutex :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + m: sync.Ticket_Mutex, + number: int, + } + + p :: proc(th: ^thread.Thread) { + data := cast(^Data)th.data + + // log.debugf("TIC-%i> entering", th.id) + // intrinsics.debug_trap() + sync.ticket_mutex_lock(&data.m) + // log.debugf("TIC-%i> locked", th.id) + data.number += 1 + // log.debugf("TIC-%i> unlocking", th.id) + sync.ticket_mutex_unlock(&data.m) + // log.debugf("TIC-%i> leaving", th.id) + } + + data: Data + threads: [THREADS]^thread.Thread + + for &v in threads { + v = thread.create(p) + v.data = &data + v.init_context = context + thread.start(v) + } + + wait_for(threads[:]) + + testing.expect_value(t, data.m.ticket, THREADS) + testing.expect_value(t, data.m.serving, THREADS) + testing.expect_value(t, data.number, THREADS) +} + +@test +test_benaphore :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + b: sync.Benaphore, + number: int, + } + + p :: proc(th: ^thread.Thread) { + data := cast(^Data)th.data + sync.benaphore_lock(&data.b) + data.number += 1 + sync.benaphore_unlock(&data.b) + } + + data: Data + threads: [THREADS]^thread.Thread + + for &v in threads { + v = thread.create(p) + v.data = &data + v.init_context = context + thread.start(v) + } + + wait_for(threads[:]) + + testing.expect_value(t, data.b.counter, 0) + testing.expect_value(t, data.number, THREADS) +} + +@test +test_recursive_benaphore :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + b: sync.Recursive_Benaphore, + number: int, + } + + p :: proc(th: ^thread.Thread) { + data := cast(^Data)th.data + + // log.debugf("REC_BEP-%i> entering", th.id) + tried1 := sync.recursive_benaphore_try_lock(&data.b) + for _ in 0..<3 { + sync.recursive_benaphore_lock(&data.b) + } + tried2 := sync.recursive_benaphore_try_lock(&data.b) + // log.debugf("REC_BEP-%i> locked", th.id) + data.number += 1 + for _ in 0..<3 { + sync.recursive_benaphore_unlock(&data.b) + } + if tried1 { sync.recursive_benaphore_unlock(&data.b) } + if tried2 { sync.recursive_benaphore_unlock(&data.b) } + // log.debugf("REC_BEP-%i> leaving", th.id) + } + + data: Data + threads: [THREADS]^thread.Thread + + for &v in threads { + v = thread.create(p) + v.data = &data + v.init_context = context + thread.start(v) + } + + wait_for(threads[:]) + + // The benaphore should be unowned at the end. + testing.expect_value(t, data.b.counter, 0) + testing.expect_value(t, data.b.owner, 0) + testing.expect_value(t, data.b.recursion, 0) + testing.expect_value(t, data.number, THREADS) +} + +@test +test_once :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + once: sync.Once, + number: int, + } + + write :: proc "contextless" (data: rawptr) { + data := cast(^Data)data + data.number += 1 + } + + p :: proc(th: ^thread.Thread) { + data := cast(^Data)th.data + // log.debugf("ONCE-%v> entering", th.id) + sync.once_do_with_data_contextless(&data.once, write, data) + // log.debugf("ONCE-%v> leaving", th.id) + } + + data: Data + threads: [THREADS]^thread.Thread + + for &v in threads { + v = thread.create(p) + v.data = &data + v.init_context = context + thread.start(v) + } + + wait_for(threads[:]) + + testing.expect_value(t, data.once.done, true) + testing.expect_value(t, data.number, 1) +} + +@test +test_park :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + car: sync.Parker, + number: int, + } + + data: Data + + th := thread.create_and_start_with_data(&data, proc(data: rawptr) { + data := cast(^Data)data + time.sleep(SLEEP_TIME) + sync.unpark(&data.car) + data.number += 1 + }) + + sync.park(&data.car) + + wait_for([]^thread.Thread{ th }) + + PARKER_EMPTY :: 0 + testing.expect_value(t, data.car.state, PARKER_EMPTY) + testing.expect_value(t, data.number, 1) +} + +@test +test_park_with_timeout :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + car: sync.Parker + sync.park_with_timeout(&car, SLEEP_TIME) +} + +@test +test_one_shot_event :: proc(t: ^testing.T) { + testing.set_fail_timeout(t, FAIL_TIME) + + Data :: struct { + event: sync.One_Shot_Event, + number: int, + } + + data: Data + + th := thread.create_and_start_with_data(&data, proc(data: rawptr) { + data := cast(^Data)data + time.sleep(SLEEP_TIME) + sync.one_shot_event_signal(&data.event) + data.number += 1 + }) + + sync.one_shot_event_wait(&data.event) + + wait_for([]^thread.Thread{ th }) + + testing.expect_value(t, data.event.state, 1) + testing.expect_value(t, data.number, 1) +} From e90f5d25281c082fc179cb0170edfe87b8e6c0c5 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 14 Sep 2024 10:03:04 +1100 Subject: [PATCH 54/72] [mem]: Adjust the docs on the buddy allocator --- core/mem/allocators.odin | 205 ++++++++++++++++++++++++++++++++++++--- core/mem/doc.odin | 5 + 2 files changed, 197 insertions(+), 13 deletions(-) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index f1e45d1a1..4b5efbacb 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -112,6 +112,12 @@ allocation occupies the next adjacent region of memory in the buffer. Since arena allocator does not keep track of any metadata associated with the allocations and their locations, it is impossible to free individual allocations. + +The arena allocator can be used for temporary allocations in frame-based memory +management. Games are one example of such applications. A global arena can be +used for any temporary memory allocations, and at the end of each frame all +temporary allocations are freed. Since no temporary object is going to live +longer than a frame, no lifetimes are violated. */ @(require_results) arena_allocator :: proc(arena: ^Arena) -> Allocator { @@ -423,7 +429,7 @@ scratch_alloc_bytes :: proc( } /* -Allocate memory from scratch allocator. +Allocate non-initialized memory from scratch allocator. This procedure allocates `size` bytes of memory aligned on a boundary specified by `alignment`. The allocated memory region is not explicitly zero-initialized. @@ -441,7 +447,7 @@ scratch_alloc_non_zeroed :: proc( } /* -Allocate memory from scratch allocator. +Allocate non-initialized memory from scratch allocator. This procedure allocates `size` bytes of memory aligned on a boundary specified by `alignment`. The allocated memory region is not explicitly zero-initialized. @@ -499,7 +505,7 @@ scratch_alloc_bytes_non_zeroed :: proc( } /* -Free memory to scratch allocator. +Free memory to the scratch allocator. This procedure frees the memory region allocated at pointer `ptr`. @@ -1176,14 +1182,6 @@ Each subsequent allocation will get the next adjacent memory region. The metadata is stored in the allocation headers, that are located before the start of each allocated memory region. Each header contains the amount of padding bytes between that header and end of the previous allocation. - -## Properties - -**Performance characteristics**: TODO - -**Has a backing allocator**: No - -**Saves metadata**: Allocation header before each allocation. */ @(require_results) small_stack_allocator :: proc(stack: ^Small_Stack) -> Allocator { @@ -1608,6 +1606,9 @@ dynamic_arena_allocator :: proc(a: ^Dynamic_Arena) -> Allocator { /* Destroy a dynamic arena. + +This procedure frees all allocations, made on a dynamic arena, including the +unused blocks, as well as the arrays for storing blocks. */ dynamic_arena_destroy :: proc(a: ^Dynamic_Arena) { dynamic_arena_free_all(a) @@ -1646,12 +1647,28 @@ _dynamic_arena_cycle_new_block :: proc(a: ^Dynamic_Arena, loc := #caller_locatio return } +/* +Allocate memory from a dynamic arena. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment` from a dynamic arena `a`. The allocated memory is +zero-initialized. This procedure returns a pointer to the newly allocated memory +region. +*/ @(private, require_results) dynamic_arena_alloc :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_location) -> (rawptr, Allocator_Error) { data, err := dynamic_arena_alloc_bytes(a, size, loc) return raw_data(data), err } +/* +Allocate memory from a dynamic arena. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment` from a dynamic arena `a`. The allocated memory is +zero-initialized. This procedure returns a slice of the newly allocated memory +region. +*/ @(require_results) dynamic_arena_alloc_bytes :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { bytes, err := dynamic_arena_alloc_bytes_non_zeroed(a, size, loc) @@ -1661,12 +1678,28 @@ dynamic_arena_alloc_bytes :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_l return bytes, err } +/* +Allocate non-initialized memory from a dynamic arena. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment` from a dynamic arena `a`. The allocated memory is not explicitly +zero-initialized. This procedure returns a pointer to the newly allocated +memory region. +*/ @(require_results) dynamic_arena_alloc_non_zeroed :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_location) -> (rawptr, Allocator_Error) { data, err := dynamic_arena_alloc_bytes_non_zeroed(a, size, loc) return raw_data(data), err } +/* +Allocate non-initialized memory from a dynamic arena. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment` from a dynamic arena `a`. The allocated memory is not explicitly +zero-initialized. This procedure returns a slice of the newly allocated +memory region. +*/ @(require_results) dynamic_arena_alloc_bytes_non_zeroed :: proc(a: ^Dynamic_Arena, size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { n := align_formula(size, a.alignment) @@ -1696,6 +1729,12 @@ dynamic_arena_alloc_bytes_non_zeroed :: proc(a: ^Dynamic_Arena, size: int, loc : return ([^]byte)(memory)[:size], nil } +/* +Reset the dynamic arena. + +This procedure frees all the allocations, owned by the dynamic arena, excluding +the unused blocks. +*/ dynamic_arena_reset :: proc(a: ^Dynamic_Arena, loc := #caller_location) { if a.current_block != nil { append(&a.unused_blocks, a.current_block, loc=loc) @@ -1712,6 +1751,12 @@ dynamic_arena_reset :: proc(a: ^Dynamic_Arena, loc := #caller_location) { a.bytes_left = 0 // Make new allocations call `_dynamic_arena_cycle_new_block` again. } +/* +Free all memory from a dynamic arena. + +This procedure frees all the allocations, owned by the dynamic arena, including +the unused blocks. +*/ dynamic_arena_free_all :: proc(a: ^Dynamic_Arena, loc := #caller_location) { dynamic_arena_reset(a) for block in a.unused_blocks { @@ -1720,6 +1765,22 @@ dynamic_arena_free_all :: proc(a: ^Dynamic_Arena, loc := #caller_location) { clear(&a.unused_blocks) } +/* +Resize an allocation. + +This procedure resizes a memory region, defined by its location, `old_memory`, +and its size, `old_size` to have a size `size` and alignment `alignment`. The +newly allocated memory, if any is zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `dynamic_arena_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `dynamic_arena_free()`, freeing +the memory region located at an address specified by `old_memory`. + +This procedure returns the pointer to the resized memory region. +*/ @(require_results) dynamic_arena_resize :: proc( a: ^Dynamic_Arena, @@ -1732,6 +1793,22 @@ dynamic_arena_resize :: proc( return raw_data(bytes), err } +/* +Resize an allocation. + +This procedure resizes a memory region, specified by `old_data`, to have a size +`size` and alignment `alignment`. The newly allocated memory, if any is +zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `dynamic_arena_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `dynamic_arena_free()`, freeing the +memory region located at an address specified by `old_memory`. + +This procedure returns the slice of the resized memory region. +*/ @(require_results) dynamic_arena_resize_bytes :: proc( a: ^Dynamic_Arena, @@ -1750,6 +1827,22 @@ dynamic_arena_resize_bytes :: proc( return bytes, err } +/* +Resize an allocation without zero-initialization. + +This procedure resizes a memory region, defined by its location, `old_memory`, +and its size, `old_size` to have a size `size` and alignment `alignment`. The +newly allocated memory, if any is not explicitly zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `dynamic_arena_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `dynamic_arena_free()`, freeing the +memory region located at an address specified by `old_memory`. + +This procedure returns the pointer to the resized memory region. +*/ @(require_results) dynamic_arena_resize_non_zeroed :: proc( a: ^Dynamic_Arena, @@ -1762,6 +1855,22 @@ dynamic_arena_resize_non_zeroed :: proc( return raw_data(bytes), err } +/* +Resize an allocation. + +This procedure resizes a memory region, specified by `old_data`, to have a size +`size` and alignment `alignment`. The newly allocated memory, if any is not +explicitly zero-initialized. + +If `old_memory` is `nil`, this procedure acts just like `dynamic_arena_alloc()`, +allocating a memory region `size` bytes in size, aligned on a boundary specified +by `alignment`. + +If `size` is 0, this procedure acts just like `dynamic_arena_free()`, freeing +the memory region located at an address specified by `old_memory`. + +This procedure returns the slice of the resized memory region. +*/ @(require_results) dynamic_arena_resize_bytes_non_zeroed :: proc( a: ^Dynamic_Arena, @@ -1823,17 +1932,25 @@ dynamic_arena_allocator_proc :: proc( } - +/* +Header of the buddy block. +*/ Buddy_Block :: struct #align(align_of(uint)) { size: uint, is_free: bool, } +/* +Obtain the next buddy block. +*/ @(require_results) buddy_block_next :: proc(block: ^Buddy_Block) -> ^Buddy_Block { return (^Buddy_Block)(([^]byte)(block)[block.size:]) } +/* +Split the block into two, by truncating the given block to a given size. +*/ @(require_results) buddy_block_split :: proc(block: ^Buddy_Block, size: uint) -> ^Buddy_Block { block := block @@ -1854,6 +1971,9 @@ buddy_block_split :: proc(block: ^Buddy_Block, size: uint) -> ^Buddy_Block { return nil } +/* +Coalesce contiguous blocks in a range of blocks into one. +*/ buddy_block_coalescence :: proc(head, tail: ^Buddy_Block) { for { // Keep looping until there are no more buddies to coalesce @@ -1887,6 +2007,9 @@ buddy_block_coalescence :: proc(head, tail: ^Buddy_Block) { } } +/* +Find the best block for storing a given size in a range of blocks. +*/ @(require_results) buddy_block_find_best :: proc(head, tail: ^Buddy_Block, size: uint) -> ^Buddy_Block { assert(size != 0) @@ -1945,6 +2068,9 @@ buddy_block_find_best :: proc(head, tail: ^Buddy_Block, size: uint) -> ^Buddy_Bl return nil } +/* +The buddy allocator data. +*/ Buddy_Allocator :: struct { head: ^Buddy_Block, tail: ^Buddy_Block, @@ -1954,7 +2080,12 @@ Buddy_Allocator :: struct { /* Buddy allocator. -TODO +The buddy allocator is a type of allocator that splits the backing buffer into +multiple regions called buddy blocks. Initially, the allocator only has one +block with the size of the backing buffer. Upon each allocation, the allocator +finds the smallest block that can fit the size of requested memory region, and +splits the block according to the allocation size. If no block can be found, +the contiguous free blocks are coalesced and the search is performed again. */ @(require_results) buddy_allocator :: proc(b: ^Buddy_Allocator) -> Allocator { @@ -1964,6 +2095,12 @@ buddy_allocator :: proc(b: ^Buddy_Allocator) -> Allocator { } } +/* +Initialize the buddy allocator. + +This procedure initializes the buddy allocator `b` with a backing buffer `data` +and block alignment specified by `alignment`. +*/ buddy_allocator_init :: proc(b: ^Buddy_Allocator, data: []byte, alignment: uint, loc := #caller_location) { assert(data != nil) assert(is_power_of_two(uintptr(len(data))), "Size of the backing buffer must be power of two", loc) @@ -1981,6 +2118,9 @@ buddy_allocator_init :: proc(b: ^Buddy_Allocator, data: []byte, alignment: uint, b.alignment = alignment } +/* +Get required block size to fit in the allocation as well as the alignment padding. +*/ @(require_results) buddy_block_size_required :: proc(b: ^Buddy_Allocator, size: uint) -> uint { size := size @@ -1993,12 +2133,26 @@ buddy_block_size_required :: proc(b: ^Buddy_Allocator, size: uint) -> uint { return actual_size } +/* +Allocate memory from a buddy allocator. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment`. The allocated memory region is zero-initialized. This procedure +returns a pointer to the allocated memory region. +*/ @(require_results) buddy_allocator_alloc :: proc(b: ^Buddy_Allocator, size: uint) -> (rawptr, Allocator_Error) { bytes, err := buddy_allocator_alloc_bytes(b, size) return raw_data(bytes), err } +/* +Allocate memory from a buddy allocator. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment`. The allocated memory region is zero-initialized. This procedure +returns a slice of the allocated memory region. +*/ @(require_results) buddy_allocator_alloc_bytes :: proc(b: ^Buddy_Allocator, size: uint) -> ([]byte, Allocator_Error) { bytes, err := buddy_allocator_alloc_bytes_non_zeroed(b, size) @@ -2008,12 +2162,26 @@ buddy_allocator_alloc_bytes :: proc(b: ^Buddy_Allocator, size: uint) -> ([]byte, return bytes, err } +/* +Allocate non-initialized memory from a buddy allocator. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment`. The allocated memory region is not explicitly zero-initialized. +This procedure returns a pointer to the allocated memory region. +*/ @(require_results) buddy_allocator_alloc_non_zeroed :: proc(b: ^Buddy_Allocator, size: uint) -> (rawptr, Allocator_Error) { bytes, err := buddy_allocator_alloc_bytes_non_zeroed(b, size) return raw_data(bytes), err } +/* +Allocate non-initialized memory from a buddy allocator. + +This procedure allocates `size` bytes of memory aligned on a boundary specified +by `alignment`. The allocated memory region is not explicitly zero-initialized. +This procedure returns a slice of the allocated memory region. +*/ @(require_results) buddy_allocator_alloc_bytes_non_zeroed :: proc(b: ^Buddy_Allocator, size: uint) -> ([]byte, Allocator_Error) { if size != 0 { @@ -2034,6 +2202,14 @@ buddy_allocator_alloc_bytes_non_zeroed :: proc(b: ^Buddy_Allocator, size: uint) return nil, nil } +/* +Free memory to the buddy allocator. + +This procedure frees the memory region allocated at pointer `ptr`. + +If `ptr` is not the latest allocation and is not a leaked allocation, this +operation is a no-op. +*/ buddy_allocator_free :: proc(b: ^Buddy_Allocator, ptr: rawptr) -> Allocator_Error { if ptr != nil { if !(b.head <= ptr && ptr <= b.tail) { @@ -2046,6 +2222,9 @@ buddy_allocator_free :: proc(b: ^Buddy_Allocator, ptr: rawptr) -> Allocator_Erro return nil } +/* +Free all memory to the buddy allocator. +*/ buddy_allocator_free_all :: proc(b: ^Buddy_Allocator) { alignment := b.alignment head := ([^]byte)(b.head) diff --git a/core/mem/doc.odin b/core/mem/doc.odin index 5e8bcce6a..98755d797 100644 --- a/core/mem/doc.odin +++ b/core/mem/doc.odin @@ -48,6 +48,11 @@ Operations such as `new`, `free` and `delete` by default will use happens all called procedures will inherit the new context and use the same allocator. +We will define one concept to simplify the description of some allocator-related +procedures, which is ownership. If the memory was allocated via a specific +allocator, that allocator is said to be the *owner* of that memory region. To +note, unlike Rust, in Odin the memory ownership model is not strict. + ## Alignment An address is said to be *aligned to `N` bytes*, if the addresses's numeric From 3ed2ab6e2c18081d80961168a57155e6f31ac573 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 14 Sep 2024 10:18:51 +1100 Subject: [PATCH 55/72] [mem]: Adjust the docs for calc_padding_with_header --- core/mem/alloc.odin | 3 +-- core/mem/mem.odin | 22 +++++++++++++++++++--- 2 files changed, 20 insertions(+), 5 deletions(-) diff --git a/core/mem/alloc.odin b/core/mem/alloc.odin index 5f65e9ebc..fac58daaf 100644 --- a/core/mem/alloc.odin +++ b/core/mem/alloc.odin @@ -1019,8 +1019,7 @@ Default resize procedure. When allocator does not support resize operation, but supports `.Alloc_Non_Zeroed` and `.Free`, this procedure is used to implement allocator's -default behavior on -resize. +default behavior on resize. Unlike `default_resize_align` no new memory is being explicitly zero-initialized. diff --git a/core/mem/mem.odin b/core/mem/mem.odin index b57b18ffc..67ed56c39 100644 --- a/core/mem/mem.odin +++ b/core/mem/mem.odin @@ -644,10 +644,26 @@ align_formula :: proc "contextless" (size, align: int) -> int { } /* -Calculate the padding after the pointer with a header. +Calculate the padding for header preceding aligned data. -This procedure returns the next address, following `ptr` and `header_size` -bytes of space that is aligned to a boundary specified by `align`. +This procedure returns the padding, following the specified pointer `ptr` that +will be able to fit in a header of the size `header_size`, immediately +preceding the memory region, aligned on a boundary specified by `align`. See +the following diagram for a visual representation. + + header size + |<------>| + +---+--------+------------- - - - + | HEADER | DATA... + +---+--------+------------- - - - + ^ ^ + |<---------->| + | padding | + ptr aligned ptr + +The function takes in `ptr` and `header_size`, as well as the required +alignment for `DATA`. The return value of the function is the padding between +`ptr` and `aligned_ptr` that will be able to fit the header. */ @(require_results) calc_padding_with_header :: proc "contextless" (ptr: uintptr, align: uintptr, header_size: int) -> int { From 016d1a84d4e09ea06491d9e5a4661e313906e3aa Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 14 Sep 2024 10:46:35 +1100 Subject: [PATCH 56/72] [mem]: Document mutex, rollback stack and tracking allocators --- core/mem/mutex_allocator.odin | 15 +++ core/mem/raw.odin | 46 ++++++--- core/mem/rollback_stack_allocator.odin | 135 ++++++++++++++----------- core/mem/tracking_allocator.odin | 114 ++++++++++++++------- 4 files changed, 197 insertions(+), 113 deletions(-) diff --git a/core/mem/mutex_allocator.odin b/core/mem/mutex_allocator.odin index 1cccc7dac..d2c527fdb 100644 --- a/core/mem/mutex_allocator.odin +++ b/core/mem/mutex_allocator.odin @@ -3,16 +3,31 @@ package mem import "core:sync" +/* +The data for mutex allocator. +*/ Mutex_Allocator :: struct { backing: Allocator, mutex: sync.Mutex, } +/* +Initialize the mutex allocator. + +This procedure initializes the mutex allocator using `backin_allocator` as the +allocator that will be used to pass all allocation requests through. +*/ mutex_allocator_init :: proc(m: ^Mutex_Allocator, backing_allocator: Allocator) { m.backing = backing_allocator m.mutex = {} } +/* +Mutex allocator. + +The mutex allocator is a wrapper for allocators that is used to serialize all +allocator requests across multiple threads. +*/ @(require_results) mutex_allocator :: proc(m: ^Mutex_Allocator) -> Allocator { return Allocator{ diff --git a/core/mem/raw.odin b/core/mem/raw.odin index ab1148cea..41c91555e 100644 --- a/core/mem/raw.odin +++ b/core/mem/raw.odin @@ -4,68 +4,82 @@ import "base:builtin" import "base:runtime" /* -Mamory layout of the `any` type. +Memory layout of the `any` type. */ Raw_Any :: runtime.Raw_Any /* -Mamory layout of the `string` type. +Memory layout of the `string` type. */ Raw_String :: runtime.Raw_String + /* -Mamory layout of the `cstring` type. +Memory layout of the `cstring` type. */ Raw_Cstring :: runtime.Raw_Cstring + /* -Mamory layout of `[]T` types. +Memory layout of `[]T` types. */ Raw_Slice :: runtime.Raw_Slice + /* -Mamory layout of `[dynamic]T` types. +Memory layout of `[dynamic]T` types. */ Raw_Dynamic_Array :: runtime.Raw_Dynamic_Array + /* -Mamory layout of `map[K]V` types. +Memory layout of `map[K]V` types. */ Raw_Map :: runtime.Raw_Map + /* -Mamory layout of `#soa []T` types. +Memory layout of `#soa []T` types. */ Raw_Soa_Pointer :: runtime.Raw_Soa_Pointer + /* -Mamory layout of the `complex32` type. +Memory layout of the `complex32` type. */ Raw_Complex32 :: runtime.Raw_Complex32 + /* -Mamory layout of the `complex64` type. +Memory layout of the `complex64` type. */ Raw_Complex64 :: runtime.Raw_Complex64 + /* -Mamory layout of the `complex128` type. +Memory layout of the `complex128` type. */ Raw_Complex128 :: runtime.Raw_Complex128 + /* -Mamory layout of the `quaternion64` type. +Memory layout of the `quaternion64` type. */ Raw_Quaternion64 :: runtime.Raw_Quaternion64 + /* -Mamory layout of the `quaternion128` type. +Memory layout of the `quaternion128` type. */ Raw_Quaternion128 :: runtime.Raw_Quaternion128 + /* -Mamory layout of the `quaternion256` type. +Memory layout of the `quaternion256` type. */ Raw_Quaternion256 :: runtime.Raw_Quaternion256 + /* -Mamory layout of the `quaternion64` type. +Memory layout of the `quaternion64` type. */ Raw_Quaternion64_Vector_Scalar :: runtime.Raw_Quaternion64_Vector_Scalar + /* -Mamory layout of the `quaternion128` type. +Memory layout of the `quaternion128` type. */ Raw_Quaternion128_Vector_Scalar :: runtime.Raw_Quaternion128_Vector_Scalar + /* -Mamory layout of the `quaternion256` type. +Memory layout of the `quaternion256` type. */ Raw_Quaternion256_Vector_Scalar :: runtime.Raw_Quaternion256_Vector_Scalar diff --git a/core/mem/rollback_stack_allocator.odin b/core/mem/rollback_stack_allocator.odin index 761435552..61ec73546 100644 --- a/core/mem/rollback_stack_allocator.odin +++ b/core/mem/rollback_stack_allocator.odin @@ -1,39 +1,15 @@ package mem -/* -The Rollback Stack Allocator was designed for the test runner to be fast, -able to grow, and respect the Tracking Allocator's requirement for -individual frees. It is not overly concerned with fragmentation, however. - -It has support for expansion when configured with a block allocator and -limited support for out-of-order frees. - -Allocation has constant-time best and usual case performance. -At worst, it is linear according to the number of memory blocks. - -Allocation follows a first-fit strategy when there are multiple memory -blocks. - -Freeing has constant-time best and usual case performance. -At worst, it is linear according to the number of memory blocks and number -of freed items preceding the last item in a block. - -Resizing has constant-time performance, if it's the last item in a block, or -the new size is smaller. Naturally, this becomes linear-time if there are -multiple blocks to search for the pointer's owning block. Otherwise, the -allocator defaults to a combined alloc & free operation internally. - -Out-of-order freeing is accomplished by collapsing a run of freed items -from the last allocation backwards. - -Each allocation has an overhead of 8 bytes and any extra bytes to satisfy -the requested alignment. -*/ import "base:runtime" +/* +Rollback stack default block size. +*/ ROLLBACK_STACK_DEFAULT_BLOCK_SIZE :: 4 * Megabyte /* +Rollback stack max head block size. + This limitation is due to the size of `prev_ptr`, but it is only for the head block; any allocation in excess of the allocator's `block_size` is valid, so long as the block allocator can handle it. @@ -43,12 +19,18 @@ within is freed; they are immediately returned to the block allocator. */ ROLLBACK_STACK_MAX_HEAD_BLOCK_SIZE :: 2 * Gigabyte +/* +Allocation header of the rollback stack allocator. +*/ Rollback_Stack_Header :: bit_field u64 { prev_offset: uintptr | 32, is_free: bool | 1, prev_ptr: uintptr | 31, } +/* +Block header of the rollback stack allocator. +*/ Rollback_Stack_Block :: struct { next_block: ^Rollback_Stack_Block, last_alloc: rawptr, @@ -56,6 +38,9 @@ Rollback_Stack_Block :: struct { buffer: []byte, } +/* +Rollback stack allocator data. +*/ Rollback_Stack :: struct { head: ^Rollback_Stack_Block, block_size: int, @@ -111,6 +96,9 @@ rb_rollback_block :: proc(block: ^Rollback_Stack_Block, header: ^Rollback_Stack_ } } +/* +Free memory to a rollback stack allocator. +*/ @(private="file", require_results) rb_free :: proc(stack: ^Rollback_Stack, ptr: rawptr) -> Allocator_Error { parent, block, header := rb_find_ptr(stack, ptr) or_return @@ -129,6 +117,9 @@ rb_free :: proc(stack: ^Rollback_Stack, ptr: rawptr) -> Allocator_Error { return nil } +/* +Free all memory owned by the rollback stack allocator. +*/ @(private="file") rb_free_all :: proc(stack: ^Rollback_Stack) { for block := stack.head.next_block; block != nil; /**/ { @@ -142,14 +133,16 @@ rb_free_all :: proc(stack: ^Rollback_Stack) { stack.head.offset = 0 } +/* +Resize an allocation made on a rollback stack allocator. +*/ @(private="file", require_results) -rb_resize :: proc(stack: ^Rollback_Stack, ptr: rawptr, old_size, size, alignment: int) -> (result: []byte, err: Allocator_Error) { +rb_resize_non_zeroed :: proc(stack: ^Rollback_Stack, ptr: rawptr, old_size, size, alignment: int) -> (result: []byte, err: Allocator_Error) { if ptr != nil { if block, _, ok := rb_find_last_alloc(stack, ptr); ok { // `block.offset` should never underflow because it is contingent // on `old_size` in the first place, assuming sane arguments. assert(block.offset >= cast(uintptr)old_size, "Rollback Stack Allocator received invalid `old_size`.") - if block.offset + cast(uintptr)size - cast(uintptr)old_size < cast(uintptr)len(block.buffer) { // Prevent singleton allocations from fragmenting by forbidding // them to shrink, removing the possibility of overflow bugs. @@ -160,27 +153,26 @@ rb_resize :: proc(stack: ^Rollback_Stack, ptr: rawptr, old_size, size, alignment } } } - - result = rb_alloc(stack, size, alignment) or_return + result = rb_alloc_non_zeroed(stack, size, alignment) or_return runtime.mem_copy_non_overlapping(raw_data(result), ptr, old_size) err = rb_free(stack, ptr) - return } +/* +Allocate memory using the rollback stack allocator. +*/ @(private="file", require_results) -rb_alloc :: proc(stack: ^Rollback_Stack, size, alignment: int) -> (result: []byte, err: Allocator_Error) { +rb_alloc_non_zeroed :: proc(stack: ^Rollback_Stack, size, alignment: int) -> (result: []byte, err: Allocator_Error) { parent: ^Rollback_Stack_Block for block := stack.head; /**/; block = block.next_block { when !ODIN_DISABLE_ASSERT { allocated_new_block: bool } - if block == nil { if stack.block_allocator.procedure == nil { return nil, .Out_Of_Memory } - minimum_size_required := size_of(Rollback_Stack_Header) + size + alignment - 1 new_block_size := max(minimum_size_required, stack.block_size) block = rb_make_block(new_block_size, stack.block_allocator) or_return @@ -189,10 +181,8 @@ rb_alloc :: proc(stack: ^Rollback_Stack, size, alignment: int) -> (result: []byt allocated_new_block = true } } - start := raw_data(block.buffer)[block.offset:] padding := cast(uintptr)calc_padding_with_header(cast(uintptr)start, cast(uintptr)alignment, size_of(Rollback_Stack_Header)) - if block.offset + padding + cast(uintptr)size > cast(uintptr)len(block.buffer) { when !ODIN_DISABLE_ASSERT { if allocated_new_block { @@ -202,54 +192,50 @@ rb_alloc :: proc(stack: ^Rollback_Stack, size, alignment: int) -> (result: []byt parent = block continue } - header := cast(^Rollback_Stack_Header)(start[padding - size_of(Rollback_Stack_Header):]) ptr := start[padding:] - header^ = { prev_offset = block.offset, prev_ptr = uintptr(0) if block.last_alloc == nil else cast(uintptr)block.last_alloc - cast(uintptr)raw_data(block.buffer), is_free = false, } - block.last_alloc = ptr block.offset += padding + cast(uintptr)size - if len(block.buffer) > stack.block_size { // This block exceeds the allocator's standard block size and is considered a singleton. // Prevent any further allocations on it. block.offset = cast(uintptr)len(block.buffer) } - #no_bounds_check return ptr[:size], nil } - return nil, .Out_Of_Memory } @(private="file", require_results) rb_make_block :: proc(size: int, allocator: Allocator) -> (block: ^Rollback_Stack_Block, err: Allocator_Error) { buffer := runtime.mem_alloc(size_of(Rollback_Stack_Block) + size, align_of(Rollback_Stack_Block), allocator) or_return - block = cast(^Rollback_Stack_Block)raw_data(buffer) #no_bounds_check block.buffer = buffer[size_of(Rollback_Stack_Block):] return } - +/* +Initialize the rollback stack allocator using a fixed backing buffer. +*/ rollback_stack_init_buffered :: proc(stack: ^Rollback_Stack, buffer: []byte, location := #caller_location) { MIN_SIZE :: size_of(Rollback_Stack_Block) + size_of(Rollback_Stack_Header) + size_of(rawptr) assert(len(buffer) >= MIN_SIZE, "User-provided buffer to Rollback Stack Allocator is too small.", location) - block := cast(^Rollback_Stack_Block)raw_data(buffer) block^ = {} #no_bounds_check block.buffer = buffer[size_of(Rollback_Stack_Block):] - stack^ = {} stack.head = block stack.block_size = len(block.buffer) } +/* +Initialize the rollback stack alocator using a backing block allocator. +*/ rollback_stack_init_dynamic :: proc( stack: ^Rollback_Stack, block_size : int = ROLLBACK_STACK_DEFAULT_BLOCK_SIZE, @@ -262,22 +248,25 @@ rollback_stack_init_dynamic :: proc( // size is insufficient; check only on platforms with big enough ints. assert(block_size <= ROLLBACK_STACK_MAX_HEAD_BLOCK_SIZE, "Rollback Stack Allocators cannot support head blocks larger than 2 gigabytes.", location) } - block := rb_make_block(block_size, block_allocator) or_return - stack^ = {} stack.head = block stack.block_size = block_size stack.block_allocator = block_allocator - return nil } +/* +Initialize the rollback stack. +*/ rollback_stack_init :: proc { rollback_stack_init_buffered, rollback_stack_init_dynamic, } +/* +Destroy a rollback stack. +*/ rollback_stack_destroy :: proc(stack: ^Rollback_Stack) { if stack.block_allocator.procedure != nil { rb_free_all(stack) @@ -286,6 +275,37 @@ rollback_stack_destroy :: proc(stack: ^Rollback_Stack) { stack^ = {} } +/* +Rollback stack allocator. + +The Rollback Stack Allocator was designed for the test runner to be fast, +able to grow, and respect the Tracking Allocator's requirement for +individual frees. It is not overly concerned with fragmentation, however. + +It has support for expansion when configured with a block allocator and +limited support for out-of-order frees. + +Allocation has constant-time best and usual case performance. +At worst, it is linear according to the number of memory blocks. + +Allocation follows a first-fit strategy when there are multiple memory +blocks. + +Freeing has constant-time best and usual case performance. +At worst, it is linear according to the number of memory blocks and number +of freed items preceding the last item in a block. + +Resizing has constant-time performance, if it's the last item in a block, or +the new size is smaller. Naturally, this becomes linear-time if there are +multiple blocks to search for the pointer's owning block. Otherwise, the +allocator defaults to a combined alloc & free operation internally. + +Out-of-order freeing is accomplished by collapsing a run of freed items +from the last allocation backwards. + +Each allocation has an overhead of 8 bytes and any extra bytes to satisfy +the requested alignment. +*/ @(require_results) rollback_stack_allocator :: proc(stack: ^Rollback_Stack) -> Allocator { return Allocator { @@ -309,38 +329,31 @@ rollback_stack_allocator_proc :: proc( case .Alloc, .Alloc_Non_Zeroed: assert(size >= 0, "Size must be positive or zero.", location) assert(is_power_of_two(cast(uintptr)alignment), "Alignment must be a power of two.", location) - result = rb_alloc(stack, size, alignment) or_return - + result = rb_alloc_non_zeroed(stack, size, alignment) or_return if mode == .Alloc { zero_slice(result) } - case .Free: err = rb_free(stack, old_memory) case .Free_All: rb_free_all(stack) - case .Resize, .Resize_Non_Zeroed: assert(size >= 0, "Size must be positive or zero.", location) assert(old_size >= 0, "Old size must be positive or zero.", location) assert(is_power_of_two(cast(uintptr)alignment), "Alignment must be a power of two.", location) - result = rb_resize(stack, old_memory, old_size, size, alignment) or_return - + result = rb_resize_non_zeroed(stack, old_memory, old_size, size, alignment) or_return #no_bounds_check if mode == .Resize && size > old_size { zero_slice(result[old_size:]) } - case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Free_All, .Resize, .Resize_Non_Zeroed} } return nil, nil - case .Query_Info: return nil, .Mode_Not_Implemented } - return } diff --git a/core/mem/tracking_allocator.odin b/core/mem/tracking_allocator.odin index e75844130..e436fcb6d 100644 --- a/core/mem/tracking_allocator.odin +++ b/core/mem/tracking_allocator.odin @@ -4,50 +4,38 @@ package mem import "base:runtime" import "core:sync" +/* +Allocation entry for the tracking allocator. + +This structure stores the data related to an allocation. +*/ Tracking_Allocator_Entry :: struct { - memory: rawptr, - size: int, + // Pointer to an allocated region. + memory: rawptr, + // Size of the allocated memory region. + size: int, + // Requested alignment. alignment: int, - mode: Allocator_Mode, - err: Allocator_Error, + // Mode of the operation. + mode: Allocator_Mode, + // Error. + err: Allocator_Error, + // Location of the allocation. location: runtime.Source_Code_Location, } +/* +Bad free entry for a tracking allocator. +*/ Tracking_Allocator_Bad_Free_Entry :: struct { - memory: rawptr, + // Pointer, on which free operation was called. + memory: rawptr, + // The source location of where the operation was called. location: runtime.Source_Code_Location, } /* -An example of how to use the `Tracking_Allocator` to track subsequent allocations -in your program and report leaks and bad frees: - -Example: - - package foo - - import "core:mem" - import "core:fmt" - - _main :: proc() { - // do stuff - } - - main :: proc() { - track: mem.Tracking_Allocator - mem.tracking_allocator_init(&track, context.allocator) - defer mem.tracking_allocator_destroy(&track) - context.allocator = mem.tracking_allocator(&track) - - _main() - - for _, leak in track.allocation_map { - fmt.printf("%v leaked %m\n", leak.location, leak.size) - } - for bad_free in track.bad_free_array { - fmt.printf("%v allocation %p was freed badly\n", bad_free.location, bad_free.memory) - } - } +Tracking allocator data. */ Tracking_Allocator :: struct { backing: Allocator, @@ -63,6 +51,13 @@ Tracking_Allocator :: struct { current_memory_allocated: i64, } +/* +Initialize the tracking allocator. + +This procedure initializes the tracking allocator `t` with a backing allocator +specified with `backing_allocator`. The `internals_allocator` will used to +allocate the tracked data. +*/ tracking_allocator_init :: proc(t: ^Tracking_Allocator, backing_allocator: Allocator, internals_allocator := context.allocator) { t.backing = backing_allocator t.allocation_map.allocator = internals_allocator @@ -72,12 +67,22 @@ tracking_allocator_init :: proc(t: ^Tracking_Allocator, backing_allocator: Alloc } } +/* +Destroy the tracking allocator. +*/ tracking_allocator_destroy :: proc(t: ^Tracking_Allocator) { delete(t.allocation_map) delete(t.bad_free_array) } -// Clear only the current allocation data while keeping the totals intact. +/* +Clear the tracking allocator. + +This procedure clears the tracked data from a tracking allocator. + +**Note**: This procedure clears only the current allocation data while keeping +the totals intact. +*/ tracking_allocator_clear :: proc(t: ^Tracking_Allocator) { sync.mutex_lock(&t.mutex) clear(&t.allocation_map) @@ -86,7 +91,11 @@ tracking_allocator_clear :: proc(t: ^Tracking_Allocator) { sync.mutex_unlock(&t.mutex) } -// Reset all of a Tracking Allocator's allocation data back to zero. +/* +Reset the tracking allocator. + +Reset all of a Tracking Allocator's allocation data back to zero. +*/ tracking_allocator_reset :: proc(t: ^Tracking_Allocator) { sync.mutex_lock(&t.mutex) clear(&t.allocation_map) @@ -100,6 +109,39 @@ tracking_allocator_reset :: proc(t: ^Tracking_Allocator) { sync.mutex_unlock(&t.mutex) } +/* +Tracking allocator. + +The tracking allocator is an allocator wrapper that tracks memory allocations. +This allocator stores all the allocations in a map. Whenever a pointer that's +not inside of the map is freed, the `bad_free_array` entry is added. + +An example of how to use the `Tracking_Allocator` to track subsequent allocations +in your program and report leaks and bad frees: + +Example: + + package foo + + import "core:mem" + import "core:fmt" + + main :: proc() { + track: mem.Tracking_Allocator + mem.tracking_allocator_init(&track, context.allocator) + defer mem.tracking_allocator_destroy(&track) + context.allocator = mem.tracking_allocator(&track) + + do_stuff() + + for _, leak in track.allocation_map { + fmt.printf("%v leaked %m\n", leak.location, leak.size) + } + for bad_free in track.bad_free_array { + fmt.printf("%v allocation %p was freed badly\n", bad_free.location, bad_free.memory) + } + } +*/ @(require_results) tracking_allocator :: proc(data: ^Tracking_Allocator) -> Allocator { return Allocator{ From 466e29bb38040ce8737e125a8a13c97cd4e74252 Mon Sep 17 00:00:00 2001 From: flysand7 Date: Sat, 14 Sep 2024 12:13:56 +1100 Subject: [PATCH 57/72] [mem]: Rollback allocator API consistency --- core/mem/rollback_stack_allocator.odin | 205 ++++++++++++++++++++----- 1 file changed, 163 insertions(+), 42 deletions(-) diff --git a/core/mem/rollback_stack_allocator.odin b/core/mem/rollback_stack_allocator.odin index 61ec73546..43ef10fe9 100644 --- a/core/mem/rollback_stack_allocator.odin +++ b/core/mem/rollback_stack_allocator.odin @@ -134,36 +134,65 @@ rb_free_all :: proc(stack: ^Rollback_Stack) { } /* -Resize an allocation made on a rollback stack allocator. +Allocate memory using the rollback stack allocator. */ -@(private="file", require_results) -rb_resize_non_zeroed :: proc(stack: ^Rollback_Stack, ptr: rawptr, old_size, size, alignment: int) -> (result: []byte, err: Allocator_Error) { - if ptr != nil { - if block, _, ok := rb_find_last_alloc(stack, ptr); ok { - // `block.offset` should never underflow because it is contingent - // on `old_size` in the first place, assuming sane arguments. - assert(block.offset >= cast(uintptr)old_size, "Rollback Stack Allocator received invalid `old_size`.") - if block.offset + cast(uintptr)size - cast(uintptr)old_size < cast(uintptr)len(block.buffer) { - // Prevent singleton allocations from fragmenting by forbidding - // them to shrink, removing the possibility of overflow bugs. - if len(block.buffer) <= stack.block_size { - block.offset += cast(uintptr)size - cast(uintptr)old_size - } - #no_bounds_check return (cast([^]byte)ptr)[:size], nil - } - } +@(require_results) +rb_alloc :: proc( + stack: ^Rollback_Stack, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := rb_alloc_bytes_non_zeroed(stack, size, alignment, loc) + if bytes != nil { + zero_slice(bytes) } - result = rb_alloc_non_zeroed(stack, size, alignment) or_return - runtime.mem_copy_non_overlapping(raw_data(result), ptr, old_size) - err = rb_free(stack, ptr) - return + return raw_data(bytes), err } /* Allocate memory using the rollback stack allocator. */ -@(private="file", require_results) -rb_alloc_non_zeroed :: proc(stack: ^Rollback_Stack, size, alignment: int) -> (result: []byte, err: Allocator_Error) { +@(require_results) +rb_alloc_bytes :: proc( + stack: ^Rollback_Stack, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> ([]byte, Allocator_Error) { + bytes, err := rb_alloc_bytes_non_zeroed(stack, size, alignment, loc) + if bytes != nil { + zero_slice(bytes) + } + return bytes, err +} + +/* +Allocate non-initialized memory using the rollback stack allocator. +*/ +@(require_results) +rb_alloc_non_zeroed :: proc( + stack: ^Rollback_Stack, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := rb_alloc_bytes_non_zeroed(stack, size, alignment, loc) + return raw_data(bytes), err +} + +/* +Allocate non-initialized memory using the rollback stack allocator. +*/ +@(require_results) +rb_alloc_bytes_non_zeroed :: proc( + stack: ^Rollback_Stack, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> (result: []byte, err: Allocator_Error) { + assert(size >= 0, "Size must be positive or zero.", loc) + assert(is_power_of_two(cast(uintptr)alignment), "Alignment must be a power of two.", loc) parent: ^Rollback_Stack_Block for block := stack.head; /**/; block = block.next_block { when !ODIN_DISABLE_ASSERT { @@ -211,6 +240,106 @@ rb_alloc_non_zeroed :: proc(stack: ^Rollback_Stack, size, alignment: int) -> (re return nil, .Out_Of_Memory } +/* +Resize an allocation owned by rollback stack allocator. +*/ +@(require_results) +rb_resize :: proc( + stack: ^Rollback_Stack, + old_ptr: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := rb_resize_bytes_non_zeroed(stack, byte_slice(old_ptr, old_size), size, alignment, loc) + if bytes != nil { + if old_ptr == nil { + zero_slice(bytes) + } else if size > old_size { + zero_slice(bytes[old_size:]) + } + } + return raw_data(bytes), err +} + +/* +Resize an allocation owned by rollback stack allocator. +*/ +@(require_results) +rb_resize_bytes :: proc( + stack: ^Rollback_Stack, + old_memory: []byte, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> ([]u8, Allocator_Error) { + bytes, err := rb_resize_bytes_non_zeroed(stack, old_memory, size, alignment, loc) + if bytes != nil { + if old_memory == nil { + zero_slice(bytes) + } else if size > len(old_memory) { + zero_slice(bytes[len(old_memory):]) + } + } + return bytes, err +} + +/* +Resize an allocation owned by rollback stack allocator without explicit +zero-initialization. +*/ +@(require_results) +rb_resize_non_zeroed :: proc( + stack: ^Rollback_Stack, + old_ptr: rawptr, + old_size: int, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> (rawptr, Allocator_Error) { + bytes, err := rb_resize_bytes_non_zeroed(stack, byte_slice(old_ptr, old_size), size, alignment, loc) + return raw_data(bytes), err +} + +/* +Resize an allocation owned by rollback stack allocator without explicit +zero-initialization. +*/ +@(require_results) +rb_resize_bytes_non_zeroed :: proc( + stack: ^Rollback_Stack, + old_memory: []byte, + size: int, + alignment := DEFAULT_ALIGNMENT, + loc := #caller_location, +) -> (result: []byte, err: Allocator_Error) { + old_size := len(old_memory) + ptr := raw_data(old_memory) + assert(size >= 0, "Size must be positive or zero.", loc) + assert(old_size >= 0, "Old size must be positive or zero.", loc) + assert(is_power_of_two(cast(uintptr)alignment), "Alignment must be a power of two.", loc) + if ptr != nil { + if block, _, ok := rb_find_last_alloc(stack, ptr); ok { + // `block.offset` should never underflow because it is contingent + // on `old_size` in the first place, assuming sane arguments. + assert(block.offset >= cast(uintptr)old_size, "Rollback Stack Allocator received invalid `old_size`.") + if block.offset + cast(uintptr)size - cast(uintptr)old_size < cast(uintptr)len(block.buffer) { + // Prevent singleton allocations from fragmenting by forbidding + // them to shrink, removing the possibility of overflow bugs. + if len(block.buffer) <= stack.block_size { + block.offset += cast(uintptr)size - cast(uintptr)old_size + } + #no_bounds_check return (ptr)[:size], nil + } + } + } + result = rb_alloc_bytes_non_zeroed(stack, size, alignment) or_return + runtime.mem_copy_non_overlapping(raw_data(result), ptr, old_size) + err = rb_free(stack, ptr) + return +} + @(private="file", require_results) rb_make_block :: proc(size: int, allocator: Allocator) -> (block: ^Rollback_Stack_Block, err: Allocator_Error) { buffer := runtime.mem_alloc(size_of(Rollback_Stack_Block) + size, align_of(Rollback_Stack_Block), allocator) or_return @@ -321,31 +450,23 @@ rollback_stack_allocator_proc :: proc( size, alignment: int, old_memory: rawptr, old_size: int, - location := #caller_location, + loc := #caller_location, ) -> (result: []byte, err: Allocator_Error) { stack := cast(^Rollback_Stack)allocator_data - switch mode { - case .Alloc, .Alloc_Non_Zeroed: - assert(size >= 0, "Size must be positive or zero.", location) - assert(is_power_of_two(cast(uintptr)alignment), "Alignment must be a power of two.", location) - result = rb_alloc_non_zeroed(stack, size, alignment) or_return - if mode == .Alloc { - zero_slice(result) - } + case .Alloc: + return rb_alloc_bytes(stack, size, alignment, loc) + case .Alloc_Non_Zeroed: + return rb_alloc_bytes_non_zeroed(stack, size, alignment, loc) case .Free: - err = rb_free(stack, old_memory) - + return nil, rb_free(stack, old_memory) case .Free_All: rb_free_all(stack) - case .Resize, .Resize_Non_Zeroed: - assert(size >= 0, "Size must be positive or zero.", location) - assert(old_size >= 0, "Old size must be positive or zero.", location) - assert(is_power_of_two(cast(uintptr)alignment), "Alignment must be a power of two.", location) - result = rb_resize_non_zeroed(stack, old_memory, old_size, size, alignment) or_return - #no_bounds_check if mode == .Resize && size > old_size { - zero_slice(result[old_size:]) - } + return nil, nil + case .Resize: + return rb_resize_bytes(stack, byte_slice(old_memory, old_size), size, alignment, loc) + case .Resize_Non_Zeroed: + return rb_resize_bytes_non_zeroed(stack, byte_slice(old_memory, old_size), size, alignment, loc) case .Query_Features: set := (^Allocator_Mode_Set)(old_memory) if set != nil { From 4f3f256375e3ae7e9ac0420fa41a7e6cead4ad72 Mon Sep 17 00:00:00 2001 From: Laytan Laats Date: Sat, 14 Sep 2024 15:52:37 +0200 Subject: [PATCH 58/72] improve bit field debug info --- src/llvm_backend_debug.cpp | 80 +++++++++++++++++++++----------------- 1 file changed, 44 insertions(+), 36 deletions(-) diff --git a/src/llvm_backend_debug.cpp b/src/llvm_backend_debug.cpp index 68e1efc1c..bb6a1ba4f 100644 --- a/src/llvm_backend_debug.cpp +++ b/src/llvm_backend_debug.cpp @@ -552,6 +552,48 @@ gb_internal LLVMMetadataRef lb_debug_bitset(lbModule *m, Type *type, String name return final_decl; } +gb_internal LLVMMetadataRef lb_debug_bitfield(lbModule *m, Type *type, String name, LLVMMetadataRef scope, LLVMMetadataRef file, unsigned line) { + Type *bt = base_type(type); + GB_ASSERT(bt->kind == Type_BitField); + + lb_debug_file_line(m, bt->BitField.node, &file, &line); + + u64 size_in_bits = 8*type_size_of(bt); + u32 align_in_bits = 8*cast(u32)type_align_of(bt); + + unsigned element_count = cast(unsigned)bt->BitField.fields.count; + LLVMMetadataRef *elements = gb_alloc_array(permanent_allocator(), LLVMMetadataRef, element_count); + + u64 offset_in_bits = 0; + for (unsigned i = 0; i < element_count; i++) { + Entity *f = bt->BitField.fields[i]; + u8 bit_size = bt->BitField.bit_sizes[i]; + GB_ASSERT(f->kind == Entity_Variable); + String name = f->token.string; + elements[i] = LLVMDIBuilderCreateBitFieldMemberType(m->debug_builder, scope, cast(char const *)name.text, name.len, file, line, + bit_size, offset_in_bits, offset_in_bits, + LLVMDIFlagZero, lb_debug_type(m, f->type) + ); + + offset_in_bits += bit_size; + } + + LLVMMetadataRef final_decl = LLVMDIBuilderCreateStructType( + m->debug_builder, scope, + cast(char const *)name.text, cast(size_t)name.len, + file, line, + size_in_bits, align_in_bits, + LLVMDIFlagZero, + nullptr, + elements, element_count, + 0, + nullptr, + "", 0 + ); + lb_set_llvm_metadata(m, type, final_decl); + return final_decl; +} + gb_internal LLVMMetadataRef lb_debug_enum(lbModule *m, Type *type, String name, LLVMMetadataRef scope, LLVMMetadataRef file, unsigned line) { Type *bt = base_type(type); GB_ASSERT(bt->kind == Type_Enum); @@ -816,6 +858,7 @@ gb_internal LLVMMetadataRef lb_debug_type_internal(lbModule *m, Type *type) { case Type_Union: return lb_debug_union( m, type, make_string_c(type_to_string(type, temporary_allocator())), nullptr, nullptr, 0); case Type_BitSet: return lb_debug_bitset( m, type, make_string_c(type_to_string(type, temporary_allocator())), nullptr, nullptr, 0); case Type_Enum: return lb_debug_enum( m, type, make_string_c(type_to_string(type, temporary_allocator())), nullptr, nullptr, 0); + case Type_BitField: return lb_debug_bitfield( m, type, make_string_c(type_to_string(type, temporary_allocator())), nullptr, nullptr, 0); case Type_Tuple: if (type->Tuple.variables.count == 1) { @@ -901,42 +944,6 @@ gb_internal LLVMMetadataRef lb_debug_type_internal(lbModule *m, Type *type) { lb_debug_type(m, type->Matrix.elem), subscripts, gb_count_of(subscripts)); } - - case Type_BitField: { - LLVMMetadataRef parent_scope = nullptr; - LLVMMetadataRef scope = nullptr; - LLVMMetadataRef file = nullptr; - unsigned line = 0; - u64 size_in_bits = 8*cast(u64)type_size_of(type); - u32 align_in_bits = 8*cast(u32)type_align_of(type); - LLVMDIFlags flags = LLVMDIFlagZero; - - unsigned element_count = cast(unsigned)type->BitField.fields.count; - LLVMMetadataRef *elements = gb_alloc_array(permanent_allocator(), LLVMMetadataRef, element_count); - - u64 offset_in_bits = 0; - for (unsigned i = 0; i < element_count; i++) { - Entity *f = type->BitField.fields[i]; - u8 bit_size = type->BitField.bit_sizes[i]; - GB_ASSERT(f->kind == Entity_Variable); - String name = f->token.string; - unsigned field_line = 0; - LLVMDIFlags field_flags = LLVMDIFlagZero; - elements[i] = LLVMDIBuilderCreateBitFieldMemberType(m->debug_builder, scope, cast(char const *)name.text, name.len, file, field_line, - bit_size, offset_in_bits, offset_in_bits, - field_flags, lb_debug_type(m, f->type) - ); - - offset_in_bits += bit_size; - } - - - return LLVMDIBuilderCreateStructType(m->debug_builder, parent_scope, "", 0, file, line, - size_in_bits, align_in_bits, flags, - nullptr, elements, element_count, 0, nullptr, - "", 0 - ); - } } GB_PANIC("Invalid type %s", type_to_string(type)); @@ -1022,6 +1029,7 @@ gb_internal LLVMMetadataRef lb_debug_type(lbModule *m, Type *type) { case Type_Union: return lb_debug_union(m, type, name, scope, file, line); case Type_BitSet: return lb_debug_bitset(m, type, name, scope, file, line); case Type_Enum: return lb_debug_enum(m, type, name, scope, file, line); + case Type_BitField: return lb_debug_bitfield(m, type, name, scope, file, line); } } From 603efa860a5631f1708f6761d753146b6d47b4ba Mon Sep 17 00:00:00 2001 From: Laytan Laats Date: Sat, 14 Sep 2024 21:43:25 +0200 Subject: [PATCH 59/72] add '#caller_expression' --- base/runtime/core_builtin.odin | 4 +-- core/odin/parser/parser.odin | 10 ++++++ core/testing/testing.odin | 12 ++++--- src/check_builtin.cpp | 16 +++++++++ src/check_expr.cpp | 7 +++- src/check_type.cpp | 32 ++++++++++++++++++ src/entity.cpp | 1 + src/llvm_backend.hpp | 2 +- src/llvm_backend_proc.cpp | 62 +++++++++++++++++++++++++++++++--- 9 files changed, 133 insertions(+), 13 deletions(-) diff --git a/base/runtime/core_builtin.odin b/base/runtime/core_builtin.odin index 8157afe09..67d249d11 100644 --- a/base/runtime/core_builtin.odin +++ b/base/runtime/core_builtin.odin @@ -913,7 +913,7 @@ card :: proc "contextless" (s: $S/bit_set[$E; $U]) -> int { @builtin @(disabled=ODIN_DISABLE_ASSERT) -assert :: proc(condition: bool, message := "", loc := #caller_location) { +assert :: proc(condition: bool, message := #caller_expression(condition), loc := #caller_location) { if !condition { // NOTE(bill): This is wrapped in a procedure call // to improve performance to make the CPU not @@ -952,7 +952,7 @@ unimplemented :: proc(message := "", loc := #caller_location) -> ! { @builtin @(disabled=ODIN_DISABLE_ASSERT) -assert_contextless :: proc "contextless" (condition: bool, message := "", loc := #caller_location) { +assert_contextless :: proc "contextless" (condition: bool, message := #caller_expression(condition), loc := #caller_location) { if !condition { // NOTE(bill): This is wrapped in a procedure call // to improve performance to make the CPU not diff --git a/core/odin/parser/parser.odin b/core/odin/parser/parser.odin index aab59c29d..6f42c17db 100644 --- a/core/odin/parser/parser.odin +++ b/core/odin/parser/parser.odin @@ -2277,6 +2277,16 @@ parse_operand :: proc(p: ^Parser, lhs: bool) -> ^ast.Expr { bd.name = name.text return bd + case "caller_expression": + bd := ast.new(ast.Basic_Directive, tok.pos, end_pos(name)) + bd.tok = tok + bd.name = name.text + + if peek_token_kind(p, .Open_Paren) { + return parse_call_expr(p, bd) + } + return bd + case "location", "exists", "load", "load_directory", "load_hash", "hash", "assert", "panic", "defined", "config": bd := ast.new(ast.Basic_Directive, tok.pos, end_pos(name)) bd.tok = tok diff --git a/core/testing/testing.odin b/core/testing/testing.odin index d5e7c6830..09bf6dc0e 100644 --- a/core/testing/testing.odin +++ b/core/testing/testing.odin @@ -105,9 +105,13 @@ cleanup :: proc(t: ^T, procedure: proc(rawptr), user_data: rawptr) { append(&t.cleanups, Internal_Cleanup{procedure, user_data, context}) } -expect :: proc(t: ^T, ok: bool, msg: string = "", loc := #caller_location) -> bool { +expect :: proc(t: ^T, ok: bool, msg := "", expr := #caller_expression(ok), loc := #caller_location) -> bool { if !ok { - log.error(msg, location=loc) + if msg == "" { + log.errorf("expected %v to be true", expr, location=loc) + } else { + log.error(msg, location=loc) + } } return ok } @@ -119,10 +123,10 @@ expectf :: proc(t: ^T, ok: bool, format: string, args: ..any, loc := #caller_loc return ok } -expect_value :: proc(t: ^T, value, expected: $T, loc := #caller_location) -> bool where intrinsics.type_is_comparable(T) { +expect_value :: proc(t: ^T, value, expected: $T, loc := #caller_location, value_expr := #caller_expression(value)) -> bool where intrinsics.type_is_comparable(T) { ok := value == expected || reflect.is_nil(value) && reflect.is_nil(expected) if !ok { - log.errorf("expected %v, got %v", expected, value, location=loc) + log.errorf("expected %v to be %v, got %v", value_expr, expected, value, location=loc) } return ok } diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp index 888aa074d..909eb668e 100644 --- a/src/check_builtin.cpp +++ b/src/check_builtin.cpp @@ -1632,6 +1632,22 @@ gb_internal bool check_builtin_procedure_directive(CheckerContext *c, Operand *o operand->type = t_source_code_location; operand->mode = Addressing_Value; + } else if (name == "caller_expression") { + if (ce->args.count > 1) { + error(ce->args[0], "'#caller_expression' expects either 0 or 1 arguments, got %td", ce->args.count); + } + if (ce->args.count > 0) { + Ast *arg = ce->args[0]; + Operand o = {}; + Entity *e = check_ident(c, &o, arg, nullptr, nullptr, true); + if (e == nullptr || (e->flags & EntityFlag_Param) == 0) { + error(ce->args[0], "'#caller_expression' expected a valid earlier parameter name"); + } + arg->Ident.entity = e; + } + + operand->type = t_string; + operand->mode = Addressing_Value; } else if (name == "exists") { if (ce->args.count != 1) { error(ce->close, "'#exists' expects 1 argument, got %td", ce->args.count); diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 7f82fb58a..6776094bf 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -7807,7 +7807,8 @@ gb_internal ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *c name == "load" || name == "load_directory" || name == "load_hash" || - name == "hash" + name == "hash" || + name == "caller_expression" ) { operand->mode = Addressing_Builtin; operand->builtin_id = BuiltinProc_DIRECTIVE; @@ -8725,6 +8726,10 @@ gb_internal ExprKind check_basic_directive_expr(CheckerContext *c, Operand *o, A error(node, "#caller_location may only be used as a default argument parameter"); o->type = t_source_code_location; o->mode = Addressing_Value; + } else if (name == "caller_expression") { + error(node, "#caller_expression may only be used as a default argument parameter"); + o->type = t_string; + o->mode = Addressing_Value; } else { if (name == "location") { init_core_source_code_location(c->checker); diff --git a/src/check_type.cpp b/src/check_type.cpp index 3767f7666..f0e0acb9b 100644 --- a/src/check_type.cpp +++ b/src/check_type.cpp @@ -1605,6 +1605,25 @@ gb_internal bool is_expr_from_a_parameter(CheckerContext *ctx, Ast *expr) { return false; } +gb_internal bool is_caller_expression(Ast *expr) { + if (expr->kind == Ast_BasicDirective && expr->BasicDirective.name.string == "caller_expression") { + return true; + } + + Ast *call = unparen_expr(expr); + if (call->kind != Ast_CallExpr) { + return false; + } + + ast_node(ce, CallExpr, call); + if (ce->proc->kind != Ast_BasicDirective) { + return false; + } + + ast_node(bd, BasicDirective, ce->proc); + String name = bd->name.string; + return name == "caller_expression"; +} gb_internal ParameterValue handle_parameter_value(CheckerContext *ctx, Type *in_type, Type **out_type_, Ast *expr, bool allow_caller_location) { ParameterValue param_value = {}; @@ -1626,7 +1645,19 @@ gb_internal ParameterValue handle_parameter_value(CheckerContext *ctx, Type *in_ if (in_type) { check_assignment(ctx, &o, in_type, str_lit("parameter value")); } + } else if (is_caller_expression(expr)) { + if (expr->kind != Ast_BasicDirective) { + check_builtin_procedure_directive(ctx, &o, expr, t_string); + } + param_value.kind = ParameterValue_Expression; + o.type = t_string; + o.mode = Addressing_Value; + o.expr = expr; + + if (in_type) { + check_assignment(ctx, &o, in_type, str_lit("parameter value")); + } } else { if (in_type) { check_expr_with_type_hint(ctx, &o, expr, in_type); @@ -1858,6 +1889,7 @@ gb_internal Type *check_get_params(CheckerContext *ctx, Scope *scope, Ast *_para case ParameterValue_Nil: break; case ParameterValue_Location: + case ParameterValue_Expression: case ParameterValue_Value: gbString str = type_to_string(type); error(params[i], "A default value for a parameter must not be a polymorphic constant type, got %s", str); diff --git a/src/entity.cpp b/src/entity.cpp index db6ffdd52..0c4a20df4 100644 --- a/src/entity.cpp +++ b/src/entity.cpp @@ -104,6 +104,7 @@ enum ParameterValueKind { ParameterValue_Constant, ParameterValue_Nil, ParameterValue_Location, + ParameterValue_Expression, ParameterValue_Value, }; diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp index 29d2ccfe6..68f95cb03 100644 --- a/src/llvm_backend.hpp +++ b/src/llvm_backend.hpp @@ -528,7 +528,7 @@ gb_internal lbAddr lb_store_range_stmt_val(lbProcedure *p, Ast *stmt_val, lbValu gb_internal lbValue lb_emit_source_code_location_const(lbProcedure *p, String const &procedure, TokenPos const &pos); gb_internal lbValue lb_const_source_code_location_const(lbModule *m, String const &procedure, TokenPos const &pos); -gb_internal lbValue lb_handle_param_value(lbProcedure *p, Type *parameter_type, ParameterValue const ¶m_value, TokenPos const &pos); +gb_internal lbValue lb_handle_param_value(lbProcedure *p, Type *parameter_type, ParameterValue const ¶m_value, TypeProc *procedure_type, Ast *call_expression); gb_internal lbValue lb_equal_proc_for_type(lbModule *m, Type *type); gb_internal lbValue lb_hasher_proc_for_type(lbModule *m, Type *type); diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp index e850d3364..d84599eb0 100644 --- a/src/llvm_backend_proc.cpp +++ b/src/llvm_backend_proc.cpp @@ -699,7 +699,9 @@ gb_internal void lb_begin_procedure_body(lbProcedure *p) { } if (e->Variable.param_value.kind != ParameterValue_Invalid) { - lbValue c = lb_handle_param_value(p, e->type, e->Variable.param_value, e->token.pos); + GB_ASSERT(e->Variable.param_value.kind != ParameterValue_Location); + GB_ASSERT(e->Variable.param_value.kind != ParameterValue_Expression); + lbValue c = lb_handle_param_value(p, e->type, e->Variable.param_value, nullptr, nullptr); lb_addr_store(p, res, c); } @@ -3420,7 +3422,7 @@ gb_internal lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValu } -gb_internal lbValue lb_handle_param_value(lbProcedure *p, Type *parameter_type, ParameterValue const ¶m_value, TokenPos const &pos) { +gb_internal lbValue lb_handle_param_value(lbProcedure *p, Type *parameter_type, ParameterValue const ¶m_value, TypeProc *procedure_type, Ast* call_expression) { switch (param_value.kind) { case ParameterValue_Constant: if (is_type_constant_type(parameter_type)) { @@ -3446,8 +3448,60 @@ gb_internal lbValue lb_handle_param_value(lbProcedure *p, Type *parameter_type, if (p->entity != nullptr) { proc_name = p->entity->token.string; } + + ast_node(ce, CallExpr, call_expression); + TokenPos pos = ast_token(ce->proc).pos; + return lb_emit_source_code_location_as_global(p, proc_name, pos); } + case ParameterValue_Expression: + { + Ast *orig = param_value.original_ast_expr; + if (orig->kind == Ast_BasicDirective) { + gbString expr = expr_to_string(call_expression, temporary_allocator()); + return lb_const_string(p->module, make_string_c(expr)); + } + + isize param_idx = -1; + String param_str = {0}; + { + Ast *call = unparen_expr(orig); + GB_ASSERT(call->kind == Ast_CallExpr); + ast_node(ce, CallExpr, call); + GB_ASSERT(ce->proc->kind == Ast_BasicDirective); + GB_ASSERT(ce->args.count == 1); + Ast *target = ce->args[0]; + GB_ASSERT(target->kind == Ast_Ident); + String target_str = target->Ident.token.string; + + param_idx = lookup_procedure_parameter(procedure_type, target_str); + param_str = target_str; + } + GB_ASSERT(param_idx >= 0); + + + Ast *target_expr = nullptr; + ast_node(ce, CallExpr, call_expression); + + if (ce->split_args->positional.count > param_idx) { + target_expr = ce->split_args->positional[param_idx]; + } + + for_array(i, ce->split_args->named) { + Ast *arg = ce->split_args->named[i]; + ast_node(fv, FieldValue, arg); + GB_ASSERT(fv->field->kind == Ast_Ident); + String name = fv->field->Ident.token.string; + if (name == param_str) { + target_expr = fv->value; + break; + } + } + + gbString expr = expr_to_string(target_expr, temporary_allocator()); + return lb_const_string(p->module, make_string_c(expr)); + } + case ParameterValue_Value: return lb_build_expr(p, param_value.ast_value); } @@ -3739,8 +3793,6 @@ gb_internal lbValue lb_build_call_expr_internal(lbProcedure *p, Ast *expr) { } } - TokenPos pos = ast_token(ce->proc).pos; - if (pt->params != nullptr) { isize min_count = pt->params->Tuple.variables.count; @@ -3764,7 +3816,7 @@ gb_internal lbValue lb_build_call_expr_internal(lbProcedure *p, Ast *expr) { args[arg_index] = lb_const_nil(p->module, e->type); break; case Entity_Variable: - args[arg_index] = lb_handle_param_value(p, e->type, e->Variable.param_value, pos); + args[arg_index] = lb_handle_param_value(p, e->type, e->Variable.param_value, pt, expr); break; case Entity_Constant: From d03d9e49a6290b29a3259f99c4cdf574988b5765 Mon Sep 17 00:00:00 2001 From: Laytan Laats Date: Sun, 15 Sep 2024 00:03:20 +0200 Subject: [PATCH 60/72] fix #4243 --- src/llvm_backend_debug.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/llvm_backend_debug.cpp b/src/llvm_backend_debug.cpp index bb6a1ba4f..5cc79dcc8 100644 --- a/src/llvm_backend_debug.cpp +++ b/src/llvm_backend_debug.cpp @@ -571,7 +571,7 @@ gb_internal LLVMMetadataRef lb_debug_bitfield(lbModule *m, Type *type, String na GB_ASSERT(f->kind == Entity_Variable); String name = f->token.string; elements[i] = LLVMDIBuilderCreateBitFieldMemberType(m->debug_builder, scope, cast(char const *)name.text, name.len, file, line, - bit_size, offset_in_bits, offset_in_bits, + bit_size, offset_in_bits, 0, LLVMDIFlagZero, lb_debug_type(m, f->type) ); From d38f5ffb49733b5084b9419412acf9381e3073d4 Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Sun, 15 Sep 2024 22:00:53 -0400 Subject: [PATCH 61/72] Remove unneeded synchronizations in `Chan` Everything was already guarded by `c.mutex`. --- core/sync/chan/chan.odin | 78 ++++++++++++++++++---------------------- 1 file changed, 35 insertions(+), 43 deletions(-) diff --git a/core/sync/chan/chan.odin b/core/sync/chan/chan.odin index 5b9a764b4..c470d15f3 100644 --- a/core/sync/chan/chan.odin +++ b/core/sync/chan/chan.odin @@ -22,19 +22,17 @@ Raw_Chan :: struct { allocator: runtime.Allocator, allocation_size: int, msg_size: u16, - closed: b16, // atomic + closed: b16, // guarded by `mutex` mutex: sync.Mutex, r_cond: sync.Cond, w_cond: sync.Cond, - r_waiting: int, // atomic - w_waiting: int, // atomic + r_waiting: int, // guarded by `mutex` + w_waiting: int, // guarded by `mutex` // Buffered queue: ^Raw_Queue, // Unbuffered - r_mutex: sync.Mutex, - w_mutex: sync.Mutex, unbuffered_data: rawptr, } @@ -164,32 +162,30 @@ send_raw :: proc "contextless" (c: ^Raw_Chan, msg_in: rawptr) -> (ok: bool) { } if c.queue != nil { // buffered sync.guard(&c.mutex) - for !sync.atomic_load(&c.closed) && - c.queue.len == c.queue.cap { - sync.atomic_add(&c.w_waiting, 1) + for !c.closed && c.queue.len == c.queue.cap { + c.w_waiting += 1 sync.wait(&c.w_cond, &c.mutex) - sync.atomic_sub(&c.w_waiting, 1) + c.w_waiting -= 1 } - if sync.atomic_load(&c.closed) { + if c.closed { return false } ok = raw_queue_push(c.queue, msg_in) - if sync.atomic_load(&c.r_waiting) > 0 { + if c.r_waiting > 0 { sync.signal(&c.r_cond) } } else if c.unbuffered_data != nil { // unbuffered - sync.guard(&c.w_mutex) sync.guard(&c.mutex) - if sync.atomic_load(&c.closed) { + if c.closed { return false } mem.copy(c.unbuffered_data, msg_in, int(c.msg_size)) - sync.atomic_add(&c.w_waiting, 1) - if sync.atomic_load(&c.r_waiting) > 0 { + c.w_waiting += 1 + if c.r_waiting > 0 { sync.signal(&c.r_cond) } sync.wait(&c.w_cond, &c.mutex) @@ -206,13 +202,13 @@ recv_raw :: proc "contextless" (c: ^Raw_Chan, msg_out: rawptr) -> (ok: bool) { if c.queue != nil { // buffered sync.guard(&c.mutex) for c.queue.len == 0 { - if sync.atomic_load(&c.closed) { + if c.closed { return } - sync.atomic_add(&c.r_waiting, 1) + c.r_waiting += 1 sync.wait(&c.r_cond, &c.mutex) - sync.atomic_sub(&c.r_waiting, 1) + c.r_waiting -= 1 } msg := raw_queue_pop(c.queue) @@ -220,27 +216,26 @@ recv_raw :: proc "contextless" (c: ^Raw_Chan, msg_out: rawptr) -> (ok: bool) { mem.copy(msg_out, msg, int(c.msg_size)) } - if sync.atomic_load(&c.w_waiting) > 0 { + if c.w_waiting > 0 { sync.signal(&c.w_cond) } ok = true } else if c.unbuffered_data != nil { // unbuffered - sync.guard(&c.r_mutex) sync.guard(&c.mutex) - for !sync.atomic_load(&c.closed) && - sync.atomic_load(&c.w_waiting) == 0 { - sync.atomic_add(&c.r_waiting, 1) + for !c.closed && + c.w_waiting == 0 { + c.r_waiting += 1 sync.wait(&c.r_cond, &c.mutex) - sync.atomic_sub(&c.r_waiting, 1) + c.r_waiting -= 1 } - if sync.atomic_load(&c.closed) { + if c.closed { return } mem.copy(msg_out, c.unbuffered_data, int(c.msg_size)) - sync.atomic_sub(&c.w_waiting, 1) + c.w_waiting -= 1 sync.signal(&c.w_cond) ok = true @@ -260,25 +255,24 @@ try_send_raw :: proc "contextless" (c: ^Raw_Chan, msg_in: rawptr) -> (ok: bool) return false } - if sync.atomic_load(&c.closed) { + if c.closed { return false } ok = raw_queue_push(c.queue, msg_in) - if sync.atomic_load(&c.r_waiting) > 0 { + if c.r_waiting > 0 { sync.signal(&c.r_cond) } } else if c.unbuffered_data != nil { // unbuffered - sync.guard(&c.w_mutex) sync.guard(&c.mutex) - if sync.atomic_load(&c.closed) { + if c.closed { return false } mem.copy(c.unbuffered_data, msg_in, int(c.msg_size)) - sync.atomic_add(&c.w_waiting, 1) - if sync.atomic_load(&c.r_waiting) > 0 { + c.w_waiting += 1 + if c.r_waiting > 0 { sync.signal(&c.r_cond) } sync.wait(&c.w_cond, &c.mutex) @@ -303,21 +297,19 @@ try_recv_raw :: proc "contextless" (c: ^Raw_Chan, msg_out: rawptr) -> bool { mem.copy(msg_out, msg, int(c.msg_size)) } - if sync.atomic_load(&c.w_waiting) > 0 { + if c.w_waiting > 0 { sync.signal(&c.w_cond) } return true } else if c.unbuffered_data != nil { // unbuffered - sync.guard(&c.r_mutex) sync.guard(&c.mutex) - if sync.atomic_load(&c.closed) || - sync.atomic_load(&c.w_waiting) == 0 { + if c.closed || c.w_waiting == 0 { return false } mem.copy(msg_out, c.unbuffered_data, int(c.msg_size)) - sync.atomic_sub(&c.w_waiting, 1) + c.w_waiting -= 1 sync.signal(&c.w_cond) return true @@ -360,10 +352,10 @@ close :: proc "contextless" (c: ^Raw_Chan) -> bool { return false } sync.guard(&c.mutex) - if sync.atomic_load(&c.closed) { + if c.closed { return false } - sync.atomic_store(&c.closed, true) + c.closed = true sync.broadcast(&c.r_cond) sync.broadcast(&c.w_cond) return true @@ -375,7 +367,7 @@ is_closed :: proc "contextless" (c: ^Raw_Chan) -> bool { return true } sync.guard(&c.mutex) - return bool(sync.atomic_load(&c.closed)) + return bool(c.closed) } @@ -434,7 +426,7 @@ can_recv :: proc "contextless" (c: ^Raw_Chan) -> bool { if is_buffered(c) { return c.queue.len > 0 } - return sync.atomic_load(&c.w_waiting) > 0 + return c.w_waiting > 0 } @@ -444,7 +436,7 @@ can_send :: proc "contextless" (c: ^Raw_Chan) -> bool { if is_buffered(c) { return c.queue.len < c.queue.cap } - return sync.atomic_load(&c.w_waiting) == 0 + return c.w_waiting == 0 } @@ -493,4 +485,4 @@ select_raw :: proc "odin" (recvs: []^Raw_Chan, sends: []^Raw_Chan, send_msgs: [] ok = send_raw(sends[sel.idx], send_msgs[sel.idx]) } return -} \ No newline at end of file +} From 16ef59700b68989beff48039a450ef6153b2e6af Mon Sep 17 00:00:00 2001 From: Feoramund <161657516+Feoramund@users.noreply.github.com> Date: Sun, 15 Sep 2024 23:58:03 -0400 Subject: [PATCH 62/72] Check for `EINTR` in `sys/posix` test --- tests/core/sys/posix/structs.odin | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/core/sys/posix/structs.odin b/tests/core/sys/posix/structs.odin index bdb1c24e3..95b6258f4 100644 --- a/tests/core/sys/posix/structs.odin +++ b/tests/core/sys/posix/structs.odin @@ -63,6 +63,9 @@ execute_struct_checks :: proc(t: ^testing.T) { waiting: for { status: i32 wpid := posix.waitpid(pid, &status, {}) + if status == posix.EINTR { + continue + } if !testing.expectf(t, wpid != -1, "waitpid() failure: %v", posix.strerror()) { return false } From fff99c726e53808b5b75a89ae66e5e84ab19268e Mon Sep 17 00:00:00 2001 From: pkova Date: Tue, 17 Sep 2024 01:52:51 +0300 Subject: [PATCH 63/72] Fix core sync test deadlock on darwin --- core/sync/futex_darwin.odin | 10 ++++++++-- core/sys/darwin/sync.odin | 7 +++++++ tests/core/sync/test_core_sync.odin | 1 - 3 files changed, 15 insertions(+), 3 deletions(-) diff --git a/core/sync/futex_darwin.odin b/core/sync/futex_darwin.odin index daefd6699..3915a414d 100644 --- a/core/sync/futex_darwin.odin +++ b/core/sync/futex_darwin.odin @@ -12,6 +12,7 @@ foreign System { // __ulock_wait is not available on 10.15 // See https://github.com/odin-lang/Odin/issues/1959 __ulock_wait :: proc "c" (operation: u32, addr: rawptr, value: u64, timeout_us: u32) -> c.int --- + __ulock_wait2 :: proc "c" (operation: u32, addr: rawptr, value: u64, timeout_ns: u64, value2: u64) -> c.int --- __ulock_wake :: proc "c" (operation: u32, addr: rawptr, wake_value: u64) -> c.int --- } @@ -52,8 +53,13 @@ _futex_wait_with_timeout :: proc "contextless" (f: ^Futex, expected: u32, durati } } else { - timeout_ns := u32(duration) - s := __ulock_wait(UL_COMPARE_AND_WAIT | ULF_NO_ERRNO, f, u64(expected), timeout_ns) + when darwin.ULOCK_WAIT_2_AVAILABLE { + timeout_ns := u64(duration) + s := __ulock_wait2(UL_COMPARE_AND_WAIT | ULF_NO_ERRNO, f, u64(expected), timeout_ns, 0) + } else { + timeout_us := u32(duration) + s := __ulock_wait(UL_COMPARE_AND_WAIT | ULF_NO_ERRNO, f, u64(expected), timeout_us) + } if s >= 0 { return true } diff --git a/core/sys/darwin/sync.odin b/core/sys/darwin/sync.odin index 121d3edef..e90f30162 100644 --- a/core/sys/darwin/sync.odin +++ b/core/sys/darwin/sync.odin @@ -12,8 +12,15 @@ when ODIN_OS == .Darwin { } else { WAIT_ON_ADDRESS_AVAILABLE :: false } + when ODIN_MINIMUM_OS_VERSION >= 11_00_00 { + ULOCK_WAIT_2_AVAILABLE :: true + } else { + ULOCK_WAIT_2_AVAILABLE :: false + } + } else { WAIT_ON_ADDRESS_AVAILABLE :: false + ULOCK_WAIT_2_AVAILABLE :: false } os_sync_wait_on_address_flag :: enum u32 { diff --git a/tests/core/sync/test_core_sync.odin b/tests/core/sync/test_core_sync.odin index 32c08f935..fdd865686 100644 --- a/tests/core/sync/test_core_sync.odin +++ b/tests/core/sync/test_core_sync.odin @@ -8,7 +8,6 @@ // These tests are temporarily disabled on Darwin, as there is currently a // stall occurring which I cannot debug. -//+build !darwin package test_core_sync import "base:intrinsics" From aa25714d43716a857219d42796ade19de6c5ef70 Mon Sep 17 00:00:00 2001 From: pkova Date: Tue, 17 Sep 2024 02:11:41 +0300 Subject: [PATCH 64/72] Remove comment from core sync tests now that they're fixed --- tests/core/sync/test_core_sync.odin | 3 --- 1 file changed, 3 deletions(-) diff --git a/tests/core/sync/test_core_sync.odin b/tests/core/sync/test_core_sync.odin index fdd865686..d6a7a9517 100644 --- a/tests/core/sync/test_core_sync.odin +++ b/tests/core/sync/test_core_sync.odin @@ -4,9 +4,6 @@ // Keep in mind that running with the debug logs uncommented can result in // failures disappearing due to the delay of sending the log message causing // different synchronization patterns. -// -// These tests are temporarily disabled on Darwin, as there is currently a -// stall occurring which I cannot debug. package test_core_sync From 4d6f7dcac01061ee3060c14bb10e27f101998140 Mon Sep 17 00:00:00 2001 From: Pyry Kovanen Date: Tue, 17 Sep 2024 02:21:00 +0300 Subject: [PATCH 65/72] Fix code alignment in futex_darwin.odin Co-authored-by: Feoramund <161657516+Feoramund@users.noreply.github.com> --- core/sync/futex_darwin.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sync/futex_darwin.odin b/core/sync/futex_darwin.odin index 3915a414d..5567be963 100644 --- a/core/sync/futex_darwin.odin +++ b/core/sync/futex_darwin.odin @@ -12,7 +12,7 @@ foreign System { // __ulock_wait is not available on 10.15 // See https://github.com/odin-lang/Odin/issues/1959 __ulock_wait :: proc "c" (operation: u32, addr: rawptr, value: u64, timeout_us: u32) -> c.int --- - __ulock_wait2 :: proc "c" (operation: u32, addr: rawptr, value: u64, timeout_ns: u64, value2: u64) -> c.int --- + __ulock_wait2 :: proc "c" (operation: u32, addr: rawptr, value: u64, timeout_ns: u64, value2: u64) -> c.int --- __ulock_wake :: proc "c" (operation: u32, addr: rawptr, wake_value: u64) -> c.int --- } From 6e0f1cc866e8a566a46ccaf9f14879e7ac344fe2 Mon Sep 17 00:00:00 2001 From: pkova Date: Tue, 17 Sep 2024 02:35:00 +0300 Subject: [PATCH 66/72] Pass microseconds instead of nanoseconds to __ulock_wait --- core/sync/futex_darwin.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sync/futex_darwin.odin b/core/sync/futex_darwin.odin index 5567be963..32fdb1552 100644 --- a/core/sync/futex_darwin.odin +++ b/core/sync/futex_darwin.odin @@ -57,7 +57,7 @@ _futex_wait_with_timeout :: proc "contextless" (f: ^Futex, expected: u32, durati timeout_ns := u64(duration) s := __ulock_wait2(UL_COMPARE_AND_WAIT | ULF_NO_ERRNO, f, u64(expected), timeout_ns, 0) } else { - timeout_us := u32(duration) + timeout_us := u32(duration) * 1000 s := __ulock_wait(UL_COMPARE_AND_WAIT | ULF_NO_ERRNO, f, u64(expected), timeout_us) } if s >= 0 { From abf6ea7732b855dcb0ddb549a6454f99c40b7328 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 17 Sep 2024 10:24:19 +0100 Subject: [PATCH 67/72] Fix minor bug with addressability --- src/check_stmt.cpp | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index c8717ba98..74a9e8825 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -1641,6 +1641,8 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) Ast *expr = unparen_expr(rs->expr); + Operand rhs_operand = {}; + bool is_range = false; bool is_possibly_addressable = true; isize max_val_count = 2; @@ -1698,7 +1700,7 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) } } } - bool is_ptr = is_type_pointer(type_deref(operand.type)); + bool is_ptr = is_type_pointer(operand.type); Type *t = base_type(type_deref(operand.type)); switch (t->kind) { @@ -1750,16 +1752,19 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) break; case Type_DynamicArray: + is_possibly_addressable = true; array_add(&vals, t->DynamicArray.elem); array_add(&vals, t_int); break; case Type_Slice: + is_possibly_addressable = true; array_add(&vals, t->Slice.elem); array_add(&vals, t_int); break; case Type_Map: + is_possibly_addressable = true; is_map = true; array_add(&vals, t->Map.key); array_add(&vals, t->Map.value); @@ -1781,6 +1786,8 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) case Type_Tuple: { + is_possibly_addressable = false; + isize count = t->Tuple.variables.count; if (count < 1) { ERROR_BLOCK(); @@ -1810,8 +1817,6 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) array_add(&vals, e->type); } - is_possibly_addressable = false; - bool do_break = false; for (isize i = rs->vals.count-1; i >= 0; i--) { if (rs->vals[i] != nullptr && count < i+2) { @@ -1831,6 +1836,11 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) case Type_Struct: if (t->Struct.soa_kind != StructSoa_None) { + if (t->Struct.soa_kind == StructSoa_Fixed) { + is_possibly_addressable = operand.mode == Addressing_Variable || is_ptr; + } else { + is_possibly_addressable = true; + } is_soa = true; array_add(&vals, t->Struct.soa_elem); array_add(&vals, t_int); @@ -1907,7 +1917,7 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) if (is_possibly_addressable && i == addressable_index) { entity->flags &= ~EntityFlag_Value; } else { - char const *idx_name = is_map ? "key" : is_bit_set ? "element" : "index"; + char const *idx_name = is_map ? "key" : (is_bit_set || i == 0) ? "element" : "index"; error(token, "The %s variable '%.*s' cannot be made addressable", idx_name, LIT(str)); } } From 19c1ed154cc9e36433fe23e1e34810f9c53ec01d Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 17 Sep 2024 11:01:26 +0100 Subject: [PATCH 68/72] Add `-vet-packages:` --- src/build_settings.cpp | 3 +-- src/checker.cpp | 16 ++++------------ src/main.cpp | 30 +++++++++++++++++++++++++++++- src/parser.cpp | 31 ++++++++++++++++++++----------- 4 files changed, 54 insertions(+), 26 deletions(-) diff --git a/src/build_settings.cpp b/src/build_settings.cpp index 1aca5d424..341cbe3e1 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -383,6 +383,7 @@ struct BuildContext { u64 vet_flags; u32 sanitizer_flags; + StringSet vet_packages; bool has_resource; String link_flags; @@ -1462,8 +1463,6 @@ gb_internal void init_build_context(TargetMetrics *cross_target, Subtarget subta bc->thread_count = gb_max(bc->affinity.thread_count, 1); } - string_set_init(&bc->custom_attributes); - bc->ODIN_VENDOR = str_lit("odin"); bc->ODIN_VERSION = ODIN_VERSION; bc->ODIN_ROOT = odin_root_dir(); diff --git a/src/checker.cpp b/src/checker.cpp index 64c66c8a6..deb83bf97 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -533,18 +533,13 @@ gb_internal u64 check_vet_flags(CheckerContext *c) { c->curr_proc_decl->proc_lit) { file = c->curr_proc_decl->proc_lit->file(); } - if (file && file->vet_flags_set) { - return file->vet_flags; - } - return build_context.vet_flags; + + return ast_file_vet_flags(file); } gb_internal u64 check_vet_flags(Ast *node) { AstFile *file = node->file(); - if (file && file->vet_flags_set) { - return file->vet_flags; - } - return build_context.vet_flags; + return ast_file_vet_flags(file); } enum VettedEntityKind { @@ -6497,10 +6492,7 @@ gb_internal void check_parsed_files(Checker *c) { TIME_SECTION("check scope usage"); for (auto const &entry : c->info.files) { AstFile *f = entry.value; - u64 vet_flags = build_context.vet_flags; - if (f->vet_flags_set) { - vet_flags = f->vet_flags; - } + u64 vet_flags = ast_file_vet_flags(f); check_scope_usage(c, f->scope, vet_flags); } diff --git a/src/main.cpp b/src/main.cpp index 06c200442..9b1dcf0fa 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -346,6 +346,7 @@ enum BuildFlagKind { BuildFlag_VetSemicolon, BuildFlag_VetCast, BuildFlag_VetTabs, + BuildFlag_VetPackages, BuildFlag_CustomAttribute, BuildFlag_IgnoreUnknownAttributes, @@ -555,6 +556,7 @@ gb_internal bool parse_build_flags(Array args) { add_flag(&build_flags, BuildFlag_VetSemicolon, str_lit("vet-semicolon"), BuildFlagParam_None, Command__does_check); add_flag(&build_flags, BuildFlag_VetCast, str_lit("vet-cast"), BuildFlagParam_None, Command__does_check); add_flag(&build_flags, BuildFlag_VetTabs, str_lit("vet-tabs"), BuildFlagParam_None, Command__does_check); + add_flag(&build_flags, BuildFlag_VetPackages, str_lit("vet-packages"), BuildFlagParam_String, Command__does_check); add_flag(&build_flags, BuildFlag_CustomAttribute, str_lit("custom-attribute"), BuildFlagParam_String, Command__does_check, true); add_flag(&build_flags, BuildFlag_IgnoreUnknownAttributes, str_lit("ignore-unknown-attributes"), BuildFlagParam_None, Command__does_check); @@ -1221,6 +1223,29 @@ gb_internal bool parse_build_flags(Array args) { case BuildFlag_VetCast: build_context.vet_flags |= VetFlag_Cast; break; case BuildFlag_VetTabs: build_context.vet_flags |= VetFlag_Tabs; break; + case BuildFlag_VetPackages: + { + GB_ASSERT(value.kind == ExactValue_String); + String val = value.value_string; + String_Iterator it = {val, 0}; + for (;;) { + String pkg = string_split_iterator(&it, ','); + if (pkg.len == 0) { + break; + } + + pkg = string_trim_whitespace(pkg); + if (!string_is_valid_identifier(pkg)) { + gb_printf_err("-%.*s '%.*s' must be a valid identifier\n", LIT(name), LIT(pkg)); + bad_flags = true; + continue; + } + + string_set_add(&build_context.vet_packages, pkg); + } + } + break; + case BuildFlag_CustomAttribute: { GB_ASSERT(value.kind == ExactValue_String); @@ -1234,7 +1259,7 @@ gb_internal bool parse_build_flags(Array args) { attr = string_trim_whitespace(attr); if (!string_is_valid_identifier(attr)) { - gb_printf_err("-custom-attribute '%.*s' must be a valid identifier\n", LIT(attr)); + gb_printf_err("-%.*s '%.*s' must be a valid identifier\n", LIT(name), LIT(attr)); bad_flags = true; continue; } @@ -3150,6 +3175,9 @@ int main(int arg_count, char const **arg_ptr) { build_context.command = command; + string_set_init(&build_context.custom_attributes); + string_set_init(&build_context.vet_packages); + if (!parse_build_flags(args)) { return 1; } diff --git a/src/parser.cpp b/src/parser.cpp index 88147d465..56bea8131 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -1,10 +1,28 @@ #include "parser_pos.cpp" +gb_internal bool in_vet_packages(AstFile *file) { + if (file == nullptr) { + return true; + } + if (file->pkg == nullptr) { + return true; + } + if (build_context.vet_packages.entries.count == 0) { + return true; + } + return string_set_exists(&build_context.vet_packages, file->pkg->name); +} + gb_internal u64 ast_file_vet_flags(AstFile *f) { if (f != nullptr && f->vet_flags_set) { return f->vet_flags; } - return build_context.vet_flags; + + bool found = in_vet_packages(f); + if (found) { + return build_context.vet_flags; + } + return 0; } gb_internal bool ast_file_vet_style(AstFile *f) { @@ -5372,18 +5390,9 @@ gb_internal Ast *parse_stmt(AstFile *f) { } - -gb_internal u64 check_vet_flags(AstFile *file) { - if (file && file->vet_flags_set) { - return file->vet_flags; - } - return build_context.vet_flags; -} - - gb_internal void parse_enforce_tabs(AstFile *f) { // Checks to see if tabs have been used for indentation - if ((check_vet_flags(f) & VetFlag_Tabs) == 0) { + if ((ast_file_vet_flags(f) & VetFlag_Tabs) == 0) { return; } From 09588836e73d2def550cf5b1f6dab4d9de237e37 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 17 Sep 2024 11:33:42 +0100 Subject: [PATCH 69/72] Add `-vet-unused-procedures` --- src/build_settings.cpp | 3 +++ src/checker.cpp | 55 ++++++++++++++++++++++++++++++++++++------ src/main.cpp | 21 +++++++++++++++- 3 files changed, 71 insertions(+), 8 deletions(-) diff --git a/src/build_settings.cpp b/src/build_settings.cpp index 341cbe3e1..7aff8e650 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -285,6 +285,7 @@ enum VetFlags : u64 { VetFlag_Deprecated = 1u<<7, VetFlag_Cast = 1u<<8, VetFlag_Tabs = 1u<<9, + VetFlag_UnusedProcedures = 1u<<10, VetFlag_Unused = VetFlag_UnusedVariables|VetFlag_UnusedImports, @@ -316,6 +317,8 @@ u64 get_vet_flag_from_name(String const &name) { return VetFlag_Cast; } else if (name == "tabs") { return VetFlag_Tabs; + } else if (name == "unused-procedures") { + return VetFlag_UnusedProcedures; } return VetFlag_NONE; } diff --git a/src/checker.cpp b/src/checker.cpp index deb83bf97..af1e0e675 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -676,20 +676,45 @@ gb_internal bool check_vet_unused(Checker *c, Entity *e, VettedEntity *ve) { return false; } -gb_internal void check_scope_usage(Checker *c, Scope *scope, u64 vet_flags) { - bool vet_unused = (vet_flags & VetFlag_Unused) != 0; - bool vet_shadowing = (vet_flags & (VetFlag_Shadowing|VetFlag_Using)) != 0; - +gb_internal void check_scope_usage_internal(Checker *c, Scope *scope, u64 vet_flags, bool per_entity) { + u64 original_vet_flags = vet_flags; Array vetted_entities = {}; array_init(&vetted_entities, heap_allocator()); + defer (array_free(&vetted_entities)); rw_mutex_shared_lock(&scope->mutex); for (auto const &entry : scope->elements) { Entity *e = entry.value; if (e == nullptr) continue; + + vet_flags = original_vet_flags; + if (per_entity) { + vet_flags = ast_file_vet_flags(e->file); + } + + bool vet_unused = (vet_flags & VetFlag_Unused) != 0; + bool vet_shadowing = (vet_flags & (VetFlag_Shadowing|VetFlag_Using)) != 0; + bool vet_unused_procedures = (vet_flags & VetFlag_UnusedProcedures) != 0; + VettedEntity ve_unused = {}; VettedEntity ve_shadowed = {}; - bool is_unused = vet_unused && check_vet_unused(c, e, &ve_unused); + bool is_unused = false; + if (vet_unused && check_vet_unused(c, e, &ve_unused)) { + is_unused = true; + } else if (vet_unused_procedures && + e->kind == Entity_Procedure) { + if (e->flags&EntityFlag_Used) { + is_unused = false; + } else if (e->flags & EntityFlag_Require) { + is_unused = false; + } else if (e->pkg && e->pkg->kind == Package_Init && e->token.string == "main") { + is_unused = false; + } else { + is_unused = true; + ve_unused.kind = VettedEntity_Unused; + ve_unused.entity = e; + } + } bool is_shadowed = vet_shadowing && check_vet_shadowing(c, e, &ve_shadowed); if (is_unused && is_shadowed) { VettedEntity ve_both = ve_shadowed; @@ -712,13 +737,18 @@ gb_internal void check_scope_usage(Checker *c, Scope *scope, u64 vet_flags) { } rw_mutex_shared_unlock(&scope->mutex); - gb_sort(vetted_entities.data, vetted_entities.count, gb_size_of(VettedEntity), vetted_entity_variable_pos_cmp); + array_sort(vetted_entities, vetted_entity_variable_pos_cmp); for (auto const &ve : vetted_entities) { Entity *e = ve.entity; Entity *other = ve.other; String name = e->token.string; + vet_flags = original_vet_flags; + if (per_entity) { + vet_flags = ast_file_vet_flags(e->file); + } + if (ve.kind == VettedEntity_Shadowed_And_Unused) { error(e->token, "'%.*s' declared but not used, possibly shadows declaration at line %d", LIT(name), other->token.pos.line); } else if (vet_flags) { @@ -727,6 +757,9 @@ gb_internal void check_scope_usage(Checker *c, Scope *scope, u64 vet_flags) { if (e->kind == Entity_Variable && (vet_flags & VetFlag_UnusedVariables) != 0) { error(e->token, "'%.*s' declared but not used", LIT(name)); } + if (e->kind == Entity_Procedure && (vet_flags & VetFlag_UnusedProcedures) != 0) { + error(e->token, "'%.*s' declared but not used", LIT(name)); + } if ((e->kind == Entity_ImportName || e->kind == Entity_LibraryName) && (vet_flags & VetFlag_UnusedImports) != 0) { error(e->token, "'%.*s' declared but not used", LIT(name)); } @@ -744,7 +777,11 @@ gb_internal void check_scope_usage(Checker *c, Scope *scope, u64 vet_flags) { } } - array_free(&vetted_entities); +} + + +gb_internal void check_scope_usage(Checker *c, Scope *scope, u64 vet_flags) { + check_scope_usage_internal(c, scope, vet_flags, false); for (Scope *child = scope->head_child; child != nullptr; child = child->next) { if (child->flags & (ScopeFlag_Proc|ScopeFlag_Type|ScopeFlag_File)) { @@ -6495,6 +6532,10 @@ gb_internal void check_parsed_files(Checker *c) { u64 vet_flags = ast_file_vet_flags(f); check_scope_usage(c, f->scope, vet_flags); } + for (auto const &entry : c->info.packages) { + AstPackage *pkg = entry.value; + check_scope_usage_internal(c, pkg->scope, 0, true); + } TIME_SECTION("add basic type information"); // Add "Basic" type information diff --git a/src/main.cpp b/src/main.cpp index 9b1dcf0fa..a969e32a9 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -340,6 +340,7 @@ enum BuildFlagKind { BuildFlag_VetUnused, BuildFlag_VetUnusedImports, BuildFlag_VetUnusedVariables, + BuildFlag_VetUnusedProcedures, BuildFlag_VetUsingStmt, BuildFlag_VetUsingParam, BuildFlag_VetStyle, @@ -548,6 +549,7 @@ gb_internal bool parse_build_flags(Array args) { add_flag(&build_flags, BuildFlag_Vet, str_lit("vet"), BuildFlagParam_None, Command__does_check); add_flag(&build_flags, BuildFlag_VetUnused, str_lit("vet-unused"), BuildFlagParam_None, Command__does_check); add_flag(&build_flags, BuildFlag_VetUnusedVariables, str_lit("vet-unused-variables"), BuildFlagParam_None, Command__does_check); + add_flag(&build_flags, BuildFlag_VetUnusedProcedures, str_lit("vet-unused-procedures"), BuildFlagParam_None, Command__does_check); add_flag(&build_flags, BuildFlag_VetUnusedImports, str_lit("vet-unused-imports"), BuildFlagParam_None, Command__does_check); add_flag(&build_flags, BuildFlag_VetShadowing, str_lit("vet-shadowing"), BuildFlagParam_None, Command__does_check); add_flag(&build_flags, BuildFlag_VetUsingStmt, str_lit("vet-using-stmt"), BuildFlagParam_None, Command__does_check); @@ -1222,6 +1224,13 @@ gb_internal bool parse_build_flags(Array args) { case BuildFlag_VetSemicolon: build_context.vet_flags |= VetFlag_Semicolon; break; case BuildFlag_VetCast: build_context.vet_flags |= VetFlag_Cast; break; case BuildFlag_VetTabs: build_context.vet_flags |= VetFlag_Tabs; break; + case BuildFlag_VetUnusedProcedures: + build_context.vet_flags |= VetFlag_UnusedProcedures; + if (!set_flags[BuildFlag_VetPackages]) { + gb_printf_err("-%.*s must be used with -vet-packages\n", LIT(name)); + bad_flags = true; + } + break; case BuildFlag_VetPackages: { @@ -2389,7 +2398,7 @@ gb_internal void print_show_help(String const arg0, String const &command) { print_usage_line(0, ""); print_usage_line(1, "-vet-unused"); - print_usage_line(2, "Checks for unused declarations."); + print_usage_line(2, "Checks for unused declarations (variables and imports)."); print_usage_line(0, ""); print_usage_line(1, "-vet-unused-variables"); @@ -2431,6 +2440,16 @@ gb_internal void print_show_help(String const arg0, String const &command) { print_usage_line(1, "-vet-tabs"); print_usage_line(2, "Errs when the use of tabs has not been used for indentation."); print_usage_line(0, ""); + + print_usage_line(1, "-vet-packages:"); + print_usage_line(2, "Sets which packages by name will be vetted."); + print_usage_line(2, "Files with specific +vet tags will not be ignored if they are not in the packages set."); + print_usage_line(0, ""); + + print_usage_line(1, "-vet-unused-procedures"); + print_usage_line(2, "Checks for unused procedures."); + print_usage_line(2, "Must be used with -vet-packages or specified on a per file with +vet tags."); + print_usage_line(0, ""); } if (check) { From 0975820c48f8e876c2838a5ef94400fdb5db0f87 Mon Sep 17 00:00:00 2001 From: Laytan Laats Date: Tue, 17 Sep 2024 15:52:35 +0200 Subject: [PATCH 70/72] fix wrong ulock timeout calculation, add version check for ios --- core/sync/futex_darwin.odin | 5 ++++- core/sys/darwin/sync.odin | 8 ++++++-- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/core/sync/futex_darwin.odin b/core/sync/futex_darwin.odin index 32fdb1552..87b7b96e6 100644 --- a/core/sync/futex_darwin.odin +++ b/core/sync/futex_darwin.odin @@ -12,6 +12,7 @@ foreign System { // __ulock_wait is not available on 10.15 // See https://github.com/odin-lang/Odin/issues/1959 __ulock_wait :: proc "c" (operation: u32, addr: rawptr, value: u64, timeout_us: u32) -> c.int --- + // >= MacOS 11. __ulock_wait2 :: proc "c" (operation: u32, addr: rawptr, value: u64, timeout_ns: u64, value2: u64) -> c.int --- __ulock_wake :: proc "c" (operation: u32, addr: rawptr, wake_value: u64) -> c.int --- } @@ -57,12 +58,14 @@ _futex_wait_with_timeout :: proc "contextless" (f: ^Futex, expected: u32, durati timeout_ns := u64(duration) s := __ulock_wait2(UL_COMPARE_AND_WAIT | ULF_NO_ERRNO, f, u64(expected), timeout_ns, 0) } else { - timeout_us := u32(duration) * 1000 + timeout_us := u32(duration / time.Microsecond) s := __ulock_wait(UL_COMPARE_AND_WAIT | ULF_NO_ERRNO, f, u64(expected), timeout_us) } + if s >= 0 { return true } + switch s { case EINTR, EFAULT: return true diff --git a/core/sys/darwin/sync.odin b/core/sys/darwin/sync.odin index e90f30162..58fc7c9e4 100644 --- a/core/sys/darwin/sync.odin +++ b/core/sys/darwin/sync.odin @@ -5,6 +5,7 @@ foreign import system "system:System.framework" // #define OS_WAIT_ON_ADDR_AVAILABILITY \ // __API_AVAILABLE(macos(14.4), ios(17.4), tvos(17.4), watchos(10.4)) when ODIN_OS == .Darwin { + when ODIN_PLATFORM_SUBTARGET == .iOS && ODIN_MINIMUM_OS_VERSION >= 17_04_00 { WAIT_ON_ADDRESS_AVAILABLE :: true } else when ODIN_MINIMUM_OS_VERSION >= 14_04_00 { @@ -12,7 +13,10 @@ when ODIN_OS == .Darwin { } else { WAIT_ON_ADDRESS_AVAILABLE :: false } - when ODIN_MINIMUM_OS_VERSION >= 11_00_00 { + + when ODIN_PLATFORM_SUBTARGET == .iOS && ODIN_MINIMUM_OS_VERSION >= 14_00_00 { + ULOCK_WAIT_2_AVAILABLE :: true + } else when ODIN_MINIMUM_OS_VERSION >= 11_00_00 { ULOCK_WAIT_2_AVAILABLE :: true } else { ULOCK_WAIT_2_AVAILABLE :: false @@ -20,7 +24,7 @@ when ODIN_OS == .Darwin { } else { WAIT_ON_ADDRESS_AVAILABLE :: false - ULOCK_WAIT_2_AVAILABLE :: false + ULOCK_WAIT_2_AVAILABLE :: false } os_sync_wait_on_address_flag :: enum u32 { From c794f853e943ba0f70c0e927c50ada1bf5136117 Mon Sep 17 00:00:00 2001 From: avanspector Date: Tue, 17 Sep 2024 16:57:02 +0200 Subject: [PATCH 71/72] init ansi on a standalone testing exe --- core/testing/runner.odin | 4 ++++ core/testing/runner_windows.odin | 22 ++++++++++++++++++++++ 2 files changed, 26 insertions(+) create mode 100644 core/testing/runner_windows.odin diff --git a/core/testing/runner.odin b/core/testing/runner.odin index 386ba8cb5..10d5dca5c 100644 --- a/core/testing/runner.odin +++ b/core/testing/runner.odin @@ -204,6 +204,10 @@ runner :: proc(internal_tests: []Internal_Test) -> bool { } } + when ODIN_OS == .Windows { + console_ansi_init() + } + stdout := io.to_writer(os.stream_from_handle(os.stdout)) stderr := io.to_writer(os.stream_from_handle(os.stderr)) diff --git a/core/testing/runner_windows.odin b/core/testing/runner_windows.odin new file mode 100644 index 000000000..fa233ff84 --- /dev/null +++ b/core/testing/runner_windows.odin @@ -0,0 +1,22 @@ +//+private +package testing + +import win32 "core:sys/windows" + +console_ansi_init :: proc() { + stdout := win32.GetStdHandle(win32.STD_OUTPUT_HANDLE) + if stdout != win32.INVALID_HANDLE && stdout != nil { + old_console_mode: u32 + if win32.GetConsoleMode(stdout, &old_console_mode) { + win32.SetConsoleMode(stdout, old_console_mode | win32.ENABLE_VIRTUAL_TERMINAL_PROCESSING) + } + } + + stderr := win32.GetStdHandle(win32.STD_ERROR_HANDLE) + if stderr != win32.INVALID_HANDLE && stderr != nil { + old_console_mode: u32 + if win32.GetConsoleMode(stderr, &old_console_mode) { + win32.SetConsoleMode(stderr, old_console_mode | win32.ENABLE_VIRTUAL_TERMINAL_PROCESSING) + } + } +} From 6ef779cd5c8260b2e6979e676d28489fd53dd599 Mon Sep 17 00:00:00 2001 From: Laytan Laats Date: Tue, 17 Sep 2024 17:46:30 +0200 Subject: [PATCH 72/72] add new macos releases to 'odin report' and sys/info --- core/sys/info/platform_darwin.odin | 4 ++++ src/bug_report.cpp | 2 ++ 2 files changed, 6 insertions(+) diff --git a/core/sys/info/platform_darwin.odin b/core/sys/info/platform_darwin.odin index 3fd857bfe..493f038f0 100644 --- a/core/sys/info/platform_darwin.odin +++ b/core/sys/info/platform_darwin.odin @@ -530,6 +530,10 @@ macos_release_map: map[string]Darwin_To_Release = { "23F79" = {{23, 5, 0}, "macOS", {"Sonoma", {14, 5, 0}}}, "23G80" = {{23, 6, 0}, "macOS", {"Sonoma", {14, 6, 0}}}, "23G93" = {{23, 6, 0}, "macOS", {"Sonoma", {14, 6, 1}}}, + "23H124" = {{23, 6, 0}, "macOS", {"Sonoma", {14, 7, 0}}}, + + // MacOS Sequoia + "24A335" = {{24, 0, 0}, "macOS", {"Sequoia", {15, 0, 0}}}, } @(private) diff --git a/src/bug_report.cpp b/src/bug_report.cpp index 5f768f57f..fa7e156ce 100644 --- a/src/bug_report.cpp +++ b/src/bug_report.cpp @@ -919,6 +919,8 @@ gb_internal void report_os_info() { {"23F79", {23, 5, 0}, "macOS", {"Sonoma", {14, 5, 0}}}, {"23G80", {23, 6, 0}, "macOS", {"Sonoma", {14, 6, 0}}}, {"23G93", {23, 6, 0}, "macOS", {"Sonoma", {14, 6, 1}}}, + {"23H124", {23, 6, 0}, "macOS", {"Sonoma", {14, 7, 0}}}, + {"24A335", {24, 0, 0}, "macOS", {"Sequoia", {15, 0, 0}}}, };