#define JEMALLOC_TCACHE_C_

#include "jemalloc/internal/jemalloc_preamble.h"

#include "jemalloc/internal/jemalloc_internal_includes.h"

#include "jemalloc/internal/assert.h"

#include "jemalloc/internal/mutex.h"

#include "jemalloc/internal/safety_check.h"

#include "jemalloc/internal/sc.h"

/******************************************************************************/

/* Data. */

bool	opt_tcache = true;

ssize_t	opt_lg_tcache_max = LG_TCACHE_MAXCLASS_DEFAULT;

cache_bin_info_t	*tcache_bin_info;

static unsigned		stack_nelms; /* Total stack elms per tcache. */

unsigned		nhbins;

size_t			tcache_maxclass;

tcaches_t		*tcaches;

/* Index of first element within tcaches that has never been used. */

static unsigned		tcaches_past;

/* Head of singly linked list tracking available tcaches elements. */

static tcaches_t	*tcaches_avail;

/* Protects tcaches{,_past,_avail}. */

static malloc_mutex_t	tcaches_mtx;

/******************************************************************************/

size_t

tcache_salloc(tsdn_t *tsdn, const void *ptr) {

	return arena_salloc(tsdn, ptr);

}

void

tcache_event_hard(tsd_t *tsd, tcache_t *tcache) {

	szind_t binind = tcache->next_gc_bin;

	cache_bin_t *tbin;

	if (binind < SC_NBINS) {

		tbin = tcache_small_bin_get(tcache, binind);

	} else {

		tbin = tcache_large_bin_get(tcache, binind);

	}

	if (tbin->low_water > 0) {

		/*

		 * Flush (ceiling) 3/4 of the objects below the low water mark.

		 */

		if (binind < SC_NBINS) {

			tcache_bin_flush_small(tsd, tcache, tbin, binind,

			    tbin->ncached - tbin->low_water + (tbin->low_water

			    >> 2));

			/*

			 * Reduce fill count by 2X.  Limit lg_fill_div such that

			 * the fill count is always at least 1.

			 */

			cache_bin_info_t *tbin_info = &tcache_bin_info[binind];

			if ((tbin_info->ncached_max >>

			     (tcache->lg_fill_div[binind] + 1)) >= 1) {

				tcache->lg_fill_div[binind]++;

			}

		} else {

			tcache_bin_flush_large(tsd, tbin, binind, tbin->ncached

			    - tbin->low_water + (tbin->low_water >> 2), tcache);

		}

	} else if (tbin->low_water < 0) {

		/*

		 * Increase fill count by 2X for small bins.  Make sure

		 * lg_fill_div stays greater than 0.

		 */

		if (binind < SC_NBINS && tcache->lg_fill_div[binind] > 1) {

			tcache->lg_fill_div[binind]--;

		}

	}

	tbin->low_water = tbin->ncached;

	tcache->next_gc_bin++;

	if (tcache->next_gc_bin == nhbins) {

		tcache->next_gc_bin = 0;

	}

}

void *

tcache_alloc_small_hard(tsdn_t *tsdn, arena_t *arena, tcache_t *tcache,

    cache_bin_t *tbin, szind_t binind, bool *tcache_success) {

	void *ret;

	assert(tcache->arena != NULL);

	arena_tcache_fill_small(tsdn, arena, tcache, tbin, binind,

	    config_prof ? tcache->prof_accumbytes : 0);

	if (config_prof) {

		tcache->prof_accumbytes = 0;

	}

	ret = cache_bin_alloc_easy(tbin, tcache_success);

	return ret;

}

/* Enabled with --enable-extra-size-check. */

static void

tbin_extents_lookup_size_check(tsdn_t *tsdn, cache_bin_t *tbin, szind_t binind,

    size_t nflush, extent_t **extents){

	rtree_ctx_t rtree_ctx_fallback;

	rtree_ctx_t *rtree_ctx = tsdn_rtree_ctx(tsdn, &rtree_ctx_fallback);

	/*

	 * Verify that the items in the tcache all have the correct size; this

	 * is useful for catching sized deallocation bugs, also to fail early

	 * instead of corrupting metadata.  Since this can be turned on for opt

	 * builds, avoid the branch in the loop.

	 */

	szind_t szind;

	size_t sz_sum = binind * nflush;

	for (unsigned i = 0 ; i < nflush; i++) {

		rtree_extent_szind_read(tsdn, &extents_rtree,

		    rtree_ctx, (uintptr_t)*(tbin->avail - 1 - i), true,

		    &extents[i], &szind);

		sz_sum -= szind;

	}

	if (sz_sum != 0) {

		safety_check_fail("<jemalloc>: size mismatch in thread cache "

		    "detected, likely caused by sized deallocation bugs by "

		    "application. Abort.\n");

		abort();

	}

}

