+*.VC.db

+.vs/

+dist: precise

+ @davidtgoldblatt, @interwq)

+ $(srcroot)src/bin.c \

+ $(srcroot)src/div.c \

+ $(srcroot)src/log.c \

+ $(srcroot)test/unit/div.c \

+ $(srcroot)test/unit/log.c \

+ 'newImpl',

+ 'void* newImpl',

+AC_LANG_PUSH([C++])

+AC_LANG_POP([C++])

+ JE_CFLAGS_ADD([-Wno-format-zero-length])

+ HAVE_CPU_SPINWAIT=1

+ HAVE_CPU_SPINWAIT=0

+AC_DEFINE_UNQUOTED([HAVE_CPU_SPINWAIT], [$HAVE_CPU_SPINWAIT])

+ AC_DEFINE([JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS], [ ])

+ *-*-linux*)

+ AC_DEFINE([JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS], [ ])

+ *-*-kfreebsd*)

+ dnl syscall(2) and secure_getenv(3) are exposed by _GNU_SOURCE.

+ JE_APPEND_VS(CPPFLAGS, -D_GNU_SOURCE)

+ abi="elf"

+ AC_DEFINE([JEMALLOC_HAS_ALLOCA_H])

+ AC_DEFINE([JEMALLOC_SYSCTL_VM_OVERCOMMIT], [ ])

+ AC_DEFINE([JEMALLOC_THREADED_INIT], [ ])

+ AC_DEFINE([JEMALLOC_USE_CXX_THROW], [ ])

+ ;;

+dnl Do not log by default.

+AC_ARG_ENABLE([log],

+ [AS_HELP_STRING([--enable-log], [Support debug logging])],

+[if test "x$enable_log" = "xno" ; then

+ enable_log="0"

+else

+ enable_log="1"

+fi

+],

+[enable_log="0"]

+)

+if test "x$enable_log" = "x1" ; then

+ AC_DEFINE([JEMALLOC_LOG], [ ])

+fi

+AC_SUBST([enable_log])

+ elif test "x${je_cv_madvise}" = "xyes" ; then

+ case "${host_cpu}" in i686|x86_64)

+ case "${host}" in *-*-linux*)

+ AC_DEFINE([JEMALLOC_PURGE_MADVISE_FREE], [ ])

+ AC_DEFINE([JEMALLOC_DEFINE_MADVISE_FREE], [ ])

+ ;;

+ esac

+ ;;

+ esac

+ dnl Check for madvise(..., MADV_DO[NT]DUMP).

+ JE_COMPILABLE([madvise(..., MADV_DO[[NT]]DUMP)], [

+#include <sys/mman.h>

+], [

+ madvise((void *)0, 0, MADV_DONTDUMP);

+ madvise((void *)0, 0, MADV_DODUMP);

+], [je_cv_madv_dontdump])

+ if test "x${je_cv_madv_dontdump}" = "xyes" ; then

+ AC_DEFINE([JEMALLOC_MADVISE_DONTDUMP], [ ])

+ fi

+

+case "${host_cpu}" in

+ arm*)

+ ;;

+ *)

+ if test "x${je_cv_thp}" = "xyes" ; then

+ AC_DEFINE([JEMALLOC_HAVE_MADVISE_HUGE], [ ])

+ fi

+ ;;

+esac

+JE_CFLAGS_SAVE()

+JE_CFLAGS_ADD([-D_GNU_SOURCE])

+JE_CFLAGS_ADD([-Werror])

+JE_CFLAGS_ADD([-herror_on_warning])

+JE_COMPILABLE([strerror_r returns char with gnu source], [

+#include <errno.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+], [

+ char *buffer = (char *) malloc(100);

+ char *error = strerror_r(EINVAL, buffer, 100);

+ printf("%s\n", error);

+], [je_cv_strerror_r_returns_char_with_gnu_source])

+JE_CFLAGS_RESTORE()

+if test "x${je_cv_strerror_r_returns_char_with_gnu_source}" = "xyes" ; then

+ AC_DEFINE([JEMALLOC_STRERROR_R_RETURNS_CHAR_WITH_GNU_SOURCE], [ ])

+fi

+

+AC_MSG_RESULT([log : ${enable_log}])

+ <varlistentry id="opt.metadata_thp">

+ <term>

+ <mallctl>opt.metadata_thp</mallctl>

+ (<type>const char *</type>)

+ <literal>r-</literal>

+ </term>

+ <listitem><para>Controls whether to allow jemalloc to use transparent

+ huge page (THP) for internal metadata (see <link

+ linkend="stats.metadata">stats.metadata</link>). <quote>always</quote>

+ allows such usage. <quote>auto</quote> uses no THP initially, but may

+ begin to do so when metadata usage reaches certain level. The default

+ is <quote>disabled</quote>.</para></listitem>

+ </varlistentry>

+

+ <listitem><para>Internal background worker threads enabled/disabled.

+ Because of potential circular dependencies, enabling background thread

+ using this option may cause crash or deadlock during initialization. For

+ a reliable way to use this feature, see <link

+ linkend="background_thread">background_thread</link> for dynamic control

+ options and details. This option is disabled by

+ linkend="arena.i.dirty_decay_ms"><mallctl>arena.&lt;i&gt;.dirty_decay_ms</mallctl></link>

+ <varlistentry id="opt.lg_extent_max_active_fit">

+ <term>

+ <mallctl>opt.lg_extent_max_active_fit</mallctl>

+ (<type>size_t</type>)

+ <literal>r-</literal>

+ </term>

+ <listitem><para>When reusing dirty extents, this determines the (log

+ base 2 of the) maximum ratio between the size of the active extent

+ selected (to split off from) and the size of the requested allocation.

+ This prevents the splitting of large active extents for smaller

+ allocations, which can reduce fragmentation over the long run

+ (especially for non-active extents). Lower value may reduce

+ fragmentation, at the cost of extra active extents. The default value

+ is 6, which gives a maximum ratio of 64 (2^6).</para></listitem>

+ </varlistentry>

+

+ <varlistentry id="arena.i.retain_grow_limit">

+ <term>

+ <mallctl>arena.&lt;i&gt;.retain_grow_limit</mallctl>

+ (<type>size_t</type>)

+ <literal>rw</literal>

+ </term>

+ <listitem><para>Maximum size to grow retained region (only relevant when

+ <link linkend="opt.retain"><mallctl>opt.retain</mallctl></link> is

+ enabled). This controls the maximum increment to expand virtual memory,

+ or allocation through <link

+ linkend="arena.i.extent_hooks"><mallctl>arena.&lt;i&gt;extent_hooks</mallctl></link>.

+ In particular, if customized extent hooks reserve physical memory

+ (e.g. 1G huge pages), this is useful to control the allocation hook's

+ input size. The default is no limit.</para></listitem>

+ </varlistentry>

+

+ linkend="stats.arenas.i.internal"><mallctl>stats.arenas.&lt;i&gt;.internal</mallctl></link>).

+ Transparent huge page (enabled with <link

+ linkend="opt.metadata_thp">opt.metadata_thp</link>) usage is not

+ considered.</para></listitem>

+ </varlistentry>

+

+ <varlistentry id="stats.metadata_thp">

+ <term>

+ <mallctl>stats.metadata_thp</mallctl>

+ (<type>size_t</type>)

+ <literal>r-</literal>

+ [<option>--enable-stats</option>]

+ </term>

+ <listitem><para>Number of transparent huge pages (THP) used for

+ metadata. See <link

+ linkend="stats.metadata"><mallctl>stats.metadata</mallctl></link> and

+ <link linkend="opt.metadata_thp">opt.metadata_thp</link>) for

+ details.</para></listitem>

+ <varlistentry id="stats.arenas.i.metadata_thp">

+ <term>

+ <mallctl>stats.arenas.&lt;i&gt;.metadata_thp</mallctl>

+ (<type>size_t</type>)

+ <literal>r-</literal>

+ [<option>--enable-stats</option>]

+ </term>

+ <listitem><para>Number of transparent huge pages (THP) used for

+ metadata. See <link linkend="opt.metadata_thp">opt.metadata_thp</link>

+ for details.</para></listitem>

+ </varlistentry>

+

+#include "jemalloc/internal/bin.h"

+ bin_stats_t *bstats, arena_stats_large_t *lstats);

+ cache_bin_t *tbin, szind_t binind, uint64_t prof_accumbytes);

+void arena_alloc_junk_small(void *ptr, const bin_info_t *bin_info,

+typedef void (arena_dalloc_junk_small_t)(void *, const bin_info_t *);

+bool arena_retain_grow_limit_get_set(tsd_t *tsd, arena_t *arena,

+ size_t *old_limit, size_t *new_limit);

+#ifndef JEMALLOC_INTERNAL_ARENA_STATS_H

+#define JEMALLOC_INTERNAL_ARENA_STATS_H

+

+#include "jemalloc/internal/atomic.h"

+#include "jemalloc/internal/mutex.h"

+#include "jemalloc/internal/mutex_prof.h"

+#include "jemalloc/internal/size_classes.h"

+

+/*

+ * In those architectures that support 64-bit atomics, we use atomic updates for

+ * our 64-bit values. Otherwise, we use a plain uint64_t and synchronize

+ * externally.

+ */

+#ifdef JEMALLOC_ATOMIC_U64

+typedef atomic_u64_t arena_stats_u64_t;

+#else

+/* Must hold the arena stats mutex while reading atomically. */

+typedef uint64_t arena_stats_u64_t;

+#endif

+

+typedef struct arena_stats_large_s arena_stats_large_t;

+struct arena_stats_large_s {

+ /*

+ * Total number of allocation/deallocation requests served directly by

+ * the arena.

+ */

+ arena_stats_u64_t nmalloc;

+ arena_stats_u64_t ndalloc;

+

+ /*

+ * Number of allocation requests that correspond to this size class.

+ * This includes requests served by tcache, though tcache only

+ * periodically merges into this counter.

+ */

+ arena_stats_u64_t nrequests; /* Partially derived. */

+

+ /* Current number of allocations of this size class. */

+ size_t curlextents; /* Derived. */

+};

+

+typedef struct arena_stats_decay_s arena_stats_decay_t;

+struct arena_stats_decay_s {

+ /* Total number of purge sweeps. */

+ arena_stats_u64_t npurge;

+ /* Total number of madvise calls made. */

+ arena_stats_u64_t nmadvise;

+ /* Total number of pages purged. */

+ arena_stats_u64_t purged;

+};

+

+/*

+ * Arena stats. Note that fields marked "derived" are not directly maintained

+ * within the arena code; rather their values are derived during stats merge

+ * requests.

+ */

+typedef struct arena_stats_s arena_stats_t;

+struct arena_stats_s {

+#ifndef JEMALLOC_ATOMIC_U64

+ malloc_mutex_t mtx;

+#endif

+

+ /* Number of bytes currently mapped, excluding retained memory. */

+ atomic_zu_t mapped; /* Partially derived. */

+

+ /*

+ * Number of unused virtual memory bytes currently retained. Retained

+ * bytes are technically mapped (though always decommitted or purged),

+ * but they are excluded from the mapped statistic (above).

+ */

+ atomic_zu_t retained; /* Derived. */

+

+ arena_stats_decay_t decay_dirty;

+ arena_stats_decay_t decay_muzzy;

+

+ atomic_zu_t base; /* Derived. */

+ atomic_zu_t internal;

+ atomic_zu_t resident; /* Derived. */

+ atomic_zu_t metadata_thp;

+

+ atomic_zu_t allocated_large; /* Derived. */

+ arena_stats_u64_t nmalloc_large; /* Derived. */

+ arena_stats_u64_t ndalloc_large; /* Derived. */

+ arena_stats_u64_t nrequests_large; /* Derived. */

+

+ /* Number of bytes cached in tcache associated with this arena. */

+ atomic_zu_t tcache_bytes; /* Derived. */

+

+ mutex_prof_data_t mutex_prof_data[mutex_prof_num_arena_mutexes];

+

+ /* One element for each large size class. */

+ arena_stats_large_t lstats[NSIZES - NBINS];

+

+ /* Arena uptime. */

+ nstime_t uptime;

+};

+

+static inline bool

+arena_stats_init(tsdn_t *tsdn, arena_stats_t *arena_stats) {

+ if (config_debug) {

+ for (size_t i = 0; i < sizeof(arena_stats_t); i++) {

+ assert(((char *)arena_stats)[i] == 0);

+ }

+ }

+#ifndef JEMALLOC_ATOMIC_U64

+ if (malloc_mutex_init(&arena_stats->mtx, "arena_stats",

+ WITNESS_RANK_ARENA_STATS, malloc_mutex_rank_exclusive)) {

+ return true;

+ }

+#endif

+ /* Memory is zeroed, so there is no need to clear stats. */

+ return false;

+}

+

+static inline void

+arena_stats_lock(tsdn_t *tsdn, arena_stats_t *arena_stats) {

+#ifndef JEMALLOC_ATOMIC_U64

+ malloc_mutex_lock(tsdn, &arena_stats->mtx);

+#endif

+}

+

+static inline void

+arena_stats_unlock(tsdn_t *tsdn, arena_stats_t *arena_stats) {

+#ifndef JEMALLOC_ATOMIC_U64

+ malloc_mutex_unlock(tsdn, &arena_stats->mtx);

+#endif

+}

+

+static inline uint64_t

+arena_stats_read_u64(tsdn_t *tsdn, arena_stats_t *arena_stats,

+ arena_stats_u64_t *p) {

+#ifdef JEMALLOC_ATOMIC_U64

+ return atomic_load_u64(p, ATOMIC_RELAXED);

+#else

+ malloc_mutex_assert_owner(tsdn, &arena_stats->mtx);

+ return *p;

+#endif

+}

+

+static inline void

+arena_stats_add_u64(tsdn_t *tsdn, arena_stats_t *arena_stats,

+ arena_stats_u64_t *p, uint64_t x) {

+#ifdef JEMALLOC_ATOMIC_U64

+ atomic_fetch_add_u64(p, x, ATOMIC_RELAXED);

+#else

+ malloc_mutex_assert_owner(tsdn, &arena_stats->mtx);

+ *p += x;

+#endif

+}

+

+UNUSED static inline void

+arena_stats_sub_u64(tsdn_t *tsdn, arena_stats_t *arena_stats,

+ arena_stats_u64_t *p, uint64_t x) {

+#ifdef JEMALLOC_ATOMIC_U64

+ UNUSED uint64_t r = atomic_fetch_sub_u64(p, x, ATOMIC_RELAXED);

+ assert(r - x <= r);

+#else

+ malloc_mutex_assert_owner(tsdn, &arena_stats->mtx);

+ *p -= x;

+ assert(*p + x >= *p);

+#endif

+}

+

+/*

+ * Non-atomically sets *dst += src. *dst needs external synchronization.

+ * This lets us avoid the cost of a fetch_add when its unnecessary (note that

+ * the types here are atomic).

+ */

+static inline void

+arena_stats_accum_u64(arena_stats_u64_t *dst, uint64_t src) {

+#ifdef JEMALLOC_ATOMIC_U64

+ uint64_t cur_dst = atomic_load_u64(dst, ATOMIC_RELAXED);

+ atomic_store_u64(dst, src + cur_dst, ATOMIC_RELAXED);

+#else

+ *dst += src;

+#endif

+}

+

+static inline size_t

+arena_stats_read_zu(tsdn_t *tsdn, arena_stats_t *arena_stats, atomic_zu_t *p) {

+#ifdef JEMALLOC_ATOMIC_U64

+ return atomic_load_zu(p, ATOMIC_RELAXED);

+#else

+ malloc_mutex_assert_owner(tsdn, &arena_stats->mtx);

+ return atomic_load_zu(p, ATOMIC_RELAXED);

+#endif

+}

+

+static inline void

+arena_stats_add_zu(tsdn_t *tsdn, arena_stats_t *arena_stats, atomic_zu_t *p,

+ size_t x) {

+#ifdef JEMALLOC_ATOMIC_U64

+ atomic_fetch_add_zu(p, x, ATOMIC_RELAXED);

+#else

+ malloc_mutex_assert_owner(tsdn, &arena_stats->mtx);

+ size_t cur = atomic_load_zu(p, ATOMIC_RELAXED);

+ atomic_store_zu(p, cur + x, ATOMIC_RELAXED);

+#endif

+}

+

+static inline void

+arena_stats_sub_zu(tsdn_t *tsdn, arena_stats_t *arena_stats, atomic_zu_t *p,

+ size_t x) {

+#ifdef JEMALLOC_ATOMIC_U64

+ UNUSED size_t r = atomic_fetch_sub_zu(p, x, ATOMIC_RELAXED);

+ assert(r - x <= r);

+#else

+ malloc_mutex_assert_owner(tsdn, &arena_stats->mtx);

+ size_t cur = atomic_load_zu(p, ATOMIC_RELAXED);

+ atomic_store_zu(p, cur - x, ATOMIC_RELAXED);

+#endif

+}

+

+/* Like the _u64 variant, needs an externally synchronized *dst. */

+static inline void

+arena_stats_accum_zu(atomic_zu_t *dst, size_t src) {

+ size_t cur_dst = atomic_load_zu(dst, ATOMIC_RELAXED);

+ atomic_store_zu(dst, src + cur_dst, ATOMIC_RELAXED);

+}

+

+static inline void

+arena_stats_large_nrequests_add(tsdn_t *tsdn, arena_stats_t *arena_stats,

+ szind_t szind, uint64_t nrequests) {

+ arena_stats_lock(tsdn, arena_stats);

+ arena_stats_add_u64(tsdn, arena_stats, &arena_stats->lstats[szind -

+ NBINS].nrequests, nrequests);

+ arena_stats_unlock(tsdn, arena_stats);

+}

+

+static inline void

+arena_stats_mapped_add(tsdn_t *tsdn, arena_stats_t *arena_stats, size_t size) {

+ arena_stats_lock(tsdn, arena_stats);

+ arena_stats_add_zu(tsdn, arena_stats, &arena_stats->mapped, size);

+ arena_stats_unlock(tsdn, arena_stats);

+}

+

+

+#endif /* JEMALLOC_INTERNAL_ARENA_STATS_H */

+#include "jemalloc/internal/arena_stats.h"

+#include "jemalloc/internal/bin.h"

+ arena_stats_decay_t *stats;

+ * Lists of tcaches and cache_bin_array_descriptors for extant threads

+ * associated with this arena. Stats from these are merged

+ * incrementally, and at exit if opt_stats_print is enabled.

+ ql_head(tcache_t) tcache_ql;

+ ql_head(cache_bin_array_descriptor_t) cache_bin_array_descriptor_ql;

+ malloc_mutex_t tcache_ql_mtx;

+ * retain_grow_limit is the max allowed size ind to expand (unless the

+ * required size is greater). Default is no limit, and controlled

+ * through mallctl only.

+ *

+ pszind_t retain_grow_limit;

+ bin_t bins[NBINS];

+extern metadata_thp_mode_t opt_metadata_thp;

+extern const char *metadata_thp_mode_names[];

+

+ size_t *resident, size_t *mapped, size_t *n_thp);

