Use spin loop to initialize global lock */

* @brief Compute the log base two. * @param sz The value we want the log of. */

Get memory from the current superblock.

Push on the abandoned list.

add stderr to the delayed output after the module is loaded

purge a range of blocks return true if the full range was purged. assumes we own the area (i.e. blocks_in_use is claimed by us)

try to reserve a fresh arena space

Schedule a purge. This is usually delayed to avoid repeated decommit/commit calls. Note: assumes we (still) own the area as we may purge immediately

allocate from an arena with fallback to the OS

claim the `blocks_inuse` bits

returns true if anything was purged

destroy owned arenas; this is unsafe and should only be done using `mi_option_destroy_on_exit` for dynamic libraries that are unloaded and need to rel

Returns true only on the first invocation

Get the full bit index

Try to atomically claim a sequence of `count` bits starting from the field at `idx` in `bitmap` and crossing into subsequent fields. Returns `true` on

Expand (or shrink) in place (or fail)

Find a page with free blocks of `size`.

Transfer the pages from one heap to the other

Fallback primitive aligned allocation -- split out for better codegen

static since it is not thread safe to access heaps from other threads.

Reallocate but free `p` on errors

Visit all heap pages as areas

Is this a valid pointer in our heap?

Large and huge page allocation. Huge pages are allocated directly without being in a queue. Because huge pages contain just one block, and the segment

Claim an aligned address range for huge pages

free every huge page in a range individually (as we allocated per page) note: needed with VirtualAlloc but could potentially be done in one go on mmap

Primitive aligned allocation from the OS. This function guarantees the allocated memory is aligned.

Get a fresh page to use

Initialize a fresh page