std.mem.Allocator missing runtime-known alignment functions

[johan_alley]

Allocgate missing runtime-known alignment functions · Issue #10348 · ziglang/zig · GitHub was closed by Allocator: `allocBytes` and `reallocBytes` by leecannon · Pull Request #10352 · ziglang/zig · GitHub but it was reverted in https://codeberg.org/ziglang/zig/commit/ceb0a632 so there is no function in std.mem.Allocator to do an allocation with a runtime known alignment except rawAlloc.

Should I use rawAlloc?
Should I open an issue about this?

[Lygaen]

Isn’t there any of the allocWithOptions ? Otherwise, specify the alignement in the type directly with align(X).

Zig doesn’t store alignement as I’m aware at runtime so you need to tell the compiler directly.

Edit : OP was talking about runtime alignement

[Lygaen]

SORRY !
I’m dumb, didn’t read it correctly… I’ll leave my older message for shame.

[johan_alley]

haha no problem

[Sze]

Invalid free error with version 0.14 that did not appear in 0.13, for aligned memory that is assigned via `memcpy`

I am porting a small codebase from Zig 0.13 to Zig 0.14, and in doing so I have encountered a problem. I am unsure whether this is an expected error related to what I am doing or maybe a bug in the new version. I need to initialize a structure with a field whose memory is aligned. The alignment is done in the initialization function for ease of use, where the user passes an arbitrary slice as a parameter. I create an aligned buffer (on the page size, for example) and then I memcpy. I add a dein…

[johan_alley]

Hum it looks they did not end up needing runtime-known alignment. In my case I do actually need runtime known alignment.

[Sze]

The bottom of my answer contains a link to functions that allow runtime alignment, basically you switch on the alignment and the inline prongs of the switch turn the runtime alignment into something that is statically known allowing you to call one of the functions with the right comptime alignment.

[johan_alley]

interesting, but afaik the interface allows runtime known alignments; rawAlloc takes a runtime alignment parameter, so with it I can implement the allocation functions that I need. It just seemed like a strange hole in the Allocator api.

[johan_alley]

to add to this here’s the implementation ill be using as a workaround for now:

pub fn freeRuntimeAligned(
    allocator: std.mem.Allocator,
    old_mem: []u8,
    alignment: std.mem.Alignment,
) void {
    if (old_mem.len == 0) return;
    @memset(old_mem, undefined);
    allocator.rawFree(old_mem, alignment, @returnAddress());
}

pub fn reallocRuntimeAligned(
    allocator: std.mem.Allocator,
    old_mem: []u8,
    alignment: std.mem.Alignment,
    new_byte_count: usize,
) std.mem.Allocator.Error![]u8 {
    const return_address = @returnAddress();
    if (old_mem.len == 0) {
        const new_mem = allocator.rawAlloc(new_byte_count, alignment, return_address) orelse
            return error.OutOfMemory;
        return new_mem[0..new_byte_count];
    }
    if (new_byte_count == 0) {
        allocator.rawFree(old_mem, alignment, return_address);
        const addr = std.mem.alignBackward(usize, std.math.maxInt(usize), alignment.toByteUnits());
        const ptr: [*]u8 = @ptrFromInt(addr);
        return ptr[0..0];
    }

    if (allocator.rawRemap(old_mem, alignment, new_byte_count, return_address)) |p| {
        return p[0..new_byte_count];
    }

    const new_mem = allocator.rawAlloc(new_byte_count, alignment, return_address) orelse
        return error.OutOfMemory;
    const copy_len = @min(new_byte_count, old_mem.len);
    @memcpy(new_mem[0..copy_len], old_mem[0..copy_len]);
    @memset(old_mem, undefined);
    allocator.rawFree(old_mem, alignment, return_address);

    return new_mem[0..new_byte_count];
}

[vulpesx]

For future reference, since Allocator is a runtime interface, all information must be lowered to runtime data before the vtable because runtime function pointers can’t take comptime parameters.