+static inline bool

+metadata_thp_enabled(void) {

+ return (opt_metadata_thp != metadata_thp_disabled);

+}

+ /* Using THP when true (metadata_thp auto mode). */

+ bool auto_thp_switched;

+ /* Number of THP regions touched. */

+ size_t n_thp;

+#define METADATA_THP_DEFAULT metadata_thp_disabled

+

+/*

+ * In auto mode, arenas switch to huge pages for the base allocator on the

+ * second base block. a0 switches to thp on the 5th block (after 20 megabytes

+ * of metadata), since more metadata (e.g. rtree nodes) come from a0's base.

+ */

+

+#define BASE_AUTO_THP_THRESHOLD 2

+#define BASE_AUTO_THP_THRESHOLD_A0 5

+

+typedef enum {

+ metadata_thp_disabled = 0,

+ /*

+ * Lazily enable hugepage for metadata. To avoid high RSS caused by THP

+ * + low usage arena (i.e. THP becomes a significant percentage), the

+ * "auto" option only starts using THP after a base allocator used up

+ * the first THP region. Starting from the second hugepage (in a single

+ * arena), "auto" behaves the same as "always", i.e. madvise hugepage

+ * right away.

+ */

+ metadata_thp_auto = 1,

+ metadata_thp_always = 2,

+ metadata_thp_mode_limit = 3

+} metadata_thp_mode_t;

+

+#ifndef JEMALLOC_INTERNAL_BIN_H

+#define JEMALLOC_INTERNAL_BIN_H

+

+#include "jemalloc/internal/extent_types.h"

+#include "jemalloc/internal/extent_structs.h"

+#include "jemalloc/internal/mutex.h"

+#include "jemalloc/internal/bin_stats.h"

+

+/*

+ * A bin contains a set of extents that are currently being used for slab

+ * allocations.

+ */

+

+/*

+ * Read-only information associated with each element of arena_t's bins array

+ * is stored separately, partly to reduce memory usage (only one copy, rather

+ * than one per arena), but mainly to avoid false cacheline sharing.

+ *

+ * Each slab has the following layout:

+ *

+ * /--------------------\

+ * | region 0 |

+ * |--------------------|

+ * | region 1 |

+ * |--------------------|

+ * | ... |

+ * | ... |

+ * | ... |

+ * |--------------------|

+ * | region nregs-1 |

+ * \--------------------/

+ */

+typedef struct bin_info_s bin_info_t;

+struct bin_info_s {

+ /* Size of regions in a slab for this bin's size class. */

+ size_t reg_size;

+

+ /* Total size of a slab for this bin's size class. */

+ size_t slab_size;

+

+ /* Total number of regions in a slab for this bin's size class. */

+ uint32_t nregs;

+

+ /*

+ * Metadata used to manipulate bitmaps for slabs associated with this

+ * bin.

+ */

+ bitmap_info_t bitmap_info;

+};

+

+extern const bin_info_t bin_infos[NBINS];

+

+

+typedef struct bin_s bin_t;

+struct bin_s {

+ /* All operations on bin_t fields require lock ownership. */

+ malloc_mutex_t lock;

+

+ /*

+ * Current slab being used to service allocations of this bin's size

+ * class. slabcur is independent of slabs_{nonfull,full}; whenever

+ * slabcur is reassigned, the previous slab must be deallocated or

+ * inserted into slabs_{nonfull,full}.

+ */

+ extent_t *slabcur;

+

+ /*

+ * Heap of non-full slabs. This heap is used to assure that new

+ * allocations come from the non-full slab that is oldest/lowest in

+ * memory.

+ */

+ extent_heap_t slabs_nonfull;

+

+ /* List used to track full slabs. */

+ extent_list_t slabs_full;

+

+ /* Bin statistics. */

+ bin_stats_t stats;

+};

+

+/* Initializes a bin to empty. Returns true on error. */

+bool bin_init(bin_t *bin);

+

+/* Forking. */

+void bin_prefork(tsdn_t *tsdn, bin_t *bin);

+void bin_postfork_parent(tsdn_t *tsdn, bin_t *bin);

+void bin_postfork_child(tsdn_t *tsdn, bin_t *bin);

+

+/* Stats. */

+static inline void

+bin_stats_merge(tsdn_t *tsdn, bin_stats_t *dst_bin_stats, bin_t *bin) {

+ malloc_mutex_lock(tsdn, &bin->lock);

+ malloc_mutex_prof_read(tsdn, &dst_bin_stats->mutex_data, &bin->lock);

+ dst_bin_stats->nmalloc += bin->stats.nmalloc;

+ dst_bin_stats->ndalloc += bin->stats.ndalloc;

+ dst_bin_stats->nrequests += bin->stats.nrequests;

+ dst_bin_stats->curregs += bin->stats.curregs;

+ dst_bin_stats->nfills += bin->stats.nfills;

+ dst_bin_stats->nflushes += bin->stats.nflushes;

+ dst_bin_stats->nslabs += bin->stats.nslabs;

+ dst_bin_stats->reslabs += bin->stats.reslabs;

+ dst_bin_stats->curslabs += bin->stats.curslabs;

+ malloc_mutex_unlock(tsdn, &bin->lock);

+}

+

+#endif /* JEMALLOC_INTERNAL_BIN_H */

+#ifndef JEMALLOC_INTERNAL_BIN_STATS_H

+#define JEMALLOC_INTERNAL_BIN_STATS_H

+

+#include "jemalloc/internal/mutex_prof.h"

+

+typedef struct bin_stats_s bin_stats_t;

+struct bin_stats_s {

+ /*

+ * Total number of allocation/deallocation requests served directly by

+ * the bin. Note that tcache may allocate an object, then recycle it

+ * many times, resulting many increments to nrequests, but only one

+ * each to nmalloc and ndalloc.

+ */

+ uint64_t nmalloc;

+ uint64_t ndalloc;

+

+ /*

+ * Number of allocation requests that correspond to the size of this

+ * bin. This includes requests served by tcache, though tcache only

+ * periodically merges into this counter.

+ */

+ uint64_t nrequests;

+

+ /*

+ * Current number of regions of this size class, including regions

+ * currently cached by tcache.

+ */

+ size_t curregs;

+

+ /* Number of tcache fills from this bin. */

+ uint64_t nfills;

+

+ /* Number of tcache flushes to this bin. */

+ uint64_t nflushes;

+

+ /* Total number of slabs created for this bin's size class. */

+ uint64_t nslabs;

+

+ /*

+ * Total number of slabs reused by extracting them from the slabs heap

+ * for this bin's size class.

+ */

+ uint64_t reslabs;

+

+ /* Current number of slabs in this bin. */

+ size_t curslabs;

+

+ mutex_prof_data_t mutex_data;

+};

+

+#endif /* JEMALLOC_INTERNAL_BIN_STATS_H */

+#ifndef JEMALLOC_INTERNAL_CACHE_BIN_H

+#define JEMALLOC_INTERNAL_CACHE_BIN_H

+

+#include "jemalloc/internal/ql.h"

+

+/*

+ * The cache_bins are the mechanism that the tcache and the arena use to

+ * communicate. The tcache fills from and flushes to the arena by passing a

+ * cache_bin_t to fill/flush. When the arena needs to pull stats from the

+ * tcaches associated with it, it does so by iterating over its

+ * cache_bin_array_descriptor_t objects and reading out per-bin stats it

+ * contains. This makes it so that the arena need not know about the existence

+ * of the tcache at all.

+ */

+

+

+/*

+ * The count of the number of cached allocations in a bin. We make this signed

+ * so that negative numbers can encode "invalid" states (e.g. a low water mark

+ * of -1 for a cache that has been depleted).

+ */

+typedef int32_t cache_bin_sz_t;

+

+typedef struct cache_bin_stats_s cache_bin_stats_t;

+struct cache_bin_stats_s {

+ /*

+ * Number of allocation requests that corresponded to the size of this

+ * bin.

+ */

+ uint64_t nrequests;

+};

+

+/*

+ * Read-only information associated with each element of tcache_t's tbins array

+ * is stored separately, mainly to reduce memory usage.

+ */

+typedef struct cache_bin_info_s cache_bin_info_t;

+struct cache_bin_info_s {

+ /* Upper limit on ncached. */

+ cache_bin_sz_t ncached_max;

+};

+

+typedef struct cache_bin_s cache_bin_t;

+struct cache_bin_s {

+ /* Min # cached since last GC. */

+ cache_bin_sz_t low_water;

+ /* # of cached objects. */

+ cache_bin_sz_t ncached;

+ /*

+ * ncached and stats are both modified frequently. Let's keep them

+ * close so that they have a higher chance of being on the same

+ * cacheline, thus less write-backs.

+ */

+ cache_bin_stats_t tstats;

+ /*

+ * Stack of available objects.

+ *

+ * To make use of adjacent cacheline prefetch, the items in the avail

+ * stack goes to higher address for newer allocations. avail points

+ * just above the available space, which means that

+ * avail[-ncached, ... -1] are available items and the lowest item will

+ * be allocated first.

+ */

+ void **avail;

+};

+

+typedef struct cache_bin_array_descriptor_s cache_bin_array_descriptor_t;

+struct cache_bin_array_descriptor_s {

+ /*

+ * The arena keeps a list of the cache bins associated with it, for

+ * stats collection.

+ */

+ ql_elm(cache_bin_array_descriptor_t) link;

+ /* Pointers to the tcache bins. */

+ cache_bin_t *bins_small;

+ cache_bin_t *bins_large;

+};

+

+static inline void

+cache_bin_array_descriptor_init(cache_bin_array_descriptor_t *descriptor,

+ cache_bin_t *bins_small, cache_bin_t *bins_large) {

+ ql_elm_new(descriptor, link);

+ descriptor->bins_small = bins_small;

+ descriptor->bins_large = bins_large;

+}

+

+JEMALLOC_ALWAYS_INLINE void *

+cache_bin_alloc_easy(cache_bin_t *bin, bool *success) {

+ void *ret;

+

+ if (unlikely(bin->ncached == 0)) {

+ bin->low_water = -1;

+ *success = false;

+ return NULL;

+ }

+ /*

+ * success (instead of ret) should be checked upon the return of this

+ * function. We avoid checking (ret == NULL) because there is never a

+ * null stored on the avail stack (which is unknown to the compiler),

+ * and eagerly checking ret would cause pipeline stall (waiting for the

+ * cacheline).

+ */

+ *success = true;

+ ret = *(bin->avail - bin->ncached);

+ bin->ncached--;

+

+ if (unlikely(bin->ncached < bin->low_water)) {

+ bin->low_water = bin->ncached;

+ }

+

+ return ret;

+}

+

+#endif /* JEMALLOC_INTERNAL_CACHE_BIN_H */

+ bin_stats_t bstats[NBINS];

+ arena_stats_large_t lstats[NSIZES - NBINS];

+ size_t metadata_thp;

+#ifndef JEMALLOC_INTERNAL_DIV_H

+#define JEMALLOC_INTERNAL_DIV_H

+

+#include "jemalloc/internal/assert.h"

+

+/*

+ * This module does the division that computes the index of a region in a slab,

+ * given its offset relative to the base.

+ * That is, given a divisor d, an n = i * d (all integers), we'll return i.

+ * We do some pre-computation to do this more quickly than a CPU division

+ * instruction.

+ * We bound n < 2^32, and don't support dividing by one.

+ */

+

+typedef struct div_info_s div_info_t;

+struct div_info_s {

+ uint32_t magic;

+#ifdef JEMALLOC_DEBUG

+ size_t d;

+#endif

+};

+

+void div_init(div_info_t *div_info, size_t divisor);

+

+static inline size_t

