mallocator: align allocations to 64 bytes

[lidavidm]

Describe the enhancement requested

Some types want 16 byte (or more) alignment, such as decimal256, and it's easiest just to overallocate + align to avoid issues (even if it's not strictly required by the spec, many things in practice assume it). We have to overallocate since the allocator API is not given an alignment.

Context: apache/arrow-adbc#2526

Component(s)

Other

[lidavidm]

Ah, but Go directly uses []byte, so we have nowhere to stash the "real" pointer...

[lidavidm]

The best thing I can think of is to wrap aligned_alloc but that carries a number of caveats (requires C11, not portable to Windows, does not support realloc, cannot align an allocation smaller than the alignment). Maybe we can consider this if there's enough demand.

[zeroshade]

We're still using a memory. Buffer and can use slices, so it wouldn't be difficult to modify the buffer struct to stash the "real" pointer. We stash the pointer and then have the slice start at the aligned data?

[lidavidm]

I was looking at that. In that case maybe we just make Buffer handle the alignment and leave the allocator out of it?

[zeroshade]

Possibly, we'd have to make sure that the release callback still releases the original pointer, but otherwise it could work if we make sure to overallocate.

[lidavidm]

Well otherwise we'd have to change the allocator API to return the (base, aligned) pair

[zeroshade]

That's a good point! It's definitely easier to manage in the buffer class and use the slice!

[lidavidm]

The other complication is resizing, since resizing won't preserve the alignment; we may have to copy

[zeroshade]

Resizing frequently requires a copy anyways, so as long as we handle it properly it should be okay I think?

[lidavidm]

Yeah.

The other thing is the native Go allocator already does the trick, so we need to take care not to double-do it. So I'm thinking I'll either add a new "AllocateAligned" that does return the pair, or a flag on the allocator interface to indicate whether the allocator handles it natively or not.

[zeroshade]

Go has an AlignOf method that might help?

[lidavidm]

Well then we'd have to allocate and try again?

I'm just saying that, if the allocator already does the padding trick underneath (or otherwise somehow supports aligning the allocation), then we shouldn't add the padding ourselves in Buffer