ARC now capable of custom extra alignment. Ref, closure and seq support.

[cooldome]

Max Alignment is 256 bytes. Let me know if you want me to increase it.
Max Alignment is 32768 bytes.

For ref T I had to do the following trick, suppose the alignment is 64 bytes and we are overallocating then memory layout is: padding first then RefHeader then the object. Hence there is a padding at start such that head(myref) stil works and it does cast[int](myref) - sizeof(RefHeader).

New functions alignedAlloc, alignedRealloc, alignedDealloc mimic what the functions posix_memalign, aligned_alloc do but in the platform independent way. These functions are overallocating on windows and linux.

[cooldome]

ready for review, test failures seem unrelated

[cooldome]

found the bug with useMalloc. Investigating

[cooldome]

Ready for review. Increased max alignment to 32768.

[Araq]

New functions alignedAlloc, alignedRealloc, alignedDealloc mimic what the functions posix_memalign, aligned_alloc do but in the platform independent way. These functions are overallocating on windows and linux.

Does this mean that we also overallocate with our default native Nim allocator? When exactly do we overallocate?

[cooldome]

Here are my findings. Functions like posix_memalign, aligned_alloc are always overallocating because they need to store alignment offset somewhere hence using them in all cases is not an option as Nim's memory footprint would increase significantly. There is no standard way to reallocate aligned memory while this op is used by seqv2 implementation. Hence I implemented my own portable
version of these functions.

In order to keep overhead low I am checking if extra alignment is required at all. If not I revert back to standard allocation (either nim allocator or c_malloc depending on useMalloc).
The downside is that alignment needs to be passed as the argument in all cases even for dealloc. Such that if statement could be done:

 proc alignedDealloc(p: pointer, align: int) {.compilerproc.} = 
    if align <= MemAlign:
      existingDealloc(p)
    else:      
      let offset = cast[ptr uint16](p -! sizeof(uint16))[]
      existingDealloc(p -! offset)

Summary:
Alignment works both with useMalloc and Nim allocator. For types that doesn't need extra alignment the only overhead is extra if statement if align <= MemAlign:. Compared to allocation itself is a small overhead.

[cooldome]

Also it is a good time to reduce default MemAlign to reduce memory footprint for apps.

[cooldome]

fixes #7865

[Araq]

Write a comment that explains this logic. And also why it doesn't produce unaligned stores (which can be performance desasters on non-x86 CPUs).

[cooldome]

I have added the comments. I have carefully reviewed the code for unaligned reads or stores. I dont' see any.

[cooldome]

ready for review

[planetis-m]

@cooldome Do you plan to make doc comments, export aligned* and add changelog entry in a follow up or it wasn't exported on purpose?