+div_compute(div_info_t *div_info, size_t n) {

+ assert(n <= (uint32_t)-1);

+ /*

+ * This generates, e.g. mov; imul; shr on x86-64. On a 32-bit machine,

+ * the compilers I tried were all smart enough to turn this into the

+ * appropriate "get the high 32 bits of the result of a multiply" (e.g.

+ * mul; mov edx eax; on x86, umull on arm, etc.).

+ */

+ size_t i = ((uint64_t)n * (uint64_t)div_info->magic) >> 32;

+#ifdef JEMALLOC_DEBUG

+ assert(i * div_info->d == n);

+#endif

+ return i;

+}

+

+#endif /* JEMALLOC_INTERNAL_DIV_H */

+extern size_t opt_lg_extent_max_active_fit;

+

+extern rtree_t extents_rtree;

+extern const extent_hooks_t extent_hooks_default;

+extern mutex_pool_t extent_mutex_pool;

+extent_dumpable_get(const extent_t *extent) {

+ return (bool)((extent->e_bits & EXTENT_BITS_DUMPABLE_MASK) >>

+ EXTENT_BITS_DUMPABLE_SHIFT);

+}

+

+static inline bool

+ size_t r;

+ if (!tsdn_null(tsdn)) {

+ tsd_t *tsd = tsdn_tsd(tsdn);

+ r = (size_t)prng_lg_range_u64(

+ tsd_offset_statep_get(tsd), lg_range);

+ } else {

+ r = prng_lg_range_zu(

+ &extent_arena_get(extent)->offset_state,

+ lg_range, true);

+ }

+extent_dumpable_set(extent_t *extent, bool dumpable) {

+ extent->e_bits = (extent->e_bits & ~EXTENT_BITS_DUMPABLE_MASK) |

+ ((uint64_t)dumpable << EXTENT_BITS_DUMPABLE_SHIFT);

+}

+

+static inline void

+ bool committed, bool dumpable) {

+ extent_dumpable_set(extent, dumpable);

+ extent_dumpable_set(extent, true);

+extent_list_prepend(extent_list_t *list, extent_t *extent) {

+ ql_head_insert(list, extent, ql_link);

+}

+

+static inline void

+ * d: dumpable

+ * nnnnnnnn ... nnnnffff ffffffii iiiiiitt zdcbaaaa aaaaaaaa

+ * dumpable: The dumpable flag indicates whether or not we've set the

+ * memory in question to be dumpable. Note that this

+ * interacts somewhat subtly with user-specified extent hooks,

+ * since we don't know if *they* are fiddling with

+ * dumpability (in which case, we don't want to undo whatever

+ * they're doing). To deal with this scenario, we:

+ * - Make dumpable false only for memory allocated with the

+ * default hooks.

+ * - Only allow memory to go from non-dumpable to dumpable,

+ * and only once.

+ * - Never make the OS call to allow dumping when the

+ * dumpable bit is already set.

+ * These three constraints mean that we will never

+ * accidentally dump user memory that the user meant to set

+ * nondumpable with their extent hooks.

+ *

+ *

+#define MASK(CURRENT_FIELD_WIDTH, CURRENT_FIELD_SHIFT) ((((((uint64_t)0x1U) << (CURRENT_FIELD_WIDTH)) - 1)) << (CURRENT_FIELD_SHIFT))

+

+#define EXTENT_BITS_ARENA_WIDTH MALLOCX_ARENA_BITS

+#define EXTENT_BITS_ARENA_SHIFT 0

+#define EXTENT_BITS_ARENA_MASK MASK(EXTENT_BITS_ARENA_WIDTH, EXTENT_BITS_ARENA_SHIFT)

+#define EXTENT_BITS_SLAB_WIDTH 1

+#define EXTENT_BITS_SLAB_SHIFT (EXTENT_BITS_ARENA_WIDTH + EXTENT_BITS_ARENA_SHIFT)

+#define EXTENT_BITS_SLAB_MASK MASK(EXTENT_BITS_SLAB_WIDTH, EXTENT_BITS_SLAB_SHIFT)

+#define EXTENT_BITS_COMMITTED_WIDTH 1

+#define EXTENT_BITS_COMMITTED_SHIFT (EXTENT_BITS_SLAB_WIDTH + EXTENT_BITS_SLAB_SHIFT)

+#define EXTENT_BITS_COMMITTED_MASK MASK(EXTENT_BITS_COMMITTED_WIDTH, EXTENT_BITS_COMMITTED_SHIFT)

+#define EXTENT_BITS_DUMPABLE_WIDTH 1

+#define EXTENT_BITS_DUMPABLE_SHIFT (EXTENT_BITS_COMMITTED_WIDTH + EXTENT_BITS_COMMITTED_SHIFT)

+#define EXTENT_BITS_DUMPABLE_MASK MASK(EXTENT_BITS_DUMPABLE_WIDTH, EXTENT_BITS_DUMPABLE_SHIFT)

+#define EXTENT_BITS_ZEROED_WIDTH 1

+#define EXTENT_BITS_ZEROED_SHIFT (EXTENT_BITS_DUMPABLE_WIDTH + EXTENT_BITS_DUMPABLE_SHIFT)

+#define EXTENT_BITS_ZEROED_MASK MASK(EXTENT_BITS_ZEROED_WIDTH, EXTENT_BITS_ZEROED_SHIFT)

+#define EXTENT_BITS_STATE_WIDTH 2

+#define EXTENT_BITS_STATE_SHIFT (EXTENT_BITS_ZEROED_WIDTH + EXTENT_BITS_ZEROED_SHIFT)

+#define EXTENT_BITS_STATE_MASK MASK(EXTENT_BITS_STATE_WIDTH, EXTENT_BITS_STATE_SHIFT)

+#define EXTENT_BITS_SZIND_WIDTH LG_CEIL_NSIZES

+#define EXTENT_BITS_SZIND_SHIFT (EXTENT_BITS_STATE_WIDTH + EXTENT_BITS_STATE_SHIFT)

+#define EXTENT_BITS_SZIND_MASK MASK(EXTENT_BITS_SZIND_WIDTH, EXTENT_BITS_SZIND_SHIFT)

+#define EXTENT_BITS_NFREE_WIDTH (LG_SLAB_MAXREGS + 1)

+#define EXTENT_BITS_NFREE_SHIFT (EXTENT_BITS_SZIND_WIDTH + EXTENT_BITS_SZIND_SHIFT)

+#define EXTENT_BITS_NFREE_MASK MASK(EXTENT_BITS_NFREE_WIDTH, EXTENT_BITS_NFREE_SHIFT)

+

+#define EXTENT_BITS_SN_SHIFT (EXTENT_BITS_NFREE_WIDTH + EXTENT_BITS_NFREE_SHIFT)

+#define EXTENT_BITS_SN_MASK (UINT64_MAX << EXTENT_BITS_SN_SHIFT)

+ /*

+ * List linkage, used by a variety of lists:

+ * - bin_t's slabs_full

+ * - extents_t's LRU

+ * - stashed dirty extents

+ * - arena's large allocations

+ */

+ ql_elm(extent_t) ql_link;

+ /*

+ * Linkage for per size class sn/address-ordered heaps, and

+ * for extent_avail

+ */

+typedef ph(extent_t) extent_tree_t;

+#define EXTENT_GROW_MAX_PIND (NPSIZES - 1)

+

+/*

+ * When reuse (and split) an active extent, (1U << opt_lg_extent_max_active_fit)

+ * is the max ratio between the size of the active extent and the new extent.

+ */

+#define LG_EXTENT_MAX_ACTIVE_FIT_DEFAULT 6

+

+ case 15: k2 ^= ((uint64_t)(tail[14])) << 48; /* falls through */

+ case 14: k2 ^= ((uint64_t)(tail[13])) << 40; /* falls through */

+ case 13: k2 ^= ((uint64_t)(tail[12])) << 32; /* falls through */

+ case 12: k2 ^= ((uint64_t)(tail[11])) << 24; /* falls through */

+ case 11: k2 ^= ((uint64_t)(tail[10])) << 16; /* falls through */

+ case 10: k2 ^= ((uint64_t)(tail[ 9])) << 8; /* falls through */

+ /* falls through */

+ case 8: k1 ^= ((uint64_t)(tail[ 7])) << 56; /* falls through */

+ case 7: k1 ^= ((uint64_t)(tail[ 6])) << 48; /* falls through */

+ case 6: k1 ^= ((uint64_t)(tail[ 5])) << 40; /* falls through */

+ case 5: k1 ^= ((uint64_t)(tail[ 4])) << 32; /* falls through */

+ case 4: k1 ^= ((uint64_t)(tail[ 3])) << 24; /* falls through */

+ case 3: k1 ^= ((uint64_t)(tail[ 2])) << 16; /* falls through */

+ case 2: k1 ^= ((uint64_t)(tail[ 1])) << 8; /* falls through */

+/* 1 if CPU_SPINWAIT is defined, 0 otherwise. */

+#undef HAVE_CPU_SPINWAIT

+ * If defined, enable logging facilities. We make this a configure option to

+ * avoid taking extra branches everywhere.

+ */

+#undef JEMALLOC_LOG

+

+/*

+ * Defined if transparent huge pages are supported via the MADV_[NO]HUGEPAGE

+ * arguments to madvise(2).

+ */

+#undef JEMALLOC_HAVE_MADVISE_HUGE

+

+/*

+/* Defined if madvise(2) is available but MADV_FREE is not (x86 Linux only). */

+#undef JEMALLOC_DEFINE_MADVISE_FREE

+

+/*

+ * Defined if MADV_DO[NT]DUMP is supported as an argument to madvise.

+ */

+#undef JEMALLOC_MADVISE_DONTDUMP

+

+/*

+ * Defined if strerror_r returns char * if _GNU_SOURCE is defined.

+ */

+#undef JEMALLOC_STRERROR_R_RETURNS_CHAR_WITH_GNU_SOURCE

+

+JEMALLOC_ALWAYS_INLINE cache_bin_t *

+ return &tcache->bins_small[binind];

+JEMALLOC_ALWAYS_INLINE cache_bin_t *

+ return &tcache->bins_large[binind - NBINS];

+ assert(tsd_reentrancy_level_get(tsd) < INT8_MAX);

+/*

+ * Translating the names of the 'i' functions:

+ * Abbreviations used in the first part of the function name (before

+ * alloc/dalloc) describe what that function accomplishes:

+ * a: arena (query)

+ * s: size (query, or sized deallocation)

+ * e: extent (query)

+ * p: aligned (allocates)

+ * vs: size (query, without knowing that the pointer is into the heap)

+ * r: rallocx implementation

+ * x: xallocx implementation

+ * Abbreviations used in the second part of the function name (after

+ * alloc/dalloc) describe the arguments it takes

+ * z: whether to return zeroed memory

+ * t: accepts a tcache_t * parameter

+ * m: accepts an arena_t * parameter

+ */

+

+ if (!tsdn_null(tsdn) && tsd_reentrancy_level_get(tsdn_tsd(tsdn)) == 0) {

+ witness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),

+ WITNESS_RANK_CORE, 0);

+ }

+ if (!is_internal && !tsdn_null(tsdn) &&

+ tsd_reentrancy_level_get(tsdn_tsd(tsdn)) != 0) {

+#define JEMALLOC_VA_ARGS_HEAD(head, ...) head

+#define JEMALLOC_VA_ARGS_TAIL(head, ...) __VA_ARGS__

+

+# ifdef __m68k__

+# define LG_QUANTUM 3

+# endif

+# ifdef __nios2__

+# define LG_QUANTUM 3

+# endif

+# if defined(__riscv) || defined(__riscv__)

+# if (defined (__SH3E__) || defined(__SH4_SINGLE__) || defined(__SH4__) || \

+ defined(__SH4_SINGLE_ONLY__))

+#ifdef JEMALLOC_DEFINE_MADVISE_FREE

+# define JEMALLOC_MADV_FREE 8

+#endif

+

+static const bool have_madvise_huge =

+#ifdef JEMALLOC_HAVE_MADVISE_HUGE

+ true

+#else

+ false

+#endif

+ ;

+/*

+ * Undocumented, for jemalloc development use only at the moment. See the note

+ * in jemalloc/internal/log.h.

+ */

+static const bool config_log =

+#ifdef JEMALLOC_LOG

+ true

+#else

+ false

+#endif

+ ;

+#ifndef JEMALLOC_INTERNAL_LOG_H

+#define JEMALLOC_INTERNAL_LOG_H

+

+#include "jemalloc/internal/atomic.h"

+#include "jemalloc/internal/malloc_io.h"

+#include "jemalloc/internal/mutex.h"

+

+#ifdef JEMALLOC_LOG

+# define JEMALLOC_LOG_VAR_BUFSIZE 1000

+#else

+# define JEMALLOC_LOG_VAR_BUFSIZE 1

+#endif

+

+#define JEMALLOC_LOG_BUFSIZE 4096

+

+/*

+ * The log malloc_conf option is a '|'-delimited list of log_var name segments

+ * which should be logged. The names are themselves hierarchical, with '.' as

+ * the delimiter (a "segment" is just a prefix in the log namespace). So, if

+ * you have:

+ *

+ * log("arena", "log msg for arena"); // 1

+ * log("arena.a", "log msg for arena.a"); // 2

+ * log("arena.b", "log msg for arena.b"); // 3

+ * log("arena.a.a", "log msg for arena.a.a"); // 4

+ * log("extent.a", "log msg for extent.a"); // 5

+ * log("extent.b", "log msg for extent.b"); // 6

+ *

+ * And your malloc_conf option is "log=arena.a|extent", then lines 2, 4, 5, and

+ * 6 will print at runtime. You can enable logging from all log vars by

+ * writing "log=.".

+ *

+ * None of this should be regarded as a stable API for right now. It's intended

+ * as a debugging interface, to let us keep around some of our printf-debugging

+ * statements.

+ */

+

+extern char log_var_names[JEMALLOC_LOG_VAR_BUFSIZE];

+extern atomic_b_t log_init_done;

+

+typedef struct log_var_s log_var_t;

+struct log_var_s {

+ /*

+ * Lowest bit is "inited", second lowest is "enabled". Putting them in

+ * a single word lets us avoid any fences on weak architectures.

+ */

+ atomic_u_t state;

+ const char *name;

+};

+

+#define LOG_NOT_INITIALIZED 0U

+#define LOG_INITIALIZED_NOT_ENABLED 1U

+#define LOG_ENABLED 2U

+

+#define LOG_VAR_INIT(name_str) {ATOMIC_INIT(LOG_NOT_INITIALIZED), name_str}

+

+/*

+ * Returns the value we should assume for state (which is not necessarily

+ * accurate; if logging is done before logging has finished initializing, then

+ * we default to doing the safe thing by logging everything).

+ */

+unsigned log_var_update_state(log_var_t *log_var);

+

+/* We factor out the metadata management to allow us to test more easily. */

+#define log_do_begin(log_var) \

+if (config_log) { \

+ unsigned log_state = atomic_load_u(&(log_var).state, \

+ ATOMIC_RELAXED); \

+ if (unlikely(log_state == LOG_NOT_INITIALIZED)) { \

+ log_state = log_var_update_state(&(log_var)); \

+ assert(log_state != LOG_NOT_INITIALIZED); \

+ } \

+ if (log_state == LOG_ENABLED) { \

+ {

+ /* User code executes here. */

+#define log_do_end(log_var) \

+ } \

+ } \

+}

+

+/*

+ * MSVC has some preprocessor bugs in its expansion of __VA_ARGS__ during

+ * preprocessing. To work around this, we take all potential extra arguments in

+ * a var-args functions. Since a varargs macro needs at least one argument in

+ * the "...", we accept the format string there, and require that the first

+ * argument in this "..." is a const char *.

+ */

+static inline void