void

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

    szind_t binind, unsigned rem) {

	bool merged_stats = false;

	assert(binind < SC_NBINS);

	assert((cache_bin_sz_t)rem <= tbin->ncached);

	arena_t *arena = tcache->arena;

	assert(arena != NULL);

	unsigned nflush = tbin->ncached - rem;

	VARIABLE_ARRAY(extent_t *, item_extent, nflush);

	/* Look up extent once per item. */

	if (config_opt_safety_checks) {

		tbin_extents_lookup_size_check(tsd_tsdn(tsd), tbin, binind,

		    nflush, item_extent);

	} else {

		for (unsigned i = 0 ; i < nflush; i++) {

			item_extent[i] = iealloc(tsd_tsdn(tsd),

			    *(tbin->avail - 1 - i));

		}

	}

	while (nflush > 0) {

		/* Lock the arena bin associated with the first object. */

		extent_t *extent = item_extent[0];

		unsigned bin_arena_ind = extent_arena_ind_get(extent);

		arena_t *bin_arena = arena_get(tsd_tsdn(tsd), bin_arena_ind,

		    false);

		unsigned binshard = extent_binshard_get(extent);

		assert(binshard < bin_infos[binind].n_shards);

		bin_t *bin = &bin_arena->bins[binind].bin_shards[binshard];

		if (config_prof && bin_arena == arena) {

			if (arena_prof_accum(tsd_tsdn(tsd), arena,

			    tcache->prof_accumbytes)) {

				prof_idump(tsd_tsdn(tsd));

			}

			tcache->prof_accumbytes = 0;

		}

		malloc_mutex_lock(tsd_tsdn(tsd), &bin->lock);

		if (config_stats && bin_arena == arena && !merged_stats) {

			merged_stats = true;

			bin->stats.nflushes++;

			bin->stats.nrequests += tbin->tstats.nrequests;

			tbin->tstats.nrequests = 0;

		}

		unsigned ndeferred = 0;

		for (unsigned i = 0; i < nflush; i++) {

			void *ptr = *(tbin->avail - 1 - i);

			extent = item_extent[i];

			assert(ptr != NULL && extent != NULL);

			if (extent_arena_ind_get(extent) == bin_arena_ind

			    && extent_binshard_get(extent) == binshard) {

				arena_dalloc_bin_junked_locked(tsd_tsdn(tsd),

				    bin_arena, bin, binind, extent, ptr);

			} else {

				/*

				 * This object was allocated via a different

				 * arena bin than the one that is currently

				 * locked.  Stash the object, so that it can be

				 * handled in a future pass.

				 */

				*(tbin->avail - 1 - ndeferred) = ptr;

				item_extent[ndeferred] = extent;

				ndeferred++;

			}

		}

		malloc_mutex_unlock(tsd_tsdn(tsd), &bin->lock);

		arena_decay_ticks(tsd_tsdn(tsd), bin_arena, nflush - ndeferred);

		nflush = ndeferred;

	}

	if (config_stats && !merged_stats) {

		/*

		 * The flush loop didn't happen to flush to this thread's

		 * arena, so the stats didn't get merged.  Manually do so now.

		 */

		unsigned binshard;

		bin_t *bin = arena_bin_choose_lock(tsd_tsdn(tsd), arena, binind,

		    &binshard);

		bin->stats.nflushes++;

		bin->stats.nrequests += tbin->tstats.nrequests;

		tbin->tstats.nrequests = 0;

		malloc_mutex_unlock(tsd_tsdn(tsd), &bin->lock);

	}

	memmove(tbin->avail - rem, tbin->avail - tbin->ncached, rem *

	    sizeof(void *));

	tbin->ncached = rem;

	if (tbin->ncached < tbin->low_water) {

		tbin->low_water = tbin->ncached;

	}

}

