This avoids signed/unsigned comparison warnings when specifying integer
constants as inputs.

This disables run_tests.sh configurations that use the combination of
32-bit clang and heap profiling.

This regression was introduced by
194d6f9d (Restructure *CFLAGS/*CXXFLAGS
configuration.).

This fixes a regression introduced by
d433471f (Derive
{allocated,nmalloc,ndalloc,nrequests}_large stats.).

Remove obsolete unit test scaffolding for extent quantization.  Remove
redundant assertions.  Add an assertion to
extents_first_best_fit_locked() that should help prevent aligned
allocation regressions.

We don't touch witness at all when config_debug == false.  Let's only pay the
memory cost in malloc_mutex_s when needed. Note that when !config_debug, we keep
the field in a union so that we don't have to do #ifdefs in multiple places.

malloc_conf does not reliably work with MSVC, which complains of
"inconsistent dll linkage", i.e. its inability to support the
application overriding malloc_conf when dynamically linking/loading.
Work around this limitation by adding test harness support for per test
shell script sourcing, and converting all tests to use MALLOC_CONF
instead of malloc_conf.

This complements 94c5d22a (Remove mb.h,
which is unused).

This removes an unneeded library dependency when falling back to
intrinsics-based backtracing (or failing to enable heap profiling at
all).

Remove a call to arena_maybe_purge() that was necessary for ratio-based
purging, but is obsolete in the context of decay-based purging.

Extent splitting and coalescing is a major component of large allocation
overhead, and disabling coalescing of cached extents provides a simple
and effective hysteresis mechanism.  Once two-phase purging is
implemented, it will probably make sense to leave coalescing disabled
for the first phase, but coalesce during the second phase.

Refactor extent_can_coalesce(), extent_coalesce(), and extent_record()
to avoid needlessly repeating extent [de]activation operations.

Mapped memory increases when extent_alloc_wrapper() succeeds, and
decreases when extent_dalloc_wrapper() is called (during purging).

This removes the last use of arena->lock.

This mildly reduces stats update overhead during normal operation.

This replaces arena->lock synchronization.

This avoids a gcc diagnostic note:
    note: The ABI for passing parameters with 64-byte alignment has
    changed in GCC 4.6
This note related to the cacheline alignment of rtree_ctx_t, which was
introduced by 4a346f55 (Replace rtree
path cache with LRU cache.).

Fix extent_alloc_dss() to account for bytes that are not a multiple of
the page size.  This regression was introduced by
577d4572 (Make dss operations
lockless.), which was first released in 4.3.0.

Fix rtree_subkey() to use uintptr_t rather than unsigned for key
bitmasking.  This regression was introduced by
4a346f55 (Replace rtree path cache with
LRU cache.).

This fixes interactions with witness_assert_depth[_to_rank](), which was
added in d0e93ada (Add
witness_assert_depth[_to_rank]().).

This avoids worst case behavior if e.g. another thread is preempted
while owning the resource the spinning thread is waiting for.

NULL can never actually be inserted in practice, and removing support
allows a branch to be removed from the fast path.

Rather than dynamically building a table to aid per level computations,
define a constant table at compile time.  Omit both high and low
insignificant bits.  Use one to three tree levels, depending on the
number of significant bits.

A subsequent change instead ignores insignificant high bits.

Anything but a hit in the first element of the lookup cache is
expensive enough to negate the benefits of inlining.

Rework rtree_ctx_t to encapsulate an rtree leaf LRU lookup cache rather
than a single-path element lookup cache.  The replacement is logically
much simpler, as well as slightly faster in the fast path case and less
prone to degraded performance during non-trivial sequences of lookups.

Read adjacent rtree elements while holding element locks, since the
extents mutex only protects against relevant like-state extent mutation.

Fix management of the 'coalesced' loop state variable to merge
forward/backward results, rather than overwriting the result of forward
coalescing if attempting to coalesce backward.  In practice this caused
no correctness issues, but could cause extra iterations in rare cases.

These regressions were introduced by
d27f29b4 (Disentangle arena and extent
locking.).