From 1541efc4273dcdead23a23e0016e71510e97f698 Mon Sep 17 00:00:00 2001 From: tporadowski Date: Mon, 6 Jan 2020 08:39:32 +0100 Subject: [PATCH] jemalloc now calls Redis' memory functions - jemalloc is compiled with USE_WIN32_EXTERNAL_HEAP_ALLOC to make use of Redis' AllocHeapBlock/FreeHeapBlock/PurgePages - adjusted LG_PAGE definition to 22 by hand (although detected was 12) in jemalloc_internal_defs.h --- .../jemalloc/internal/jemalloc_internal.h | 1134 +++++++++++++ .../internal/jemalloc_internal_defs.h | 6 +- .../include/jemalloc/internal/pages.h | 12 + .../jemalloc/internal/private_namespace.h | 499 ++++++ .../jemalloc/internal/private_symbols.awk | 2 +- .../jemalloc/internal/private_symbols_jet.awk | 2 +- .../jemalloc/internal/private_unnamespace.h | 499 ++++++ .../jemalloc/internal/public_namespace.h | 2 +- .../jemalloc/internal/public_symbols.txt | 2 +- .../jemalloc/internal/public_unnamespace.h | 2 +- .../include/jemalloc/internal/size_classes.h | 1451 +++++++++++++++++ .../include/jemalloc/jemalloc.h | 12 +- .../include/jemalloc/jemalloc_macros.h | 6 +- .../include/jemalloc/jemalloc_mangle.h | 4 +- .../include/jemalloc/jemalloc_mangle_jet.h | 4 +- .../include/jemalloc/jemalloc_rename.h | 2 +- .../projects/vc2017/jemalloc/jemalloc.vcxproj | 169 +- .../vc2017/test_threads/test_threads.vcxproj | 17 +- deps/jemalloc-5.2.1/src/pages.c | 35 +- msvs/RedisServer.sln | 138 +- src/Win32_Interop/Win32_QFork.cpp | 1 - 21 files changed, 3806 insertions(+), 193 deletions(-) create mode 100644 deps/jemalloc-5.2.1/include/jemalloc/internal/jemalloc_internal.h create mode 100644 deps/jemalloc-5.2.1/include/jemalloc/internal/private_namespace.h create mode 100644 deps/jemalloc-5.2.1/include/jemalloc/internal/private_unnamespace.h create mode 100644 deps/jemalloc-5.2.1/include/jemalloc/internal/size_classes.h diff --git a/deps/jemalloc-5.2.1/include/jemalloc/internal/jemalloc_internal.h b/deps/jemalloc-5.2.1/include/jemalloc/internal/jemalloc_internal.h new file mode 100644 index 00000000..62225aea --- /dev/null +++ b/deps/jemalloc-5.2.1/include/jemalloc/internal/jemalloc_internal.h @@ -0,0 +1,1134 @@ +#ifndef JEMALLOC_INTERNAL_H +#define JEMALLOC_INTERNAL_H + +#include "jemalloc_internal_defs.h" +#include "jemalloc/internal/jemalloc_internal_decls.h" + +#ifdef JEMALLOC_UTRACE +#include +#endif + +#define JEMALLOC_NO_DEMANGLE +#ifdef JEMALLOC_JET +# define JEMALLOC_N(n) jet_##n +# include "jemalloc/internal/public_namespace.h" +# define JEMALLOC_NO_RENAME +# include "../jemalloc.h" +# undef JEMALLOC_NO_RENAME +#else +# define JEMALLOC_N(n) je_##n +# include "../jemalloc.h" +#endif +#include "jemalloc/internal/private_namespace.h" + +static const bool config_debug = +#ifdef JEMALLOC_DEBUG + true +#else + false +#endif + ; +static const bool have_dss = +#ifdef JEMALLOC_DSS + true +#else + false +#endif + ; +static const bool config_fill = +#ifdef JEMALLOC_FILL + true +#else + false +#endif + ; +static const bool config_lazy_lock = +#ifdef JEMALLOC_LAZY_LOCK + true +#else + false +#endif + ; +static const bool config_prof = +#ifdef JEMALLOC_PROF + true +#else + false +#endif + ; +static const bool config_prof_libgcc = +#ifdef JEMALLOC_PROF_LIBGCC + true +#else + false +#endif + ; +static const bool config_prof_libunwind = +#ifdef JEMALLOC_PROF_LIBUNWIND + true +#else + false +#endif + ; +static const bool maps_coalesce = +#ifdef JEMALLOC_MAPS_COALESCE + true +#else + false +#endif + ; +static const bool config_munmap = +#ifdef JEMALLOC_MUNMAP + true +#else + false +#endif + ; +static const bool config_stats = +#ifdef JEMALLOC_STATS + true +#else + false +#endif + ; +static const bool config_tcache = +#ifdef JEMALLOC_TCACHE + true +#else + false +#endif + ; +static const bool config_tls = +#ifdef JEMALLOC_TLS + true +#else + false +#endif + ; +static const bool config_utrace = +#ifdef JEMALLOC_UTRACE + true +#else + false +#endif + ; +static const bool config_valgrind = +#ifdef JEMALLOC_VALGRIND + true +#else + false +#endif + ; +static const bool config_xmalloc = +#ifdef JEMALLOC_XMALLOC + true +#else + false +#endif + ; +static const bool config_ivsalloc = +#ifdef JEMALLOC_IVSALLOC + true +#else + false +#endif + ; +static const bool config_cache_oblivious = +#ifdef JEMALLOC_CACHE_OBLIVIOUS + true +#else + false +#endif + ; + +#ifdef JEMALLOC_C11ATOMICS +#include +#endif + +#ifdef JEMALLOC_ATOMIC9 +#include +#endif + +#if (defined(JEMALLOC_OSATOMIC) || defined(JEMALLOC_OSSPIN)) +#include +#endif + +#ifdef JEMALLOC_ZONE +#include +#include +#include +#include +#endif + +#define RB_COMPACT +#include "jemalloc/internal/rb.h" +#include "jemalloc/internal/qr.h" +#include "jemalloc/internal/ql.h" + +/* + * jemalloc can conceptually be broken into components (arena, tcache, etc.), + * but there are circular dependencies that cannot be broken without + * substantial performance degradation. In order to reduce the effect on + * visual code flow, read the header files in multiple passes, with one of the + * following cpp variables defined during each pass: + * + * JEMALLOC_H_TYPES : Preprocessor-defined constants and psuedo-opaque data + * types. + * JEMALLOC_H_STRUCTS : Data structures. + * JEMALLOC_H_EXTERNS : Extern data declarations and function prototypes. + * JEMALLOC_H_INLINES : Inline functions. + */ +/******************************************************************************/ +#define JEMALLOC_H_TYPES + +#include "jemalloc/internal/jemalloc_internal_macros.h" + +/* Size class index type. */ +typedef unsigned szind_t; + +/* + * Flags bits: + * + * a: arena + * t: tcache + * 0: unused + * z: zero + * n: alignment + * + * aaaaaaaa aaaatttt tttttttt 0znnnnnn + */ +#define MALLOCX_ARENA_MASK ((int)~0xfffff) +#define MALLOCX_ARENA_MAX 0xffe +#define MALLOCX_TCACHE_MASK ((int)~0xfff000ffU) +#define MALLOCX_TCACHE_MAX 0xffd +#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) +/* Use MALLOCX_ALIGN_GET() if alignment may not be specified in flags. */ +#define MALLOCX_ALIGN_GET_SPECIFIED(flags) \ + (ZU(1) << (flags & MALLOCX_LG_ALIGN_MASK)) +#define MALLOCX_ALIGN_GET(flags) \ + (MALLOCX_ALIGN_GET_SPECIFIED(flags) & (SIZE_T_MAX-1)) +#define MALLOCX_ZERO_GET(flags) \ + ((bool)(flags & MALLOCX_ZERO)) + +#define MALLOCX_TCACHE_GET(flags) \ + (((unsigned)((flags & MALLOCX_TCACHE_MASK) >> 8)) - 2) +#define MALLOCX_ARENA_GET(flags) \ + (((unsigned)(((unsigned)flags) >> 20)) - 1) + +/* Smallest size class to support. */ +#define TINY_MIN (1U << LG_TINY_MIN) + +/* + * Minimum allocation alignment is 2^LG_QUANTUM bytes (ignoring tiny size + * classes). + */ +#ifndef LG_QUANTUM +# if (defined(__i386__) || defined(_M_IX86)) +# define LG_QUANTUM 4 +# endif +# ifdef __ia64__ +# define LG_QUANTUM 4 +# endif +# ifdef __alpha__ +# define LG_QUANTUM 4 +# endif +# if (defined(__sparc64__) || defined(__sparcv9)) +# define LG_QUANTUM 4 +# endif +# if (defined(__amd64__) || defined(__x86_64__) || defined(_M_X64)) +# define LG_QUANTUM 4 +# endif +# ifdef __arm__ +# define LG_QUANTUM 3 +# endif +# ifdef __aarch64__ +# define LG_QUANTUM 4 +# endif +# ifdef __hppa__ +# define LG_QUANTUM 4 +# endif +# ifdef __mips__ +# define LG_QUANTUM 3 +# endif +# ifdef __or1k__ +# define LG_QUANTUM 3 +# endif +# ifdef __powerpc__ +# define LG_QUANTUM 4 +# endif +# ifdef __s390__ +# define LG_QUANTUM 4 +# endif +# ifdef __SH4__ +# define LG_QUANTUM 4 +# endif +# ifdef __tile__ +# define LG_QUANTUM 4 +# endif +# ifdef __le32__ +# define LG_QUANTUM 4 +# endif +# ifndef LG_QUANTUM +# error "Unknown minimum alignment for architecture; specify via " + "--with-lg-quantum" +# endif +#endif + +#define QUANTUM ((size_t)(1U << LG_QUANTUM)) +#define QUANTUM_MASK (QUANTUM - 1) + +/* Return the smallest quantum multiple that is >= a. */ +#define QUANTUM_CEILING(a) \ + (((a) + QUANTUM_MASK) & ~QUANTUM_MASK) + +#define LONG ((size_t)(1U << LG_SIZEOF_LONG)) +#define LONG_MASK (LONG - 1) + +/* Return the smallest long multiple that is >= a. */ +#define LONG_CEILING(a) \ + (((a) + LONG_MASK) & ~LONG_MASK) + +#define SIZEOF_PTR (1U << LG_SIZEOF_PTR) +#define PTR_MASK (SIZEOF_PTR - 1) + +/* Return the smallest (void *) multiple that is >= a. */ +#define PTR_CEILING(a) \ + (((a) + PTR_MASK) & ~PTR_MASK) + +/* + * Maximum size of L1 cache line. This is used to avoid cache line aliasing. + * In addition, this controls the spacing of cacheline-spaced size classes. + * + * CACHELINE cannot be based on LG_CACHELINE because __declspec(align()) can + * only handle raw constants. + */ +#define LG_CACHELINE 6 +#define CACHELINE 64 +#define CACHELINE_MASK (CACHELINE - 1) + +/* Return the smallest cacheline multiple that is >= s. */ +#define CACHELINE_CEILING(s) \ + (((s) + CACHELINE_MASK) & ~CACHELINE_MASK) + +/* Page size. LG_PAGE is determined by the configure script. */ +#ifdef PAGE_MASK +# undef PAGE_MASK +#endif +#define PAGE ((size_t)(1U << LG_PAGE)) +#define PAGE_MASK ((size_t)(PAGE - 1)) + +/* Return the smallest pagesize multiple that is >= s. */ +#define PAGE_CEILING(s) \ + (((s) + PAGE_MASK) & ~PAGE_MASK) + +/* Return the nearest aligned address at or below a. */ +#define ALIGNMENT_ADDR2BASE(a, alignment) \ + ((void *)((uintptr_t)(a) & (-(alignment)))) + +/* Return the offset between a and the nearest aligned address at or below a. */ +#define ALIGNMENT_ADDR2OFFSET(a, alignment) \ + ((size_t)((uintptr_t)(a) & (alignment - 1))) + +/* Return the smallest alignment multiple that is >= s. */ +#define ALIGNMENT_CEILING(s, alignment) \ + (((s) + (alignment - 1)) & (-(alignment))) + +/* Declare a variable-length array. */ +#if __STDC_VERSION__ < 199901L +# ifdef _MSC_VER +# include +# define alloca _alloca +# else +# ifdef JEMALLOC_HAS_ALLOCA_H +# include +# else +# include +# endif +# endif +# define VARIABLE_ARRAY(type, name, count) \ + type *name = alloca(sizeof(type) * (count)) +#else +# define VARIABLE_ARRAY(type, name, count) type name[(count)] +#endif + +#include "jemalloc/internal/valgrind.h" +#include "jemalloc/internal/util.h" +#include "jemalloc/internal/atomic.h" +#include "jemalloc/internal/prng.h" +#include "jemalloc/internal/ckh.h" +#include "jemalloc/internal/size_classes.h" +#include "jemalloc/internal/stats.h" +#include "jemalloc/internal/ctl.h" +#include "jemalloc/internal/mutex.h" +#include "jemalloc/internal/tsd.h" +#include "jemalloc/internal/mb.h" +#include "jemalloc/internal/extent.h" +#include "jemalloc/internal/arena.h" +#include "jemalloc/internal/bitmap.h" +#include "jemalloc/internal/base.h" +#include "jemalloc/internal/rtree.h" +#include "jemalloc/internal/pages.h" +#include "jemalloc/internal/chunk.h" +#include "jemalloc/internal/huge.h" +#include "jemalloc/internal/tcache.h" +#include "jemalloc/internal/hash.h" +#include "jemalloc/internal/quarantine.h" +#include "jemalloc/internal/prof.h" + +#undef JEMALLOC_H_TYPES +/******************************************************************************/ +#define JEMALLOC_H_STRUCTS + +#include "jemalloc/internal/valgrind.h" +#include "jemalloc/internal/util.h" +#include "jemalloc/internal/atomic.h" +#include "jemalloc/internal/prng.h" +#include "jemalloc/internal/ckh.h" +#include "jemalloc/internal/size_classes.h" +#include "jemalloc/internal/stats.h" +#include "jemalloc/internal/ctl.h" +#include "jemalloc/internal/mutex.h" +#include "jemalloc/internal/mb.h" +#include "jemalloc/internal/bitmap.h" +#define JEMALLOC_ARENA_STRUCTS_A +#include "jemalloc/internal/arena.h" +#undef JEMALLOC_ARENA_STRUCTS_A +#include "jemalloc/internal/extent.h" +#define JEMALLOC_ARENA_STRUCTS_B +#include "jemalloc/internal/arena.h" +#undef JEMALLOC_ARENA_STRUCTS_B +#include "jemalloc/internal/base.h" +#include "jemalloc/internal/rtree.h" +#include "jemalloc/internal/pages.h" +#include "jemalloc/internal/chunk.h" +#include "jemalloc/internal/huge.h" +#include "jemalloc/internal/tcache.h" +#include "jemalloc/internal/hash.h" +#include "jemalloc/internal/quarantine.h" +#include "jemalloc/internal/prof.h" + +#include "jemalloc/internal/tsd.h" + +#undef JEMALLOC_H_STRUCTS +/******************************************************************************/ +#define JEMALLOC_H_EXTERNS + +extern bool opt_abort; +extern const char *opt_junk; +extern bool opt_junk_alloc; +extern bool opt_junk_free; +extern size_t opt_quarantine; +extern bool opt_redzone; +extern bool opt_utrace; +extern bool opt_xmalloc; +extern bool opt_zero; +extern size_t opt_narenas; + +extern bool in_valgrind; + +/* Number of CPUs. */ +extern unsigned ncpus; + +/* + * index2size_tab encodes the same information as could be computed (at + * unacceptable cost in some code paths) by index2size_compute(). + */ +extern size_t const index2size_tab[NSIZES]; +/* + * size2index_tab is a compact lookup table that rounds request sizes up to + * size classes. In order to reduce cache footprint, the table is compressed, + * and all accesses are via size2index(). + */ +extern uint8_t const size2index_tab[]; + +arena_t *a0get(void); +void *a0malloc(size_t size); +void a0dalloc(void *ptr); +void *bootstrap_malloc(size_t size); +void *bootstrap_calloc(size_t num, size_t size); +void bootstrap_free(void *ptr); +arena_t *arenas_extend(unsigned ind); +arena_t *arena_init(unsigned ind); +unsigned narenas_total_get(void); +arena_t *arena_get_hard(tsd_t *tsd, unsigned ind, bool init_if_missing); +arena_t *arena_choose_hard(tsd_t *tsd); +void arena_migrate(tsd_t *tsd, unsigned oldind, unsigned newind); +unsigned arena_nbound(unsigned ind); +void thread_allocated_cleanup(tsd_t *tsd); +void thread_deallocated_cleanup(tsd_t *tsd); +void arena_cleanup(tsd_t *tsd); +void arenas_cache_cleanup(tsd_t *tsd); +void narenas_cache_cleanup(tsd_t *tsd); +void arenas_cache_bypass_cleanup(tsd_t *tsd); +void jemalloc_prefork(void); +void jemalloc_postfork_parent(void); +void jemalloc_postfork_child(void); + +#include "jemalloc/internal/valgrind.h" +#include "jemalloc/internal/util.h" +#include "jemalloc/internal/atomic.h" +#include "jemalloc/internal/prng.h" +#include "jemalloc/internal/ckh.h" +#include "jemalloc/internal/size_classes.h" +#include "jemalloc/internal/stats.h" +#include "jemalloc/internal/ctl.h" +#include "jemalloc/internal/mutex.h" +#include "jemalloc/internal/mb.h" +#include "jemalloc/internal/bitmap.h" +#include "jemalloc/internal/extent.h" +#include "jemalloc/internal/arena.h" +#include "jemalloc/internal/base.h" +#include "jemalloc/internal/rtree.h" +#include "jemalloc/internal/pages.h" +#include "jemalloc/internal/chunk.h" +#include "jemalloc/internal/huge.h" +#include "jemalloc/internal/tcache.h" +#include "jemalloc/internal/hash.h" +#include "jemalloc/internal/quarantine.h" +#include "jemalloc/internal/prof.h" +#include "jemalloc/internal/tsd.h" + +#undef JEMALLOC_H_EXTERNS +/******************************************************************************/ +#define JEMALLOC_H_INLINES + +#include "jemalloc/internal/valgrind.h" +#include "jemalloc/internal/util.h" +#include "jemalloc/internal/atomic.h" +#include "jemalloc/internal/prng.h" +#include "jemalloc/internal/ckh.h" +#include "jemalloc/internal/size_classes.h" +#include "jemalloc/internal/stats.h" +#include "jemalloc/internal/ctl.h" +#include "jemalloc/internal/mutex.h" +#include "jemalloc/internal/tsd.h" +#include "jemalloc/internal/mb.h" +#include "jemalloc/internal/extent.h" +#include "jemalloc/internal/base.h" +#include "jemalloc/internal/rtree.h" +#include "jemalloc/internal/pages.h" +#include "jemalloc/internal/chunk.h" +#include "jemalloc/internal/huge.h" + +#ifndef JEMALLOC_ENABLE_INLINE +szind_t size2index_compute(size_t size); +szind_t size2index_lookup(size_t size); +szind_t size2index(size_t size); +size_t index2size_compute(szind_t index); +size_t index2size_lookup(szind_t index); +size_t index2size(szind_t index); +size_t s2u_compute(size_t size); +size_t s2u_lookup(size_t size); +size_t s2u(size_t size); +size_t sa2u(size_t size, size_t alignment); +arena_t *arena_choose(tsd_t *tsd, arena_t *arena); +arena_t *arena_get(tsd_t *tsd, unsigned ind, bool init_if_missing, + bool refresh_if_missing); +#endif + +#if (defined(JEMALLOC_ENABLE_INLINE) || defined(JEMALLOC_C_)) +JEMALLOC_INLINE szind_t +size2index_compute(size_t size) +{ + +#if (NTBINS != 0) + if (size <= (ZU(1) << LG_TINY_MAXCLASS)) { + size_t lg_tmin = LG_TINY_MAXCLASS - NTBINS + 1; + size_t lg_ceil = lg_floor(pow2_ceil(size)); + return (lg_ceil < lg_tmin ? 0 : lg_ceil - lg_tmin); + } +#endif + { + size_t x = unlikely(ZI(size) < 0) ? ((size<<1) ? + (ZU(1)<<(LG_SIZEOF_PTR+3)) : ((ZU(1)<<(LG_SIZEOF_PTR+3))-1)) + : lg_floor((size<<1)-1); + size_t shift = (x < LG_SIZE_CLASS_GROUP + LG_QUANTUM) ? 0 : + x - (LG_SIZE_CLASS_GROUP + LG_QUANTUM); + size_t grp = shift << LG_SIZE_CLASS_GROUP; + + size_t lg_delta = (x < LG_SIZE_CLASS_GROUP + LG_QUANTUM + 1) + ? LG_QUANTUM : x - LG_SIZE_CLASS_GROUP - 1; + + size_t delta_inverse_mask = ZI(-1) << lg_delta; + size_t mod = ((((size-1) & delta_inverse_mask) >> lg_delta)) & + ((ZU(1) << LG_SIZE_CLASS_GROUP) - 1); + + size_t index = NTBINS + grp + mod; + return (index); + } +} + +JEMALLOC_ALWAYS_INLINE szind_t +size2index_lookup(size_t size) +{ + + assert(size <= LOOKUP_MAXCLASS); + { + size_t ret = ((size_t)(size2index_tab[(size-1) >> + LG_TINY_MIN])); + assert(ret == size2index_compute(size)); + return (ret); + } +} + +JEMALLOC_ALWAYS_INLINE szind_t +size2index(size_t size) +{ + + assert(size > 0); + if (likely(size <= LOOKUP_MAXCLASS)) + return (size2index_lookup(size)); + return (size2index_compute(size)); +} + +JEMALLOC_INLINE size_t +index2size_compute(szind_t index) +{ + +#if (NTBINS > 0) + if (index < NTBINS) + return (ZU(1) << (LG_TINY_MAXCLASS - NTBINS + 1 + index)); +#endif + { + size_t reduced_index = index - NTBINS; + size_t grp = reduced_index >> LG_SIZE_CLASS_GROUP; + size_t mod = reduced_index & ((ZU(1) << LG_SIZE_CLASS_GROUP) - + 1); + + size_t grp_size_mask = ~((!!grp)-1); + size_t grp_size = ((ZU(1) << (LG_QUANTUM + + (LG_SIZE_CLASS_GROUP-1))) << grp) & grp_size_mask; + + size_t shift = (grp == 0) ? 1 : grp; + size_t lg_delta = shift + (LG_QUANTUM-1); + size_t mod_size = (mod+1) << lg_delta; + + size_t usize = grp_size + mod_size; + return (usize); + } +} + +JEMALLOC_ALWAYS_INLINE size_t +index2size_lookup(szind_t index) +{ + size_t ret = (size_t)index2size_tab[index]; + assert(ret == index2size_compute(index)); + return (ret); +} + +JEMALLOC_ALWAYS_INLINE size_t +index2size(szind_t index) +{ + + assert(index < NSIZES); + return (index2size_lookup(index)); +} + +JEMALLOC_ALWAYS_INLINE size_t +s2u_compute(size_t size) +{ + +#if (NTBINS > 0) + if (size <= (ZU(1) << LG_TINY_MAXCLASS)) { + size_t lg_tmin = LG_TINY_MAXCLASS - NTBINS + 1; + size_t lg_ceil = lg_floor(pow2_ceil(size)); + return (lg_ceil < lg_tmin ? (ZU(1) << lg_tmin) : + (ZU(1) << lg_ceil)); + } +#endif + { + size_t x = unlikely(ZI(size) < 0) ? ((size<<1) ? + (ZU(1)<<(LG_SIZEOF_PTR+3)) : ((ZU(1)<<(LG_SIZEOF_PTR+3))-1)) + : lg_floor((size<<1)-1); + size_t lg_delta = (x < LG_SIZE_CLASS_GROUP + LG_QUANTUM + 1) + ? LG_QUANTUM : x - LG_SIZE_CLASS_GROUP - 1; + size_t delta = ZU(1) << lg_delta; + size_t delta_mask = delta - 1; + size_t usize = (size + delta_mask) & ~delta_mask; + return (usize); + } +} + +JEMALLOC_ALWAYS_INLINE size_t +s2u_lookup(size_t size) +{ + size_t ret = index2size_lookup(size2index_lookup(size)); + + assert(ret == s2u_compute(size)); + return (ret); +} + +/* + * Compute usable size that would result from allocating an object with the + * specified size. + */ +JEMALLOC_ALWAYS_INLINE size_t +s2u(size_t size) +{ + + assert(size > 0); + if (likely(size <= LOOKUP_MAXCLASS)) + return (s2u_lookup(size)); + return (s2u_compute(size)); +} + +/* + * Compute usable size that would result from allocating an object with the + * specified size and alignment. + */ +JEMALLOC_ALWAYS_INLINE size_t +sa2u(size_t size, size_t alignment) +{ + size_t usize; + + assert(alignment != 0 && ((alignment - 1) & alignment) == 0); + + /* Try for a small size class. */ + if (size <= SMALL_MAXCLASS && alignment < PAGE) { + /* + * Round size up to the nearest multiple of alignment. + * + * This done, we can take advantage of the fact that for each + * small size class, every object is aligned at the smallest + * power of two that is non-zero in the base two representation + * of the size. For example: + * + * Size | Base 2 | Minimum alignment + * -----+----------+------------------ + * 96 | 1100000 | 32 + * 144 | 10100000 | 32 + * 192 | 11000000 | 64 + */ + usize = s2u(ALIGNMENT_CEILING(size, alignment)); + if (usize < LARGE_MINCLASS) + return (usize); + } + + /* Try for a large size class. */ + if (likely(size <= large_maxclass) && likely(alignment < chunksize)) { + /* + * We can't achieve subpage alignment, so round up alignment + * to the minimum that can actually be supported. + */ + alignment = PAGE_CEILING(alignment); + + /* Make sure result is a large size class. */ + usize = (size <= LARGE_MINCLASS) ? LARGE_MINCLASS : s2u(size); + + /* + * Calculate the size of the over-size run that arena_palloc() + * would need to allocate in order to guarantee the alignment. + */ + if (usize + large_pad + alignment - PAGE <= arena_maxrun) + return (usize); + } + + /* Huge size class. Beware of size_t overflow. */ + + /* + * We can't achieve subchunk alignment, so round up alignment to the + * minimum that can actually be supported. + */ + alignment = CHUNK_CEILING(alignment); + if (alignment == 0) { + /* size_t overflow. */ + return (0); + } + + /* Make sure result is a huge size class. */ + if (size <= chunksize) + usize = chunksize; + else { + usize = s2u(size); + if (usize < size) { + /* size_t overflow. */ + return (0); + } + } + + /* + * Calculate the multi-chunk mapping that huge_palloc() would need in + * order to guarantee the alignment. + */ + if (usize + alignment - PAGE < usize) { + /* size_t overflow. */ + return (0); + } + return (usize); +} + +/* Choose an arena based on a per-thread value. */ +JEMALLOC_INLINE arena_t * +arena_choose(tsd_t *tsd, arena_t *arena) +{ + arena_t *ret; + + if (arena != NULL) + return (arena); + + if (unlikely((ret = tsd_arena_get(tsd)) == NULL)) + ret = arena_choose_hard(tsd); + + return (ret); +} + +JEMALLOC_INLINE arena_t * +arena_get(tsd_t *tsd, unsigned ind, bool init_if_missing, + bool refresh_if_missing) +{ + arena_t *arena; + arena_t **arenas_cache = tsd_arenas_cache_get(tsd); + + /* init_if_missing requires refresh_if_missing. */ + assert(!init_if_missing || refresh_if_missing); + + if (unlikely(arenas_cache == NULL)) { + /* arenas_cache hasn't been initialized yet. */ + return (arena_get_hard(tsd, ind, init_if_missing)); + } + if (unlikely(ind >= tsd_narenas_cache_get(tsd))) { + /* + * ind is invalid, cache is old (too small), or arena to be + * initialized. + */ + return (refresh_if_missing ? arena_get_hard(tsd, ind, + init_if_missing) : NULL); + } + arena = arenas_cache[ind]; + if (likely(arena != NULL) || !refresh_if_missing) + return (arena); + return (arena_get_hard(tsd, ind, init_if_missing)); +} +#endif + +#include "jemalloc/internal/bitmap.h" +/* + * Include portions of arena.h interleaved with tcache.h in order to resolve + * circular dependencies. + */ +#define JEMALLOC_ARENA_INLINE_A +#include "jemalloc/internal/arena.h" +#undef JEMALLOC_ARENA_INLINE_A +#include "jemalloc/internal/tcache.h" +#define JEMALLOC_ARENA_INLINE_B +#include "jemalloc/internal/arena.h" +#undef JEMALLOC_ARENA_INLINE_B +#include "jemalloc/internal/hash.h" +#include "jemalloc/internal/quarantine.h" + +#ifndef JEMALLOC_ENABLE_INLINE +arena_t *iaalloc(const void *ptr); +size_t isalloc(const void *ptr, bool demote); +void *iallocztm(tsd_t *tsd, size_t size, bool zero, tcache_t *tcache, + bool is_metadata, arena_t *arena); +void *imalloct(tsd_t *tsd, size_t size, tcache_t *tcache, arena_t *arena); +void *imalloc(tsd_t *tsd, size_t size); +void *icalloct(tsd_t *tsd, size_t size, tcache_t *tcache, arena_t *arena); +void *icalloc(tsd_t *tsd, size_t size); +void *ipallocztm(tsd_t *tsd, size_t usize, size_t alignment, bool zero, + tcache_t *tcache, bool is_metadata, arena_t *arena); +void *ipalloct(tsd_t *tsd, size_t usize, size_t alignment, bool zero, + tcache_t *tcache, arena_t *arena); +void *ipalloc(tsd_t *tsd, size_t usize, size_t alignment, bool zero); +size_t ivsalloc(const void *ptr, bool demote); +size_t u2rz(size_t usize); +size_t p2rz(const void *ptr); +void idalloctm(tsd_t *tsd, void *ptr, tcache_t *tcache, bool is_metadata); +void idalloct(tsd_t *tsd, void *ptr, tcache_t *tcache); +void idalloc(tsd_t *tsd, void *ptr); +void iqalloc(tsd_t *tsd, void *ptr, tcache_t *tcache); +void isdalloct(tsd_t *tsd, void *ptr, size_t size, tcache_t *tcache); +void isqalloc(tsd_t *tsd, void *ptr, size_t size, tcache_t *tcache); +void *iralloct_realign(tsd_t *tsd, void *ptr, size_t oldsize, size_t size, + size_t extra, size_t alignment, bool zero, tcache_t *tcache, + arena_t *arena); +void *iralloct(tsd_t *tsd, void *ptr, size_t oldsize, size_t size, + size_t alignment, bool zero, tcache_t *tcache, arena_t *arena); +void *iralloc(tsd_t *tsd, void *ptr, size_t oldsize, size_t size, + size_t alignment, bool zero); +bool ixalloc(void *ptr, size_t oldsize, size_t size, size_t extra, + size_t alignment, bool zero); +#endif + +#if (defined(JEMALLOC_ENABLE_INLINE) || defined(JEMALLOC_C_)) +JEMALLOC_ALWAYS_INLINE arena_t * +iaalloc(const void *ptr) +{ + + assert(ptr != NULL); + + return (arena_aalloc(ptr)); +} + +/* + * Typical usage: + * void *ptr = [...] + * size_t sz = isalloc(ptr, config_prof); + */ +JEMALLOC_ALWAYS_INLINE size_t +isalloc(const void *ptr, bool demote) +{ + + assert(ptr != NULL); + /* Demotion only makes sense if config_prof is true. */ + assert(config_prof || !demote); + + return (arena_salloc(ptr, demote)); +} + +JEMALLOC_ALWAYS_INLINE void * +iallocztm(tsd_t *tsd, size_t size, bool zero, tcache_t *tcache, bool is_metadata, + arena_t *arena) +{ + void *ret; + + assert(size != 0); + + ret = arena_malloc(tsd, arena, size, zero, tcache); + if (config_stats && is_metadata && likely(ret != NULL)) { + arena_metadata_allocated_add(iaalloc(ret), isalloc(ret, + config_prof)); + } + return (ret); +} + +JEMALLOC_ALWAYS_INLINE void * +imalloct(tsd_t *tsd, size_t size, tcache_t *tcache, arena_t *arena) +{ + + return (iallocztm(tsd, size, false, tcache, false, arena)); +} + +JEMALLOC_ALWAYS_INLINE void * +imalloc(tsd_t *tsd, size_t size) +{ + + return (iallocztm(tsd, size, false, tcache_get(tsd, true), false, NULL)); +} + +JEMALLOC_ALWAYS_INLINE void * +icalloct(tsd_t *tsd, size_t size, tcache_t *tcache, arena_t *arena) +{ + + return (iallocztm(tsd, size, true, tcache, false, arena)); +} + +JEMALLOC_ALWAYS_INLINE void * +icalloc(tsd_t *tsd, size_t size) +{ + + return (iallocztm(tsd, size, true, tcache_get(tsd, true), false, NULL)); +} + +JEMALLOC_ALWAYS_INLINE void * +ipallocztm(tsd_t *tsd, size_t usize, size_t alignment, bool zero, + tcache_t *tcache, bool is_metadata, arena_t *arena) +{ + void *ret; + + assert(usize != 0); + assert(usize == sa2u(usize, alignment)); + + ret = arena_palloc(tsd, arena, usize, alignment, zero, tcache); + assert(ALIGNMENT_ADDR2BASE(ret, alignment) == ret); + if (config_stats && is_metadata && likely(ret != NULL)) { + arena_metadata_allocated_add(iaalloc(ret), isalloc(ret, + config_prof)); + } + return (ret); +} + +JEMALLOC_ALWAYS_INLINE void * +ipalloct(tsd_t *tsd, size_t usize, size_t alignment, bool zero, + tcache_t *tcache, arena_t *arena) +{ + + return (ipallocztm(tsd, usize, alignment, zero, tcache, false, arena)); +} + +JEMALLOC_ALWAYS_INLINE void * +ipalloc(tsd_t *tsd, size_t usize, size_t alignment, bool zero) +{ + + return (ipallocztm(tsd, usize, alignment, zero, tcache_get(tsd, + NULL), false, NULL)); +} + +JEMALLOC_ALWAYS_INLINE size_t +ivsalloc(const void *ptr, bool demote) +{ + extent_node_t *node; + + /* Return 0 if ptr is not within a chunk managed by jemalloc. */ + node = chunk_lookup(ptr, false); + if (node == NULL) + return (0); + /* Only arena chunks should be looked up via interior pointers. */ + assert(extent_node_addr_get(node) == ptr || + extent_node_achunk_get(node)); + + return (isalloc(ptr, demote)); +} + +JEMALLOC_INLINE size_t +u2rz(size_t usize) +{ + size_t ret; + + if (usize <= SMALL_MAXCLASS) { + szind_t binind = size2index(usize); + ret = arena_bin_info[binind].redzone_size; + } else + ret = 0; + + return (ret); +} + +JEMALLOC_INLINE size_t +p2rz(const void *ptr) +{ + size_t usize = isalloc(ptr, false); + + return (u2rz(usize)); +} + +JEMALLOC_ALWAYS_INLINE void +idalloctm(tsd_t *tsd, void *ptr, tcache_t *tcache, bool is_metadata) +{ + + assert(ptr != NULL); + if (config_stats && is_metadata) { + arena_metadata_allocated_sub(iaalloc(ptr), isalloc(ptr, + config_prof)); + } + + arena_dalloc(tsd, ptr, tcache); +} + +JEMALLOC_ALWAYS_INLINE void +idalloct(tsd_t *tsd, void *ptr, tcache_t *tcache) +{ + + idalloctm(tsd, ptr, tcache, false); +} + +JEMALLOC_ALWAYS_INLINE void +idalloc(tsd_t *tsd, void *ptr) +{ + + idalloctm(tsd, ptr, tcache_get(tsd, false), false); +} + +JEMALLOC_ALWAYS_INLINE void +iqalloc(tsd_t *tsd, void *ptr, tcache_t *tcache) +{ + + if (config_fill && unlikely(opt_quarantine)) + quarantine(tsd, ptr); + else + idalloctm(tsd, ptr, tcache, false); +} + +JEMALLOC_ALWAYS_INLINE void +isdalloct(tsd_t *tsd, void *ptr, size_t size, tcache_t *tcache) +{ + + arena_sdalloc(tsd, ptr, size, tcache); +} + +JEMALLOC_ALWAYS_INLINE void +isqalloc(tsd_t *tsd, void *ptr, size_t size, tcache_t *tcache) +{ + + if (config_fill && unlikely(opt_quarantine)) + quarantine(tsd, ptr); + else + isdalloct(tsd, ptr, size, tcache); +} + +JEMALLOC_ALWAYS_INLINE void * +iralloct_realign(tsd_t *tsd, void *ptr, size_t oldsize, size_t size, + size_t extra, size_t alignment, bool zero, tcache_t *tcache, arena_t *arena) +{ + void *p; + size_t usize, copysize; + + usize = sa2u(size + extra, alignment); + if (usize == 0) + return (NULL); + p = ipalloct(tsd, usize, alignment, zero, tcache, arena); + if (p == NULL) { + if (extra == 0) + return (NULL); + /* Try again, without extra this time. */ + usize = sa2u(size, alignment); + if (usize == 0) + return (NULL); + p = ipalloct(tsd, usize, alignment, zero, tcache, arena); + if (p == NULL) + return (NULL); + } + /* + * Copy at most size bytes (not size+extra), since the caller has no + * expectation that the extra bytes will be reliably preserved. + */ + copysize = (size < oldsize) ? size : oldsize; + memcpy(p, ptr, copysize); + isqalloc(tsd, ptr, oldsize, tcache); + return (p); +} + +JEMALLOC_ALWAYS_INLINE void * +iralloct(tsd_t *tsd, void *ptr, size_t oldsize, size_t size, size_t alignment, + bool zero, tcache_t *tcache, arena_t *arena) +{ + + assert(ptr != NULL); + assert(size != 0); + + if (alignment != 0 && ((uintptr_t)ptr & ((uintptr_t)alignment-1)) + != 0) { + /* + * Existing object alignment is inadequate; allocate new space + * and copy. + */ + return (iralloct_realign(tsd, ptr, oldsize, size, 0, alignment, + zero, tcache, arena)); + } + + return (arena_ralloc(tsd, arena, ptr, oldsize, size, alignment, zero, + tcache)); +} + +JEMALLOC_ALWAYS_INLINE void * +iralloc(tsd_t *tsd, void *ptr, size_t oldsize, size_t size, size_t alignment, + bool zero) +{ + + return (iralloct(tsd, ptr, oldsize, size, alignment, zero, + tcache_get(tsd, true), NULL)); +} + +JEMALLOC_ALWAYS_INLINE bool +ixalloc(void *ptr, size_t oldsize, size_t size, size_t extra, size_t alignment, + bool zero) +{ + + assert(ptr != NULL); + assert(size != 0); + + if (alignment != 0 && ((uintptr_t)ptr & ((uintptr_t)alignment-1)) + != 0) { + /* Existing object alignment is inadequate. */ + return (true); + } + + return (arena_ralloc_no_move(ptr, oldsize, size, extra, zero)); +} +#endif + +#include "jemalloc/internal/prof.h" + +#undef JEMALLOC_H_INLINES +/******************************************************************************/ +#endif /* JEMALLOC_INTERNAL_H */ diff --git a/deps/jemalloc-5.2.1/include/jemalloc/internal/jemalloc_internal_defs.h b/deps/jemalloc-5.2.1/include/jemalloc/internal/jemalloc_internal_defs.h index 73645c3b..2aceb340 100644 --- a/deps/jemalloc-5.2.1/include/jemalloc/internal/jemalloc_internal_defs.h +++ b/deps/jemalloc-5.2.1/include/jemalloc/internal/jemalloc_internal_defs.h @@ -176,14 +176,14 @@ /* #undef LG_QUANTUM */ /* One page is 2^LG_PAGE bytes. */ -#define LG_PAGE 12 +#define LG_PAGE 22 /* * One huge page is 2^LG_HUGEPAGE bytes. Note that this is defined even if the * system does not explicitly support huge pages; system calls that require * explicit huge page support are separately configured. */ -#define LG_HUGEPAGE 21 +#define LG_HUGEPAGE 22 /* * If defined, adjacent virtual memory mappings with identical attributes @@ -351,7 +351,7 @@ /* #undef JEMALLOC_EXPORT */ /* config.malloc_conf options string. */ -#define JEMALLOC_CONFIG_MALLOC_CONF "background_thread:false" +#define JEMALLOC_CONFIG_MALLOC_CONF "" /* If defined, jemalloc takes the malloc/free/etc. symbol names. */ /* #undef JEMALLOC_IS_MALLOC */ diff --git a/deps/jemalloc-5.2.1/include/jemalloc/internal/pages.h b/deps/jemalloc-5.2.1/include/jemalloc/internal/pages.h index 7dae633a..c5df3785 100644 --- a/deps/jemalloc-5.2.1/include/jemalloc/internal/pages.h +++ b/deps/jemalloc-5.2.1/include/jemalloc/internal/pages.h @@ -85,4 +85,16 @@ bool pages_dodump(void *addr, size_t size); bool pages_boot(void); void pages_set_thp_state (void *ptr, size_t size); +#ifdef USE_WIN32_EXTERNAL_HEAP_ALLOC +/* + * Instead of using VirtualAlloc and VirtualFree we will call external + * AllocHeapBlock, FreeHeapBlock and PurgePages that may have additional + * logic related to memory allocations. + * This is an extension used by Redis for Windows (https://github.com/tporadowski/redis). + */ +extern LPVOID AllocHeapBlock(LPVOID addr, size_t size, BOOL zero); +extern BOOL FreeHeapBlock(LPVOID addr, size_t size); +extern BOOL PurgePages(LPVOID addr, size_t length); +#endif + #endif /* JEMALLOC_INTERNAL_PAGES_EXTERNS_H */ diff --git a/deps/jemalloc-5.2.1/include/jemalloc/internal/private_namespace.h b/deps/jemalloc-5.2.1/include/jemalloc/internal/private_namespace.h new file mode 100644 index 00000000..c43f73d6 --- /dev/null +++ b/deps/jemalloc-5.2.1/include/jemalloc/internal/private_namespace.h @@ -0,0 +1,499 @@ +#define a0dalloc JEMALLOC_N(a0dalloc) +#define a0get JEMALLOC_N(a0get) +#define a0malloc JEMALLOC_N(a0malloc) +#define arena_aalloc JEMALLOC_N(arena_aalloc) +#define arena_alloc_junk_small JEMALLOC_N(arena_alloc_junk_small) +#define arena_bin_index JEMALLOC_N(arena_bin_index) +#define arena_bin_info JEMALLOC_N(arena_bin_info) +#define arena_bitselm_get JEMALLOC_N(arena_bitselm_get) +#define arena_boot JEMALLOC_N(arena_boot) +#define arena_choose JEMALLOC_N(arena_choose) +#define arena_choose_hard JEMALLOC_N(arena_choose_hard) +#define arena_chunk_alloc_huge JEMALLOC_N(arena_chunk_alloc_huge) +#define arena_chunk_cache_maybe_insert JEMALLOC_N(arena_chunk_cache_maybe_insert) +#define arena_chunk_cache_maybe_remove JEMALLOC_N(arena_chunk_cache_maybe_remove) +#define arena_chunk_dalloc_huge JEMALLOC_N(arena_chunk_dalloc_huge) +#define arena_chunk_ralloc_huge_expand JEMALLOC_N(arena_chunk_ralloc_huge_expand) +#define arena_chunk_ralloc_huge_shrink JEMALLOC_N(arena_chunk_ralloc_huge_shrink) +#define arena_chunk_ralloc_huge_similar JEMALLOC_N(arena_chunk_ralloc_huge_similar) +#define arena_cleanup JEMALLOC_N(arena_cleanup) +#define arena_dalloc JEMALLOC_N(arena_dalloc) +#define arena_dalloc_bin JEMALLOC_N(arena_dalloc_bin) +#define arena_dalloc_bin_junked_locked JEMALLOC_N(arena_dalloc_bin_junked_locked) +#define arena_dalloc_junk_large JEMALLOC_N(arena_dalloc_junk_large) +#define arena_dalloc_junk_small JEMALLOC_N(arena_dalloc_junk_small) +#define arena_dalloc_large JEMALLOC_N(arena_dalloc_large) +#define arena_dalloc_large_junked_locked JEMALLOC_N(arena_dalloc_large_junked_locked) +#define arena_dalloc_small JEMALLOC_N(arena_dalloc_small) +#define arena_dss_prec_get JEMALLOC_N(arena_dss_prec_get) +#define arena_dss_prec_set JEMALLOC_N(arena_dss_prec_set) +#define arena_get JEMALLOC_N(arena_get) +#define arena_get_hard JEMALLOC_N(arena_get_hard) +#define arena_init JEMALLOC_N(arena_init) +#define arena_lg_dirty_mult_default_get JEMALLOC_N(arena_lg_dirty_mult_default_get) +#define arena_lg_dirty_mult_default_set JEMALLOC_N(arena_lg_dirty_mult_default_set) +#define arena_lg_dirty_mult_get JEMALLOC_N(arena_lg_dirty_mult_get) +#define arena_lg_dirty_mult_set JEMALLOC_N(arena_lg_dirty_mult_set) +#define arena_malloc JEMALLOC_N(arena_malloc) +#define arena_malloc_large JEMALLOC_N(arena_malloc_large) +#define arena_malloc_small JEMALLOC_N(arena_malloc_small) +#define arena_mapbits_allocated_get JEMALLOC_N(arena_mapbits_allocated_get) +#define arena_mapbits_binind_get JEMALLOC_N(arena_mapbits_binind_get) +#define arena_mapbits_decommitted_get JEMALLOC_N(arena_mapbits_decommitted_get) +#define arena_mapbits_dirty_get JEMALLOC_N(arena_mapbits_dirty_get) +#define arena_mapbits_get JEMALLOC_N(arena_mapbits_get) +#define arena_mapbits_internal_set JEMALLOC_N(arena_mapbits_internal_set) +#define arena_mapbits_large_binind_set JEMALLOC_N(arena_mapbits_large_binind_set) +#define arena_mapbits_large_get JEMALLOC_N(arena_mapbits_large_get) +#define arena_mapbits_large_set JEMALLOC_N(arena_mapbits_large_set) +#define arena_mapbits_large_size_get JEMALLOC_N(arena_mapbits_large_size_get) +#define arena_mapbitsp_get JEMALLOC_N(arena_mapbitsp_get) +#define arena_mapbitsp_read JEMALLOC_N(arena_mapbitsp_read) +#define arena_mapbitsp_write JEMALLOC_N(arena_mapbitsp_write) +#define arena_mapbits_size_decode JEMALLOC_N(arena_mapbits_size_decode) +#define arena_mapbits_size_encode JEMALLOC_N(arena_mapbits_size_encode) +#define arena_mapbits_small_runind_get JEMALLOC_N(arena_mapbits_small_runind_get) +#define arena_mapbits_small_set JEMALLOC_N(arena_mapbits_small_set) +#define arena_mapbits_unallocated_set JEMALLOC_N(arena_mapbits_unallocated_set) +#define arena_mapbits_unallocated_size_get JEMALLOC_N(arena_mapbits_unallocated_size_get) +#define arena_mapbits_unallocated_size_set JEMALLOC_N(arena_mapbits_unallocated_size_set) +#define arena_mapbits_unzeroed_get JEMALLOC_N(arena_mapbits_unzeroed_get) +#define arena_maxrun JEMALLOC_N(arena_maxrun) +#define arena_maybe_purge JEMALLOC_N(arena_maybe_purge) +#define arena_metadata_allocated_add JEMALLOC_N(arena_metadata_allocated_add) +#define arena_metadata_allocated_get JEMALLOC_N(arena_metadata_allocated_get) +#define arena_metadata_allocated_sub JEMALLOC_N(arena_metadata_allocated_sub) +#define arena_migrate JEMALLOC_N(arena_migrate) +#define arena_miscelm_get JEMALLOC_N(arena_miscelm_get) +#define arena_miscelm_to_pageind JEMALLOC_N(arena_miscelm_to_pageind) +#define arena_miscelm_to_rpages JEMALLOC_N(arena_miscelm_to_rpages) +#define arena_nbound JEMALLOC_N(arena_nbound) +#define arena_new JEMALLOC_N(arena_new) +#define arena_node_alloc JEMALLOC_N(arena_node_alloc) +#define arena_node_dalloc JEMALLOC_N(arena_node_dalloc) +#define arena_palloc JEMALLOC_N(arena_palloc) +#define arena_postfork_child JEMALLOC_N(arena_postfork_child) +#define arena_postfork_parent JEMALLOC_N(arena_postfork_parent) +#define arena_prefork JEMALLOC_N(arena_prefork) +#define arena_prof_accum JEMALLOC_N(arena_prof_accum) +#define arena_prof_accum_impl JEMALLOC_N(arena_prof_accum_impl) +#define arena_prof_accum_locked JEMALLOC_N(arena_prof_accum_locked) +#define arena_prof_promoted JEMALLOC_N(arena_prof_promoted) +#define arena_prof_tctx_get JEMALLOC_N(arena_prof_tctx_get) +#define arena_prof_tctx_reset JEMALLOC_N(arena_prof_tctx_reset) +#define arena_prof_tctx_set JEMALLOC_N(arena_prof_tctx_set) +#define arena_ptr_small_binind_get JEMALLOC_N(arena_ptr_small_binind_get) +#define arena_purge_all JEMALLOC_N(arena_purge_all) +#define arena_quarantine_junk_small JEMALLOC_N(arena_quarantine_junk_small) +#define arena_ralloc JEMALLOC_N(arena_ralloc) +#define arena_ralloc_junk_large JEMALLOC_N(arena_ralloc_junk_large) +#define arena_ralloc_no_move JEMALLOC_N(arena_ralloc_no_move) +#define arena_rd_to_miscelm JEMALLOC_N(arena_rd_to_miscelm) +#define arena_redzone_corruption JEMALLOC_N(arena_redzone_corruption) +#define arena_run_regind JEMALLOC_N(arena_run_regind) +#define arena_run_to_miscelm JEMALLOC_N(arena_run_to_miscelm) +#define arena_salloc JEMALLOC_N(arena_salloc) +#define arenas_cache_bypass_cleanup JEMALLOC_N(arenas_cache_bypass_cleanup) +#define arenas_cache_cleanup JEMALLOC_N(arenas_cache_cleanup) +#define arena_sdalloc JEMALLOC_N(arena_sdalloc) +#define arena_stats_merge JEMALLOC_N(arena_stats_merge) +#define arena_tcache_fill_small JEMALLOC_N(arena_tcache_fill_small) +#define atomic_add_p JEMALLOC_N(atomic_add_p) +#define atomic_add_u JEMALLOC_N(atomic_add_u) +#define atomic_add_uint32 JEMALLOC_N(atomic_add_uint32) +#define atomic_add_uint64 JEMALLOC_N(atomic_add_uint64) +#define atomic_add_z JEMALLOC_N(atomic_add_z) +#define atomic_cas_p JEMALLOC_N(atomic_cas_p) +#define atomic_cas_u JEMALLOC_N(atomic_cas_u) +#define atomic_cas_uint32 JEMALLOC_N(atomic_cas_uint32) +#define atomic_cas_uint64 JEMALLOC_N(atomic_cas_uint64) +#define atomic_cas_z JEMALLOC_N(atomic_cas_z) +#define atomic_sub_p JEMALLOC_N(atomic_sub_p) +#define atomic_sub_u JEMALLOC_N(atomic_sub_u) +#define atomic_sub_uint32 JEMALLOC_N(atomic_sub_uint32) +#define atomic_sub_uint64 JEMALLOC_N(atomic_sub_uint64) +#define atomic_sub_z JEMALLOC_N(atomic_sub_z) +#define base_alloc JEMALLOC_N(base_alloc) +#define base_boot JEMALLOC_N(base_boot) +#define base_postfork_child JEMALLOC_N(base_postfork_child) +#define base_postfork_parent JEMALLOC_N(base_postfork_parent) +#define base_prefork JEMALLOC_N(base_prefork) +#define base_stats_get JEMALLOC_N(base_stats_get) +#define bitmap_full JEMALLOC_N(bitmap_full) +#define bitmap_get JEMALLOC_N(bitmap_get) +#define bitmap_info_init JEMALLOC_N(bitmap_info_init) +#define bitmap_info_ngroups JEMALLOC_N(bitmap_info_ngroups) +#define bitmap_init JEMALLOC_N(bitmap_init) +#define bitmap_set JEMALLOC_N(bitmap_set) +#define bitmap_sfu JEMALLOC_N(bitmap_sfu) +#define bitmap_size JEMALLOC_N(bitmap_size) +#define bitmap_unset JEMALLOC_N(bitmap_unset) +#define bootstrap_calloc JEMALLOC_N(bootstrap_calloc) +#define bootstrap_free JEMALLOC_N(bootstrap_free) +#define bootstrap_malloc JEMALLOC_N(bootstrap_malloc) +#define bt_init JEMALLOC_N(bt_init) +#define buferror JEMALLOC_N(buferror) +#define chunk_alloc_base JEMALLOC_N(chunk_alloc_base) +#define chunk_alloc_cache JEMALLOC_N(chunk_alloc_cache) +#define chunk_alloc_dss JEMALLOC_N(chunk_alloc_dss) +#define chunk_alloc_mmap JEMALLOC_N(chunk_alloc_mmap) +#define chunk_alloc_wrapper JEMALLOC_N(chunk_alloc_wrapper) +#define chunk_boot JEMALLOC_N(chunk_boot) +#define chunk_dalloc_arena JEMALLOC_N(chunk_dalloc_arena) +#define chunk_dalloc_cache JEMALLOC_N(chunk_dalloc_cache) +#define chunk_dalloc_mmap JEMALLOC_N(chunk_dalloc_mmap) +#define chunk_dalloc_wrapper JEMALLOC_N(chunk_dalloc_wrapper) +#define chunk_deregister JEMALLOC_N(chunk_deregister) +#define chunk_dss_boot JEMALLOC_N(chunk_dss_boot) +#define chunk_dss_postfork_child JEMALLOC_N(chunk_dss_postfork_child) +#define chunk_dss_postfork_parent JEMALLOC_N(chunk_dss_postfork_parent) +#define chunk_dss_prec_get JEMALLOC_N(chunk_dss_prec_get) +#define chunk_dss_prec_set JEMALLOC_N(chunk_dss_prec_set) +#define chunk_dss_prefork JEMALLOC_N(chunk_dss_prefork) +#define chunk_hooks_default JEMALLOC_N(chunk_hooks_default) +#define chunk_hooks_get JEMALLOC_N(chunk_hooks_get) +#define chunk_hooks_set JEMALLOC_N(chunk_hooks_set) +#define chunk_in_dss JEMALLOC_N(chunk_in_dss) +#define chunk_lookup JEMALLOC_N(chunk_lookup) +#define chunk_npages JEMALLOC_N(chunk_npages) +#define chunk_postfork_child JEMALLOC_N(chunk_postfork_child) +#define chunk_postfork_parent JEMALLOC_N(chunk_postfork_parent) +#define chunk_prefork JEMALLOC_N(chunk_prefork) +#define chunk_purge_arena JEMALLOC_N(chunk_purge_arena) +#define chunk_purge_wrapper JEMALLOC_N(chunk_purge_wrapper) +#define chunk_register JEMALLOC_N(chunk_register) +#define chunksize JEMALLOC_N(chunksize) +#define chunksize_mask JEMALLOC_N(chunksize_mask) +#define chunks_rtree JEMALLOC_N(chunks_rtree) +#define ckh_count JEMALLOC_N(ckh_count) +#define ckh_delete JEMALLOC_N(ckh_delete) +#define ckh_insert JEMALLOC_N(ckh_insert) +#define ckh_iter JEMALLOC_N(ckh_iter) +#define ckh_new JEMALLOC_N(ckh_new) +#define ckh_pointer_hash JEMALLOC_N(ckh_pointer_hash) +#define ckh_pointer_keycomp JEMALLOC_N(ckh_pointer_keycomp) +#define ckh_remove JEMALLOC_N(ckh_remove) +#define ckh_search JEMALLOC_N(ckh_search) +#define ckh_string_hash JEMALLOC_N(ckh_string_hash) +#define ckh_string_keycomp JEMALLOC_N(ckh_string_keycomp) +#define ctl_boot JEMALLOC_N(ctl_boot) +#define ctl_bymib JEMALLOC_N(ctl_bymib) +#define ctl_byname JEMALLOC_N(ctl_byname) +#define ctl_nametomib JEMALLOC_N(ctl_nametomib) +#define ctl_postfork_child JEMALLOC_N(ctl_postfork_child) +#define ctl_postfork_parent JEMALLOC_N(ctl_postfork_parent) +#define ctl_prefork JEMALLOC_N(ctl_prefork) +#define dss_prec_names JEMALLOC_N(dss_prec_names) +#define extent_node_achunk_get JEMALLOC_N(extent_node_achunk_get) +#define extent_node_achunk_set JEMALLOC_N(extent_node_achunk_set) +#define extent_node_addr_get JEMALLOC_N(extent_node_addr_get) +#define extent_node_addr_set JEMALLOC_N(extent_node_addr_set) +#define extent_node_arena_get JEMALLOC_N(extent_node_arena_get) +#define extent_node_arena_set JEMALLOC_N(extent_node_arena_set) +#define extent_node_dirty_insert JEMALLOC_N(extent_node_dirty_insert) +#define extent_node_dirty_linkage_init JEMALLOC_N(extent_node_dirty_linkage_init) +#define extent_node_dirty_remove JEMALLOC_N(extent_node_dirty_remove) +#define extent_node_init JEMALLOC_N(extent_node_init) +#define extent_node_prof_tctx_get JEMALLOC_N(extent_node_prof_tctx_get) +#define extent_node_prof_tctx_set JEMALLOC_N(extent_node_prof_tctx_set) +#define extent_node_size_get JEMALLOC_N(extent_node_size_get) +#define extent_node_size_set JEMALLOC_N(extent_node_size_set) +#define extent_node_zeroed_get JEMALLOC_N(extent_node_zeroed_get) +#define extent_node_zeroed_set JEMALLOC_N(extent_node_zeroed_set) +#define extent_tree_ad_empty JEMALLOC_N(extent_tree_ad_empty) +#define extent_tree_ad_first JEMALLOC_N(extent_tree_ad_first) +#define extent_tree_ad_insert JEMALLOC_N(extent_tree_ad_insert) +#define extent_tree_ad_iter JEMALLOC_N(extent_tree_ad_iter) +#define extent_tree_ad_iter_recurse JEMALLOC_N(extent_tree_ad_iter_recurse) +#define extent_tree_ad_iter_start JEMALLOC_N(extent_tree_ad_iter_start) +#define extent_tree_ad_last JEMALLOC_N(extent_tree_ad_last) +#define extent_tree_ad_new JEMALLOC_N(extent_tree_ad_new) +#define extent_tree_ad_next JEMALLOC_N(extent_tree_ad_next) +#define extent_tree_ad_nsearch JEMALLOC_N(extent_tree_ad_nsearch) +#define extent_tree_ad_prev JEMALLOC_N(extent_tree_ad_prev) +#define extent_tree_ad_psearch JEMALLOC_N(extent_tree_ad_psearch) +#define extent_tree_ad_remove JEMALLOC_N(extent_tree_ad_remove) +#define extent_tree_ad_reverse_iter JEMALLOC_N(extent_tree_ad_reverse_iter) +#define extent_tree_ad_reverse_iter_recurse JEMALLOC_N(extent_tree_ad_reverse_iter_recurse) +#define extent_tree_ad_reverse_iter_start JEMALLOC_N(extent_tree_ad_reverse_iter_start) +#define extent_tree_ad_search JEMALLOC_N(extent_tree_ad_search) +#define extent_tree_szad_empty JEMALLOC_N(extent_tree_szad_empty) +#define extent_tree_szad_first JEMALLOC_N(extent_tree_szad_first) +#define extent_tree_szad_insert JEMALLOC_N(extent_tree_szad_insert) +#define extent_tree_szad_iter JEMALLOC_N(extent_tree_szad_iter) +#define extent_tree_szad_iter_recurse JEMALLOC_N(extent_tree_szad_iter_recurse) +#define extent_tree_szad_iter_start JEMALLOC_N(extent_tree_szad_iter_start) +#define extent_tree_szad_last JEMALLOC_N(extent_tree_szad_last) +#define extent_tree_szad_new JEMALLOC_N(extent_tree_szad_new) +#define extent_tree_szad_next JEMALLOC_N(extent_tree_szad_next) +#define extent_tree_szad_nsearch JEMALLOC_N(extent_tree_szad_nsearch) +#define extent_tree_szad_prev JEMALLOC_N(extent_tree_szad_prev) +#define extent_tree_szad_psearch JEMALLOC_N(extent_tree_szad_psearch) +#define extent_tree_szad_remove JEMALLOC_N(extent_tree_szad_remove) +#define extent_tree_szad_reverse_iter JEMALLOC_N(extent_tree_szad_reverse_iter) +#define extent_tree_szad_reverse_iter_recurse JEMALLOC_N(extent_tree_szad_reverse_iter_recurse) +#define extent_tree_szad_reverse_iter_start JEMALLOC_N(extent_tree_szad_reverse_iter_start) +#define extent_tree_szad_search JEMALLOC_N(extent_tree_szad_search) +#define get_errno JEMALLOC_N(get_errno) +#define hash JEMALLOC_N(hash) +#define hash_fmix_32 JEMALLOC_N(hash_fmix_32) +#define hash_fmix_64 JEMALLOC_N(hash_fmix_64) +#define hash_get_block_32 JEMALLOC_N(hash_get_block_32) +#define hash_get_block_64 JEMALLOC_N(hash_get_block_64) +#define hash_rotl_32 JEMALLOC_N(hash_rotl_32) +#define hash_rotl_64 JEMALLOC_N(hash_rotl_64) +#define hash_x64_128 JEMALLOC_N(hash_x64_128) +#define hash_x86_128 JEMALLOC_N(hash_x86_128) +#define hash_x86_32 JEMALLOC_N(hash_x86_32) +#define huge_aalloc JEMALLOC_N(huge_aalloc) +#define huge_dalloc JEMALLOC_N(huge_dalloc) +#define huge_dalloc_junk JEMALLOC_N(huge_dalloc_junk) +#define huge_malloc JEMALLOC_N(huge_malloc) +#define huge_palloc JEMALLOC_N(huge_palloc) +#define huge_prof_tctx_get JEMALLOC_N(huge_prof_tctx_get) +#define huge_prof_tctx_reset JEMALLOC_N(huge_prof_tctx_reset) +#define huge_prof_tctx_set JEMALLOC_N(huge_prof_tctx_set) +#define huge_ralloc JEMALLOC_N(huge_ralloc) +#define huge_ralloc_no_move JEMALLOC_N(huge_ralloc_no_move) +#define huge_salloc JEMALLOC_N(huge_salloc) +#define iaalloc JEMALLOC_N(iaalloc) +#define iallocztm JEMALLOC_N(iallocztm) +#define icalloc JEMALLOC_N(icalloc) +#define icalloct JEMALLOC_N(icalloct) +#define idalloc JEMALLOC_N(idalloc) +#define idalloct JEMALLOC_N(idalloct) +#define idalloctm JEMALLOC_N(idalloctm) +#define imalloc JEMALLOC_N(imalloc) +#define imalloct JEMALLOC_N(imalloct) +#define index2size JEMALLOC_N(index2size) +#define index2size_compute JEMALLOC_N(index2size_compute) +#define index2size_lookup JEMALLOC_N(index2size_lookup) +#define index2size_tab JEMALLOC_N(index2size_tab) +#define in_valgrind JEMALLOC_N(in_valgrind) +#define ipalloc JEMALLOC_N(ipalloc) +#define ipalloct JEMALLOC_N(ipalloct) +#define ipallocztm JEMALLOC_N(ipallocztm) +#define iqalloc JEMALLOC_N(iqalloc) +#define iralloc JEMALLOC_N(iralloc) +#define iralloct JEMALLOC_N(iralloct) +#define iralloct_realign JEMALLOC_N(iralloct_realign) +#define isalloc JEMALLOC_N(isalloc) +#define isdalloct JEMALLOC_N(isdalloct) +#define isqalloc JEMALLOC_N(isqalloc) +#define isthreaded JEMALLOC_N(isthreaded) +#define ivsalloc JEMALLOC_N(ivsalloc) +#define ixalloc JEMALLOC_N(ixalloc) +#define jemalloc_postfork_child JEMALLOC_N(jemalloc_postfork_child) +#define jemalloc_postfork_parent JEMALLOC_N(jemalloc_postfork_parent) +#define jemalloc_prefork JEMALLOC_N(jemalloc_prefork) +#define large_maxclass JEMALLOC_N(large_maxclass) +#define lg_floor JEMALLOC_N(lg_floor) +#define malloc_cprintf JEMALLOC_N(malloc_cprintf) +#define malloc_mutex_init JEMALLOC_N(malloc_mutex_init) +#define malloc_mutex_lock JEMALLOC_N(malloc_mutex_lock) +#define malloc_mutex_postfork_child JEMALLOC_N(malloc_mutex_postfork_child) +#define malloc_mutex_postfork_parent JEMALLOC_N(malloc_mutex_postfork_parent) +#define malloc_mutex_prefork JEMALLOC_N(malloc_mutex_prefork) +#define malloc_mutex_unlock JEMALLOC_N(malloc_mutex_unlock) +#define malloc_printf JEMALLOC_N(malloc_printf) +#define malloc_snprintf JEMALLOC_N(malloc_snprintf) +#define malloc_strtoumax JEMALLOC_N(malloc_strtoumax) +#define malloc_tsd_boot0 JEMALLOC_N(malloc_tsd_boot0) +#define malloc_tsd_boot1 JEMALLOC_N(malloc_tsd_boot1) +#define malloc_tsd_cleanup_register JEMALLOC_N(malloc_tsd_cleanup_register) +#define malloc_tsd_dalloc JEMALLOC_N(malloc_tsd_dalloc) +#define malloc_tsd_malloc JEMALLOC_N(malloc_tsd_malloc) +#define malloc_tsd_no_cleanup JEMALLOC_N(malloc_tsd_no_cleanup) +#define malloc_vcprintf JEMALLOC_N(malloc_vcprintf) +#define malloc_vsnprintf JEMALLOC_N(malloc_vsnprintf) +#define malloc_write JEMALLOC_N(malloc_write) +#define map_bias JEMALLOC_N(map_bias) +#define map_misc_offset JEMALLOC_N(map_misc_offset) +#define mb_write JEMALLOC_N(mb_write) +#define mutex_boot JEMALLOC_N(mutex_boot) +#define narenas_cache_cleanup JEMALLOC_N(narenas_cache_cleanup) +#define narenas_total_get JEMALLOC_N(narenas_total_get) +#define ncpus JEMALLOC_N(ncpus) +#define nhbins JEMALLOC_N(nhbins) +#define opt_abort JEMALLOC_N(opt_abort) +#define opt_dss JEMALLOC_N(opt_dss) +#define opt_junk JEMALLOC_N(opt_junk) +#define opt_junk_alloc JEMALLOC_N(opt_junk_alloc) +#define opt_junk_free JEMALLOC_N(opt_junk_free) +#define opt_lg_chunk JEMALLOC_N(opt_lg_chunk) +#define opt_lg_dirty_mult JEMALLOC_N(opt_lg_dirty_mult) +#define opt_lg_prof_interval JEMALLOC_N(opt_lg_prof_interval) +#define opt_lg_prof_sample JEMALLOC_N(opt_lg_prof_sample) +#define opt_lg_tcache_max JEMALLOC_N(opt_lg_tcache_max) +#define opt_narenas JEMALLOC_N(opt_narenas) +#define opt_prof JEMALLOC_N(opt_prof) +#define opt_prof_accum JEMALLOC_N(opt_prof_accum) +#define opt_prof_active JEMALLOC_N(opt_prof_active) +#define opt_prof_final JEMALLOC_N(opt_prof_final) +#define opt_prof_gdump JEMALLOC_N(opt_prof_gdump) +#define opt_prof_leak JEMALLOC_N(opt_prof_leak) +#define opt_prof_prefix JEMALLOC_N(opt_prof_prefix) +#define opt_prof_thread_active_init JEMALLOC_N(opt_prof_thread_active_init) +#define opt_quarantine JEMALLOC_N(opt_quarantine) +#define opt_redzone JEMALLOC_N(opt_redzone) +#define opt_stats_print JEMALLOC_N(opt_stats_print) +#define opt_tcache JEMALLOC_N(opt_tcache) +#define opt_utrace JEMALLOC_N(opt_utrace) +#define opt_xmalloc JEMALLOC_N(opt_xmalloc) +#define opt_zero JEMALLOC_N(opt_zero) +#define p2rz JEMALLOC_N(p2rz) +#define pages_commit JEMALLOC_N(pages_commit) +#define pages_decommit JEMALLOC_N(pages_decommit) +#define pages_map JEMALLOC_N(pages_map) +#define pages_purge JEMALLOC_N(pages_purge) +#define pages_trim JEMALLOC_N(pages_trim) +#define pages_unmap JEMALLOC_N(pages_unmap) +#define pow2_ceil JEMALLOC_N(pow2_ceil) +#define prof_active_get JEMALLOC_N(prof_active_get) +#define prof_active_get_unlocked JEMALLOC_N(prof_active_get_unlocked) +#define prof_active_set JEMALLOC_N(prof_active_set) +#define prof_alloc_prep JEMALLOC_N(prof_alloc_prep) +#define prof_alloc_rollback JEMALLOC_N(prof_alloc_rollback) +#define prof_backtrace JEMALLOC_N(prof_backtrace) +#define prof_boot0 JEMALLOC_N(prof_boot0) +#define prof_boot1 JEMALLOC_N(prof_boot1) +#define prof_boot2 JEMALLOC_N(prof_boot2) +#define prof_dump_header JEMALLOC_N(prof_dump_header) +#define prof_dump_open JEMALLOC_N(prof_dump_open) +#define prof_free JEMALLOC_N(prof_free) +#define prof_free_sampled_object JEMALLOC_N(prof_free_sampled_object) +#define prof_gdump JEMALLOC_N(prof_gdump) +#define prof_gdump_get JEMALLOC_N(prof_gdump_get) +#define prof_gdump_get_unlocked JEMALLOC_N(prof_gdump_get_unlocked) +#define prof_gdump_set JEMALLOC_N(prof_gdump_set) +#define prof_gdump_val JEMALLOC_N(prof_gdump_val) +#define prof_idump JEMALLOC_N(prof_idump) +#define prof_interval JEMALLOC_N(prof_interval) +#define prof_lookup JEMALLOC_N(prof_lookup) +#define prof_malloc JEMALLOC_N(prof_malloc) +#define prof_malloc_sample_object JEMALLOC_N(prof_malloc_sample_object) +#define prof_mdump JEMALLOC_N(prof_mdump) +#define prof_postfork_child JEMALLOC_N(prof_postfork_child) +#define prof_postfork_parent JEMALLOC_N(prof_postfork_parent) +#define prof_prefork JEMALLOC_N(prof_prefork) +#define prof_realloc JEMALLOC_N(prof_realloc) +#define prof_reset JEMALLOC_N(prof_reset) +#define prof_sample_accum_update JEMALLOC_N(prof_sample_accum_update) +#define prof_sample_threshold_update JEMALLOC_N(prof_sample_threshold_update) +#define prof_tctx_get JEMALLOC_N(prof_tctx_get) +#define prof_tctx_reset JEMALLOC_N(prof_tctx_reset) +#define prof_tctx_set JEMALLOC_N(prof_tctx_set) +#define prof_tdata_cleanup JEMALLOC_N(prof_tdata_cleanup) +#define prof_tdata_get JEMALLOC_N(prof_tdata_get) +#define prof_tdata_init JEMALLOC_N(prof_tdata_init) +#define prof_tdata_reinit JEMALLOC_N(prof_tdata_reinit) +#define prof_thread_active_get JEMALLOC_N(prof_thread_active_get) +#define prof_thread_active_init_get JEMALLOC_N(prof_thread_active_init_get) +#define prof_thread_active_init_set JEMALLOC_N(prof_thread_active_init_set) +#define prof_thread_active_set JEMALLOC_N(prof_thread_active_set) +#define prof_thread_name_get JEMALLOC_N(prof_thread_name_get) +#define prof_thread_name_set JEMALLOC_N(prof_thread_name_set) +#define quarantine JEMALLOC_N(quarantine) +#define quarantine_alloc_hook JEMALLOC_N(quarantine_alloc_hook) +#define quarantine_alloc_hook_work JEMALLOC_N(quarantine_alloc_hook_work) +#define quarantine_cleanup JEMALLOC_N(quarantine_cleanup) +#define register_zone JEMALLOC_N(register_zone) +#define rtree_child_read JEMALLOC_N(rtree_child_read) +#define rtree_child_read_hard JEMALLOC_N(rtree_child_read_hard) +#define rtree_child_tryread JEMALLOC_N(rtree_child_tryread) +#define rtree_delete JEMALLOC_N(rtree_delete) +#define rtree_get JEMALLOC_N(rtree_get) +#define rtree_new JEMALLOC_N(rtree_new) +#define rtree_node_valid JEMALLOC_N(rtree_node_valid) +#define rtree_set JEMALLOC_N(rtree_set) +#define rtree_start_level JEMALLOC_N(rtree_start_level) +#define rtree_subkey JEMALLOC_N(rtree_subkey) +#define rtree_subtree_read JEMALLOC_N(rtree_subtree_read) +#define rtree_subtree_read_hard JEMALLOC_N(rtree_subtree_read_hard) +#define rtree_subtree_tryread JEMALLOC_N(rtree_subtree_tryread) +#define rtree_val_read JEMALLOC_N(rtree_val_read) +#define rtree_val_write JEMALLOC_N(rtree_val_write) +#define s2u JEMALLOC_N(s2u) +#define s2u_compute JEMALLOC_N(s2u_compute) +#define s2u_lookup JEMALLOC_N(s2u_lookup) +#define sa2u JEMALLOC_N(sa2u) +#define set_errno JEMALLOC_N(set_errno) +#define size2index JEMALLOC_N(size2index) +#define size2index_compute JEMALLOC_N(size2index_compute) +#define size2index_lookup JEMALLOC_N(size2index_lookup) +#define size2index_tab JEMALLOC_N(size2index_tab) +#define stats_cactive JEMALLOC_N(stats_cactive) +#define stats_cactive_add JEMALLOC_N(stats_cactive_add) +#define stats_cactive_get JEMALLOC_N(stats_cactive_get) +#define stats_cactive_sub JEMALLOC_N(stats_cactive_sub) +#define stats_print JEMALLOC_N(stats_print) +#define tcache_alloc_easy JEMALLOC_N(tcache_alloc_easy) +#define tcache_alloc_large JEMALLOC_N(tcache_alloc_large) +#define tcache_alloc_small JEMALLOC_N(tcache_alloc_small) +#define tcache_alloc_small_hard JEMALLOC_N(tcache_alloc_small_hard) +#define tcache_arena_associate JEMALLOC_N(tcache_arena_associate) +#define tcache_arena_dissociate JEMALLOC_N(tcache_arena_dissociate) +#define tcache_arena_reassociate JEMALLOC_N(tcache_arena_reassociate) +#define tcache_bin_flush_large JEMALLOC_N(tcache_bin_flush_large) +#define tcache_bin_flush_small JEMALLOC_N(tcache_bin_flush_small) +#define tcache_bin_info JEMALLOC_N(tcache_bin_info) +#define tcache_boot JEMALLOC_N(tcache_boot) +#define tcache_cleanup JEMALLOC_N(tcache_cleanup) +#define tcache_create JEMALLOC_N(tcache_create) +#define tcache_dalloc_large JEMALLOC_N(tcache_dalloc_large) +#define tcache_dalloc_small JEMALLOC_N(tcache_dalloc_small) +#define tcache_enabled_cleanup JEMALLOC_N(tcache_enabled_cleanup) +#define tcache_enabled_get JEMALLOC_N(tcache_enabled_get) +#define tcache_enabled_set JEMALLOC_N(tcache_enabled_set) +#define tcache_event JEMALLOC_N(tcache_event) +#define tcache_event_hard JEMALLOC_N(tcache_event_hard) +#define tcache_flush JEMALLOC_N(tcache_flush) +#define tcache_get JEMALLOC_N(tcache_get) +#define tcache_get_hard JEMALLOC_N(tcache_get_hard) +#define tcache_maxclass JEMALLOC_N(tcache_maxclass) +#define tcaches JEMALLOC_N(tcaches) +#define tcache_salloc JEMALLOC_N(tcache_salloc) +#define tcaches_create JEMALLOC_N(tcaches_create) +#define tcaches_destroy JEMALLOC_N(tcaches_destroy) +#define tcaches_flush JEMALLOC_N(tcaches_flush) +#define tcaches_get JEMALLOC_N(tcaches_get) +#define tcache_stats_merge JEMALLOC_N(tcache_stats_merge) +#define thread_allocated_cleanup JEMALLOC_N(thread_allocated_cleanup) +#define thread_deallocated_cleanup JEMALLOC_N(thread_deallocated_cleanup) +#define tsd_arena_get JEMALLOC_N(tsd_arena_get) +#define tsd_arena_set JEMALLOC_N(tsd_arena_set) +#define tsd_boot JEMALLOC_N(tsd_boot) +#define tsd_boot0 JEMALLOC_N(tsd_boot0) +#define tsd_boot1 JEMALLOC_N(tsd_boot1) +#define tsd_booted JEMALLOC_N(tsd_booted) +#define tsd_cleanup JEMALLOC_N(tsd_cleanup) +#define tsd_cleanup_wrapper JEMALLOC_N(tsd_cleanup_wrapper) +#define tsd_fetch JEMALLOC_N(tsd_fetch) +#define tsd_get JEMALLOC_N(tsd_get) +#define tsd_wrapper_get JEMALLOC_N(tsd_wrapper_get) +#define tsd_wrapper_set JEMALLOC_N(tsd_wrapper_set) +#define tsd_initialized JEMALLOC_N(tsd_initialized) +#define tsd_init_check_recursion JEMALLOC_N(tsd_init_check_recursion) +#define tsd_init_finish JEMALLOC_N(tsd_init_finish) +#define tsd_init_head JEMALLOC_N(tsd_init_head) +#define tsd_nominal JEMALLOC_N(tsd_nominal) +#define tsd_quarantine_get JEMALLOC_N(tsd_quarantine_get) +#define tsd_quarantine_set JEMALLOC_N(tsd_quarantine_set) +#define tsd_set JEMALLOC_N(tsd_set) +#define tsd_tcache_enabled_get JEMALLOC_N(tsd_tcache_enabled_get) +#define tsd_tcache_enabled_set JEMALLOC_N(tsd_tcache_enabled_set) +#define tsd_tcache_get JEMALLOC_N(tsd_tcache_get) +#define tsd_tcache_set JEMALLOC_N(tsd_tcache_set) +#define tsd_tls JEMALLOC_N(tsd_tls) +#define tsd_tsd JEMALLOC_N(tsd_tsd) +#define tsd_prof_tdata_get JEMALLOC_N(tsd_prof_tdata_get) +#define tsd_prof_tdata_set JEMALLOC_N(tsd_prof_tdata_set) +#define tsd_thread_allocated_get JEMALLOC_N(tsd_thread_allocated_get) +#define tsd_thread_allocated_set JEMALLOC_N(tsd_thread_allocated_set) +#define tsd_thread_deallocated_get JEMALLOC_N(tsd_thread_deallocated_get) +#define tsd_thread_deallocated_set JEMALLOC_N(tsd_thread_deallocated_set) +#define u2rz JEMALLOC_N(u2rz) +#define valgrind_freelike_block JEMALLOC_N(valgrind_freelike_block) +#define valgrind_make_mem_defined JEMALLOC_N(valgrind_make_mem_defined) +#define valgrind_make_mem_noaccess JEMALLOC_N(valgrind_make_mem_noaccess) +#define valgrind_make_mem_undefined JEMALLOC_N(valgrind_make_mem_undefined) diff --git a/deps/jemalloc-5.2.1/include/jemalloc/internal/private_symbols.awk b/deps/jemalloc-5.2.1/include/jemalloc/internal/private_symbols.awk index 20e4b38d..4a255aee 100644 --- a/deps/jemalloc-5.2.1/include/jemalloc/internal/private_symbols.awk +++ b/deps/jemalloc-5.2.1/include/jemalloc/internal/private_symbols.awk @@ -16,7 +16,7 @@ BEGIN { je_malloc_stats_print \ je_malloc_usable_size \ je_mallocx \ - je_smallocx_0000000000000000000000000000000000000000 \ + je_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 \ je_nallocx \ je_posix_memalign \ je_rallocx \ diff --git a/deps/jemalloc-5.2.1/include/jemalloc/internal/private_symbols_jet.awk b/deps/jemalloc-5.2.1/include/jemalloc/internal/private_symbols_jet.awk index 89ce2149..68145c08 100644 --- a/deps/jemalloc-5.2.1/include/jemalloc/internal/private_symbols_jet.awk +++ b/deps/jemalloc-5.2.1/include/jemalloc/internal/private_symbols_jet.awk @@ -16,7 +16,7 @@ BEGIN { jet_malloc_stats_print \ jet_malloc_usable_size \ jet_mallocx \ - jet_smallocx_0000000000000000000000000000000000000000 \ + jet_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 \ jet_nallocx \ jet_posix_memalign \ jet_rallocx \ diff --git a/deps/jemalloc-5.2.1/include/jemalloc/internal/private_unnamespace.h b/deps/jemalloc-5.2.1/include/jemalloc/internal/private_unnamespace.h new file mode 100644 index 00000000..9e060fcf --- /dev/null +++ b/deps/jemalloc-5.2.1/include/jemalloc/internal/private_unnamespace.h @@ -0,0 +1,499 @@ +#undef a0dalloc +#undef a0get +#undef a0malloc +#undef arena_aalloc +#undef arena_alloc_junk_small +#undef arena_bin_index +#undef arena_bin_info +#undef arena_bitselm_get +#undef arena_boot +#undef arena_choose +#undef arena_choose_hard +#undef arena_chunk_alloc_huge +#undef arena_chunk_cache_maybe_insert +#undef arena_chunk_cache_maybe_remove +#undef arena_chunk_dalloc_huge +#undef arena_chunk_ralloc_huge_expand +#undef arena_chunk_ralloc_huge_shrink +#undef arena_chunk_ralloc_huge_similar +#undef arena_cleanup +#undef arena_dalloc +#undef arena_dalloc_bin +#undef arena_dalloc_bin_junked_locked +#undef arena_dalloc_junk_large +#undef arena_dalloc_junk_small +#undef arena_dalloc_large +#undef arena_dalloc_large_junked_locked +#undef arena_dalloc_small +#undef arena_dss_prec_get +#undef arena_dss_prec_set +#undef arena_get +#undef arena_get_hard +#undef arena_init +#undef arena_lg_dirty_mult_default_get +#undef arena_lg_dirty_mult_default_set +#undef arena_lg_dirty_mult_get +#undef arena_lg_dirty_mult_set +#undef arena_malloc +#undef arena_malloc_large +#undef arena_malloc_small +#undef arena_mapbits_allocated_get +#undef arena_mapbits_binind_get +#undef arena_mapbits_decommitted_get +#undef arena_mapbits_dirty_get +#undef arena_mapbits_get +#undef arena_mapbits_internal_set +#undef arena_mapbits_large_binind_set +#undef arena_mapbits_large_get +#undef arena_mapbits_large_set +#undef arena_mapbits_large_size_get +#undef arena_mapbitsp_get +#undef arena_mapbitsp_read +#undef arena_mapbitsp_write +#undef arena_mapbits_size_decode +#undef arena_mapbits_size_encode +#undef arena_mapbits_small_runind_get +#undef arena_mapbits_small_set +#undef arena_mapbits_unallocated_set +#undef arena_mapbits_unallocated_size_get +#undef arena_mapbits_unallocated_size_set +#undef arena_mapbits_unzeroed_get +#undef arena_maxrun +#undef arena_maybe_purge +#undef arena_metadata_allocated_add +#undef arena_metadata_allocated_get +#undef arena_metadata_allocated_sub +#undef arena_migrate +#undef arena_miscelm_get +#undef arena_miscelm_to_pageind +#undef arena_miscelm_to_rpages +#undef arena_nbound +#undef arena_new +#undef arena_node_alloc +#undef arena_node_dalloc +#undef arena_palloc +#undef arena_postfork_child +#undef arena_postfork_parent +#undef arena_prefork +#undef arena_prof_accum +#undef arena_prof_accum_impl +#undef arena_prof_accum_locked +#undef arena_prof_promoted +#undef arena_prof_tctx_get +#undef arena_prof_tctx_reset +#undef arena_prof_tctx_set +#undef arena_ptr_small_binind_get +#undef arena_purge_all +#undef arena_quarantine_junk_small +#undef arena_ralloc +#undef arena_ralloc_junk_large +#undef arena_ralloc_no_move +#undef arena_rd_to_miscelm +#undef arena_redzone_corruption +#undef arena_run_regind +#undef arena_run_to_miscelm +#undef arena_salloc +#undef arenas_cache_bypass_cleanup +#undef arenas_cache_cleanup +#undef arena_sdalloc +#undef arena_stats_merge +#undef arena_tcache_fill_small +#undef atomic_add_p +#undef atomic_add_u +#undef atomic_add_uint32 +#undef atomic_add_uint64 +#undef atomic_add_z +#undef atomic_cas_p +#undef atomic_cas_u +#undef atomic_cas_uint32 +#undef atomic_cas_uint64 +#undef atomic_cas_z +#undef atomic_sub_p +#undef atomic_sub_u +#undef atomic_sub_uint32 +#undef atomic_sub_uint64 +#undef atomic_sub_z +#undef base_alloc +#undef base_boot +#undef base_postfork_child +#undef base_postfork_parent +#undef base_prefork +#undef base_stats_get +#undef bitmap_full +#undef bitmap_get +#undef bitmap_info_init +#undef bitmap_info_ngroups +#undef bitmap_init +#undef bitmap_set +#undef bitmap_sfu +#undef bitmap_size +#undef bitmap_unset +#undef bootstrap_calloc +#undef bootstrap_free +#undef bootstrap_malloc +#undef bt_init +#undef buferror +#undef chunk_alloc_base +#undef chunk_alloc_cache +#undef chunk_alloc_dss +#undef chunk_alloc_mmap +#undef chunk_alloc_wrapper +#undef chunk_boot +#undef chunk_dalloc_arena +#undef chunk_dalloc_cache +#undef chunk_dalloc_mmap +#undef chunk_dalloc_wrapper +#undef chunk_deregister +#undef chunk_dss_boot +#undef chunk_dss_postfork_child +#undef chunk_dss_postfork_parent +#undef chunk_dss_prec_get +#undef chunk_dss_prec_set +#undef chunk_dss_prefork +#undef chunk_hooks_default +#undef chunk_hooks_get +#undef chunk_hooks_set +#undef chunk_in_dss +#undef chunk_lookup +#undef chunk_npages +#undef chunk_postfork_child +#undef chunk_postfork_parent +#undef chunk_prefork +#undef chunk_purge_arena +#undef chunk_purge_wrapper +#undef chunk_register +#undef chunksize +#undef chunksize_mask +#undef chunks_rtree +#undef ckh_count +#undef ckh_delete +#undef ckh_insert +#undef ckh_iter +#undef ckh_new +#undef ckh_pointer_hash +#undef ckh_pointer_keycomp +#undef ckh_remove +#undef ckh_search +#undef ckh_string_hash +#undef ckh_string_keycomp +#undef ctl_boot +#undef ctl_bymib +#undef ctl_byname +#undef ctl_nametomib +#undef ctl_postfork_child +#undef ctl_postfork_parent +#undef ctl_prefork +#undef dss_prec_names +#undef extent_node_achunk_get +#undef extent_node_achunk_set +#undef extent_node_addr_get +#undef extent_node_addr_set +#undef extent_node_arena_get +#undef extent_node_arena_set +#undef extent_node_dirty_insert +#undef extent_node_dirty_linkage_init +#undef extent_node_dirty_remove +#undef extent_node_init +#undef extent_node_prof_tctx_get +#undef extent_node_prof_tctx_set +#undef extent_node_size_get +#undef extent_node_size_set +#undef extent_node_zeroed_get +#undef extent_node_zeroed_set +#undef extent_tree_ad_empty +#undef extent_tree_ad_first +#undef extent_tree_ad_insert +#undef extent_tree_ad_iter +#undef extent_tree_ad_iter_recurse +#undef extent_tree_ad_iter_start +#undef extent_tree_ad_last +#undef extent_tree_ad_new +#undef extent_tree_ad_next +#undef extent_tree_ad_nsearch +#undef extent_tree_ad_prev +#undef extent_tree_ad_psearch +#undef extent_tree_ad_remove +#undef extent_tree_ad_reverse_iter +#undef extent_tree_ad_reverse_iter_recurse +#undef extent_tree_ad_reverse_iter_start +#undef extent_tree_ad_search +#undef extent_tree_szad_empty +#undef extent_tree_szad_first +#undef extent_tree_szad_insert +#undef extent_tree_szad_iter +#undef extent_tree_szad_iter_recurse +#undef extent_tree_szad_iter_start +#undef extent_tree_szad_last +#undef extent_tree_szad_new +#undef extent_tree_szad_next +#undef extent_tree_szad_nsearch +#undef extent_tree_szad_prev +#undef extent_tree_szad_psearch +#undef extent_tree_szad_remove +#undef extent_tree_szad_reverse_iter +#undef extent_tree_szad_reverse_iter_recurse +#undef extent_tree_szad_reverse_iter_start +#undef extent_tree_szad_search +#undef get_errno +#undef hash +#undef hash_fmix_32 +#undef hash_fmix_64 +#undef hash_get_block_32 +#undef hash_get_block_64 +#undef hash_rotl_32 +#undef hash_rotl_64 +#undef hash_x64_128 +#undef hash_x86_128 +#undef hash_x86_32 +#undef huge_aalloc +#undef huge_dalloc +#undef huge_dalloc_junk +#undef huge_malloc +#undef huge_palloc +#undef huge_prof_tctx_get +#undef huge_prof_tctx_reset +#undef huge_prof_tctx_set +#undef huge_ralloc +#undef huge_ralloc_no_move +#undef huge_salloc +#undef iaalloc +#undef iallocztm +#undef icalloc +#undef icalloct +#undef idalloc +#undef idalloct +#undef idalloctm +#undef imalloc +#undef imalloct +#undef index2size +#undef index2size_compute +#undef index2size_lookup +#undef index2size_tab +#undef in_valgrind +#undef ipalloc +#undef ipalloct +#undef ipallocztm +#undef iqalloc +#undef iralloc +#undef iralloct +#undef iralloct_realign +#undef isalloc +#undef isdalloct +#undef isqalloc +#undef isthreaded +#undef ivsalloc +#undef ixalloc +#undef jemalloc_postfork_child +#undef jemalloc_postfork_parent +#undef jemalloc_prefork +#undef large_maxclass +#undef lg_floor +#undef malloc_cprintf +#undef malloc_mutex_init +#undef malloc_mutex_lock +#undef malloc_mutex_postfork_child +#undef malloc_mutex_postfork_parent +#undef malloc_mutex_prefork +#undef malloc_mutex_unlock +#undef malloc_printf +#undef malloc_snprintf +#undef malloc_strtoumax +#undef malloc_tsd_boot0 +#undef malloc_tsd_boot1 +#undef malloc_tsd_cleanup_register +#undef malloc_tsd_dalloc +#undef malloc_tsd_malloc +#undef malloc_tsd_no_cleanup +#undef malloc_vcprintf +#undef malloc_vsnprintf +#undef malloc_write +#undef map_bias +#undef map_misc_offset +#undef mb_write +#undef mutex_boot +#undef narenas_cache_cleanup +#undef narenas_total_get +#undef ncpus +#undef nhbins +#undef opt_abort +#undef opt_dss +#undef opt_junk +#undef opt_junk_alloc +#undef opt_junk_free +#undef opt_lg_chunk +#undef opt_lg_dirty_mult +#undef opt_lg_prof_interval +#undef opt_lg_prof_sample +#undef opt_lg_tcache_max +#undef opt_narenas +#undef opt_prof +#undef opt_prof_accum +#undef opt_prof_active +#undef opt_prof_final +#undef opt_prof_gdump +#undef opt_prof_leak +#undef opt_prof_prefix +#undef opt_prof_thread_active_init +#undef opt_quarantine +#undef opt_redzone +#undef opt_stats_print +#undef opt_tcache +#undef opt_utrace +#undef opt_xmalloc +#undef opt_zero +#undef p2rz +#undef pages_commit +#undef pages_decommit +#undef pages_map +#undef pages_purge +#undef pages_trim +#undef pages_unmap +#undef pow2_ceil +#undef prof_active_get +#undef prof_active_get_unlocked +#undef prof_active_set +#undef prof_alloc_prep +#undef prof_alloc_rollback +#undef prof_backtrace +#undef prof_boot0 +#undef prof_boot1 +#undef prof_boot2 +#undef prof_dump_header +#undef prof_dump_open +#undef prof_free +#undef prof_free_sampled_object +#undef prof_gdump +#undef prof_gdump_get +#undef prof_gdump_get_unlocked +#undef prof_gdump_set +#undef prof_gdump_val +#undef prof_idump +#undef prof_interval +#undef prof_lookup +#undef prof_malloc +#undef prof_malloc_sample_object +#undef prof_mdump +#undef prof_postfork_child +#undef prof_postfork_parent +#undef prof_prefork +#undef prof_realloc +#undef prof_reset +#undef prof_sample_accum_update +#undef prof_sample_threshold_update +#undef prof_tctx_get +#undef prof_tctx_reset +#undef prof_tctx_set +#undef prof_tdata_cleanup +#undef prof_tdata_get +#undef prof_tdata_init +#undef prof_tdata_reinit +#undef prof_thread_active_get +#undef prof_thread_active_init_get +#undef prof_thread_active_init_set +#undef prof_thread_active_set +#undef prof_thread_name_get +#undef prof_thread_name_set +#undef quarantine +#undef quarantine_alloc_hook +#undef quarantine_alloc_hook_work +#undef quarantine_cleanup +#undef register_zone +#undef rtree_child_read +#undef rtree_child_read_hard +#undef rtree_child_tryread +#undef rtree_delete +#undef rtree_get +#undef rtree_new +#undef rtree_node_valid +#undef rtree_set +#undef rtree_start_level +#undef rtree_subkey +#undef rtree_subtree_read +#undef rtree_subtree_read_hard +#undef rtree_subtree_tryread +#undef rtree_val_read +#undef rtree_val_write +#undef s2u +#undef s2u_compute +#undef s2u_lookup +#undef sa2u +#undef set_errno +#undef size2index +#undef size2index_compute +#undef size2index_lookup +#undef size2index_tab +#undef stats_cactive +#undef stats_cactive_add +#undef stats_cactive_get +#undef stats_cactive_sub +#undef stats_print +#undef tcache_alloc_easy +#undef tcache_alloc_large +#undef tcache_alloc_small +#undef tcache_alloc_small_hard +#undef tcache_arena_associate +#undef tcache_arena_dissociate +#undef tcache_arena_reassociate +#undef tcache_bin_flush_large +#undef tcache_bin_flush_small +#undef tcache_bin_info +#undef tcache_boot +#undef tcache_cleanup +#undef tcache_create +#undef tcache_dalloc_large +#undef tcache_dalloc_small +#undef tcache_enabled_cleanup +#undef tcache_enabled_get +#undef tcache_enabled_set +#undef tcache_event +#undef tcache_event_hard +#undef tcache_flush +#undef tcache_get +#undef tcache_get_hard +#undef tcache_maxclass +#undef tcaches +#undef tcache_salloc +#undef tcaches_create +#undef tcaches_destroy +#undef tcaches_flush +#undef tcaches_get +#undef tcache_stats_merge +#undef thread_allocated_cleanup +#undef thread_deallocated_cleanup +#undef tsd_arena_get +#undef tsd_arena_set +#undef tsd_boot +#undef tsd_boot0 +#undef tsd_boot1 +#undef tsd_booted +#undef tsd_cleanup +#undef tsd_cleanup_wrapper +#undef tsd_fetch +#undef tsd_get +#undef tsd_wrapper_get +#undef tsd_wrapper_set +#undef tsd_initialized +#undef tsd_init_check_recursion +#undef tsd_init_finish +#undef tsd_init_head +#undef tsd_nominal +#undef tsd_quarantine_get +#undef tsd_quarantine_set +#undef tsd_set +#undef tsd_tcache_enabled_get +#undef tsd_tcache_enabled_set +#undef tsd_tcache_get +#undef tsd_tcache_set +#undef tsd_tls +#undef tsd_tsd +#undef tsd_prof_tdata_get +#undef tsd_prof_tdata_set +#undef tsd_thread_allocated_get +#undef tsd_thread_allocated_set +#undef tsd_thread_deallocated_get +#undef tsd_thread_deallocated_set +#undef u2rz +#undef valgrind_freelike_block +#undef valgrind_make_mem_defined +#undef valgrind_make_mem_noaccess +#undef valgrind_make_mem_undefined diff --git a/deps/jemalloc-5.2.1/include/jemalloc/internal/public_namespace.h b/deps/jemalloc-5.2.1/include/jemalloc/internal/public_namespace.h index ad306c1f..e76d4a8e 100644 --- a/deps/jemalloc-5.2.1/include/jemalloc/internal/public_namespace.h +++ b/deps/jemalloc-5.2.1/include/jemalloc/internal/public_namespace.h @@ -11,7 +11,7 @@ #define je_malloc_stats_print JEMALLOC_N(malloc_stats_print) #define je_malloc_usable_size JEMALLOC_N(malloc_usable_size) #define je_mallocx JEMALLOC_N(mallocx) -#define je_smallocx_0000000000000000000000000000000000000000 JEMALLOC_N(smallocx_0000000000000000000000000000000000000000) +#define je_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 JEMALLOC_N(smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756) #define je_nallocx JEMALLOC_N(nallocx) #define je_posix_memalign JEMALLOC_N(posix_memalign) #define je_rallocx JEMALLOC_N(rallocx) diff --git a/deps/jemalloc-5.2.1/include/jemalloc/internal/public_symbols.txt b/deps/jemalloc-5.2.1/include/jemalloc/internal/public_symbols.txt index bac52914..f5644796 100644 --- a/deps/jemalloc-5.2.1/include/jemalloc/internal/public_symbols.txt +++ b/deps/jemalloc-5.2.1/include/jemalloc/internal/public_symbols.txt @@ -11,7 +11,7 @@ malloc_message:je_malloc_message malloc_stats_print:je_malloc_stats_print malloc_usable_size:je_malloc_usable_size mallocx:je_mallocx -smallocx_0000000000000000000000000000000000000000:je_smallocx_0000000000000000000000000000000000000000 +smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756:je_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 nallocx:je_nallocx posix_memalign:je_posix_memalign rallocx:je_rallocx diff --git a/deps/jemalloc-5.2.1/include/jemalloc/internal/public_unnamespace.h b/deps/jemalloc-5.2.1/include/jemalloc/internal/public_unnamespace.h index 690b472a..4e35ff07 100644 --- a/deps/jemalloc-5.2.1/include/jemalloc/internal/public_unnamespace.h +++ b/deps/jemalloc-5.2.1/include/jemalloc/internal/public_unnamespace.h @@ -11,7 +11,7 @@ #undef je_malloc_stats_print #undef je_malloc_usable_size #undef je_mallocx -#undef je_smallocx_0000000000000000000000000000000000000000 +#undef je_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 #undef je_nallocx #undef je_posix_memalign #undef je_rallocx diff --git a/deps/jemalloc-5.2.1/include/jemalloc/internal/size_classes.h b/deps/jemalloc-5.2.1/include/jemalloc/internal/size_classes.h new file mode 100644 index 00000000..d6715bb7 --- /dev/null +++ b/deps/jemalloc-5.2.1/include/jemalloc/internal/size_classes.h @@ -0,0 +1,1451 @@ +/* This file was automatically generated by size_classes.sh. */ +/******************************************************************************/ +#ifdef JEMALLOC_H_TYPES + +/* + * This header requires LG_SIZEOF_PTR, LG_TINY_MIN, LG_QUANTUM, and LG_PAGE to + * be defined prior to inclusion, and it in turn defines: + * + * LG_SIZE_CLASS_GROUP: Lg of size class count for each size doubling. + * SIZE_CLASSES: Complete table of + * SC(index, lg_grp, lg_delta, ndelta, bin, lg_delta_lookup) + * tuples. + * index: Size class index. + * lg_grp: Lg group base size (no deltas added). + * lg_delta: Lg delta to previous size class. + * ndelta: Delta multiplier. size == 1< 255) +# error "Too many small size classes" +#endif + +#endif /* JEMALLOC_H_TYPES */ +/******************************************************************************/ +#ifdef JEMALLOC_H_STRUCTS + + +#endif /* JEMALLOC_H_STRUCTS */ +/******************************************************************************/ +#ifdef JEMALLOC_H_EXTERNS + + +#endif /* JEMALLOC_H_EXTERNS */ +/******************************************************************************/ +#ifdef JEMALLOC_H_INLINES + + +#endif /* JEMALLOC_H_INLINES */ +/******************************************************************************/ diff --git a/deps/jemalloc-5.2.1/include/jemalloc/jemalloc.h b/deps/jemalloc-5.2.1/include/jemalloc/jemalloc.h index abe8eb1a..3a41088f 100644 --- a/deps/jemalloc-5.2.1/include/jemalloc/jemalloc.h +++ b/deps/jemalloc-5.2.1/include/jemalloc/jemalloc.h @@ -72,7 +72,7 @@ extern "C" { # define je_malloc_stats_print je_malloc_stats_print # define je_malloc_usable_size je_malloc_usable_size # define je_mallocx je_mallocx -# define je_smallocx_0000000000000000000000000000000000000000 je_smallocx_0000000000000000000000000000000000000000 +# define je_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 je_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 # define je_nallocx je_nallocx # define je_posix_memalign je_posix_memalign # define je_rallocx je_rallocx @@ -88,13 +88,13 @@ extern "C" { #include #include -#define JEMALLOC_VERSION "5.2.1-0-g0000000000000000000000000000000000000000" +#define JEMALLOC_VERSION "5.2.1-0-gea6b3e973b477b8061e0076bb257dbd7f3faa756" #define JEMALLOC_VERSION_MAJOR 5 #define JEMALLOC_VERSION_MINOR 2 #define JEMALLOC_VERSION_BUGFIX 1 #define JEMALLOC_VERSION_NREV 0 -#define JEMALLOC_VERSION_GID "0000000000000000000000000000000000000000" -#define JEMALLOC_VERSION_GID_IDENT 0000000000000000000000000000000000000000 +#define JEMALLOC_VERSION_GID "ea6b3e973b477b8061e0076bb257dbd7f3faa756" +#define JEMALLOC_VERSION_GID_IDENT ea6b3e973b477b8061e0076bb257dbd7f3faa756 #define MALLOCX_LG_ALIGN(la) ((int)(la)) #if LG_SIZEOF_PTR == 2 @@ -381,7 +381,7 @@ struct extent_hooks_s { # define malloc_stats_print je_malloc_stats_print # define malloc_usable_size je_malloc_usable_size # define mallocx je_mallocx -# define smallocx_0000000000000000000000000000000000000000 je_smallocx_0000000000000000000000000000000000000000 +# define smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 je_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 # define nallocx je_nallocx # define posix_memalign je_posix_memalign # define rallocx je_rallocx @@ -412,7 +412,7 @@ struct extent_hooks_s { # undef je_malloc_stats_print # undef je_malloc_usable_size # undef je_mallocx -# undef je_smallocx_0000000000000000000000000000000000000000 +# undef je_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 # undef je_nallocx # undef je_posix_memalign # undef je_rallocx diff --git a/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_macros.h b/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_macros.h index 84c34cc5..34235894 100644 --- a/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_macros.h +++ b/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_macros.h @@ -4,13 +4,13 @@ #include #include -#define JEMALLOC_VERSION "5.2.1-0-g0000000000000000000000000000000000000000" +#define JEMALLOC_VERSION "5.2.1-0-gea6b3e973b477b8061e0076bb257dbd7f3faa756" #define JEMALLOC_VERSION_MAJOR 5 #define JEMALLOC_VERSION_MINOR 2 #define JEMALLOC_VERSION_BUGFIX 1 #define JEMALLOC_VERSION_NREV 0 -#define JEMALLOC_VERSION_GID "0000000000000000000000000000000000000000" -#define JEMALLOC_VERSION_GID_IDENT 0000000000000000000000000000000000000000 +#define JEMALLOC_VERSION_GID "ea6b3e973b477b8061e0076bb257dbd7f3faa756" +#define JEMALLOC_VERSION_GID_IDENT ea6b3e973b477b8061e0076bb257dbd7f3faa756 #define MALLOCX_LG_ALIGN(la) ((int)(la)) #if LG_SIZEOF_PTR == 2 diff --git a/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_mangle.h b/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_mangle.h index 17eccf62..8613d255 100644 --- a/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_mangle.h +++ b/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_mangle.h @@ -22,7 +22,7 @@ # define malloc_stats_print je_malloc_stats_print # define malloc_usable_size je_malloc_usable_size # define mallocx je_mallocx -# define smallocx_0000000000000000000000000000000000000000 je_smallocx_0000000000000000000000000000000000000000 +# define smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 je_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 # define nallocx je_nallocx # define posix_memalign je_posix_memalign # define rallocx je_rallocx @@ -53,7 +53,7 @@ # undef je_malloc_stats_print # undef je_malloc_usable_size # undef je_mallocx -# undef je_smallocx_0000000000000000000000000000000000000000 +# undef je_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 # undef je_nallocx # undef je_posix_memalign # undef je_rallocx diff --git a/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_mangle_jet.h b/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_mangle_jet.h index 962b8818..97bd78fc 100644 --- a/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_mangle_jet.h +++ b/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_mangle_jet.h @@ -22,7 +22,7 @@ # define malloc_stats_print jet_malloc_stats_print # define malloc_usable_size jet_malloc_usable_size # define mallocx jet_mallocx -# define smallocx_0000000000000000000000000000000000000000 jet_smallocx_0000000000000000000000000000000000000000 +# define smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 jet_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 # define nallocx jet_nallocx # define posix_memalign jet_posix_memalign # define rallocx jet_rallocx @@ -53,7 +53,7 @@ # undef jet_malloc_stats_print # undef jet_malloc_usable_size # undef jet_mallocx -# undef jet_smallocx_0000000000000000000000000000000000000000 +# undef jet_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 # undef jet_nallocx # undef jet_posix_memalign # undef jet_rallocx diff --git a/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_rename.h b/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_rename.h index 97f52e81..2e93e527 100644 --- a/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_rename.h +++ b/deps/jemalloc-5.2.1/include/jemalloc/jemalloc_rename.h @@ -17,7 +17,7 @@ # define je_malloc_stats_print je_malloc_stats_print # define je_malloc_usable_size je_malloc_usable_size # define je_mallocx je_mallocx -# define je_smallocx_0000000000000000000000000000000000000000 je_smallocx_0000000000000000000000000000000000000000 +# define je_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 je_smallocx_ea6b3e973b477b8061e0076bb257dbd7f3faa756 # define je_nallocx je_nallocx # define je_posix_memalign je_posix_memalign # define je_rallocx je_rallocx diff --git a/deps/jemalloc-5.2.1/msvc/projects/vc2017/jemalloc/jemalloc.vcxproj b/deps/jemalloc-5.2.1/msvc/projects/vc2017/jemalloc/jemalloc.vcxproj index 64e628e1..ca8f09f2 100644 --- a/deps/jemalloc-5.2.1/msvc/projects/vc2017/jemalloc/jemalloc.vcxproj +++ b/deps/jemalloc-5.2.1/msvc/projects/vc2017/jemalloc/jemalloc.vcxproj @@ -1,13 +1,26 @@  - + + Debug-static + Win32 + + + Debug-static + x64 + Debug Win32 - - + + Release-static + Win32 + + + Release-static + x64 + Release Win32 @@ -64,36 +77,57 @@ + DynamicLibrary + true + v142 + MultiByte + + StaticLibrary true v142 MultiByte - + DynamicLibrary + false + v142 + true + MultiByte + + StaticLibrary false v142 true MultiByte - + DynamicLibrary + true + v142 + MultiByte + + StaticLibrary true v142 MultiByte - + DynamicLibrary + false + v142 + true + MultiByte + + StaticLibrary false v142 true MultiByte - false - @@ -102,43 +136,83 @@ - + + + - + + + - + + + - + + + $(SolutionDir)$(Platform)\$(Configuration)\ $(Platform)\$(Configuration)\ $(ProjectName)d - + + $(SolutionDir)$(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\ + $(ProjectName)-$(PlatformToolset)-$(Configuration) + $(SolutionDir)$(Platform)\$(Configuration)\ $(Platform)\$(Configuration)\ - + + $(SolutionDir)$(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\ + $(ProjectName)-$(PlatformToolset)-$(Configuration) + $(SolutionDir)$(Platform)\$(Configuration)\ $(Platform)\$(Configuration)\ $(ProjectName)d - + + $(SolutionDir)$(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\ + $(ProjectName)-vc$(PlatformToolsetVersion)-$(Configuration) + $(SolutionDir)$(Platform)\$(Configuration)\ $(Platform)\$(Configuration)\ - + + $(SolutionDir)$(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\ + $(ProjectName)-vc$(PlatformToolsetVersion)-$(Configuration) + + + + + Level3 + Disabled + _REENTRANT;_WINDLL;DLLEXPORT;JEMALLOC_DEBUG;_DEBUG;%(PreprocessorDefinitions) + ..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories) + 4090;4146;4267;4334 + $(OutputPath)$(TargetName).pdb + + + Windows + true + + + @@ -155,14 +229,29 @@ true - Level3 Disabled - JEMALLOC_NO_PRIVATE_NAMESPACE;JEMALLOC_DEBUG;_REENTRANT;JEMALLOC_EXPORT=;_DEBUG;_LIB;%(PreprocessorDefinitions) + JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;_WINDLL;DLLEXPORT;JEMALLOC_DEBUG;_DEBUG;USE_WIN32_EXTERNAL_HEAP_ALLOC;%(PreprocessorDefinitions) + ..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories) + 4090;4146;4267;4334 + $(OutputPath)$(TargetName).pdb + + + Windows + true + + + + + + + Level3 + Disabled + JEMALLOC_NO_PRIVATE_NAMESPACE;JEMALLOC_DEBUG;_REENTRANT;JEMALLOC_EXPORT=;_DEBUG;_LIB;USE_WIN32_EXTERNAL_HEAP_ALLOC;%(PreprocessorDefinitions) ..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories) MultiThreadedDebug 4090;4146;4267;4334 @@ -174,8 +263,27 @@ true - + + Level3 + + + MaxSpeed + true + true + _REENTRANT;_WINDLL;DLLEXPORT;NDEBUG;%(PreprocessorDefinitions) + ..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories) + 4090;4146;4267;4334 + $(OutputPath)$(TargetName).pdb + + + Windows + true + true + true + + + Level3 @@ -204,7 +312,27 @@ MaxSpeed true true - JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;JEMALLOC_EXPORT=;NDEBUG;_LIB;%(PreprocessorDefinitions) + ..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories) + JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;_WINDLL;DLLEXPORT;NDEBUG;JEMALLOC_STATIC;USE_WIN32_EXTERNAL_HEAP_ALLOC;%(PreprocessorDefinitions) + 4090;4146;4267;4334 + $(OutputPath)$(TargetName).pdb + + + Windows + true + true + true + + + + + Level3 + + + MaxSpeed + true + true + JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;JEMALLOC_EXPORT=;NDEBUG;_LIB;USE_WIN32_EXTERNAL_HEAP_ALLOC;%(PreprocessorDefinitions) ..\..\..\..\include;..\..\..\..\include\msvc_compat;%(AdditionalIncludeDirectories) MultiThreaded 4090;4146;4267;4334 @@ -217,7 +345,6 @@ true - diff --git a/deps/jemalloc-5.2.1/msvc/projects/vc2017/test_threads/test_threads.vcxproj b/deps/jemalloc-5.2.1/msvc/projects/vc2017/test_threads/test_threads.vcxproj index c35b0f5a..3a96447f 100644 --- a/deps/jemalloc-5.2.1/msvc/projects/vc2017/test_threads/test_threads.vcxproj +++ b/deps/jemalloc-5.2.1/msvc/projects/vc2017/test_threads/test_threads.vcxproj @@ -38,57 +38,58 @@ {09028CFD-4EB7-491D-869C-0708DB97ED44} Win32Proj test_threads + 10.0 Application true - v141 + v142 MultiByte Application true - v141 + v142 MultiByte Application false - v141 + v142 true MultiByte Application false - v141 + v142 true MultiByte Application true - v141 + v142 MultiByte Application true - v141 + v142 MultiByte Application false - v141 + v142 true MultiByte Application false - v141 + v142 true MultiByte diff --git a/deps/jemalloc-5.2.1/src/pages.c b/deps/jemalloc-5.2.1/src/pages.c index 13de27a0..24336ea9 100644 --- a/deps/jemalloc-5.2.1/src/pages.c +++ b/deps/jemalloc-5.2.1/src/pages.c @@ -66,8 +66,12 @@ os_pages_map(void *addr, size_t size, size_t alignment, bool *commit) { * If VirtualAlloc can't allocate at the given address when one is * given, it fails and returns NULL. */ - ret = VirtualAlloc(addr, size, MEM_RESERVE | (*commit ? MEM_COMMIT : 0), - PAGE_READWRITE); + #ifdef USE_WIN32_EXTERNAL_HEAP_ALLOC + ret = AllocHeapBlock(addr, size, TRUE); + #else + ret = VirtualAlloc(addr, size, MEM_RESERVE | (*commit ? MEM_COMMIT : 0), + PAGE_READWRITE); + #endif //USE_WIN32_EXTERNAL_HEAP_ALLOC #else /* * We don't use MAP_FIXED here, because it can cause the *replacement* @@ -130,7 +134,11 @@ os_pages_unmap(void *addr, size_t size) { assert(ALIGNMENT_CEILING(size, os_page) == size); #ifdef _WIN32 - if (VirtualFree(addr, 0, MEM_RELEASE) == 0) + #ifdef USE_WIN32_EXTERNAL_HEAP_ALLOC + if (FreeHeapBlock(addr, size) == 0) + #else + if (VirtualFree(addr, 0, MEM_RELEASE) == 0) + #endif //USE_WIN32_EXTERNAL_HEAP_ALLOC #else if (munmap(addr, size) == -1) #endif @@ -140,7 +148,11 @@ os_pages_unmap(void *addr, size_t size) { buferror(get_errno(), buf, sizeof(buf)); malloc_printf(": Error in " #ifdef _WIN32 - "VirtualFree" + #ifdef USE_WIN32_EXTERNAL_HEAP_ALLOC + "FreeHeapBlock" + #else + "VirtualFree" + #endif //USE_WIN32_EXTERNAL_HEAP_ALLOC #else "munmap" #endif @@ -255,8 +267,13 @@ pages_commit_impl(void *addr, size_t size, bool commit) { } #ifdef _WIN32 - return (commit ? (addr != VirtualAlloc(addr, size, MEM_COMMIT, - PAGE_READWRITE)) : (!VirtualFree(addr, size, MEM_DECOMMIT))); + #ifdef USE_WIN32_EXTERNAL_HEAP_ALLOC + return (commit ? (addr != AllocHeapBlock(addr, size, TRUE)) + : (!FreeHeapBlock(addr, size))); + #else + return (commit ? (addr != VirtualAlloc(addr, size, MEM_COMMIT, + PAGE_READWRITE)) : (!VirtualFree(addr, size, MEM_DECOMMIT))); + #endif //USE_WIN32_EXTERNAL_HEAP_ALLOC #else { int prot = commit ? PAGES_PROT_COMMIT : PAGES_PROT_DECOMMIT; @@ -305,7 +322,11 @@ pages_purge_lazy(void *addr, size_t size) { } #ifdef _WIN32 - VirtualAlloc(addr, size, MEM_RESET, PAGE_READWRITE); + #ifdef USE_WIN32_EXTERNAL_HEAP_ALLOC + PurgePages(addr, size); + #else + VirtualAlloc(addr, size, MEM_RESET, PAGE_READWRITE); + #endif //USE_WIN32_EXTERNAL_HEAP_ALLOC return false; #elif defined(JEMALLOC_PURGE_MADVISE_FREE) return (madvise(addr, size, diff --git a/msvs/RedisServer.sln b/msvs/RedisServer.sln index fece98c0..f5bb0585 100644 --- a/msvs/RedisServer.sln +++ b/msvs/RedisServer.sln @@ -39,12 +39,10 @@ Global Debug|Win32 = Debug|Win32 Debug|x64 = Debug|x64 Debug|x86 = Debug|x86 - Release|Mixed Platforms = Release|Mixed Platforms Release|Win32 = Release|Win32 Release|x64 = Release|x64 Release|x86 = Release|x86 - EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {46842776-68A5-EC98-6A09-1859BBFC73AA}.Debug|Mixed Platforms.ActiveCfg = Release|Win32 @@ -55,14 +53,6 @@ Global {46842776-68A5-EC98-6A09-1859BBFC73AA}.Debug|x64.Build.0 = Debug|x64 {46842776-68A5-EC98-6A09-1859BBFC73AA}.Debug|x86.ActiveCfg = Debug|Win32 {46842776-68A5-EC98-6A09-1859BBFC73AA}.Debug|x86.Build.0 = Debug|Win32 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Debug-static|Mixed Platforms.ActiveCfg = Debug|Win32 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Debug-static|Mixed Platforms.Build.0 = Debug|Win32 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Debug-static|Win32.ActiveCfg = Debug|Win32 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Debug-static|Win32.Build.0 = Debug|Win32 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Debug-static|x64.ActiveCfg = Debug|x64 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Debug-static|x64.Build.0 = Debug|x64 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Debug-static|x86.ActiveCfg = Debug|Win32 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Debug-static|x86.Build.0 = Debug|Win32 {46842776-68A5-EC98-6A09-1859BBFC73AA}.Release|Mixed Platforms.ActiveCfg = Release|Win32 {46842776-68A5-EC98-6A09-1859BBFC73AA}.Release|Mixed Platforms.Build.0 = Release|Win32 {46842776-68A5-EC98-6A09-1859BBFC73AA}.Release|Win32.ActiveCfg = Release|Win32 @@ -71,14 +61,6 @@ Global {46842776-68A5-EC98-6A09-1859BBFC73AA}.Release|x64.Build.0 = Release|x64 {46842776-68A5-EC98-6A09-1859BBFC73AA}.Release|x86.ActiveCfg = Release|Win32 {46842776-68A5-EC98-6A09-1859BBFC73AA}.Release|x86.Build.0 = Release|Win32 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Release-static|Mixed Platforms.ActiveCfg = Release|Win32 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Release-static|Mixed Platforms.Build.0 = Release|Win32 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Release-static|Win32.ActiveCfg = Release|Win32 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Release-static|Win32.Build.0 = Release|Win32 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Release-static|x64.ActiveCfg = Release|x64 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Release-static|x64.Build.0 = Release|x64 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Release-static|x86.ActiveCfg = Release|Win32 - {46842776-68A5-EC98-6A09-1859BBFC73AA}.Release-static|x86.Build.0 = Release|Win32 {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Debug|Mixed Platforms.ActiveCfg = Release|Win32 {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Debug|Mixed Platforms.Build.0 = Release|Win32 {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Debug|Win32.ActiveCfg = Debug|Win32 @@ -87,14 +69,6 @@ Global {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Debug|x64.Build.0 = Debug|x64 {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Debug|x86.ActiveCfg = Debug|Win32 {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Debug|x86.Build.0 = Debug|Win32 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Debug-static|Mixed Platforms.ActiveCfg = Debug|Win32 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Debug-static|Mixed Platforms.Build.0 = Debug|Win32 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Debug-static|Win32.ActiveCfg = Debug|Win32 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Debug-static|Win32.Build.0 = Debug|Win32 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Debug-static|x64.ActiveCfg = Debug|x64 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Debug-static|x64.Build.0 = Debug|x64 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Debug-static|x86.ActiveCfg = Debug|Win32 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Debug-static|x86.Build.0 = Debug|Win32 {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Release|Mixed Platforms.ActiveCfg = Release|Win32 {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Release|Mixed Platforms.Build.0 = Release|Win32 {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Release|Win32.ActiveCfg = Release|Win32 @@ -103,14 +77,6 @@ Global {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Release|x64.Build.0 = Release|x64 {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Release|x86.ActiveCfg = Release|Win32 {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Release|x86.Build.0 = Release|Win32 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Release-static|Mixed Platforms.ActiveCfg = Release|Win32 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Release-static|Mixed Platforms.Build.0 = Release|Win32 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Release-static|Win32.ActiveCfg = Release|Win32 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Release-static|Win32.Build.0 = Release|Win32 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Release-static|x64.ActiveCfg = Release|x64 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Release-static|x64.Build.0 = Release|x64 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Release-static|x86.ActiveCfg = Release|Win32 - {13E85053-54B3-487B-8DDB-3430B1C1B3BF}.Release-static|x86.Build.0 = Release|Win32 {B00D4BB5-44DE-405E-839C-D16F547006CF}.Debug|Mixed Platforms.ActiveCfg = Release|Win32 {B00D4BB5-44DE-405E-839C-D16F547006CF}.Debug|Mixed Platforms.Build.0 = Release|Win32 {B00D4BB5-44DE-405E-839C-D16F547006CF}.Debug|Win32.ActiveCfg = Debug|Win32 @@ -119,14 +85,6 @@ Global {B00D4BB5-44DE-405E-839C-D16F547006CF}.Debug|x64.Build.0 = Debug|x64 {B00D4BB5-44DE-405E-839C-D16F547006CF}.Debug|x86.ActiveCfg = Debug|Win32 {B00D4BB5-44DE-405E-839C-D16F547006CF}.Debug|x86.Build.0 = Debug|Win32 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Debug-static|Mixed Platforms.ActiveCfg = Debug|Win32 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Debug-static|Mixed Platforms.Build.0 = Debug|Win32 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Debug-static|Win32.ActiveCfg = Debug|Win32 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Debug-static|Win32.Build.0 = Debug|Win32 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Debug-static|x64.ActiveCfg = Debug|x64 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Debug-static|x64.Build.0 = Debug|x64 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Debug-static|x86.ActiveCfg = Debug|Win32 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Debug-static|x86.Build.0 = Debug|Win32 {B00D4BB5-44DE-405E-839C-D16F547006CF}.Release|Mixed Platforms.ActiveCfg = Release|Win32 {B00D4BB5-44DE-405E-839C-D16F547006CF}.Release|Mixed Platforms.Build.0 = Release|Win32 {B00D4BB5-44DE-405E-839C-D16F547006CF}.Release|Win32.ActiveCfg = Release|Win32 @@ -135,14 +93,6 @@ Global {B00D4BB5-44DE-405E-839C-D16F547006CF}.Release|x64.Build.0 = Release|x64 {B00D4BB5-44DE-405E-839C-D16F547006CF}.Release|x86.ActiveCfg = Release|Win32 {B00D4BB5-44DE-405E-839C-D16F547006CF}.Release|x86.Build.0 = Release|Win32 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Release-static|Mixed Platforms.ActiveCfg = Release|Win32 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Release-static|Mixed Platforms.Build.0 = Release|Win32 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Release-static|Win32.ActiveCfg = Release|Win32 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Release-static|Win32.Build.0 = Release|Win32 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Release-static|x64.ActiveCfg = Release|x64 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Release-static|x64.Build.0 = Release|x64 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Release-static|x86.ActiveCfg = Release|Win32 - {B00D4BB5-44DE-405E-839C-D16F547006CF}.Release-static|x86.Build.0 = Release|Win32 {392BBB91-3934-4A56-AF42-65C5728311E8}.Debug|Mixed Platforms.ActiveCfg = Release|Win32 {392BBB91-3934-4A56-AF42-65C5728311E8}.Debug|Mixed Platforms.Build.0 = Release|Win32 {392BBB91-3934-4A56-AF42-65C5728311E8}.Debug|Win32.ActiveCfg = Debug|Win32 @@ -151,14 +101,6 @@ Global {392BBB91-3934-4A56-AF42-65C5728311E8}.Debug|x64.Build.0 = Debug|x64 {392BBB91-3934-4A56-AF42-65C5728311E8}.Debug|x86.ActiveCfg = Debug|Win32 {392BBB91-3934-4A56-AF42-65C5728311E8}.Debug|x86.Build.0 = Debug|Win32 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Debug-static|Mixed Platforms.ActiveCfg = Debug|Win32 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Debug-static|Mixed Platforms.Build.0 = Debug|Win32 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Debug-static|Win32.ActiveCfg = Debug|Win32 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Debug-static|Win32.Build.0 = Debug|Win32 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Debug-static|x64.ActiveCfg = Debug|x64 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Debug-static|x64.Build.0 = Debug|x64 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Debug-static|x86.ActiveCfg = Debug|Win32 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Debug-static|x86.Build.0 = Debug|Win32 {392BBB91-3934-4A56-AF42-65C5728311E8}.Release|Mixed Platforms.ActiveCfg = Release|Win32 {392BBB91-3934-4A56-AF42-65C5728311E8}.Release|Mixed Platforms.Build.0 = Release|Win32 {392BBB91-3934-4A56-AF42-65C5728311E8}.Release|Win32.ActiveCfg = Release|Win32 @@ -167,14 +109,6 @@ Global {392BBB91-3934-4A56-AF42-65C5728311E8}.Release|x64.Build.0 = Release|x64 {392BBB91-3934-4A56-AF42-65C5728311E8}.Release|x86.ActiveCfg = Release|Win32 {392BBB91-3934-4A56-AF42-65C5728311E8}.Release|x86.Build.0 = Release|Win32 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Release-static|Mixed Platforms.ActiveCfg = Release|Win32 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Release-static|Mixed Platforms.Build.0 = Release|Win32 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Release-static|Win32.ActiveCfg = Release|Win32 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Release-static|Win32.Build.0 = Release|Win32 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Release-static|x64.ActiveCfg = Release|x64 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Release-static|x64.Build.0 = Release|x64 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Release-static|x86.ActiveCfg = Release|Win32 - {392BBB91-3934-4A56-AF42-65C5728311E8}.Release-static|x86.Build.0 = Release|Win32 {170B0909-5F75-467F-9501-C99DEC16C6DC}.Debug|Mixed Platforms.ActiveCfg = Release|Win32 {170B0909-5F75-467F-9501-C99DEC16C6DC}.Debug|Mixed Platforms.Build.0 = Release|Win32 {170B0909-5F75-467F-9501-C99DEC16C6DC}.Debug|Win32.ActiveCfg = Debug|Win32 @@ -183,14 +117,6 @@ Global {170B0909-5F75-467F-9501-C99DEC16C6DC}.Debug|x64.Build.0 = Debug|x64 {170B0909-5F75-467F-9501-C99DEC16C6DC}.Debug|x86.ActiveCfg = Debug|Win32 {170B0909-5F75-467F-9501-C99DEC16C6DC}.Debug|x86.Build.0 = Debug|Win32 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Debug-static|Mixed Platforms.ActiveCfg = Debug|Win32 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Debug-static|Mixed Platforms.Build.0 = Debug|Win32 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Debug-static|Win32.ActiveCfg = Debug|Win32 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Debug-static|Win32.Build.0 = Debug|Win32 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Debug-static|x64.ActiveCfg = Debug|x64 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Debug-static|x64.Build.0 = Debug|x64 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Debug-static|x86.ActiveCfg = Debug|Win32 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Debug-static|x86.Build.0 = Debug|Win32 {170B0909-5F75-467F-9501-C99DEC16C6DC}.Release|Mixed Platforms.ActiveCfg = Release|Win32 {170B0909-5F75-467F-9501-C99DEC16C6DC}.Release|Mixed Platforms.Build.0 = Release|Win32 {170B0909-5F75-467F-9501-C99DEC16C6DC}.Release|Win32.ActiveCfg = Release|Win32 @@ -199,14 +125,6 @@ Global {170B0909-5F75-467F-9501-C99DEC16C6DC}.Release|x64.Build.0 = Release|x64 {170B0909-5F75-467F-9501-C99DEC16C6DC}.Release|x86.ActiveCfg = Release|Win32 {170B0909-5F75-467F-9501-C99DEC16C6DC}.Release|x86.Build.0 = Release|Win32 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Release-static|Mixed Platforms.ActiveCfg = Release|Win32 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Release-static|Mixed Platforms.Build.0 = Release|Win32 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Release-static|Win32.ActiveCfg = Release|Win32 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Release-static|Win32.Build.0 = Release|Win32 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Release-static|x64.ActiveCfg = Release|x64 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Release-static|x64.Build.0 = Release|x64 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Release-static|x86.ActiveCfg = Release|Win32 - {170B0909-5F75-467F-9501-C99DEC16C6DC}.Release-static|x86.Build.0 = Release|Win32 {8C07F811-C81C-432C-B334-1AE6FAECF951}.Debug|Mixed Platforms.ActiveCfg = Release|Win32 {8C07F811-C81C-432C-B334-1AE6FAECF951}.Debug|Mixed Platforms.Build.0 = Release|Win32 {8C07F811-C81C-432C-B334-1AE6FAECF951}.Debug|Win32.ActiveCfg = Debug|Win32 @@ -215,14 +133,6 @@ Global {8C07F811-C81C-432C-B334-1AE6FAECF951}.Debug|x64.Build.0 = Debug|x64 {8C07F811-C81C-432C-B334-1AE6FAECF951}.Debug|x86.ActiveCfg = Debug|Win32 {8C07F811-C81C-432C-B334-1AE6FAECF951}.Debug|x86.Build.0 = Debug|Win32 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Debug-static|Mixed Platforms.ActiveCfg = Debug|Win32 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Debug-static|Mixed Platforms.Build.0 = Debug|Win32 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Debug-static|Win32.ActiveCfg = Debug|Win32 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Debug-static|Win32.Build.0 = Debug|Win32 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Debug-static|x64.ActiveCfg = Debug|x64 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Debug-static|x64.Build.0 = Debug|x64 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Debug-static|x86.ActiveCfg = Debug|Win32 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Debug-static|x86.Build.0 = Debug|Win32 {8C07F811-C81C-432C-B334-1AE6FAECF951}.Release|Mixed Platforms.ActiveCfg = Release|Win32 {8C07F811-C81C-432C-B334-1AE6FAECF951}.Release|Mixed Platforms.Build.0 = Release|Win32 {8C07F811-C81C-432C-B334-1AE6FAECF951}.Release|Win32.ActiveCfg = Release|Win32 @@ -231,14 +141,6 @@ Global {8C07F811-C81C-432C-B334-1AE6FAECF951}.Release|x64.Build.0 = Release|x64 {8C07F811-C81C-432C-B334-1AE6FAECF951}.Release|x86.ActiveCfg = Release|Win32 {8C07F811-C81C-432C-B334-1AE6FAECF951}.Release|x86.Build.0 = Release|Win32 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Release-static|Mixed Platforms.ActiveCfg = Release|Win32 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Release-static|Mixed Platforms.Build.0 = Release|Win32 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Release-static|Win32.ActiveCfg = Release|Win32 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Release-static|Win32.Build.0 = Release|Win32 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Release-static|x64.ActiveCfg = Release|x64 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Release-static|x64.Build.0 = Release|x64 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Release-static|x86.ActiveCfg = Release|Win32 - {8C07F811-C81C-432C-B334-1AE6FAECF951}.Release-static|x86.Build.0 = Release|Win32 {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Debug|Mixed Platforms.ActiveCfg = Release|Win32 {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Debug|Mixed Platforms.Build.0 = Release|Win32 {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Debug|Win32.ActiveCfg = Debug|Win32 @@ -247,14 +149,6 @@ Global {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Debug|x64.Build.0 = Debug|x64 {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Debug|x86.ActiveCfg = Debug|Win32 {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Debug|x86.Build.0 = Debug|Win32 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Debug-static|Mixed Platforms.ActiveCfg = Debug|Win32 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Debug-static|Mixed Platforms.Build.0 = Debug|Win32 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Debug-static|Win32.ActiveCfg = Debug|Win32 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Debug-static|Win32.Build.0 = Debug|Win32 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Debug-static|x64.ActiveCfg = Debug|x64 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Debug-static|x64.Build.0 = Debug|x64 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Debug-static|x86.ActiveCfg = Debug|Win32 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Debug-static|x86.Build.0 = Debug|Win32 {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Release|Mixed Platforms.ActiveCfg = Release|Win32 {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Release|Mixed Platforms.Build.0 = Release|Win32 {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Release|Win32.ActiveCfg = Release|Win32 @@ -263,46 +157,22 @@ Global {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Release|x64.Build.0 = Release|x64 {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Release|x86.ActiveCfg = Release|Win32 {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Release|x86.Build.0 = Release|Win32 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Release-static|Mixed Platforms.ActiveCfg = Release|Win32 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Release-static|Mixed Platforms.Build.0 = Release|Win32 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Release-static|Win32.ActiveCfg = Release|Win32 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Release-static|Win32.Build.0 = Release|Win32 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Release-static|x64.ActiveCfg = Release|x64 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Release-static|x64.Build.0 = Release|x64 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Release-static|x86.ActiveCfg = Release|Win32 - {2B888C28-52CF-4E94-993C-B43D77E0B91A}.Release-static|x86.Build.0 = Release|Win32 {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32 {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|Mixed Platforms.Build.0 = Debug|Win32 {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|Win32.ActiveCfg = Debug|Win32 {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|Win32.Build.0 = Debug|Win32 - {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|x64.ActiveCfg = Debug-static|x64 + {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|x64.Build.0 = Debug-static|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|Mixed Platforms.ActiveCfg = Debug|Win32 - {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|Mixed Platforms.Build.0 = Debug|Win32 - {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|Win32.ActiveCfg = Debug|Win32 - {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|Win32.Build.0 = Debug|Win32 - {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x64.ActiveCfg = Debug|x64 - {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x64.Build.0 = Debug|x64 - {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x86.ActiveCfg = Debug|Win32 - {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x86.Build.0 = Debug|Win32 {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|Mixed Platforms.ActiveCfg = Release|Win32 {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|Mixed Platforms.Build.0 = Release|Win32 {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|Win32.ActiveCfg = Release|Win32 {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|Win32.Build.0 = Release|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|x64.ActiveCfg = Release-static|x64 + {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|x64.Build.0 = Release-static|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|Mixed Platforms.ActiveCfg = Release|Win32 - {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|Mixed Platforms.Build.0 = Release|Win32 - {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|Win32.ActiveCfg = Release|Win32 - {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|Win32.Build.0 = Release|Win32 - {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x64.ActiveCfg = Release|x64 - {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x64.Build.0 = Release|x64 - {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x86.ActiveCfg = Release|Win32 - {8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x86.Build.0 = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/src/Win32_Interop/Win32_QFork.cpp b/src/Win32_Interop/Win32_QFork.cpp index 4932265a..1673b3f5 100644 --- a/src/Win32_Interop/Win32_QFork.cpp +++ b/src/Win32_Interop/Win32_QFork.cpp @@ -25,7 +25,6 @@ without halting the main redis process, or crashing due to code that was never designed to be thread safe. Essentially we need to replicate the COW behavior of fork() on Windows, but we don't actually need a complete fork() implementation. A complete fork() implementation would require subsystem level support to make happen. The following is required to make this quasi-fork scheme work: - (references to DLMalloc* are obsolete as only "jemalloc" from http://jemalloc.net/ is used) DLMallocMemoryMap: - An uncomitted memory map whose size is the total physical memory on the system less some memory for the rest of the system so that