Restoring authorship annotation for <bugaevskiy@yandex-team.ru>. Commit 1 of 2.

1 files changed, 613 insertions, 613 deletions

diff --git a/contrib/libs/jemalloc/src/tcache.c b/contrib/libs/jemalloc/src/tcache.c
index 50099a9f2c..2c574e8f48 100644
--- a/contrib/libs/jemalloc/src/tcache.c
+++ b/contrib/libs/jemalloc/src/tcache.c
@@ -1,193 +1,193 @@
-#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"
-
+#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;
+cache_bin_info_t	*tcache_bin_info; 
 static unsigned		stack_nelms; /* Total stack elms per tcache. */
 
-unsigned		nhbins;
+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;
-
+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);
+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);
-	}
+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]++;
-			}
+		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);
+			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.
+		 * 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]--;
-		}
+		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) {
+	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) {
+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,
+	assert(tcache->arena != NULL); 
+	arena_tcache_fill_small(tsdn, arena, tcache, tbin, binind, 
 	    config_prof ? tcache->prof_accumbytes : 0);
-	if (config_prof) {
+	if (config_prof) { 
 		tcache->prof_accumbytes = 0;
-	}
-	ret = cache_bin_alloc_easy(tbin, tcache_success);
-
-	return ret;
-}
+	} 
+	ret = cache_bin_alloc_easy(tbin, tcache_success); 
 
-/* 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();
-	}
+	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) {
+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) {
+	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));
-			}
+		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) {
+		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);
+		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
@@ -195,573 +195,573 @@ tcache_bin_flush_small(tsd_t *tsd, tcache_t *tcache, cache_bin_t *tbin,
 				 * locked.  Stash the object, so that it can be
 				 * handled in a future pass.
 				 */
-				*(tbin->avail - 1 - ndeferred) = ptr;
-				item_extent[ndeferred] = extent;
+				*(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;
+		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) {
+	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);
+		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);
+		malloc_mutex_unlock(tsd_tsdn(tsd), &bin->lock); 
 	}
 
-	memmove(tbin->avail - rem, tbin->avail - tbin->ncached, rem *
-	    sizeof(void *));
+	memmove(tbin->avail - rem, tbin->avail - tbin->ncached, rem * 
+	    sizeof(void *)); 
 	tbin->ncached = rem;
-	if (tbin->ncached < tbin->low_water) {
+	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) {
+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) {
+	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;
+		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) {
+		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)) {
+		} 
+ 
+		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);
+				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);
+				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 {
+		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;
+				*(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) {
+		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);
+		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 *));
+	memmove(tbin->avail - rem, tbin->avail - tbin->ncached, rem * 
+	    sizeof(void *)); 
 	tbin->ncached = rem;
-	if (tbin->ncached < tbin->low_water) {
+	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;
+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);
-
+		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);
+		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);
+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;
+		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; 
 }
 
-/* Created manual tcache for tcache.create mallctl. */
+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_create_explicit(tsd_t *tsd) { 
 	tcache_t *tcache;
 	size_t size, stack_offset;
 
-	size = sizeof(tcache_t);
+	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);
+	/* 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 = 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));
+	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;
+	return tcache; 
 }
 
-static void
-tcache_flush_cache(tsd_t *tsd, tcache_t *tcache) {
-	assert(tcache->arena != NULL);
+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);
+	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);
+		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);
+	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_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));
-	}
+	    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_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;
+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) {
+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);
+	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);
+		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);
+		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;
-}
-
+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;
-
+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;
-	}
+	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) {
+	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);
+			    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;
@@ -773,26 +773,26 @@ tcache_boot(tsdn_t *tsdn) {
 		stack_nelms += tcache_bin_info[i].ncached_max;
 	}
 
-	return false;
+	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);
-	}
+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); 
+	} 
 }