void

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

    unsigned rem, tcache_t *tcache) {

	bool merged_stats = false;

	assert(binind < nhbins);

	assert((cache_bin_sz_t)rem <= tbin->ncached);

	arena_t *tcache_arena = tcache->arena;

	assert(tcache_arena != NULL);

	unsigned nflush = tbin->ncached - rem;

	VARIABLE_ARRAY(extent_t *, item_extent, nflush);

#ifndef JEMALLOC_EXTRA_SIZE_CHECK

	/* Look up extent once per item. */

	for (unsigned i = 0 ; i < nflush; i++) {

		item_extent[i] = iealloc(tsd_tsdn(tsd), *(tbin->avail - 1 - i));

	}

#else

	tbin_extents_lookup_size_check(tsd_tsdn(tsd), tbin, binind, nflush,

	    item_extent);

#endif

	while (nflush > 0) {

		/* Lock the arena associated with the first object. */

		extent_t *extent = item_extent[0];

		unsigned locked_arena_ind = extent_arena_ind_get(extent);

		arena_t *locked_arena = arena_get(tsd_tsdn(tsd),

		    locked_arena_ind, false);

		bool idump;

		if (config_prof) {

			idump = false;

		}

		bool lock_large = !arena_is_auto(locked_arena);

		if (lock_large) {

			malloc_mutex_lock(tsd_tsdn(tsd), &locked_arena->large_mtx);

		}

		for (unsigned i = 0; i < nflush; i++) {

			void *ptr = *(tbin->avail - 1 - i);

			assert(ptr != NULL);

			extent = item_extent[i];

			if (extent_arena_ind_get(extent) == locked_arena_ind) {

				large_dalloc_prep_junked_locked(tsd_tsdn(tsd),

				    extent);

			}

		}

		if ((config_prof || config_stats) &&

		    (locked_arena == tcache_arena)) {

			if (config_prof) {

				idump = arena_prof_accum(tsd_tsdn(tsd),

				    tcache_arena, tcache->prof_accumbytes);

				tcache->prof_accumbytes = 0;

			}

			if (config_stats) {

				merged_stats = true;

				arena_stats_large_flush_nrequests_add(

				    tsd_tsdn(tsd), &tcache_arena->stats, binind,

				    tbin->tstats.nrequests);

				tbin->tstats.nrequests = 0;

			}

		}

		if (lock_large) {

			malloc_mutex_unlock(tsd_tsdn(tsd), &locked_arena->large_mtx);

		}

		unsigned ndeferred = 0;

		for (unsigned i = 0; i < nflush; i++) {

			void *ptr = *(tbin->avail - 1 - i);

			extent = item_extent[i];

			assert(ptr != NULL && extent != NULL);

			if (extent_arena_ind_get(extent) == locked_arena_ind) {

				large_dalloc_finish(tsd_tsdn(tsd), extent);

			} else {

				/*

				 * This object was allocated via a different

				 * arena than the one that is currently locked.

				 * Stash the object, so that it can be handled

				 * in a future pass.

				 */

				*(tbin->avail - 1 - ndeferred) = ptr;

				item_extent[ndeferred] = extent;

				ndeferred++;

			}

		}

		if (config_prof && idump) {

			prof_idump(tsd_tsdn(tsd));

		}

		arena_decay_ticks(tsd_tsdn(tsd), locked_arena, nflush -

		    ndeferred);

		nflush = ndeferred;

	}

	if (config_stats && !merged_stats) {

		/*

		 * The flush loop didn't happen to flush to this thread's

		 * arena, so the stats didn't get merged.  Manually do so now.

		 */

		arena_stats_large_flush_nrequests_add(tsd_tsdn(tsd),

		    &tcache_arena->stats, binind, tbin->tstats.nrequests);

		tbin->tstats.nrequests = 0;

	}

	memmove(tbin->avail - rem, tbin->avail - tbin->ncached, rem *

	    sizeof(void *));

	tbin->ncached = rem;

	if (tbin->ncached < tbin->low_water) {

		tbin->low_water = tbin->ncached;

	}

}

void

