Helper for mi_free_try_collect_mt: try to reclaim the page for ourselves

release ownership of a page. This may free the page if all blocks were concurrently freed in the meantime. Returns true if the page was freed.

Release ownership of a page. This may free or reabandoned the page if other blocks are concurrently freed in the meantime. Returns `true` if the page

add stderr to the delayed output after the module is loaded

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

Size of an arena

determine the start of search; important to keep heaps and threads into their own memory regions to reduce contention.

returns -1 = nothing was purged 0 = nothing was purged yet because have not yet reached the expire time 1 = some pages in the arena were purged

Return idx of the slice past the last used slice

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

Set a bit in the chunkmap

Check if a sequence of `n` bits within a chunk are all set/cleared. This can cross bfield's

Count set bits a sequence of `n` bits.

Check if a sequence of `n` bits within a chunk are all set/cleared. This can cross bfield's

Set `0 < n <= MI_BFIELD_BITS`, and return true of the mask bits transitioned from all 0's to 1's. `already_set` contains the count of bits that were a

Try to atomically clear a sequence of `n` bits within a chunk. Returns true if all bits transitioned from 1 to 0, and false otherwise leaving all bit

Try to atomically clear `n` bits starting at `chunk_idx` where `n` can span over multiple chunks

find least aligned byte in a chunk with all bits set, and try unset it atomically set `*pidx` to its bit index (0 <= *pidx < MI_BCHUNK_BITS) on succes

Clear a bit atomically. Returns `true` if the bit transitioned from 1 to 0. `all_clear` is set if the new bfield is zero.

Clear a mask set of bits atomically, and return true of the mask bits transitioned from all 1's to 0's `all_clear` is set to `true` if the new bfield

Clear a bit but only when/once it is set. This is used by concurrent free's while the page is abandoned and mapped. This can incure a busy wait :-( bu

Check if a bit is clear

Check if all bits corresponding to a mask are clear.

Check if all bits corresponding to a mask are set.

Check if a bit is xset

Set a bit atomically. Returns `true` if the bit transitioned from 0 to 1

Try to clear a full field of bits atomically, and return true all bits transitioned from all 1's to 0's. and false otherwise leaving the bit field as-

find the most significant bit that is set. return false if `x==0` (with `*idx` undefined) and true otherwise, with the `idx` is set to the bit index (

Go through the bitmap and for every sequence of `n` set bits, call the visitor function. If it returns `true` stop the search.

Return count of all set bits in a bitmap.

Bit scan forward: find the least significant bit that is set (i.e. count trailing zero's) return false if `x==0` (with `*idx` undefined) and true othe

sum of all the bytes in `x` if it is guaranteed that the sum < 256!

sum of all the bytes in `x` if it is guaranteed that the sum < 256!

Find a page with free blocks of `size`.

We freed a block in an abandoned page (that was not owned). Try to collect

Huge pages contain just one block, and the segment contains just that page. Huge pages are also use if the requested alignment is very large (> MI_BLO

Create an arena memid