+log_impl_varargs(const char *name, ...) {

+ char buf[JEMALLOC_LOG_BUFSIZE];

+ va_list ap;

+

+ va_start(ap, name);

+ const char *format = va_arg(ap, const char *);

+ size_t dst_offset = 0;

+ dst_offset += malloc_snprintf(buf, JEMALLOC_LOG_BUFSIZE, "%s: ", name);

+ dst_offset += malloc_vsnprintf(buf + dst_offset,

+ JEMALLOC_LOG_BUFSIZE - dst_offset, format, ap);

+ dst_offset += malloc_snprintf(buf + dst_offset,

+ JEMALLOC_LOG_BUFSIZE - dst_offset, "\n");

+ va_end(ap);

+

+ malloc_write(buf);

+}

+

+/* Call as log("log.var.str", "format_string %d", arg_for_format_string); */

+#define LOG(log_var_str, ...) \

+do { \

+ static log_var_t log_var = LOG_VAR_INIT(log_var_str); \

+ log_do_begin(log_var) \

+ log_impl_varargs((log_var).name, __VA_ARGS__); \

+ log_do_end(log_var) \

+} while (0)

+

+#endif /* JEMALLOC_INTERNAL_LOG_H */

+/*

+ * The caller can set write_cb and cbopaque to null to choose to print with the

+ * je_malloc_message hook.

+ */

+#define MUTEX_PROF_UINT64_COUNTERS \

+ OP(num_spin_acq, uint64_t) \

+ OP(num_owner_switch, uint64_t) \

+ OP(total_wait_time, uint64_t) \

+ OP(max_wait_time, uint64_t)

+

+#define MUTEX_PROF_UINT32_COUNTERS \

+#define MUTEX_PROF_COUNTERS \

+ MUTEX_PROF_UINT64_COUNTERS \

+ MUTEX_PROF_UINT32_COUNTERS

+

+

+#define COUNTER_ENUM(counter_list, t) \

+ typedef enum { \

+ counter_list \

+ mutex_prof_num_##t##_counters \

+ } mutex_prof_##t##_counter_ind_t;

+

+COUNTER_ENUM(MUTEX_PROF_UINT64_COUNTERS, uint64_t)

+COUNTER_ENUM(MUTEX_PROF_UINT32_COUNTERS, uint32_t)

+

+#undef COUNTER_ENUM

+/* Whether transparent huge page state is "madvise". */

+extern bool thp_state_madvise;

+

+bool pages_dontdump(void *addr, size_t size);

+bool pages_dodump(void *addr, size_t size);

+# ifdef __aarch64__

+ /*

+ * aarch64 doesn't sign extend the highest virtual address bit to set

+ * the higher ones. Instead, the high bits gets zeroed.

+ */

+ uintptr_t high_bit_mask = ((uintptr_t)1 << LG_VADDR) - 1;

+ /* Mask off the slab bit. */

+ uintptr_t low_bit_mask = ~(uintptr_t)1;

+ uintptr_t mask = high_bit_mask & low_bit_mask;

+ return (extent_t *)(bits & mask);

+# else

+# endif

+#define RTREE_CTX_ZERO_INITIALIZER {{{0}}, {{0}}}

+static inline void

+spin_cpu_spinwait() {

+# if HAVE_CPU_SPINWAIT

+ CPU_SPINWAIT;

+# else

+ volatile int x = 0;

+ x = x;

+# endif

+}

+

+static inline void

+ spin_cpu_spinwait();

+ size_t delta_inverse_mask = ZU(-1) << lg_delta;

+ size_t delta_inverse_mask = ZU(-1) << lg_delta;

+extern cache_bin_info_t *tcache_bin_info;

+ cache_bin_t *tbin, szind_t binind, bool *tcache_success);