tcache_arena_associate(tsdn_t *tsdn, tcache_t *tcache, arena_t *arena) {

	assert(tcache->arena == NULL);

	tcache->arena = arena;

	if (config_stats) {

		/* Link into list of extant tcaches. */

		malloc_mutex_lock(tsdn, &arena->tcache_ql_mtx);

		ql_elm_new(tcache, link);

		ql_tail_insert(&arena->tcache_ql, tcache, link);

		cache_bin_array_descriptor_init(

		    &tcache->cache_bin_array_descriptor, tcache->bins_small,

		    tcache->bins_large);

		ql_tail_insert(&arena->cache_bin_array_descriptor_ql,

		    &tcache->cache_bin_array_descriptor, link);

		malloc_mutex_unlock(tsdn, &arena->tcache_ql_mtx);

	}

}

static void

tcache_arena_dissociate(tsdn_t *tsdn, tcache_t *tcache) {

	arena_t *arena = tcache->arena;

	assert(arena != NULL);

	if (config_stats) {

		/* Unlink from list of extant tcaches. */

		malloc_mutex_lock(tsdn, &arena->tcache_ql_mtx);

		if (config_debug) {

			bool in_ql = false;

			tcache_t *iter;

			ql_foreach(iter, &arena->tcache_ql, link) {

				if (iter == tcache) {

					in_ql = true;

					break;

				}

			}

			assert(in_ql);

		}

		ql_remove(&arena->tcache_ql, tcache, link);

		ql_remove(&arena->cache_bin_array_descriptor_ql,

		    &tcache->cache_bin_array_descriptor, link);

		tcache_stats_merge(tsdn, tcache, arena);

		malloc_mutex_unlock(tsdn, &arena->tcache_ql_mtx);

	}

	tcache->arena = NULL;

}

void

tcache_arena_reassociate(tsdn_t *tsdn, tcache_t *tcache, arena_t *arena) {

	tcache_arena_dissociate(tsdn, tcache);

	tcache_arena_associate(tsdn, tcache, arena);

}

bool

tsd_tcache_enabled_data_init(tsd_t *tsd) {

	/* Called upon tsd initialization. */

	tsd_tcache_enabled_set(tsd, opt_tcache);

	tsd_slow_update(tsd);

	if (opt_tcache) {

		/* Trigger tcache init. */

		tsd_tcache_data_init(tsd);

	}

	return false;

}

/* Initialize auto tcache (embedded in TSD). */

static void

tcache_init(tsd_t *tsd, tcache_t *tcache, void *avail_stack) {

	memset(&tcache->link, 0, sizeof(ql_elm(tcache_t)));

	tcache->prof_accumbytes = 0;

	tcache->next_gc_bin = 0;

	tcache->arena = NULL;

	ticker_init(&tcache->gc_ticker, TCACHE_GC_INCR);

	size_t stack_offset = 0;

	assert((TCACHE_NSLOTS_SMALL_MAX & 1U) == 0);

	memset(tcache->bins_small, 0, sizeof(cache_bin_t) * SC_NBINS);

	memset(tcache->bins_large, 0, sizeof(cache_bin_t) * (nhbins - SC_NBINS));

	unsigned i = 0;

	for (; i < SC_NBINS; i++) {

		tcache->lg_fill_div[i] = 1;

		stack_offset += tcache_bin_info[i].ncached_max * sizeof(void *);

		/*

		 * avail points past the available space.  Allocations will

		 * access the slots toward higher addresses (for the benefit of

		 * prefetch).

		 */

		tcache_small_bin_get(tcache, i)->avail =

		    (void **)((uintptr_t)avail_stack + (uintptr_t)stack_offset);

	}

	for (; i < nhbins; i++) {

		stack_offset += tcache_bin_info[i].ncached_max * sizeof(void *);

		tcache_large_bin_get(tcache, i)->avail =

		    (void **)((uintptr_t)avail_stack + (uintptr_t)stack_offset);

	}

	assert(stack_offset == stack_nelms * sizeof(void *));

}

/* Initialize auto tcache (embedded in TSD). */

bool

