Redesign of the Allocator interface

[gingerBill]

Current Interface:

// Allocation Stuff
Allocator_Mode :: enum byte {
	Alloc,
	Free,
	Free_All,
	Resize,
}

Allocator_Proc :: #type proc(allocator_data: rawptr, mode: Allocator_Mode,
                             size, alignment: int,
                             old_memory: rawptr, old_size: int, flags: u64 = 0, location: Source_Code_Location = #caller_location) -> rawptr;

Allocator :: struct {
	procedure: Allocator_Proc,
	data:      rawptr,
}

Proposed Interface (General Idea):

Allocator_Flag :: enum {
    Zero_Memory,
    Free_All_Memory,
}
Allocator_Flags :: bit_set[Allocator_Flag; u64];

Allocator_Error :: enum {
    None,
    Out_Of_Memory,
    Invalid_Memory, 
}

Allocator_Proc :: #type proc(allocator_data: rawptr, 
                             size, alignment: int, old_memory: []byte, 
                             flags := Allocator_Flags{.Zero_Memory}, location := #caller_location) -> (memory: []byte, err: Allocator_Error);

Allocator :: struct {
	procedure: Allocator_Proc,
	data:      rawptr,
}

Current Interface:

• Separates allocation modes and makes the allocator handle them separately, if at all.
• Takes in and returns a rawptr for memory

Proposed Interface:

• The procedure interface acts like a (sane) version of C's realloc meaning that free and alloc map to realloc
  • e.g. malloc(size) == realloc(NULL, size) and free(ptr) == realloc(ptr, 0)
• Takes in and returns a []byte for memory
• Returns an error
• Takes explicit flags for zeroing memory and freeing all memory

[ThisDevDane]

One thing you lose with this is it could be hard to make an allocater that record what you're doing such as a leakchecking allocator or something that just helps you visualize what kind of allocations, frees etc that you're doing since you no longer have the mode,

[gingerBill]

You can figure out the mode from the inputs, but yes, it is less explicit.

[ThisDevDane]

Well yes and no, you can guess the mode from input but what if it was something that was passed as as an error? You would then incorrectly assume the wrong mode

[oskarnp]

You can incorrectly pass the wrong mode, so don't see how that's a valid argument :)

[gingerBill]

old_memory == nil --> Alloc
old_memory != nil && size == 0 --> Free
old_memory != nil && size != 0 --> Resize

[ThisDevDane]

You can pass the incorrect mode yes but I think that's a lot easier to spot