+void tcache_bin_flush_small(tsd_t *tsd, tcache_t *tcache, cache_bin_t *tbin,

+void tcache_bin_flush_large(tsd_t *tsd, cache_bin_t *tbin, szind_t binind,

+#include "jemalloc/internal/bin.h"

+ cache_bin_t *bin;

+ bin = tcache_small_bin_get(tcache, binind);

+ ret = cache_bin_alloc_easy(bin, &tcache_success);

+ bin, binind, &tcache_hard_success);

+ arena_alloc_junk_small(ret, &bin_infos[binind],

+ false);

+ arena_alloc_junk_small(ret, &bin_infos[binind], true);

+ bin->tstats.nrequests++;

+ cache_bin_t *bin;

+ bin = tcache_large_bin_get(tcache, binind);

+ ret = cache_bin_alloc_easy(bin, &tcache_success);

+ bin->tstats.nrequests++;

+ cache_bin_t *bin;

+ cache_bin_info_t *bin_info;

+ arena_dalloc_junk_small(ptr, &bin_infos[binind]);

+ bin = tcache_small_bin_get(tcache, binind);

+ bin_info = &tcache_bin_info[binind];

+ if (unlikely(bin->ncached == bin_info->ncached_max)) {

+ tcache_bin_flush_small(tsd, tcache, bin, binind,

+ (bin_info->ncached_max >> 1));

+ assert(bin->ncached < bin_info->ncached_max);

+ bin->ncached++;

+ *(bin->avail - bin->ncached) = ptr;

+ cache_bin_t *bin;

+ cache_bin_info_t *bin_info;

+ bin = tcache_large_bin_get(tcache, binind);

+ bin_info = &tcache_bin_info[binind];

+ if (unlikely(bin->ncached == bin_info->ncached_max)) {

+ tcache_bin_flush_large(tsd, bin, binind,

+ (bin_info->ncached_max >> 1), tcache);

+ assert(bin->ncached < bin_info->ncached_max);

+ bin->ncached++;

+ *(bin->avail - bin->ncached) = ptr;

+#include "jemalloc/internal/cache_bin.h"

+struct tcache_s {

+ * To minimize our cache-footprint, we put the frequently accessed data

+ * together at the start of this struct.

+

+ /* Cleared after arena_prof_accum(). */

+ uint64_t prof_accumbytes;

+ /* Drives incremental GC. */

+ ticker_t gc_ticker;

+ * The pointer stacks associated with bins follow as a contiguous array.

+ * During tcache initialization, the avail pointer in each element of

+ * tbins is initialized to point to the proper offset within this array.

+ cache_bin_t bins_small[NBINS];

+ * This data is less hot; we can be a little less careful with our

+ * footprint here.

+ /* Lets us track all the tcaches in an arena. */

+ ql_elm(tcache_t) link;

+ /*

+ * The descriptor lets the arena find our cache bins without seeing the

+ * tcache definition. This enables arenas to aggregate stats across

+ * tcaches without having a tcache dependency.

+ */

+ cache_bin_array_descriptor_t cache_bin_array_descriptor;

+

+ /* The arena this tcache is associated with. */

+ arena_t *arena;

+ /* Next bin to GC. */

+ szind_t next_gc_bin;

+ /*

+ * We put the cache bins for large size classes at the end of the

+ * struct, since some of them might not get used. This might end up

+ * letting us avoid touching an extra page if we don't have to.

+ */

+ cache_bin_t bins_large[NSIZES-NBINS];

+ O(offset_state, uint64_t, uint64_t) \

+ 0, \

+#define WITNESS_RANK_BIN WITNESS_RANK_LEAF

+#!/bin/sh -eu

+2. Install Visual Studio 2015 or 2017 with Visual C++

+4. Open "x64 Native Tools Command Prompt for VS 2017"

+ msvc\jemalloc_vc2017.sln

+

+Microsoft Visual Studio Solution File, Format Version 12.00

+# Visual Studio 14

+VisualStudioVersion = 14.0.24720.0

+MinimumVisualStudioVersion = 10.0.40219.1

+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{70A99006-6DE9-472B-8F83-4CEE6C616DF3}"

+ ProjectSection(SolutionItems) = preProject

+ ReadMe.txt = ReadMe.txt

+ EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "jemalloc", "projects\vc2017\jemalloc\jemalloc.vcxproj", "{8D6BB292-9E1C-413D-9F98-4864BDC1514A}"

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_threads", "projects\vc2017\test_threads\test_threads.vcxproj", "{09028CFD-4EB7-491D-869C-0708DB97ED44}"

+EndProject

+Global

+ GlobalSection(SolutionConfigurationPlatforms) = preSolution

+ Debug|x64 = Debug|x64

+ Debug|x86 = Debug|x86

+ Debug-static|x64 = Debug-static|x64

+ Debug-static|x86 = Debug-static|x86

+ Release|x64 = Release|x64

+ Release|x86 = Release|x86

+ Release-static|x64 = Release-static|x64

+ Release-static|x86 = Release-static|x86

+ EndGlobalSection

+ GlobalSection(ProjectConfigurationPlatforms) = postSolution

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|x64.ActiveCfg = Debug|x64

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|x64.Build.0 = Debug|x64

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|x86.ActiveCfg = Debug|Win32

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|x86.Build.0 = Debug|Win32

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x64.ActiveCfg = Debug-static|x64

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x64.Build.0 = Debug-static|x64

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x86.ActiveCfg = Debug-static|Win32

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x86.Build.0 = Debug-static|Win32

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|x64.ActiveCfg = Release|x64

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|x64.Build.0 = Release|x64

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|x86.ActiveCfg = Release|Win32

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|x86.Build.0 = Release|Win32

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x64.ActiveCfg = Release-static|x64

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x64.Build.0 = Release-static|x64

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x86.ActiveCfg = Release-static|Win32

+ {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x86.Build.0 = Release-static|Win32

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug|x64.ActiveCfg = Debug|x64

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug|x64.Build.0 = Debug|x64

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug|x86.ActiveCfg = Debug|Win32

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug|x86.Build.0 = Debug|Win32

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug-static|x64.ActiveCfg = Debug-static|x64

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug-static|x64.Build.0 = Debug-static|x64

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug-static|x86.ActiveCfg = Debug-static|Win32

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug-static|x86.Build.0 = Debug-static|Win32

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Release|x64.ActiveCfg = Release|x64

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Release|x64.Build.0 = Release|x64

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Release|x86.ActiveCfg = Release|Win32

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Release|x86.Build.0 = Release|Win32

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Release-static|x64.ActiveCfg = Release-static|x64

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Release-static|x64.Build.0 = Release-static|x64

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Release-static|x86.ActiveCfg = Release-static|Win32

+ {09028CFD-4EB7-491D-869C-0708DB97ED44}.Release-static|x86.Build.0 = Release-static|Win32

+ EndGlobalSection

+ GlobalSection(SolutionProperties) = preSolution

+ HideSolutionNode = FALSE

+ EndGlobalSection

+EndGlobal

+ <ClCompile Include="..\..\..\..\src\log.c" />

+ <ClCompile Include="..\..\..\..\src\log.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\test_threads\test_threads.cpp" />

+ <ClCompile Include="..\..\..\test_threads\test_threads_main.cpp" />

+ <ClInclude Include="..\..\..\test_threads\test_threads.h" />

+ <ClCompile Include="..\..\..\test_threads\test_threads.cpp">

+ <ClCompile Include="..\..\..\test_threads\test_threads_main.cpp">

+ <ClInclude Include="..\..\..\test_threads\test_threads.h">

+<?xml version="1.0" encoding="utf-8"?>

+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+ <ItemGroup Label="ProjectConfigurations">

+ <ProjectConfiguration Include="Debug-static|Win32">

+ <Configuration>Debug-static</Configuration>

+ <Platform>Win32</Platform>

+ </ProjectConfiguration>

+ <ProjectConfiguration Include="Debug-static|x64">

+ <Configuration>Debug-static</Configuration>

+ <Platform>x64</Platform>

+ </ProjectConfiguration>

+ <ProjectConfiguration Include="Debug|Win32">

+ <Configuration>Debug</Configuration>

+ <Platform>Win32</Platform>

+ </ProjectConfiguration>

+ <ProjectConfiguration Include="Release-static|Win32">

+ <Configuration>Release-static</Configuration>

+ <Platform>Win32</Platform>

+ </ProjectConfiguration>

+ <ProjectConfiguration Include="Release-static|x64">

+ <Configuration>Release-static</Configuration>

+ <Platform>x64</Platform>

+ </ProjectConfiguration>

+ <ProjectConfiguration Include="Release|Win32">

+ <Configuration>Release</Configuration>

+ <Platform>Win32</Platform>

+ </ProjectConfiguration>

+ <ProjectConfiguration Include="Debug|x64">

+ <Configuration>Debug</Configuration>

+ <Platform>x64</Platform>

+ </ProjectConfiguration>

+ <ProjectConfiguration Include="Release|x64">

+ <Configuration>Release</Configuration>

+ <Platform>x64</Platform>

+ </ProjectConfiguration>

+ </ItemGroup>

+ <ItemGroup>

+ <ClCompile Include="..\..\..\..\src\arena.c" />

+ <ClCompile Include="..\..\..\..\src\background_thread.c" />

+ <ClCompile Include="..\..\..\..\src\base.c" />

+ <ClCompile Include="..\..\..\..\src\bitmap.c" />

+ <ClCompile Include="..\..\..\..\src\ckh.c" />

+ <ClCompile Include="..\..\..\..\src\ctl.c" />

+ <ClCompile Include="..\..\..\..\src\extent.c" />

+ <ClCompile Include="..\..\..\..\src\extent_dss.c" />

+ <ClCompile Include="..\..\..\..\src\extent_mmap.c" />

+ <ClCompile Include="..\..\..\..\src\hash.c" />

+ <ClCompile Include="..\..\..\..\src\hooks.c" />

+ <ClCompile Include="..\..\..\..\src\jemalloc.c" />

+ <ClCompile Include="..\..\..\..\src\large.c" />

+ <ClCompile Include="..\..\..\..\src\log.c" />

+ <ClCompile Include="..\..\..\..\src\malloc_io.c" />

+ <ClCompile Include="..\..\..\..\src\mutex.c" />

+ <ClCompile Include="..\..\..\..\src\mutex_pool.c" />

+ <ClCompile Include="..\..\..\..\src\nstime.c" />

+ <ClCompile Include="..\..\..\..\src\pages.c" />

+ <ClCompile Include="..\..\..\..\src\prng.c" />

+ <ClCompile Include="..\..\..\..\src\prof.c" />

+ <ClCompile Include="..\..\..\..\src\rtree.c" />

+ <ClCompile Include="..\..\..\..\src\stats.c" />

+ <ClCompile Include="..\..\..\..\src\sz.c" />

+ <ClCompile Include="..\..\..\..\src\tcache.c" />

+ <ClCompile Include="..\..\..\..\src\ticker.c" />

+ <ClCompile Include="..\..\..\..\src\tsd.c" />

+ <ClCompile Include="..\..\..\..\src\witness.c" />

+ </ItemGroup>

+ <PropertyGroup Label="Globals">

+ <ProjectGuid>{8D6BB292-9E1C-413D-9F98-4864BDC1514A}</ProjectGuid>

+ <Keyword>Win32Proj</Keyword>

+ <RootNamespace>jemalloc</RootNamespace>

+ </PropertyGroup>

+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

+ <ConfigurationType>DynamicLibrary</ConfigurationType>

+ <UseDebugLibraries>true</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|Win32'" Label="Configuration">

+ <ConfigurationType>StaticLibrary</ConfigurationType>

+ <UseDebugLibraries>true</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">

+ <ConfigurationType>DynamicLibrary</ConfigurationType>

+ <UseDebugLibraries>false</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <WholeProgramOptimization>true</WholeProgramOptimization>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|Win32'" Label="Configuration">

+ <ConfigurationType>StaticLibrary</ConfigurationType>

+ <UseDebugLibraries>false</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <WholeProgramOptimization>true</WholeProgramOptimization>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">

+ <ConfigurationType>DynamicLibrary</ConfigurationType>

+ <UseDebugLibraries>true</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|x64'" Label="Configuration">

+ <ConfigurationType>StaticLibrary</ConfigurationType>

+ <UseDebugLibraries>true</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">

+ <ConfigurationType>DynamicLibrary</ConfigurationType>

+ <UseDebugLibraries>false</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <WholeProgramOptimization>true</WholeProgramOptimization>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|x64'" Label="Configuration">

+ <ConfigurationType>StaticLibrary</ConfigurationType>

+ <UseDebugLibraries>false</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <WholeProgramOptimization>true</WholeProgramOptimization>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

+ <ImportGroup Label="ExtensionSettings">

+ </ImportGroup>

+ <ImportGroup Label="Shared">

+ </ImportGroup>

+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|Win32'" Label="PropertySheets">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|Win32'" Label="PropertySheets">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|x64'" Label="PropertySheets">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|x64'" Label="PropertySheets">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <PropertyGroup Label="UserMacros" />

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ <IntDir>$(Platform)\$(Configuration)\</IntDir>

+ <TargetName>$(ProjectName)d</TargetName>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|Win32'">

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ <IntDir>$(Platform)\$(Configuration)\</IntDir>

+ <TargetName>$(ProjectName)-$(PlatformToolset)-$(Configuration)</TargetName>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ <IntDir>$(Platform)\$(Configuration)\</IntDir>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|Win32'">

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ <IntDir>$(Platform)\$(Configuration)\</IntDir>

+ <TargetName>$(ProjectName)-$(PlatformToolset)-$(Configuration)</TargetName>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ <IntDir>$(Platform)\$(Configuration)\</IntDir>

+ <TargetName>$(ProjectName)d</TargetName>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|x64'">

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ <IntDir>$(Platform)\$(Configuration)\</IntDir>

+ <TargetName>$(ProjectName)-vc$(PlatformToolsetVersion)-$(Configuration)</TargetName>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ <IntDir>$(Platform)\$(Configuration)\</IntDir>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|x64'">

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ <IntDir>$(Platform)\$(Configuration)\</IntDir>

+ <TargetName>$(ProjectName)-vc$(PlatformToolsetVersion)-$(Configuration)</TargetName>

+ </PropertyGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+ <ClCompile>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <WarningLevel>Level3</WarningLevel>

+ <Optimization>Disabled</Optimization>

+ <PreprocessorDefinitions>_REENTRANT;_WINDLL;DLLEXPORT;JEMALLOC_DEBUG;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ <DisableSpecificWarnings>4090;4146;4267;4334</DisableSpecificWarnings>

+ <ProgramDataBaseFileName>$(OutputPath)$(TargetName).pdb</ProgramDataBaseFileName>

+ </ClCompile>

+ <Link>

+ <SubSystem>Windows</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|Win32'">

+ <ClCompile>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <WarningLevel>Level3</WarningLevel>

+ <Optimization>Disabled</Optimization>

+ <PreprocessorDefinitions>JEMALLOC_DEBUG;_REENTRANT;JEMALLOC_EXPORT=;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>

+ <DisableSpecificWarnings>4090;4146;4267;4334</DisableSpecificWarnings>

+ <ProgramDataBaseFileName>$(OutputPath)$(TargetName).pdb</ProgramDataBaseFileName>

+ </ClCompile>

+ <Link>

+ <SubSystem>Windows</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

+ <ClCompile>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <WarningLevel>Level3</WarningLevel>

+ <Optimization>Disabled</Optimization>

+ <PreprocessorDefinitions>JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;_WINDLL;DLLEXPORT;JEMALLOC_DEBUG;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ <DisableSpecificWarnings>4090;4146;4267;4334</DisableSpecificWarnings>

+ <ProgramDataBaseFileName>$(OutputPath)$(TargetName).pdb</ProgramDataBaseFileName>

+ </ClCompile>

+ <Link>

+ <SubSystem>Windows</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|x64'">

+ <ClCompile>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <WarningLevel>Level3</WarningLevel>

+ <Optimization>Disabled</Optimization>

+ <PreprocessorDefinitions>JEMALLOC_NO_PRIVATE_NAMESPACE;JEMALLOC_DEBUG;_REENTRANT;JEMALLOC_EXPORT=;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>

+ <DisableSpecificWarnings>4090;4146;4267;4334</DisableSpecificWarnings>

+ <DebugInformationFormat>OldStyle</DebugInformationFormat>

+ <MinimalRebuild>false</MinimalRebuild>

+ </ClCompile>

+ <Link>

+ <SubSystem>Windows</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+ <ClCompile>

+ <WarningLevel>Level3</WarningLevel>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <Optimization>MaxSpeed</Optimization>

+ <FunctionLevelLinking>true</FunctionLevelLinking>

+ <IntrinsicFunctions>true</IntrinsicFunctions>

+ <PreprocessorDefinitions>_REENTRANT;_WINDLL;DLLEXPORT;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ <DisableSpecificWarnings>4090;4146;4267;4334</DisableSpecificWarnings>

+ <ProgramDataBaseFileName>$(OutputPath)$(TargetName).pdb</ProgramDataBaseFileName>

+ </ClCompile>

+ <Link>

+ <SubSystem>Windows</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ <EnableCOMDATFolding>true</EnableCOMDATFolding>

+ <OptimizeReferences>true</OptimizeReferences>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|Win32'">

+ <ClCompile>

+ <WarningLevel>Level3</WarningLevel>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <Optimization>MaxSpeed</Optimization>

+ <FunctionLevelLinking>true</FunctionLevelLinking>

+ <IntrinsicFunctions>true</IntrinsicFunctions>

+ <PreprocessorDefinitions>_REENTRANT;JEMALLOC_EXPORT=;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ <RuntimeLibrary>MultiThreaded</RuntimeLibrary>

+ <DisableSpecificWarnings>4090;4146;4267;4334</DisableSpecificWarnings>

+ <ProgramDataBaseFileName>$(OutputPath)$(TargetName).pdb</ProgramDataBaseFileName>

+ </ClCompile>

+ <Link>

+ <SubSystem>Windows</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ <EnableCOMDATFolding>true</EnableCOMDATFolding>

+ <OptimizeReferences>true</OptimizeReferences>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

+ <ClCompile>

+ <WarningLevel>Level3</WarningLevel>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <Optimization>MaxSpeed</Optimization>

+ <FunctionLevelLinking>true</FunctionLevelLinking>

+ <IntrinsicFunctions>true</IntrinsicFunctions>

+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ <PreprocessorDefinitions>JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;_WINDLL;DLLEXPORT;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <DisableSpecificWarnings>4090;4146;4267;4334</DisableSpecificWarnings>

+ <ProgramDataBaseFileName>$(OutputPath)$(TargetName).pdb</ProgramDataBaseFileName>

+ </ClCompile>

+ <Link>

+ <SubSystem>Windows</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ <EnableCOMDATFolding>true</EnableCOMDATFolding>

+ <OptimizeReferences>true</OptimizeReferences>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|x64'">

+ <ClCompile>

+ <WarningLevel>Level3</WarningLevel>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <Optimization>MaxSpeed</Optimization>

+ <FunctionLevelLinking>true</FunctionLevelLinking>

+ <IntrinsicFunctions>true</IntrinsicFunctions>

+ <PreprocessorDefinitions>JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;JEMALLOC_EXPORT=;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ <RuntimeLibrary>MultiThreaded</RuntimeLibrary>

+ <DisableSpecificWarnings>4090;4146;4267;4334</DisableSpecificWarnings>

+ <DebugInformationFormat>OldStyle</DebugInformationFormat>

+ </ClCompile>

+ <Link>

+ <SubSystem>Windows</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ <EnableCOMDATFolding>true</EnableCOMDATFolding>

+ <OptimizeReferences>true</OptimizeReferences>

+ </Link>

+ </ItemDefinitionGroup>

+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

+ <ImportGroup Label="ExtensionTargets">

+ </ImportGroup>

+</Project> \ No newline at end of file

+<?xml version="1.0" encoding="utf-8"?>

+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+ <ItemGroup>

+ <Filter Include="Source Files">

+ <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>

+ <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>

+ </Filter>

+ </ItemGroup>

+ <ItemGroup>

+ <ClCompile Include="..\..\..\..\src\arena.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\background_thread.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\base.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\bitmap.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\ckh.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\ctl.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\extent.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\extent_dss.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\extent_mmap.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\hash.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\hooks.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\jemalloc.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\large.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\malloc_io.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\mutex.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\mutex_pool.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\nstime.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\pages.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\prng.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\prof.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\rtree.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\stats.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\sz.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\tcache.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\ticker.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\tsd.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\witness.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\..\src\log.c">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ </ItemGroup>

+</Project> \ No newline at end of file

+<?xml version="1.0" encoding="utf-8"?>

+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+ <ItemGroup Label="ProjectConfigurations">

+ <ProjectConfiguration Include="Debug-static|Win32">

+ <Configuration>Debug-static</Configuration>

+ <Platform>Win32</Platform>

+ </ProjectConfiguration>

+ <ProjectConfiguration Include="Debug-static|x64">

+ <Configuration>Debug-static</Configuration>

+ <Platform>x64</Platform>

+ </ProjectConfiguration>

+ <ProjectConfiguration Include="Debug|Win32">

+ <Configuration>Debug</Configuration>

+ <Platform>Win32</Platform>

+ </ProjectConfiguration>

+ <ProjectConfiguration Include="Release-static|Win32">

+ <Configuration>Release-static</Configuration>

+ <Platform>Win32</Platform>

+ </ProjectConfiguration>

+ <ProjectConfiguration Include="Release-static|x64">

+ <Configuration>Release-static</Configuration>

+ <Platform>x64</Platform>

+ </ProjectConfiguration>

+ <ProjectConfiguration Include="Release|Win32">

+ <Configuration>Release</Configuration>

+ <Platform>Win32</Platform>

+ </ProjectConfiguration>

+ <ProjectConfiguration Include="Debug|x64">

+ <Configuration>Debug</Configuration>

+ <Platform>x64</Platform>

+ </ProjectConfiguration>

+ <ProjectConfiguration Include="Release|x64">

+ <Configuration>Release</Configuration>

+ <Platform>x64</Platform>

+ </ProjectConfiguration>

+ </ItemGroup>

+ <PropertyGroup Label="Globals">

+ <ProjectGuid>{09028CFD-4EB7-491D-869C-0708DB97ED44}</ProjectGuid>

+ <Keyword>Win32Proj</Keyword>

+ <RootNamespace>test_threads</RootNamespace>

+ </PropertyGroup>

+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

+ <ConfigurationType>Application</ConfigurationType>

+ <UseDebugLibraries>true</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|Win32'" Label="Configuration">

+ <ConfigurationType>Application</ConfigurationType>

+ <UseDebugLibraries>true</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">

+ <ConfigurationType>Application</ConfigurationType>

+ <UseDebugLibraries>false</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <WholeProgramOptimization>true</WholeProgramOptimization>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|Win32'" Label="Configuration">

+ <ConfigurationType>Application</ConfigurationType>

+ <UseDebugLibraries>false</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <WholeProgramOptimization>true</WholeProgramOptimization>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">

+ <ConfigurationType>Application</ConfigurationType>

+ <UseDebugLibraries>true</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|x64'" Label="Configuration">

+ <ConfigurationType>Application</ConfigurationType>

+ <UseDebugLibraries>true</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">

+ <ConfigurationType>Application</ConfigurationType>

+ <UseDebugLibraries>false</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <WholeProgramOptimization>true</WholeProgramOptimization>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|x64'" Label="Configuration">

+ <ConfigurationType>Application</ConfigurationType>

+ <UseDebugLibraries>false</UseDebugLibraries>

+ <PlatformToolset>v141</PlatformToolset>

+ <WholeProgramOptimization>true</WholeProgramOptimization>

+ <CharacterSet>MultiByte</CharacterSet>

+ </PropertyGroup>

+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

+ <ImportGroup Label="ExtensionSettings">

+ </ImportGroup>

+ <ImportGroup Label="Shared">

+ </ImportGroup>

+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|Win32'" Label="PropertySheets">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|Win32'" Label="PropertySheets">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|x64'" Label="PropertySheets">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|x64'" Label="PropertySheets">

+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+ </ImportGroup>

+ <PropertyGroup Label="UserMacros" />

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ <IntDir>$(Platform)\$(Configuration)\</IntDir>

+ <LinkIncremental>true</LinkIncremental>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|Win32'">

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ <IntDir>$(Platform)\$(Configuration)\</IntDir>

+ <LinkIncremental>true</LinkIncremental>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

+ <LinkIncremental>true</LinkIncremental>

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|x64'">

+ <LinkIncremental>true</LinkIncremental>

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ <IntDir>$(Platform)\$(Configuration)\</IntDir>

+ <LinkIncremental>false</LinkIncremental>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|Win32'">

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ <IntDir>$(Platform)\$(Configuration)\</IntDir>

+ <LinkIncremental>false</LinkIncremental>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ <IntDir>$(Platform)\$(Configuration)\</IntDir>

+ <LinkIncremental>false</LinkIncremental>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|x64'">

+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

+ <IntDir>$(Platform)\$(Configuration)\</IntDir>

+ <LinkIncremental>false</LinkIncremental>

+ </PropertyGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+ <ClCompile>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <WarningLevel>Level3</WarningLevel>

+ <Optimization>Disabled</Optimization>

+ <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\test\include;..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ </ClCompile>

+ <Link>

+ <SubSystem>Console</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ <AdditionalLibraryDirectories>$(SolutionDir)$(Platform)\$(Configuration)</AdditionalLibraryDirectories>

+ <AdditionalDependencies>jemallocd.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|Win32'">

+ <ClCompile>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <WarningLevel>Level3</WarningLevel>

+ <Optimization>Disabled</Optimization>

+ <PreprocessorDefinitions>JEMALLOC_EXPORT=;JEMALLOC_STATIC;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\test\include;..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>

+ </ClCompile>

+ <Link>

+ <SubSystem>Console</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ <AdditionalLibraryDirectories>$(SolutionDir)$(Platform)\$(Configuration)</AdditionalLibraryDirectories>

+ <AdditionalDependencies>jemalloc-$(PlatformToolset)-$(Configuration).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

+ <ClCompile>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <WarningLevel>Level3</WarningLevel>

+ <Optimization>Disabled</Optimization>

+ <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\test\include;..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ </ClCompile>

+ <Link>

+ <SubSystem>Console</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ <AdditionalDependencies>jemallocd.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+ <AdditionalLibraryDirectories>$(SolutionDir)$(Platform)\$(Configuration)</AdditionalLibraryDirectories>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug-static|x64'">

+ <ClCompile>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <WarningLevel>Level3</WarningLevel>

+ <Optimization>Disabled</Optimization>

+ <PreprocessorDefinitions>JEMALLOC_EXPORT=;JEMALLOC_STATIC;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\test\include;..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>

+ </ClCompile>

+ <Link>

+ <SubSystem>Console</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ <AdditionalDependencies>jemalloc-vc$(PlatformToolsetVersion)-$(Configuration).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+ <AdditionalLibraryDirectories>$(SolutionDir)$(Platform)\$(Configuration)</AdditionalLibraryDirectories>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+ <ClCompile>

+ <WarningLevel>Level3</WarningLevel>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <Optimization>MaxSpeed</Optimization>

+ <FunctionLevelLinking>true</FunctionLevelLinking>

+ <IntrinsicFunctions>true</IntrinsicFunctions>

+ <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\test\include;..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ </ClCompile>

+ <Link>

+ <SubSystem>Console</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ <EnableCOMDATFolding>true</EnableCOMDATFolding>

+ <OptimizeReferences>true</OptimizeReferences>

+ <AdditionalLibraryDirectories>$(SolutionDir)$(Platform)\$(Configuration)</AdditionalLibraryDirectories>

+ <AdditionalDependencies>jemalloc.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|Win32'">

+ <ClCompile>

+ <WarningLevel>Level3</WarningLevel>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <Optimization>MaxSpeed</Optimization>

+ <FunctionLevelLinking>true</FunctionLevelLinking>

+ <IntrinsicFunctions>true</IntrinsicFunctions>

+ <PreprocessorDefinitions>JEMALLOC_EXPORT=;JEMALLOC_STATIC;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\test\include;..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ <RuntimeLibrary>MultiThreaded</RuntimeLibrary>

+ </ClCompile>

+ <Link>

+ <SubSystem>Console</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ <EnableCOMDATFolding>true</EnableCOMDATFolding>

+ <OptimizeReferences>true</OptimizeReferences>

+ <AdditionalLibraryDirectories>$(SolutionDir)$(Platform)\$(Configuration)</AdditionalLibraryDirectories>

+ <AdditionalDependencies>jemalloc-$(PlatformToolset)-$(Configuration).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

+ <ClCompile>

+ <WarningLevel>Level3</WarningLevel>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <Optimization>MaxSpeed</Optimization>

+ <FunctionLevelLinking>true</FunctionLevelLinking>

+ <IntrinsicFunctions>true</IntrinsicFunctions>

+ <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\test\include;..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ </ClCompile>

+ <Link>

+ <SubSystem>Console</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ <EnableCOMDATFolding>true</EnableCOMDATFolding>

+ <OptimizeReferences>true</OptimizeReferences>

+ <AdditionalLibraryDirectories>$(SolutionDir)$(Platform)\$(Configuration)</AdditionalLibraryDirectories>

+ <AdditionalDependencies>jemalloc.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release-static|x64'">

+ <ClCompile>

+ <WarningLevel>Level3</WarningLevel>

+ <PrecompiledHeader>

+ </PrecompiledHeader>

+ <Optimization>MaxSpeed</Optimization>

+ <FunctionLevelLinking>true</FunctionLevelLinking>

+ <IntrinsicFunctions>true</IntrinsicFunctions>

+ <PreprocessorDefinitions>JEMALLOC_EXPORT=;JEMALLOC_STATIC;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+ <AdditionalIncludeDirectories>..\..\..\..\test\include;..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+ <RuntimeLibrary>MultiThreaded</RuntimeLibrary>

+ </ClCompile>

+ <Link>

+ <SubSystem>Console</SubSystem>

+ <GenerateDebugInformation>true</GenerateDebugInformation>

+ <EnableCOMDATFolding>true</EnableCOMDATFolding>

+ <OptimizeReferences>true</OptimizeReferences>

+ <AdditionalLibraryDirectories>$(SolutionDir)$(Platform)\$(Configuration)</AdditionalLibraryDirectories>

+ <AdditionalDependencies>jemalloc-vc$(PlatformToolsetVersion)-$(Configuration).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemGroup>

+ <ClCompile Include="..\..\..\test_threads\test_threads.cpp" />

+ <ClCompile Include="..\..\..\test_threads\test_threads_main.cpp" />

+ </ItemGroup>

+ <ItemGroup>

+ <ProjectReference Include="..\jemalloc\jemalloc.vcxproj">

+ <Project>{8d6bb292-9e1c-413d-9f98-4864bdc1514a}</Project>

+ </ProjectReference>

+ </ItemGroup>

+ <ItemGroup>

+ <ClInclude Include="..\..\..\test_threads\test_threads.h" />

+ </ItemGroup>

+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

+ <ImportGroup Label="ExtensionTargets">

+ </ImportGroup>

+</Project> \ No newline at end of file

+<?xml version="1.0" encoding="utf-8"?>

+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+ <ItemGroup>

+ <Filter Include="Source Files">

+ <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>

+ <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>

+ </Filter>

+ <Filter Include="Header Files">

+ <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>

+ <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>

+ </Filter>

+ </ItemGroup>

+ <ItemGroup>

+ <ClCompile Include="..\..\..\test_threads\test_threads.cpp">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ <ClCompile Include="..\..\..\test_threads\test_threads_main.cpp">

+ <Filter>Source Files</Filter>

+ </ClCompile>

+ </ItemGroup>

+ <ItemGroup>

+ <ClInclude Include="..\..\..\test_threads\test_threads.h">

+ <Filter>Header Files</Filter>

+ </ClInclude>

+ </ItemGroup>

+</Project> \ No newline at end of file

+#include "jemalloc/internal/div.h"

+static div_info_t arena_binind_div_info[NBINS];

+

+ size_t npages_decay_max, bool is_background_thread);

+ bin_t *bin);

+ bin_t *bin);

+ bin_stats_t *bstats, arena_stats_large_t *lstats) {

+ size_t base_allocated, base_resident, base_mapped, metadata_thp;

+ &base_mapped, &metadata_thp);

+ arena_stats_accum_zu(&astats->metadata_thp, metadata_thp);

+ cache_bin_array_descriptor_t *descriptor;

+ ql_foreach(descriptor, &arena->cache_bin_array_descriptor_ql, link) {

+ cache_bin_t *tbin = &descriptor->bins_small[i];

+ cache_bin_t *tbin = &descriptor->bins_large[i];

+ bin_stats_merge(tsdn, &bstats[i], &arena->bins[i]);

+arena_slab_reg_alloc(tsdn_t *tsdn, extent_t *slab, const bin_info_t *bin_info) {

+ (uintptr_t)bin_infos[binind].reg_size == 0);

+ /* Avoid doing division with a variable divisor. */

+ regind = div_compute(&arena_binind_div_info[binind], diff);

+

+ assert(regind < bin_infos[binind].nregs);

+ const bin_info_t *bin_info = &bin_infos[binind];

+ npages_limit, current_npages - npages_limit,

+ is_background_thread);

+ arena_stats_decay_t *stats) {

+ 0, extents_npages_get(extents),

+ is_background_thread);