tsd_tcache_data_init(tsd_t *tsd) {

	tcache_t *tcache = tsd_tcachep_get_unsafe(tsd);

	assert(tcache_small_bin_get(tcache, 0)->avail == NULL);

	size_t size = stack_nelms * sizeof(void *);

	/* Avoid false cacheline sharing. */

	size = sz_sa2u(size, CACHELINE);

	void *avail_array = ipallocztm(tsd_tsdn(tsd), size, CACHELINE, true,

	    NULL, true, arena_get(TSDN_NULL, 0, true));

	if (avail_array == NULL) {

		return true;

	}

	tcache_init(tsd, tcache, avail_array);

	/*

	 * Initialization is a bit tricky here.  After malloc init is done, all

	 * threads can rely on arena_choose and associate tcache accordingly.

	 * However, the thread that does actual malloc bootstrapping relies on

	 * functional tsd, and it can only rely on a0.  In that case, we

	 * associate its tcache to a0 temporarily, and later on

	 * arena_choose_hard() will re-associate properly.

	 */

	tcache->arena = NULL;

	arena_t *arena;

	if (!malloc_initialized()) {

		/* If in initialization, assign to a0. */

		arena = arena_get(tsd_tsdn(tsd), 0, false);

		tcache_arena_associate(tsd_tsdn(tsd), tcache, arena);

	} else {

		arena = arena_choose(tsd, NULL);

		/* This may happen if thread.tcache.enabled is used. */

		if (tcache->arena == NULL) {

			tcache_arena_associate(tsd_tsdn(tsd), tcache, arena);

		}

	}

	assert(arena == tcache->arena);

	return false;

}

/* Created manual tcache for tcache.create mallctl. */

tcache_t *

tcache_create_explicit(tsd_t *tsd) {

	tcache_t *tcache;

	size_t size, stack_offset;

	size = sizeof(tcache_t);

	/* Naturally align the pointer stacks. */

	size = PTR_CEILING(size);

	stack_offset = size;

	size += stack_nelms * sizeof(void *);

	/* Avoid false cacheline sharing. */

	size = sz_sa2u(size, CACHELINE);

	tcache = ipallocztm(tsd_tsdn(tsd), size, CACHELINE, true, NULL, true,

	    arena_get(TSDN_NULL, 0, true));

	if (tcache == NULL) {

		return NULL;

	}

	tcache_init(tsd, tcache,

	    (void *)((uintptr_t)tcache + (uintptr_t)stack_offset));

	tcache_arena_associate(tsd_tsdn(tsd), tcache, arena_ichoose(tsd, NULL));

	return tcache;

}

static void

tcache_flush_cache(tsd_t *tsd, tcache_t *tcache) {

	assert(tcache->arena != NULL);

	for (unsigned i = 0; i < SC_NBINS; i++) {

		cache_bin_t *tbin = tcache_small_bin_get(tcache, i);

		tcache_bin_flush_small(tsd, tcache, tbin, i, 0);

		if (config_stats) {

			assert(tbin->tstats.nrequests == 0);

		}

	}

	for (unsigned i = SC_NBINS; i < nhbins; i++) {

		cache_bin_t *tbin = tcache_large_bin_get(tcache, i);

		tcache_bin_flush_large(tsd, tbin, i, 0, tcache);

		if (config_stats) {

			assert(tbin->tstats.nrequests == 0);

		}

	}

	if (config_prof && tcache->prof_accumbytes > 0 &&

	    arena_prof_accum(tsd_tsdn(tsd), tcache->arena,

	    tcache->prof_accumbytes)) {

		prof_idump(tsd_tsdn(tsd));

	}

}

void

tcache_flush(tsd_t *tsd) {

	assert(tcache_available(tsd));

	tcache_flush_cache(tsd, tsd_tcachep_get(tsd));

}

static void

tcache_destroy(tsd_t *tsd, tcache_t *tcache, bool tsd_tcache) {

	tcache_flush_cache(tsd, tcache);

	arena_t *arena = tcache->arena;

	tcache_arena_dissociate(tsd_tsdn(tsd), tcache);

	if (tsd_tcache) {

		/* Release the avail array for the TSD embedded auto tcache. */

		void *avail_array =

		    (void *)((uintptr_t)tcache_small_bin_get(tcache, 0)->avail -

		    (uintptr_t)tcache_bin_info[0].ncached_max * sizeof(void *));

		idalloctm(tsd_tsdn(tsd), avail_array, NULL, NULL, true, true);

	} else {

		/* Release both the tcache struct and avail array. */

		idalloctm(tsd_tsdn(tsd), tcache, NULL, NULL, true, true);

	}

	/*

	 * The deallocation and tcache flush above may not trigger decay since

	 * we are on the tcache shutdown path (potentially with non-nominal

	 * tsd).  Manually trigger decay to avoid pathological cases.  Also

	 * include arena 0 because the tcache array is allocated from it.

	 */

	arena_decay(tsd_tsdn(tsd), arena_get(tsd_tsdn(tsd), 0, false),

	    false, false);

	if (arena_nthreads_get(arena, false) == 0 &&

	    !background_thread_enabled()) {

		/* Force purging when no threads assigned to the arena anymore. */

		arena_decay(tsd_tsdn(tsd), arena, false, true);

	} else {

		arena_decay(tsd_tsdn(tsd), arena, false, false);

	}

}

