Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

allocators: don’t assume MIN_ALIGN for small sizes #46117

Merged
merged 3 commits into from Nov 25, 2017

Commits on Nov 20, 2017

  1. alloc_system: don’t assume MIN_ALIGN for small sizes, fix rust-lang#4…

    …5955
    
    The GNU C library (glibc) is documented to always allocate with an alignment
    of at least 8 or 16 bytes, on 32-bit or 64-bit platforms:
    https://www.gnu.org/software/libc/manual/html_node/Aligned-Memory-Blocks.html
    
    This matches our use of `MIN_ALIGN` before this commit.
    However, even when libc is glibc, the program might be linked
    with another allocator that redefines the `malloc` symbol and friends.
    (The `alloc_jemalloc` crate does, in some cases.)
    
    So `alloc_system` doesn’t know which allocator it calls,
    and needs to be conservative in assumptions it makes.
    
    The C standard says:
    
    https://port70.net/%7Ensz/c/c11/n1570.html#7.22.3
    > The pointer returned if the allocation succeeds is suitably aligned
    > so that it may be assigned to a pointer to any type of object
    > with a fundamental alignment requirement
    
    https://port70.net/~nsz/c/c11/n1570.html#6.2.8p2
    > A fundamental alignment is represented by an alignment less than
    > or equal to the greatest alignment supported by the implementation
    > in all contexts, which is equal to `_Alignof (max_align_t)`.
    
    `_Alignof (max_align_t)` depends on the ABI and doesn’t seem to have
    a clear definition, but it seems to match our `MIN_ALIGN` in practice.
    
    However, the size of objects is rounded up to the next multiple
    of their alignment (since that size is also the stride used in arrays).
    Conversely, the alignment of a non-zero-size object is at most its size.
    So for example it seems ot be legal for `malloc(8)` to return a pointer
    that’s only 8-bytes-aligned, even if `_Alignof (max_align_t)` is 16.
    SimonSapin committed Nov 20, 2017
    Copy the full SHA
    21d8992 View commit details
    Browse the repository at this point in the history
  2. alloc_jemalloc: don’t assume MIN_ALIGN for small sizes

    See previous commit’s message for what is expected of allocators
    in general, and jemalloc/jemalloc#1072
    for discussion of what jemalloc does specifically.
    SimonSapin committed Nov 20, 2017
    Copy the full SHA
    2dd268b View commit details
    Browse the repository at this point in the history
  3. Remove comment about a branch being optimized out, fix rust-lang#45831

    Most often, this code is used through the `std::heap::Heap`
    and `#[gloabal_allocator]` indirection, so this branch is not
    optimized out anymore.
    SimonSapin committed Nov 20, 2017
    Copy the full SHA
    43e32b5 View commit details
    Browse the repository at this point in the history