+ size_t npages_decay_max, extent_list_t *decay_extents) {

+ while (nstashed < npages_decay_max &&

+ (extent = extents_evict(tsdn, arena, r_extent_hooks, extents,

+ * npages_limit: Decay at most npages_decay_max pages without violating the

+ * invariant: (extents_npages_get(extents) >= npages_limit). We need an upper

+ * bound on number of pages in order to prevent unbounded growth (namely in

+ * stashed), otherwise unbounded new pages could be added to extents during the

+ * current decay run, so that the purging thread never finishes.

+ extents_t *extents, bool all, size_t npages_limit, size_t npages_decay_max,

+ npages_limit, npages_decay_max, &decay_extents);

+ extents_npages_get(extents), is_background_thread);

+arena_bin_slabs_nonfull_insert(bin_t *bin, extent_t *slab) {

+arena_bin_slabs_nonfull_remove(bin_t *bin, extent_t *slab) {

+arena_bin_slabs_nonfull_tryget(bin_t *bin) {

+arena_bin_slabs_full_insert(arena_t *arena, bin_t *bin, extent_t *slab) {

+arena_bin_slabs_full_remove(arena_t *arena, bin_t *bin, extent_t *slab) {

+ bin_t *bin = &arena->bins[i];

+ extent_hooks_t **r_extent_hooks, const bin_info_t *bin_info,

+ const bin_info_t *bin_info) {

+arena_bin_nonfull_slab_get(tsdn_t *tsdn, arena_t *arena, bin_t *bin,

+ const bin_info_t *bin_info;

+ bin_info = &bin_infos[binind];

+arena_bin_malloc_hard(tsdn_t *tsdn, arena_t *arena, bin_t *bin,

+ const bin_info_t *bin_info;

+ bin_info = &bin_infos[binind];

+ cache_bin_t *tbin, szind_t binind, uint64_t prof_accumbytes) {

+ bin_t *bin;

+ &bin_infos[binind]);

+ arena_alloc_junk_small(ptr, &bin_infos[binind], true);

+arena_alloc_junk_small(void *ptr, const bin_info_t *bin_info, bool zero) {

+arena_dalloc_junk_small_impl(void *ptr, const bin_info_t *bin_info) {

+ bin_t *bin;

+ ret = arena_slab_reg_alloc(tsdn, slab, &bin_infos[binind]);

+ &bin_infos[binind], false);

+ arena_alloc_junk_small(ret, &bin_infos[binind],

+arena_dissociate_bin_slab(arena_t *arena, extent_t *slab, bin_t *bin) {

+ const bin_info_t *bin_info = &bin_infos[binind];

+ bin_t *bin) {

+arena_bin_lower_slab(tsdn_t *tsdn, arena_t *arena, extent_t *slab, bin_t *bin) {

+ bin_t *bin = &arena->bins[binind];

+ const bin_info_t *bin_info = &bin_infos[binind];

+ bin_t *bin = &arena->bins[binind];

+ assert(bin_infos[sz_size2index(oldsize)].reg_size ==

+bool

+arena_retain_grow_limit_get_set(tsd_t *tsd, arena_t *arena, size_t *old_limit,

+ size_t *new_limit) {

+ assert(opt_retain);

+

+ pszind_t new_ind JEMALLOC_CC_SILENCE_INIT(0);

+ if (new_limit != NULL) {

+ size_t limit = *new_limit;

+ /* Grow no more than the new limit. */

+ if ((new_ind = sz_psz2ind(limit + 1) - 1) >

+ EXTENT_GROW_MAX_PIND) {

+ return true;

+ }

+ }

+

+ malloc_mutex_lock(tsd_tsdn(tsd), &arena->extent_grow_mtx);

+ if (old_limit != NULL) {

+ *old_limit = sz_pind2sz(arena->retain_grow_limit);

+ }

+ if (new_limit != NULL) {

+ arena->retain_grow_limit = new_ind;

+ }

+ malloc_mutex_unlock(tsd_tsdn(tsd), &arena->extent_grow_mtx);

+

+ return false;

+}

+

+ ql_new(&arena->cache_bin_array_descriptor_ql);

+ arena->retain_grow_limit = EXTENT_GROW_MAX_PIND;

+ bool err = bin_init(&arena->bins[i]);

+ if (err) {

+#define REGIND_bin_yes(index, reg_size) \

+ div_init(&arena_binind_div_info[(index)], (reg_size));

+#define REGIND_bin_no(index, reg_size)

+#define SC(index, lg_grp, lg_delta, ndelta, psz, bin, pgs, \

+ lg_delta_lookup) \

+ REGIND_bin_##bin(index, (1U<<lg_grp) + (ndelta << lg_delta))

+ SIZE_CLASSES

+#undef REGIND_bin_yes

+#undef REGIND_bin_no

+#undef SC

+ bin_prefork(tsdn, &arena->bins[i]);

+ bin_postfork_parent(tsdn, &arena->bins[i]);

+ ql_new(&arena->cache_bin_array_descriptor_ql);

+ cache_bin_array_descriptor_init(

+ &tcache->cache_bin_array_descriptor,

+ tcache->bins_small, tcache->bins_large);

+ ql_tail_insert(&arena->cache_bin_array_descriptor_ql,

+ &tcache->cache_bin_array_descriptor, link);

+ bin_postfork_child(tsdn, &arena->bins[i]);

+pthread_create_wrapper_init(void) {

+ if (!isthreaded) {

+ isthreaded = true;

+ }

+ pthread_create_wrapper_init();

+ pthread_create_wrapper_init();

+static base_t *b0;

+

+metadata_thp_mode_t opt_metadata_thp = METADATA_THP_DEFAULT;

+

+const char *metadata_thp_mode_names[] = {

+ "disabled",

+ "auto",

+ "always"

+};

+static inline bool

+metadata_thp_madvise(void) {

+ return (metadata_thp_enabled() && thp_state_madvise);

+}

+

+ /* Use huge page sizes and alignment regardless of opt_metadata_thp. */

+ size_t alignment = HUGEPAGE;

+ addr = extent_alloc_mmap(NULL, size, alignment, &zero, &commit);

+ addr = extent_hooks->alloc(extent_hooks, NULL, size, alignment,

+ goto label_done;

+ goto label_done;

+ goto label_done;

+ goto label_done;

+ goto label_post_reentrancy;

+ goto label_post_reentrancy;

+ goto label_post_reentrancy;

+ goto label_post_reentrancy;

+ label_post_reentrancy:

+ }

+label_done:

+ if (metadata_thp_madvise()) {

+ /* Set NOHUGEPAGE after unmap to avoid kernel defrag. */

+ assert(((uintptr_t)addr & HUGEPAGE_MASK) == 0 &&

+ (size & HUGEPAGE_MASK) == 0);

+ pages_nohuge(addr, size);

+static size_t

+base_get_num_blocks(base_t *base, bool with_new_block) {

+ base_block_t *b = base->blocks;

+ assert(b != NULL);

+

+ size_t n_blocks = with_new_block ? 2 : 1;

+ while (b->next != NULL) {

+ n_blocks++;

+ b = b->next;

+ }

+

+ return n_blocks;

+}

+

+static void

+base_auto_thp_switch(tsdn_t *tsdn, base_t *base) {

+ assert(opt_metadata_thp == metadata_thp_auto);

+ malloc_mutex_assert_owner(tsdn, &base->mtx);

+ if (base->auto_thp_switched) {

+ return;

+ }

+ /* Called when adding a new block. */

+ bool should_switch;

+ if (base_ind_get(base) != 0) {

+ should_switch = (base_get_num_blocks(base, true) ==

+ BASE_AUTO_THP_THRESHOLD);

+ } else {

+ should_switch = (base_get_num_blocks(base, true) ==

+ BASE_AUTO_THP_THRESHOLD_A0);

+ }

+ if (!should_switch) {

+ return;

+ }

+

+ base->auto_thp_switched = true;

+ assert(!config_stats || base->n_thp == 0);

+ /* Make the initial blocks THP lazily. */

+ base_block_t *block = base->blocks;

+ while (block != NULL) {

+ assert((block->size & HUGEPAGE_MASK) == 0);

+ pages_huge(block, block->size);

+ if (config_stats) {

+ base->n_thp += HUGEPAGE_CEILING(block->size -

+ extent_bsize_get(&block->extent)) >> LG_HUGEPAGE;

+ }

+ block = block->next;

+ assert(block == NULL || (base_ind_get(base) == 0));

+ }

+}

+

+ * crossed by the new allocation. Adjust n_thp similarly when

+ * metadata_thp is enabled.

+ if (metadata_thp_madvise() && (opt_metadata_thp ==

+ metadata_thp_always || base->auto_thp_switched)) {

+ base->n_thp += (HUGEPAGE_CEILING((uintptr_t)addr + size)

+ - HUGEPAGE_CEILING((uintptr_t)addr - gap_size)) >>

+ LG_HUGEPAGE;

+ assert(base->mapped >= base->n_thp << LG_HUGEPAGE);

+ }

+base_block_alloc(tsdn_t *tsdn, base_t *base, extent_hooks_t *extent_hooks,

+ unsigned ind, pszind_t *pind_last, size_t *extent_sn_next, size_t size,

+

+ if (metadata_thp_madvise()) {

+ void *addr = (void *)block;

+ assert(((uintptr_t)addr & HUGEPAGE_MASK) == 0 &&

+ (block_size & HUGEPAGE_MASK) == 0);

+ if (opt_metadata_thp == metadata_thp_always) {

+ pages_huge(addr, block_size);

+ } else if (opt_metadata_thp == metadata_thp_auto &&

+ base != NULL) {

+ /* base != NULL indicates this is not a new base. */

+ malloc_mutex_lock(tsdn, &base->mtx);

+ base_auto_thp_switch(tsdn, base);

+ if (base->auto_thp_switched) {

+ pages_huge(addr, block_size);

+ }

+ malloc_mutex_unlock(tsdn, &base->mtx);

+ }

+ }

+

+ base_block_t *block = base_block_alloc(tsdn, base, extent_hooks,

+ if (metadata_thp_madvise() &&

+ !(opt_metadata_thp == metadata_thp_auto

+ && !base->auto_thp_switched)) {

+ assert(base->n_thp > 0);

+ base->n_thp += HUGEPAGE_CEILING(sizeof(base_block_t)) >>

+ LG_HUGEPAGE;

+ }

+ assert(base->n_thp << LG_HUGEPAGE <= base->mapped);

+ base_block_t *block = base_block_alloc(tsdn, NULL, extent_hooks, ind,

+ base->auto_thp_switched = false;

+ base->n_thp = (opt_metadata_thp == metadata_thp_always) &&

+ metadata_thp_madvise() ? HUGEPAGE_CEILING(sizeof(base_block_t))

+ >> LG_HUGEPAGE : 0;

+ assert(base->n_thp << LG_HUGEPAGE <= base->mapped);

+ size_t *mapped, size_t *n_thp) {

+ *n_thp = base->n_thp;

+#include "jemalloc/internal/jemalloc_preamble.h"

+#include "jemalloc/internal/jemalloc_internal_includes.h"

+

+#include "jemalloc/internal/bin.h"

+#include "jemalloc/internal/witness.h"

+

+const bin_info_t bin_infos[NBINS] = {

+#define BIN_INFO_bin_yes(reg_size, slab_size, nregs) \

+ {reg_size, slab_size, nregs, BITMAP_INFO_INITIALIZER(nregs)},

+#define BIN_INFO_bin_no(reg_size, slab_size, nregs)

+#define SC(index, lg_grp, lg_delta, ndelta, psz, bin, pgs, \

+ lg_delta_lookup) \

+ BIN_INFO_bin_##bin((1U<<lg_grp) + (ndelta<<lg_delta), \

+ (pgs << LG_PAGE), (pgs << LG_PAGE) / ((1U<<lg_grp) + \

+ (ndelta<<lg_delta)))

+ SIZE_CLASSES

+#undef BIN_INFO_bin_yes

+#undef BIN_INFO_bin_no

+#undef SC

+};

+

+bool

+bin_init(bin_t *bin) {

+ if (malloc_mutex_init(&bin->lock, "bin", WITNESS_RANK_BIN,

+ malloc_mutex_rank_exclusive)) {

+ return true;

+ }

+ bin->slabcur = NULL;

+ extent_heap_new(&bin->slabs_nonfull);

+ extent_list_init(&bin->slabs_full);

+ if (config_stats) {

+ memset(&bin->stats, 0, sizeof(bin_stats_t));

+ }

+ return false;

+}

+

+void

+bin_prefork(tsdn_t *tsdn, bin_t *bin) {

+ malloc_mutex_prefork(tsdn, &bin->lock);

+}

+

+void

+bin_postfork_parent(tsdn_t *tsdn, bin_t *bin) {

+ malloc_mutex_postfork_parent(tsdn, &bin->lock);

+}

+

+void

+bin_postfork_child(tsdn_t *tsdn, bin_t *bin) {

+ malloc_mutex_postfork_child(tsdn, &bin->lock);

+}

+CTL_PROTO(opt_metadata_thp)

+CTL_PROTO(opt_lg_extent_max_active_fit)

+CTL_PROTO(arena_i_retain_grow_limit)

+CTL_PROTO(stats_arenas_i_metadata_thp)

+CTL_PROTO(stats_metadata_thp)

+ {NAME("metadata_thp"), CTL(opt_metadata_thp)},

+ {NAME("lg_extent_max_active_fit"), CTL(opt_lg_extent_max_active_fit)},

+ {NAME("extent_hooks"), CTL(arena_i_extent_hooks)},

+ {NAME("retain_grow_limit"), CTL(arena_i_retain_grow_limit)}

+ {NAME("metadata_thp"), CTL(stats_arenas_i_metadata_thp)},

+ {NAME("metadata_thp"), CTL(stats_metadata_thp)},

+ctl_accum_arena_stats_u64(arena_stats_u64_t *dst, arena_stats_u64_t *src) {

+ctl_arena_stats_read_u64(arena_stats_u64_t *p) {

+static void

+accum_atomic_zu(atomic_zu_t *dst, atomic_zu_t *src) {

+ sizeof(bin_stats_t));

+ sizeof(arena_stats_large_t));

+ ctl_accum_arena_stats_u64(&sdstats->astats.decay_dirty.npurge,

+ ctl_accum_arena_stats_u64(&sdstats->astats.decay_dirty.nmadvise,

+ ctl_accum_arena_stats_u64(&sdstats->astats.decay_dirty.purged,

+ ctl_accum_arena_stats_u64(&sdstats->astats.decay_muzzy.npurge,

+ ctl_accum_arena_stats_u64(&sdstats->astats.decay_muzzy.nmadvise,

+ ctl_accum_arena_stats_u64(&sdstats->astats.decay_muzzy.purged,

+ accum_atomic_zu(&sdstats->astats.metadata_thp,

+ &astats->astats.metadata_thp);

+ ctl_accum_arena_stats_u64(&sdstats->astats.nmalloc_large,

+ ctl_accum_arena_stats_u64(&sdstats->astats.ndalloc_large,

+ ctl_accum_arena_stats_u64(&sdstats->astats.nrequests_large,

+ ctl_accum_arena_stats_u64(&sdstats->lstats[i].nmalloc,

+ ctl_accum_arena_stats_u64(&sdstats->lstats[i].ndalloc,

+ ctl_accum_arena_stats_u64(&sdstats->lstats[i].nrequests,

+ ctl_stats->metadata_thp = atomic_load_zu(

+ &ctl_sarena->astats->astats.metadata_thp, ATOMIC_RELAXED);

+CTL_RO_NL_GEN(opt_metadata_thp, metadata_thp_mode_names[opt_metadata_thp],

+ const char *)

+CTL_RO_NL_GEN(opt_lg_extent_max_active_fit, opt_lg_extent_max_active_fit,

+ size_t)

+static int

+arena_i_retain_grow_limit_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,

+ void *oldp, size_t *oldlenp, void *newp, size_t newlen) {

+ int ret;

+ unsigned arena_ind;

+ arena_t *arena;

+

+ if (!opt_retain) {

+ /* Only relevant when retain is enabled. */

+ return ENOENT;

+ }

+

+ malloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);

+ MIB_UNSIGNED(arena_ind, 1);

+ if (arena_ind < narenas_total_get() && (arena =

+ arena_get(tsd_tsdn(tsd), arena_ind, false)) != NULL) {

+ size_t old_limit, new_limit;

+ if (newp != NULL) {

+ WRITE(new_limit, size_t);

+ }

+ bool err = arena_retain_grow_limit_get_set(tsd, arena,

+ &old_limit, newp != NULL ? &new_limit : NULL);

+ if (!err) {

+ READ(old_limit, size_t);

+ ret = 0;

+ } else {

+ ret = EFAULT;

+ }

+ } else {

+ ret = EFAULT;

+ }

+label_return:

+ malloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);

+ return ret;

+}

+

+ if (dirty ? arena_dirty_decay_ms_default_set(*(ssize_t *)newp)

+CTL_RO_NL_GEN(arenas_bin_i_size, bin_infos[mib[2]].reg_size, size_t)

+CTL_RO_NL_GEN(arenas_bin_i_nregs, bin_infos[mib[2]].nregs, uint32_t)

+CTL_RO_NL_GEN(arenas_bin_i_slab_size, bin_infos[mib[2]].slab_size, size_t)

+CTL_RO_CGEN(config_stats, stats_metadata_thp, ctl_stats->metadata_thp, size_t)

+ ctl_arena_stats_read_u64(

+ &arenas_i(mib[2])->astats->astats.decay_dirty.npurge), uint64_t)

+ ctl_arena_stats_read_u64(

+ ctl_arena_stats_read_u64(

+ &arenas_i(mib[2])->astats->astats.decay_dirty.purged), uint64_t)

+ ctl_arena_stats_read_u64(

+ &arenas_i(mib[2])->astats->astats.decay_muzzy.npurge), uint64_t)

+ ctl_arena_stats_read_u64(

+ ctl_arena_stats_read_u64(

+ &arenas_i(mib[2])->astats->astats.decay_muzzy.purged), uint64_t)

+CTL_RO_CGEN(config_stats, stats_arenas_i_metadata_thp,

+ atomic_load_zu(&arenas_i(mib[2])->astats->astats.metadata_thp,

+ ATOMIC_RELAXED), size_t)

+ ctl_arena_stats_read_u64(

+ &arenas_i(mib[2])->astats->astats.nmalloc_large), uint64_t)

+ ctl_arena_stats_read_u64(

+ &arenas_i(mib[2])->astats->astats.ndalloc_large), uint64_t)

+/*

+ * Note: "nmalloc" here instead of "nrequests" in the read. This is intentional.

+ */

+ ctl_arena_stats_read_u64(

+ &arenas_i(mib[2])->astats->astats.nmalloc_large), uint64_t) /* Intentional. */

+ bin_t *bin = &arena->bins[i];

+ ctl_arena_stats_read_u64(

+ &arenas_i(mib[2])->astats->lstats[mib[4]].nmalloc), uint64_t)

+ ctl_arena_stats_read_u64(

+ &arenas_i(mib[2])->astats->lstats[mib[4]].ndalloc), uint64_t)

+ ctl_arena_stats_read_u64(

+ &arenas_i(mib[2])->astats->lstats[mib[4]].nrequests), uint64_t)

+#include "jemalloc/internal/jemalloc_preamble.h"

+

+#include "jemalloc/internal/div.h"

+

+#include "jemalloc/internal/assert.h"

+

+/*

+ * Suppose we have n = q * d, all integers. We know n and d, and want q = n / d.

+ *

+ * For any k, we have (here, all division is exact; not C-style rounding):

+ * floor(ceil(2^k / d) * n / 2^k) = floor((2^k + r) / d * n / 2^k), where

+ * r = (-2^k) mod d.

+ *

+ * Expanding this out:

+ * ... = floor(2^k / d * n / 2^k + r / d * n / 2^k)

+ * = floor(n / d + (r / d) * (n / 2^k)).

+ *

+ * The fractional part of n / d is 0 (because of the assumption that d divides n

+ * exactly), so we have:

+ * ... = n / d + floor((r / d) * (n / 2^k))

+ *

+ * So that our initial expression is equal to the quantity we seek, so long as

+ * (r / d) * (n / 2^k) < 1.

+ *

+ * r is a remainder mod d, so r < d and r / d < 1 always. We can make

+ * n / 2 ^ k < 1 by setting k = 32. This gets us a value of magic that works.

+ */

+

+void

+div_init(div_info_t *div_info, size_t d) {

+ /* Nonsensical. */

+ assert(d != 0);

+ /*

+ * This would make the value of magic too high to fit into a uint32_t

+ * (we would want magic = 2^32 exactly). This would mess with code gen

+ * on 32-bit machines.

+ */

+ assert(d != 1);

+

+ uint64_t two_to_k = ((uint64_t)1 << 32);

+ uint32_t magic = (uint32_t)(two_to_k / d);

+

+ /*

+ * We want magic = ceil(2^k / d), but C gives us floor. We have to

+ * increment it unless the result was exact (i.e. unless d is a power of

+ * two).

+ */

+ if (two_to_k % d != 0) {

+ magic++;

+ }

+ div_info->magic = magic;

+#ifdef JEMALLOC_DEBUG

+ div_info->d = d;

+#endif

+}

+size_t opt_lg_extent_max_active_fit = LG_EXTENT_MAX_ACTIVE_FIT_DEFAULT;

+

+ph_gen(UNUSED, extent_avail_, extent_tree_t, extent_t, ph_link,

+/*

+ * Find an extent with size [min_size, max_size) to satisfy the alignment

+ * requirement. For each size, try only the first extent in the heap.

+ */

+static extent_t *

+extents_fit_alignment(extents_t *extents, size_t min_size, size_t max_size,

+ size_t alignment) {

+ pszind_t pind = sz_psz2ind(extent_size_quantize_ceil(min_size));

+ pszind_t pind_max = sz_psz2ind(extent_size_quantize_ceil(max_size));

+

+ for (pszind_t i = (pszind_t)bitmap_ffu(extents->bitmap,

+ &extents_bitmap_info, (size_t)pind); i < pind_max; i =

+ (pszind_t)bitmap_ffu(extents->bitmap, &extents_bitmap_info,

+ (size_t)i+1)) {

+ assert(i < NPSIZES);

+ assert(!extent_heap_empty(&extents->heaps[i]));

+ extent_t *extent = extent_heap_first(&extents->heaps[i]);

+ uintptr_t base = (uintptr_t)extent_base_get(extent);

+ size_t candidate_size = extent_size_get(extent);

+ assert(candidate_size >= min_size);

+

+ uintptr_t next_align = ALIGNMENT_CEILING((uintptr_t)base,

+ PAGE_CEILING(alignment));

+ if (base > next_align || base + candidate_size <= next_align) {

+ /* Overflow or not crossing the next alignment. */

+ continue;

+ }

+

+ size_t leadsize = next_align - base;

+ if (candidate_size - leadsize >= min_size) {

+ return extent;

+ }

+ }

+

+ return NULL;

+}

+

+ /*

+ * In order to reduce fragmentation, avoid reusing and splitting

+ * large extents for much smaller sizes.

+ */

+ if ((sz_pind2sz(i) >> opt_lg_extent_max_active_fit) > size) {

+ return NULL;

+ }

+ extent_t *extent = extent_heap_first(&extents->heaps[i]);

+ size_t esize, size_t alignment) {

+ size_t max_size = esize + PAGE_CEILING(alignment) - PAGE;

+ /* Beware size_t wrap-around. */

+ if (max_size < esize) {

+ return NULL;

+ }

+

+ extent_t *extent = extents->delay_coalesce ?

+ extents_best_fit_locked(tsdn, arena, extents, max_size) :

+ extents_first_fit_locked(tsdn, arena, extents, max_size);

+

+ if (alignment > PAGE && extent == NULL) {

+ /*

+ * max_size guarantees the alignment requirement but is rather

+ * pessimistic. Next we try to satisfy the aligned allocation

+ * with sizes in [esize, max_size).

+ */

+ extent = extents_fit_alignment(extents, esize, max_size,

+ alignment);

+ }

+

+ return extent;

+ extent_t *extent = extent_recycle(tsdn, arena, r_extent_hooks, extents,

+ new_addr, size, pad, alignment, slab, szind, zero, commit, false);

+ assert(extent == NULL || extent_dumpable_get(extent));

+ return extent;

+ assert(extent_dumpable_get(extent));

+ if (extents_npages <= npages_min) {

+/*

+ * Removes all pointers to the given extent from the global rtree indices for

+ * its interior. This is relevant for slab extents, for which we need to do

+ * metadata lookups at places other than the head of the extent. We deregister

+ * on the interior, then, when an extent moves from being an active slab to an

+ * inactive state.

+ */

+/*

+ * Removes all pointers to the given extent from the global rtree.

+ */

+extent_deregister_impl(tsdn_t *tsdn, extent_t *extent, bool gdump) {

+ if (config_prof && gdump) {

+static void

+extent_deregister(tsdn_t *tsdn, extent_t *extent) {

+ extent_deregister_impl(tsdn, extent, true);

+}

+

+static void

+extent_deregister_no_gdump_sub(tsdn_t *tsdn, extent_t *extent) {

+ extent_deregister_impl(tsdn, extent, false);

+}

+

+/*

+ * Tries to find and remove an extent from extents that can be used for the

+ * given allocation request.

+ */

+ bool growing_retained) {

+ extent = extents_fit_locked(tsdn, arena, extents, esize,

+ alignment);

+/*

+ * Given an allocation request and an extent guaranteed to be able to satisfy

+ * it, this splits off lead and trail extents, leaving extent pointing to an

+ * extent satisfying the allocation.

+ * This function doesn't put lead or trail into any extents_t; it's the caller's

+ * job to ensure that they can be reused.

+ */

+typedef enum {

+ /*

+ * Split successfully. lead, extent, and trail, are modified to extents

+ * describing the ranges before, in, and after the given allocation.

+ */

+ extent_split_interior_ok,

+ /*

+ * The extent can't satisfy the given allocation request. None of the

+ * input extent_t *s are touched.

+ */

+ extent_split_interior_cant_alloc,

+ /*

+ * In a potentially invalid state. Must leak (if *to_leak is non-NULL),

+ * and salvage what's still salvageable (if *to_salvage is non-NULL).

+ * None of lead, extent, or trail are valid.

+ */

+ extent_split_interior_error

+} extent_split_interior_result_t;

+

+static extent_split_interior_result_t

+extent_split_interior(tsdn_t *tsdn, arena_t *arena,

+ extent_hooks_t **r_extent_hooks, rtree_ctx_t *rtree_ctx,

+ /* The result of splitting, in case of success. */

+ extent_t **extent, extent_t **lead, extent_t **trail,

+ /* The mess to clean up, in case of error. */

+ extent_t **to_leak, extent_t **to_salvage,

+ szind_t szind, bool growing_retained) {

+ size_t leadsize = ALIGNMENT_CEILING((uintptr_t)extent_base_get(*extent),

+ PAGE_CEILING(alignment)) - (uintptr_t)extent_base_get(*extent);

+ if (extent_size_get(*extent) < leadsize + esize) {

+ return extent_split_interior_cant_alloc;

+ }

+ size_t trailsize = extent_size_get(*extent) - leadsize - esize;

+

+ *lead = NULL;

+ *trail = NULL;

+ *to_leak = NULL;

+ *to_salvage = NULL;

+ *lead = *extent;

+ *extent = extent_split_impl(tsdn, arena, r_extent_hooks,

+ *lead, leadsize, NSIZES, false, esize + trailsize, szind,

+ if (*extent == NULL) {

+ *to_leak = *lead;

+ *lead = NULL;

+ return extent_split_interior_error;

+ *trail = extent_split_impl(tsdn, arena, r_extent_hooks, *extent,

+ esize, szind, slab, trailsize, NSIZES, false,

+ growing_retained);

+ if (*trail == NULL) {

+ *to_leak = *extent;

+ *to_salvage = *lead;

+ *lead = NULL;

+ *extent = NULL;

+ return extent_split_interior_error;

+ }

+

+ if (leadsize == 0 && trailsize == 0) {

+ extent_szind_set(*extent, szind);

+ (uintptr_t)extent_addr_get(*extent), szind, slab);

+ if (slab && extent_size_get(*extent) > PAGE) {

+ (uintptr_t)extent_past_get(*extent) -

+ return extent_split_interior_ok;

+/*

+ * This fulfills the indicated allocation request out of the given extent (which

+ * the caller should have ensured was big enough). If there's any unused space

+ * before or after the resulting allocation, that space is given its own extent

+ * and put back into extents.

+ */

+static extent_t *

+extent_recycle_split(tsdn_t *tsdn, arena_t *arena,

+ extent_hooks_t **r_extent_hooks, rtree_ctx_t *rtree_ctx, extents_t *extents,

+ void *new_addr, size_t size, size_t pad, size_t alignment, bool slab,

+ szind_t szind, extent_t *extent, bool growing_retained) {

+ extent_t *lead;

+ extent_t *trail;

+ extent_t *to_leak;

+ extent_t *to_salvage;

+

+ extent_split_interior_result_t result = extent_split_interior(

+ tsdn, arena, r_extent_hooks, rtree_ctx, &extent, &lead, &trail,

+ &to_leak, &to_salvage, new_addr, size, pad, alignment, slab, szind,

+ growing_retained);

+

+ if (result == extent_split_interior_ok) {

+ if (lead != NULL) {

+ extent_deactivate(tsdn, arena, extents, lead, false);

+ }

+ if (trail != NULL) {

+ extent_deactivate(tsdn, arena, extents, trail, false);

+ }

+ return extent;

+ } else {

+ /*

+ * We should have picked an extent that was large enough to

+ * fulfill our allocation request.

+ */

+ assert(result == extent_split_interior_error);

+ if (to_salvage != NULL) {

+ extent_deregister(tsdn, to_salvage);

+ }

+ if (to_leak != NULL) {

+ void *leak = extent_base_get(to_leak);

+ extent_deregister_no_gdump_sub(tsdn, to_leak);

+ extents_leak(tsdn, arena, r_extent_hooks, extents,

+ to_leak, growing_retained);

+ assert(extent_lock_from_addr(tsdn, rtree_ctx, leak)

+ == NULL);

+ }

+ return NULL;

+ }

+ unreachable();

+}

+

+/*

+ * Tries to satisfy the given allocation request by reusing one of the extents

+ * in the given extents_t.

+ */

+ rtree_ctx, extents, new_addr, size, pad, alignment, slab,

+ growing_retained);

+ if (extent_committed_get(extent)) {

+ *commit = true;

+ }

+ if (extent_zeroed_get(extent)) {

+ *zero = true;

+ }

+

+ if (arena == arena_get(tsd_tsdn(tsd), 0, false)) {

+ /*

+ * The only legitimate case of customized extent hooks for a0 is

+ * hooks with no allocation activities. One such example is to

+ * place metadata on pre-allocated resources such as huge pages.

+ * In that case, rely on reentrancy_level checks to catch

+ * infinite recursions.

+ */

+ pre_reentrancy(tsd, NULL);

+ } else {

+ pre_reentrancy(tsd, arena);

+ }

+ committed, true);

+

+ rtree_ctx_t rtree_ctx_fallback;

+ rtree_ctx_t *rtree_ctx = tsdn_rtree_ctx(tsdn, &rtree_ctx_fallback);

+

+ extent_t *lead;

+ extent_t *trail;

+ extent_t *to_leak;

+ extent_t *to_salvage;

+ extent_split_interior_result_t result = extent_split_interior(

+ tsdn, arena, r_extent_hooks, rtree_ctx, &extent, &lead, &trail,

+ &to_leak, &to_salvage, NULL, size, pad, alignment, slab, szind,

+ true);

+

+ if (result == extent_split_interior_ok) {

+ if (lead != NULL) {

+ extent_record(tsdn, arena, r_extent_hooks,

+ if (trail != NULL) {

+ extent_record(tsdn, arena, r_extent_hooks,

+ &arena->extents_retained, trail, true);

+ }

+ } else {

+ /*

+ * We should have allocated a sufficiently large extent; the

+ * cant_alloc case should not occur.

+ */

+ assert(result == extent_split_interior_error);

+ if (to_leak != NULL) {

+ extent_deregister_no_gdump_sub(tsdn, to_leak);

+ &arena->extents_retained, to_leak, true);

+ * Note: we don't handle the non-NULL to_salvage case at all.

+ * This maintains the behavior that was present when the

+ * refactor pulling extent_split_interior into a helper function

+ * was added. I think this is actually a bug (we leak both the

+ * memory and the extent_t in that case), but since this code is

+ * getting deleted very shortly (in a subsequent commit),

+ * ensuring correctness down this path isn't worth the effort.

+ * Increment extent_grow_next if doing so wouldn't exceed the allowed

+ if (arena->extent_grow_next + egn_skip + 1 <=

+ arena->retain_grow_limit) {

+ arena->extent_grow_next = arena->retain_grow_limit;

+ arena_extent_sn_next(arena), extent_state_active, zero, commit,

+ true);

+ if (opt_retain && new_addr != NULL) {

+ /*

+ * When retain is enabled and new_addr is set, we do not

+ * attempt extent_alloc_wrapper_hard which does mmap

+ * that is very unlikely to succeed (unless it happens

+ * to be at the end).

+ */

+ return NULL;

+ }

+ assert(extent == NULL || extent_dumpable_get(extent));

+ if (extents->delay_coalesce) {

+ * Remove outer from the LRU list so that it won't be show up in

+ * decay through extents_evict.

+ extent_list_remove(&extents->lru, outer);

+ if (!err && extents->delay_coalesce) {

+ if (forward) {

+ extent_list_prepend(&extents->lru, inner);

+ } else {

+ extent_list_prepend(&extents->lru, outer);

+ }

+ }

+ if (extents->delay_coalesce) {

+ extent_list_prepend(&extents->lru, outer);

+/*

+ * Does the metadata management portions of putting an unused extent into the

+ * given extents_t (coalesces, deregisters slab interiors, the heap operations).

+ */

+ } else if (extent_size_get(extent) >= LARGE_MINCLASS) {

+ /* Always coalesce large extents eagerly. */

+ bool coalesced;

+ size_t prev_size;

+ do {

+ prev_size = extent_size_get(extent);

+ assert(extent_state_get(extent) == extent_state_active);

+ extent = extent_try_coalesce(tsdn, arena,

+ r_extent_hooks, rtree_ctx, extents, extent,

+ &coalesced, growing_retained);

+ if (coalesced) {

+ extent_list_remove(&extents->lru, extent);

+ }

+ } while (coalesced &&

+ extent_size_get(extent) >= prev_size + LARGE_MINCLASS);

+ assert(extent_dumpable_get(extent));

+/*

+ * Accepts the extent to split, and the characteristics of each side of the

+ * split. The 'a' parameters go with the 'lead' of the resulting pair of

+ * extents (the lower addressed portion of the split), and the 'b' parameters go

+ * with the trail (the higher addressed portion). This makes 'extent' the lead,

+ * and returns the trail (except in case of error).

+ */

+ extent_committed_get(extent), extent_dumpable_get(extent));

+ extent_committed_get(extent), extent_dumpable_get(extent));

+ extent_state_active, false, true, true);

+ extent_state_active, false, true,

+ true);

+#include "jemalloc/internal/log.h"

+ if (strncmp("metadata_thp", k, klen) == 0) {

+ int i;

+ bool match = false;

+ for (i = 0; i < metadata_thp_mode_limit; i++) {

+ if (strncmp(metadata_thp_mode_names[i],

+ v, vlen) == 0) {

+ opt_metadata_thp = i;

+ match = true;

+ break;

+ }

+ }

+ if (!match) {

+ malloc_conf_error("Invalid conf value",

+ k, klen, v, vlen);

+ }

+ continue;

+ }

+ CONF_HANDLE_SIZE_T(opt_lg_extent_max_active_fit,

+ "lg_extent_max_active_fit", 0,

+ (sizeof(size_t) << 3), yes, yes, false)

+ if (config_log) {

+ if (CONF_MATCH("log")) {

+ size_t cpylen = (

+ vlen <= sizeof(log_var_names) ?

+ vlen : sizeof(log_var_names) - 1);

+ strncpy(log_var_names, v, cpylen);

+ log_var_names[cpylen] = '\0';

+ continue;

+ }

+ }

+ atomic_store_b(&log_init_done, true, ATOMIC_RELEASE);

+ witness_assert_lockless(witness_tsd_tsdn(

+ tsd_witness_tsdp_get_unsafe(tsd)));

+ * threads (pthread_create depends on malloc). ctl_init (which

+ * sets isthreaded) needs to be called without holding any lock.

+ background_thread_ctl_init(tsd_tsdn(tsd));

+

+ static const size_t high_bits = SIZE_T_MAX << (sizeof(size_t) * 8 / 2);

+ LOG("core.malloc.entry", "size: %zu", size);

+

+ LOG("core.malloc.exit", "result: %p", ret);

+

+ LOG("core.posix_memalign.entry", "mem ptr: %p, alignment: %zu, "

+ "size: %zu", memptr, alignment, size);

+

+

+ LOG("core.posix_memalign.exit", "result: %d, alloc ptr: %p", ret,

+ *memptr);

+

+ LOG("core.aligned_alloc.entry", "alignment: %zu, size: %zu\n",

+ alignment, size);

+

+

+ LOG("core.aligned_alloc.exit", "result: %p", ret);

+

+ LOG("core.calloc.entry", "num: %zu, size: %zu\n", num, size);

+

+ LOG("core.calloc.exit", "result: %p", ret);

+

+ if (!config_cache_oblivious && ((uintptr_t)ptr & PAGE_MASK) != 0) {

+ /*

+ * When cache_oblivious is disabled and ptr is not page aligned,

+ * the allocation was not sampled -- usize can be used to

+ * determine szind directly.

+ */

+ alloc_ctx.szind = sz_size2index(usize);

+ alloc_ctx.slab = true;

+ ctx = &alloc_ctx;

+ if (config_debug) {

+ alloc_ctx_t dbg_ctx;

+ rtree_ctx_t *rtree_ctx = tsd_rtree_ctx(tsd);

+ rtree_szind_slab_read(tsd_tsdn(tsd), &extents_rtree,

+ rtree_ctx, (uintptr_t)ptr, true, &dbg_ctx.szind,

+ &dbg_ctx.slab);

+ assert(dbg_ctx.szind == alloc_ctx.szind);

+ assert(dbg_ctx.slab == alloc_ctx.slab);

+ }

+ } else if (config_prof && opt_prof) {

+ if (config_prof && opt_prof) {

+ prof_free(tsd, ptr, usize, ctx);

+ }

+ LOG("core.realloc.entry", "ptr: %p, size: %zu\n", ptr, size);

+

+

+ LOG("core.realloc.exit", "result: %p", NULL);

+ void *ret = je_malloc(size);

+ LOG("core.realloc.exit", "result: %p", ret);

+ return ret;

+

+ LOG("core.realloc.exit", "result: %p", ret);

+ LOG("core.free.entry", "ptr: %p", ptr);

+

+ LOG("core.free.exit", "");

+ LOG("core.memalign.entry", "alignment: %zu, size: %zu\n", alignment,

+ size);

+

+

+ LOG("core.memalign.exit", "result: %p", ret);

+ LOG("core.valloc.entry", "size: %zu\n", size);

+

+ LOG("core.valloc.exit", "result: %p\n", ret);

+ LOG("core.mallocx.entry", "size: %zu, flags: %d", size, flags);

+

+

+ LOG("core.mallocx.exit", "result: %p", ret);

+ LOG("core.rallocx.entry", "ptr: %p, size: %zu, flags: %d", ptr,

+ size, flags);

+

+

+

+ LOG("core.rallocx.exit", "result: %p", p);

+

+ LOG("core.rallocx.exit", "result: %p", NULL);