/* For auto tcache (embedded in TSD) only. */

void

tcache_cleanup(tsd_t *tsd) {

	tcache_t *tcache = tsd_tcachep_get(tsd);

	if (!tcache_available(tsd)) {

		assert(tsd_tcache_enabled_get(tsd) == false);

		if (config_debug) {

			assert(tcache_small_bin_get(tcache, 0)->avail == NULL);

		}

		return;

	}

	assert(tsd_tcache_enabled_get(tsd));

	assert(tcache_small_bin_get(tcache, 0)->avail != NULL);

	tcache_destroy(tsd, tcache, true);

	if (config_debug) {

		tcache_small_bin_get(tcache, 0)->avail = NULL;

	}

}

void

tcache_stats_merge(tsdn_t *tsdn, tcache_t *tcache, arena_t *arena) {

	unsigned i;

	cassert(config_stats);

	/* Merge and reset tcache stats. */

	for (i = 0; i < SC_NBINS; i++) {

		cache_bin_t *tbin = tcache_small_bin_get(tcache, i);

		unsigned binshard;

		bin_t *bin = arena_bin_choose_lock(tsdn, arena, i, &binshard);

		bin->stats.nrequests += tbin->tstats.nrequests;

		malloc_mutex_unlock(tsdn, &bin->lock);

		tbin->tstats.nrequests = 0;

	}

	for (; i < nhbins; i++) {

		cache_bin_t *tbin = tcache_large_bin_get(tcache, i);

		arena_stats_large_flush_nrequests_add(tsdn, &arena->stats, i,

		    tbin->tstats.nrequests);

		tbin->tstats.nrequests = 0;

	}

}

static bool

tcaches_create_prep(tsd_t *tsd) {

	bool err;

	malloc_mutex_lock(tsd_tsdn(tsd), &tcaches_mtx);

	if (tcaches == NULL) {

		tcaches = base_alloc(tsd_tsdn(tsd), b0get(), sizeof(tcache_t *)

		    * (MALLOCX_TCACHE_MAX+1), CACHELINE);

		if (tcaches == NULL) {

			err = true;

			goto label_return;

		}

	}

	if (tcaches_avail == NULL && tcaches_past > MALLOCX_TCACHE_MAX) {

		err = true;

		goto label_return;

	}

	err = false;

label_return:

	malloc_mutex_unlock(tsd_tsdn(tsd), &tcaches_mtx);

	return err;

}

bool

tcaches_create(tsd_t *tsd, unsigned *r_ind) {

	witness_assert_depth(tsdn_witness_tsdp_get(tsd_tsdn(tsd)), 0);

	bool err;

	if (tcaches_create_prep(tsd)) {

		err = true;

		goto label_return;

	}

	tcache_t *tcache = tcache_create_explicit(tsd);

	if (tcache == NULL) {

		err = true;

		goto label_return;

	}

	tcaches_t *elm;

	malloc_mutex_lock(tsd_tsdn(tsd), &tcaches_mtx);

	if (tcaches_avail != NULL) {

		elm = tcaches_avail;

		tcaches_avail = tcaches_avail->next;

		elm->tcache = tcache;

		*r_ind = (unsigned)(elm - tcaches);

	} else {

		elm = &tcaches[tcaches_past];

		elm->tcache = tcache;

		*r_ind = tcaches_past;

		tcaches_past++;

	}

	malloc_mutex_unlock(tsd_tsdn(tsd), &tcaches_mtx);

	err = false;

label_return:

	witness_assert_depth(tsdn_witness_tsdp_get(tsd_tsdn(tsd)), 0);

	return err;

}

static tcache_t *

tcaches_elm_remove(tsd_t *tsd, tcaches_t *elm, bool allow_reinit) {

	malloc_mutex_assert_owner(tsd_tsdn(tsd), &tcaches_mtx);

	if (elm->tcache == NULL) {

		return NULL;

	}

	tcache_t *tcache = elm->tcache;

	if (allow_reinit) {

		elm->tcache = TCACHES_ELM_NEED_REINIT;

	} else {

		elm->tcache = NULL;

	}

	if (tcache == TCACHES_ELM_NEED_REINIT) {

		return NULL;

	}

	return tcache;

}

void

tcaches_flush(tsd_t *tsd, unsigned ind) {

	malloc_mutex_lock(tsd_tsdn(tsd), &tcaches_mtx);

	tcache_t *tcache = tcaches_elm_remove(tsd, &tcaches[ind], true);

	malloc_mutex_unlock(tsd_tsdn(tsd), &tcaches_mtx);

	if (tcache != NULL) {

		/* Destroy the tcache; recreate in tcaches_get() if needed. */

		tcache_destroy(tsd, tcache, false);

	}

}

void

tcaches_destroy(tsd_t *tsd, unsigned ind) {

	malloc_mutex_lock(tsd_tsdn(tsd), &tcaches_mtx);

	tcaches_t *elm = &tcaches[ind];

	tcache_t *tcache = tcaches_elm_remove(tsd, elm, false);

	elm->next = tcaches_avail;

	tcaches_avail = elm;

	malloc_mutex_unlock(tsd_tsdn(tsd), &tcaches_mtx);

	if (tcache != NULL) {

		tcache_destroy(tsd, tcache, false);

	}

}

bool

tcache_boot(tsdn_t *tsdn) {

	/* If necessary, clamp opt_lg_tcache_max. */

	if (opt_lg_tcache_max < 0 || (ZU(1) << opt_lg_tcache_max) <

	    SC_SMALL_MAXCLASS) {

		tcache_maxclass = SC_SMALL_MAXCLASS;

	} else {

		tcache_maxclass = (ZU(1) << opt_lg_tcache_max);

	}

	if (malloc_mutex_init(&tcaches_mtx, "tcaches", WITNESS_RANK_TCACHES,

	    malloc_mutex_rank_exclusive)) {

		return true;

	}

	nhbins = sz_size2index(tcache_maxclass) + 1;

	/* Initialize tcache_bin_info. */

	tcache_bin_info = (cache_bin_info_t *)base_alloc(tsdn, b0get(), nhbins

	    * sizeof(cache_bin_info_t), CACHELINE);

	if (tcache_bin_info == NULL) {

		return true;

	}

	stack_nelms = 0;

	unsigned i;

	for (i = 0; i < SC_NBINS; i++) {

		if ((bin_infos[i].nregs << 1) <= TCACHE_NSLOTS_SMALL_MIN) {

			tcache_bin_info[i].ncached_max =

			    TCACHE_NSLOTS_SMALL_MIN;

		} else if ((bin_infos[i].nregs << 1) <=

		    TCACHE_NSLOTS_SMALL_MAX) {

			tcache_bin_info[i].ncached_max =

			    (bin_infos[i].nregs << 1);

		} else {

			tcache_bin_info[i].ncached_max =

			    TCACHE_NSLOTS_SMALL_MAX;

		}

		stack_nelms += tcache_bin_info[i].ncached_max;

	}

	for (; i < nhbins; i++) {

		tcache_bin_info[i].ncached_max = TCACHE_NSLOTS_LARGE;

		stack_nelms += tcache_bin_info[i].ncached_max;

	}

	return false;

}

void

tcache_prefork(tsdn_t *tsdn) {

	if (!config_prof && opt_tcache) {

		malloc_mutex_prefork(tsdn, &tcaches_mtx);

	}

}

void

tcache_postfork_parent(tsdn_t *tsdn) {

	if (!config_prof && opt_tcache) {

		malloc_mutex_postfork_parent(tsdn, &tcaches_mtx);

	}

}

void

tcache_postfork_child(tsdn_t *tsdn) {

	if (!config_prof && opt_tcache) {

		malloc_mutex_postfork_child(tsdn, &tcaches_mtx);

	}

}