--- libmalloc/libmalloc-116.30.3/src/magazine_malloc.c
+++ libmalloc/libmalloc-317.140.5/src/magazine_malloc.c
@@ -26,25 +26,16 @@
 /*
  * Multithread enhancements for "tiny" allocations introduced February 2008.
  * These are in the spirit of "Hoard". See:
- * Berger, E.D.; McKinley, K.S.; Blumofe, R.D.; Wilson, P.R. (2000).
- * "Hoard: a scalable memory allocator for multithreaded applications".
- * ACM SIGPLAN Notices 35 (11): 117-128. Berger2000.
- * <http://portal.acm.org/citation.cfm?id=356989.357000>
+ * Emery D. Berger, Kathryn S. McKinley, Robert D. Blumofe, and Paul R. Wilson. 2000.
+ * Hoard: a scalable memory allocator for multithreaded applications.
+ * In Proceedings of the ninth international conference on Architectural support for
+ * programming languages and operating systems (ASPLOS IX).
+ * ACM, New York, NY, USA, 117-128.
+ * DOI: https://doi.org/10.1145/378993.379232
  * Retrieved on 2008-02-22.
  */
 
 #include "internal.h"
-
-static volatile uintptr_t entropic_address = 0;
-static volatile uintptr_t entropic_limit = 0;
-#define ENTROPIC_KABILLION 0x10000000 /* 256Mb */
-
-// <rdar://problem/22277891> align 64bit ARM shift to 32MB PTE entries
-#if MALLOC_TARGET_IOS && MALLOC_TARGET_64BIT
-#define ENTROPIC_SHIFT 25
-#else // MALLOC_TARGET_IOS && MALLOC_TARGET_64BIT
-#define ENTROPIC_SHIFT SMALL_BLOCKS_ALIGN
-#endif
 
 #if DEBUG_MALLOC
 #define LOG(szone, ptr) (szone->log_address && (((uintptr_t)szone->log_address == -1) || (szone->log_address == (void *)(ptr))))
@@ -52,298 +43,36 @@
 #define LOG(szone, ptr) 0
 #endif
 
-/*********************	VERY LOW LEVEL UTILITIES  ************************/
-
-static void
-szone_sleep(void)
-{
-	if (getenv("MallocErrorStop")) {
-		_malloc_printf(ASL_LEVEL_NOTICE, "*** sending SIGSTOP to help debug\n");
-		kill(getpid(), SIGSTOP);
-	} else if (getenv("MallocErrorSleep")) {
-		_malloc_printf(ASL_LEVEL_NOTICE, "*** sleeping to help debug\n");
-		sleep(3600); // to help debug
-	}
-}
-
-// msg prints after fmt, ...
-void
-szone_error(szone_t *szone, int is_corruption, const char *msg, const void *ptr, const char *fmt, ...)
-{
-	va_list ap;
-	_SIMPLE_STRING b = _simple_salloc();
-
-	if (b) {
-		if (fmt) {
-			va_start(ap, fmt);
-			_simple_vsprintf(b, fmt, ap);
-			va_end(ap);
-		}
-		if (ptr) {
-			_simple_sprintf(b, "*** error for object %p: %s\n", ptr, msg);
-		} else {
-			_simple_sprintf(b, "*** error: %s\n", msg);
-		}
-		malloc_printf("%s*** set a breakpoint in malloc_error_break to debug\n", _simple_string(b));
-	} else {
-		/*
-		 * Should only get here if vm_allocate() can't get a single page of
-		 * memory, implying _simple_asl_log() would also fail.  So we just
-		 * print to the file descriptor.
-		 */
-		if (fmt) {
-			va_start(ap, fmt);
-			_malloc_vprintf(MALLOC_PRINTF_NOLOG, fmt, ap);
-			va_end(ap);
-		}
-		if (ptr) {
-			_malloc_printf(MALLOC_PRINTF_NOLOG, "*** error for object %p: %s\n", ptr, msg);
-		} else {
-			_malloc_printf(MALLOC_PRINTF_NOLOG, "*** error: %s\n", msg);
-		}
-		_malloc_printf(MALLOC_PRINTF_NOLOG, "*** set a breakpoint in malloc_error_break to debug\n");
-	}
-	malloc_error_break();
-#if DEBUG_MALLOC
-	szone_print(szone, 1);
-#endif
-	szone_sleep();
-	// Call abort() if this is a memory corruption error and the abort on
-	// corruption flag is set, or if any error should abort.
-	if ((is_corruption && (szone->debug_flags & MALLOC_ABORT_ON_CORRUPTION)) ||
-			(szone->debug_flags & MALLOC_ABORT_ON_ERROR)) {
-		_os_set_crash_log_message_dynamic(b ? _simple_string(b) : msg);
-		abort();
-	} else if (b) {
-		_simple_sfree(b);
-	}
-}
-
-void
-protect(void *address, size_t size, unsigned protection, unsigned debug_flags)
-{
-	kern_return_t err;
-
-	if (!(debug_flags & MALLOC_DONT_PROTECT_PRELUDE)) {
-		err = mprotect((void *)((uintptr_t)address - vm_page_quanta_size), vm_page_quanta_size, protection);
-		if (err) {
-			malloc_printf("*** can't protect(%p) region for prelude guard page at %p\n", protection,
-					(uintptr_t)address - vm_page_quanta_size);
-		}
-	}
-	if (!(debug_flags & MALLOC_DONT_PROTECT_POSTLUDE)) {
-		err = mprotect((void *)(round_page_quanta(((uintptr_t)address + size))), vm_page_quanta_size, protection);
-		if (err) {
-			malloc_printf("*** can't protect(%p) region for postlude guard page at %p\n", protection, (uintptr_t)address + size);
-		}
-	}
-}
-
-void *
-allocate_pages(szone_t *szone, size_t size, unsigned char align, unsigned debug_flags, int vm_page_label)
-{
-	boolean_t add_guard_pages = debug_flags & MALLOC_ADD_GUARD_PAGES;
-	boolean_t purgeable = debug_flags & MALLOC_PURGEABLE;
-	mach_vm_address_t vm_addr;
-	uintptr_t addr;
-	mach_vm_size_t allocation_size = round_page_quanta(size);
-	mach_vm_offset_t allocation_mask = ((mach_vm_offset_t)1 << align) - 1;
-	int alloc_flags = VM_FLAGS_ANYWHERE | VM_MAKE_TAG(vm_page_label);
-	kern_return_t kr;
-
-	if (!allocation_size) {
-		allocation_size = vm_page_quanta_size;
-	}
-	if (add_guard_pages) {
-		if (align > vm_page_quanta_shift) {
-			/* <rdar://problem/16601499> alignment greater than pagesize needs more work */
-			allocation_size += (1 << align) + vm_page_quanta_size;
-		} else {
-			allocation_size += 2 * vm_page_quanta_size;
-		}
-	}
-
-	if (purgeable) {
-		alloc_flags |= VM_FLAGS_PURGABLE;
-	}
-	if (allocation_size < size) { // size_t arithmetic wrapped!
-		return NULL;
-	}
-
-	vm_addr = vm_page_quanta_size;
-	kr = mach_vm_map(mach_task_self(), &vm_addr, allocation_size, allocation_mask, alloc_flags, MEMORY_OBJECT_NULL, 0, FALSE,
-			VM_PROT_DEFAULT, VM_PROT_ALL, VM_INHERIT_DEFAULT);
-	if (kr) {
-		szone_error(szone, 0, "can't allocate region", NULL, "*** mach_vm_map(size=%lu) failed (error code=%d)\n", size, kr);
-		return NULL;
-	}
-	addr = (uintptr_t)vm_addr;
-
-	if (add_guard_pages) {
-		if (align > vm_page_quanta_shift) {
-			/* <rdar://problem/16601499> calculate the first address inside the alignment padding
-			 * where we can place the guard page and still be aligned.
-			 *
-			 * |-----------------------------------------------------------|
-			 * |leading|gp|                  alloc                  |gp| t |
-			 * |-----------------------------------------------------------|
-			 */
-			uintptr_t alignaddr = ((addr + vm_page_quanta_size) + (1 << align) - 1) & ~((1 << align) - 1);
-			size_t leading = alignaddr - addr - vm_page_quanta_size;
-			size_t trailing = (1 << align) - vm_page_quanta_size - leading;
-
-			/* Unmap the excess area. */
-			kr = mach_vm_deallocate(mach_task_self(), addr, leading);
-			if (kr) {
-				szone_error(szone, 0, "can't unmap excess guard region", NULL,
-						"*** mach_vm_deallocate(addr=%p, size=%lu) failed (code=%d)", (void *)addr, leading, kr);
-				return NULL;
-			}
-
-			kr = mach_vm_deallocate(mach_task_self(), addr + allocation_size - trailing, trailing);
-			if (kr) {
-				szone_error(szone, 0, "can't unmap excess trailing guard region", NULL,
-						"*** mach_vm_deallocate(addr=%p, size=%lu) failed (code=%d)", (void *)(addr + allocation_size - trailing),
-						trailing, kr);
-				return NULL;
-			}
-
-			addr = alignaddr;
-		} else {
-			addr += vm_page_quanta_size;
-		}
-		protect((void *)addr, size, PROT_NONE, debug_flags);
-	}
-	return (void *)addr;
-}
-
-void *
-allocate_pages_securely(szone_t *szone, size_t size, unsigned char align, int vm_page_label)
-{
-	mach_vm_address_t vm_addr;
-	uintptr_t addr;
-	mach_vm_size_t allocation_size = round_page_quanta(size);
-	mach_vm_offset_t allocation_mask = ((mach_vm_offset_t)1 << align) - 1;
-	int alloc_flags = VM_FLAGS_ANYWHERE | VM_MAKE_TAG(vm_page_label);
-	kern_return_t kr;
-
-	if (szone->debug_flags & DISABLE_ASLR) {
-		return allocate_pages(szone, size, align, 0, vm_page_label);
-	}
-
-	if (!allocation_size) {
-		allocation_size = vm_page_quanta_size;
-	}
-	if (allocation_size < size) { // size_t arithmetic wrapped!
-		return NULL;
-	}
-
-retry:
-	vm_addr = entropic_address;
-	kr = mach_vm_map(mach_task_self(), &vm_addr, allocation_size, allocation_mask, alloc_flags, MEMORY_OBJECT_NULL, 0, FALSE,
-			VM_PROT_DEFAULT, VM_PROT_ALL, VM_INHERIT_DEFAULT);
-	if (kr == KERN_NO_SPACE) {
-		vm_addr = vm_page_quanta_size;
-		kr = mach_vm_map(mach_task_self(), &vm_addr, allocation_size, allocation_mask, alloc_flags, MEMORY_OBJECT_NULL, 0, FALSE,
-				VM_PROT_DEFAULT, VM_PROT_ALL, VM_INHERIT_DEFAULT);
-	}
-	if (kr) {
-		szone_error(
-				szone, 0, "can't allocate region securely", NULL, "*** mach_vm_map(size=%lu) failed (error code=%d)\n", size, kr);
-		return NULL;
-	}
-	addr = (uintptr_t)vm_addr;
-
-	// Don't allow allocation to rise above entropic_limit (for tidiness).
-	if (addr + allocation_size > entropic_limit) { // Exhausted current range?
-		uintptr_t t = entropic_address;
-		uintptr_t u = t - ENTROPIC_KABILLION;
-
-		if (u < t) { // provided we don't wrap, deallocate and retry, in the expanded entropic range
-			mach_vm_deallocate(mach_task_self(), vm_addr, allocation_size);
-			(void)__sync_bool_compare_and_swap(&entropic_address, t, u); // Just one reduction please
-			goto retry;
-		}
-		// fall through to use what we got
-	}
-
-	if (addr < entropic_address) { // we wrapped to find this allocation, expand the entropic range
-		uintptr_t t = entropic_address;
-		uintptr_t u = t - ENTROPIC_KABILLION;
-		if (u < t) {
-			(void)__sync_bool_compare_and_swap(&entropic_address, t, u); // Just one reduction please
-		}
-		// fall through to use what we got
-	}
-	return (void *)addr;
-}
-
-void
-deallocate_pages(szone_t *szone, void *addr, size_t size, unsigned debug_flags)
-{
-	boolean_t add_guard_pages = debug_flags & MALLOC_ADD_GUARD_PAGES;
-	mach_vm_address_t vm_addr = (mach_vm_address_t)addr;
-	mach_vm_size_t allocation_size = size;
-	kern_return_t kr;
-
-	if (add_guard_pages) {
-		vm_addr -= vm_page_quanta_size;
-		allocation_size += 2 * vm_page_quanta_size;
-	}
-	kr = mach_vm_deallocate(mach_task_self(), vm_addr, allocation_size);
-	if (kr && szone) {
-		szone_error(szone, 0, "Can't deallocate_pages region", addr, NULL);
-	}
-}
-
-int
-madvise_free_range(szone_t *szone, region_t r, uintptr_t pgLo, uintptr_t pgHi, uintptr_t *last)
-{
-	if (pgHi > pgLo) {
-		size_t len = pgHi - pgLo;
-
-		if (szone->debug_flags & MALLOC_DO_SCRIBBLE) {
-			memset((void *)pgLo, SCRUBBLE_BYTE, len); // Scribble on MADV_FREEd memory
-		}
-
-#if TARGET_OS_EMBEDDED
-		if (last) {
-			if (*last == pgLo) {
-				return 0;
-			}
-
-			*last = pgLo;
-		}
-#endif
-
-		MAGMALLOC_MADVFREEREGION((void *)szone, (void *)r, (void *)pgLo, (int)len); // DTrace USDT Probe
-		if (-1 == madvise((void *)pgLo, len, CONFIG_MADVISE_STYLE)) {
-/* -1 return: VM map entry change makes this unfit for reuse. Something evil lurks. */
-#if DEBUG_MADVISE
-			szone_error(szone, 0, "madvise_free_range madvise(..., MADV_FREE_REUSABLE) failed", (void *)pgLo, "length=%d\n", len);
-#endif
-		}
-	}
-	return 0;
-}
-
-int
-madvise_reuse_range(szone_t *szone, region_t r, uintptr_t pgLo, uintptr_t phHi)
-{
-	if (phHi > pgLo) {
-		size_t len = phHi - pgLo;
-
-		if (madvise((void *)pgLo, len, MADV_FREE_REUSE) == -1) {
-/* -1 return: VM map entry change makes this unfit for reuse. Something evil lurks. */
-#if DEBUG_MADVISE
-			szone_error(szone, 0, "madvise_reuse_range madvise(..., MADV_FREE_REUSE) failed", sparse_region, "length=%d\n",
-					TINY_REGION_PAYLOAD_BYTES);
-#endif
-			return 1;
-		}
-	}
-	return 0;
-}
+// Maximum number of magazines, set from the number of logical CPUS and
+// possibly limited by the MallocMaxMagazines environment variable.
+int max_magazines;
+
+// Control whether medium is enabled at all when creating new magazine zones
+bool magazine_medium_enabled = true;
+
+// Control the DRAM limit at which medium kicks in.
+uint64_t magazine_medium_active_threshold = MEDIUM_ACTIVATION_THRESHOLD;
+
+// Control the DRAM limit at which the expanded large cache kicks in.
+uint64_t magazine_large_expanded_cache_threshold = LARGE_CACHE_EXPANDED_THRESHOLD;
+
+#if CONFIG_AGGRESSIVE_MADVISE
+bool aggressive_madvise_enabled = DEFAULT_AGGRESSIVE_MADVISE_ENABLED;
+#endif // CONFIG_AGGRESSIVE_MADVISE
+
+#if CONFIG_LARGE_CACHE
+bool large_cache_enabled = DEFAULT_LARGE_CACHE_ENABLED;
+#endif // CONFIG_LARGE_CACHE
+
+// <rdar://problem/47353961> Maximum number of magzines that the medium
+// allocator will use. This addresses a 32-bit load-offset range issue found
+// in some apps when introducing medium.
+int max_medium_magazines;
+
+// Number of regions to retain in a recirc depot.
+#if CONFIG_RECIRC_DEPOT
+int recirc_retained_regions = DEFAULT_RECIRC_RETAINED_REGIONS;
+#endif // CONFIG_RECIRC_DEPOT
 
 /*********************	Zone call backs	************************/
 /*
@@ -357,7 +86,7 @@
 
 #if DEBUG_MALLOC
 	if (LOG(szone, ptr)) {
-		malloc_printf("in szone_free with %p\n", ptr);
+		malloc_report(ASL_LEVEL_INFO, "in szone_free with %p\n", ptr);
 	}
 #endif
 	if (!ptr) {
@@ -367,15 +96,15 @@
 	 * Try to free to a tiny region.
 	 */
 	if ((uintptr_t)ptr & (TINY_QUANTUM - 1)) {
-		szone_error(szone, 1, "Non-aligned pointer being freed", ptr, NULL);
-		return;
-	}
-	if ((tiny_region = tiny_region_for_ptr_no_lock(szone, ptr)) != NULL) {
+		malloc_zone_error(szone->debug_flags, true, "Non-aligned pointer %p being freed\n", ptr);
+		return;
+	}
+	if ((tiny_region = tiny_region_for_ptr_no_lock(&szone->tiny_rack, ptr)) != NULL) {
 		if (TINY_INDEX_FOR_PTR(ptr) >= NUM_TINY_BLOCKS) {
-			szone_error(szone, 1, "Pointer to metadata being freed", ptr, NULL);
+			malloc_zone_error(szone->debug_flags, true, "Pointer %p to metadata being freed\n", ptr);
 			return;
 		}
-		free_tiny(szone, ptr, tiny_region, 0);
+		free_tiny(&szone->tiny_rack, ptr, tiny_region, 0, false);
 		return;
 	}
 
@@ -383,21 +112,35 @@
 	 * Try to free to a small region.
 	 */
 	if ((uintptr_t)ptr & (SMALL_QUANTUM - 1)) {
-		szone_error(szone, 1, "Non-aligned pointer being freed (2)", ptr, NULL);
-		return;
-	}
-	if ((small_region = small_region_for_ptr_no_lock(szone, ptr)) != NULL) {
+		malloc_zone_error(szone->debug_flags, true, "Non-aligned pointer %p being freed (2)\n", ptr);
+		return;
+	}
+	if ((small_region = small_region_for_ptr_no_lock(&szone->small_rack, ptr)) != NULL) {
 		if (SMALL_META_INDEX_FOR_PTR(ptr) >= NUM_SMALL_BLOCKS) {
-			szone_error(szone, 1, "Pointer to metadata being freed (2)", ptr, NULL);
+			malloc_zone_error(szone->debug_flags, true, "Pointer %p to metadata being freed (2)\n", ptr);
 			return;
 		}
-		free_small(szone, ptr, small_region, 0);
-		return;
-	}
+		free_small(&szone->small_rack, ptr, small_region, 0);
+		return;
+	}
+
+#if CONFIG_MEDIUM_ALLOCATOR
+	region_t medium_region;
+
+	if (szone->is_medium_engaged &&
+			(medium_region = medium_region_for_ptr_no_lock(&szone->medium_rack, ptr)) != NULL) {
+		if (MEDIUM_META_INDEX_FOR_PTR(ptr) >= NUM_MEDIUM_BLOCKS) {
+			malloc_zone_error(szone->debug_flags, true, "Pointer %p to metadata being freed (2)\n", ptr);
+			return;
+		}
+		free_medium(&szone->medium_rack, ptr, medium_region, 0);
+		return;
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
 
 	/* check that it's a legal large allocation */
 	if ((uintptr_t)ptr & (vm_page_quanta_size - 1)) {
-		szone_error(szone, 1, "non-page-aligned, non-allocated pointer being freed", ptr, NULL);
+		malloc_zone_error(szone->debug_flags, true, "non-page-aligned, non-allocated pointer %p being freed\n", ptr);
 		return;
 	}
 	free_large(szone, ptr);
@@ -408,11 +151,11 @@
 {
 #if DEBUG_MALLOC
 	if (LOG(szone, ptr)) {
-		malloc_printf("in szone_free_definite_size with %p\n", ptr);
+		malloc_report(ASL_LEVEL_INFO, "in szone_free_definite_size with %p\n", ptr);
 	}
 
 	if (0 == size) {
-		szone_error(szone, 1, "pointer of size zero being freed", ptr, NULL);
+		malloc_zone_error(szone->debug_flags, true, "pointer %p of size zero being freed\n", ptr);
 		return;
 	}
 
@@ -425,15 +168,15 @@
 	 * Try to free to a tiny region.
 	 */
 	if ((uintptr_t)ptr & (TINY_QUANTUM - 1)) {
-		szone_error(szone, 1, "Non-aligned pointer being freed", ptr, NULL);
-		return;
-	}
-	if (size <= SMALL_THRESHOLD) {
+		malloc_zone_error(szone->debug_flags, true, "Non-aligned pointer %p being freed\n", ptr);
+		return;
+	}
+	if (size <= TINY_LIMIT_THRESHOLD) {
 		if (TINY_INDEX_FOR_PTR(ptr) >= NUM_TINY_BLOCKS) {
-			szone_error(szone, 1, "Pointer to metadata being freed", ptr, NULL);
+			malloc_zone_error(szone->debug_flags, true, "Pointer %p to metadata being freed\n", ptr);
 			return;
 		}
-		free_tiny(szone, ptr, TINY_REGION_FOR_PTR(ptr), size);
+		free_tiny(&szone->tiny_rack, ptr, TINY_REGION_FOR_PTR(ptr), size, false);
 		return;
 	}
 
@@ -441,21 +184,35 @@
 	 * Try to free to a small region.
 	 */
 	if ((uintptr_t)ptr & (SMALL_QUANTUM - 1)) {
-		szone_error(szone, 1, "Non-aligned pointer being freed (2)", ptr, NULL);
-		return;
-	}
-	if (size <= szone->large_threshold) {
+		malloc_zone_error(szone->debug_flags, true, "Non-aligned pointer %p being freed (2)\n", ptr);
+		return;
+	}
+	if (size <= SMALL_LIMIT_THRESHOLD) {
 		if (SMALL_META_INDEX_FOR_PTR(ptr) >= NUM_SMALL_BLOCKS) {
-			szone_error(szone, 1, "Pointer to metadata being freed (2)", ptr, NULL);
+			malloc_zone_error(szone->debug_flags, true, "Pointer %p to metadata being freed (2)\n", ptr);
 			return;
 		}
-		free_small(szone, ptr, SMALL_REGION_FOR_PTR(ptr), size);
-		return;
-	}
+		free_small(&szone->small_rack, ptr, SMALL_REGION_FOR_PTR(ptr), size);
+		return;
+	}
+
+#if CONFIG_MEDIUM_ALLOCATOR
+	/*
+	 * Try to free to a medium region.
+	 */
+	if (szone->is_medium_engaged && size <= MEDIUM_LIMIT_THRESHOLD) {
+		if (MEDIUM_META_INDEX_FOR_PTR(ptr) >= NUM_MEDIUM_BLOCKS) {
+			malloc_zone_error(szone->debug_flags, true, "Pointer %p to metadata being freed (2)\n", ptr);
+			return;
+		}
+		free_medium(&szone->medium_rack, ptr, MEDIUM_REGION_FOR_PTR(ptr), size);
+		return;
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
 
 	/* check that it's a legal large allocation */
 	if ((uintptr_t)ptr & (vm_page_quanta_size - 1)) {
-		szone_error(szone, 1, "non-page-aligned, non-allocated pointer being freed", ptr, NULL);
+		malloc_zone_error(szone->debug_flags, true, "non-page-aligned, non-allocated pointer %p being freed\n", ptr);
 		return;
 	}
 	free_large(szone, ptr);
@@ -467,25 +224,28 @@
 	void *ptr;
 	msize_t msize;
 
-	if (size <= SMALL_THRESHOLD) {
-		// tiny size: <1024 bytes (64-bit), <512 bytes (32-bit)
-		// think tiny
+	if (size <= TINY_LIMIT_THRESHOLD) {
 		msize = TINY_MSIZE_FOR_BYTES(size + TINY_QUANTUM - 1);
 		if (!msize) {
 			msize = 1;
 		}
-		ptr = tiny_malloc_should_clear(szone, msize, cleared_requested);
-	} else if (size <= szone->large_threshold) {
-		// small size: <15k (<1GB machines), <127k (>1GB machines)
-		// think small
+		ptr = tiny_malloc_should_clear(&szone->tiny_rack, msize, cleared_requested);
+	} else if (size <= SMALL_LIMIT_THRESHOLD) {
 		msize = SMALL_MSIZE_FOR_BYTES(size + SMALL_QUANTUM - 1);
 		if (!msize) {
 			msize = 1;
 		}
-		ptr = small_malloc_should_clear(szone, msize, cleared_requested);
+		ptr = small_malloc_should_clear(&szone->small_rack, msize, cleared_requested);
+#if CONFIG_MEDIUM_ALLOCATOR
+	} else if (szone->is_medium_engaged && size <= MEDIUM_LIMIT_THRESHOLD) {
+		msize = MEDIUM_MSIZE_FOR_BYTES(size + MEDIUM_QUANTUM - 1);
+		if (!msize) {
+			msize = 1;
+		}
+		ptr = medium_malloc_should_clear(&szone->medium_rack, msize, cleared_requested);
+#endif
 	} else {
-		// large: all other allocations
-		size_t num_kernel_pages = round_page_quanta(size) >> vm_page_quanta_shift;
+		size_t num_kernel_pages = round_large_page_quanta(size) >> large_vm_page_quanta_shift;
 		if (num_kernel_pages == 0) { /* Overflowed */
 			ptr = 0;
 		} else {
@@ -494,7 +254,7 @@
 	}
 #if DEBUG_MALLOC
 	if (LOG(szone, ptr)) {
-		malloc_printf("szone_malloc returned %p\n", ptr);
+		malloc_report(ASL_LEVEL_INFO, "szone_malloc returned %p\n", ptr);
 	}
 #endif
 	/*
@@ -516,29 +276,10 @@
 void *
 szone_calloc(szone_t *szone, size_t num_items, size_t size)
 {
-	size_t total_bytes = num_items * size;
-
-	// Check for overflow of integer multiplication
-	if (num_items > 1) {
-#if __LP64__ /* size_t is uint64_t */
-		if ((num_items | size) & 0xffffffff00000000ul) {
-			// num_items or size equals or exceeds sqrt(2^64) == 2^32, appeal to wider arithmetic
-			__uint128_t product = ((__uint128_t)num_items) * ((__uint128_t)size);
-			if ((uint64_t)(product >> 64)) { // compiles to test on upper register of register pair
-				return NULL;
-			}
-		}
-#else /* size_t is uint32_t */
-		if ((num_items | size) & 0xffff0000ul) {
-			// num_items or size equals or exceeds sqrt(2^32) == 2^16, appeal to wider arithmetic
-			uint64_t product = ((uint64_t)num_items) * ((uint64_t)size);
-			if ((uint32_t)(product >> 32)) { // compiles to test on upper register of register pair
-				return NULL;
-			}
-		}
-#endif
-	}
-
+	size_t total_bytes;
+	if (calloc_get_size(num_items, size, 0, &total_bytes)) {
+		return NULL;
+	}
 	return szone_malloc_should_clear(szone, total_bytes, 1);
 }
 
@@ -547,18 +288,18 @@
 {
 	void *ptr;
 
-	if (size <= szone->large_threshold) {
+	if (size <= MEDIUM_LIMIT_THRESHOLD) {
 		ptr = szone_memalign(szone, vm_page_quanta_size, size);
 	} else {
 		size_t num_kernel_pages;
 
-		num_kernel_pages = round_page_quanta(size) >> vm_page_quanta_shift;
+		num_kernel_pages = round_large_page_quanta(size) >> large_vm_page_quanta_shift;
 		ptr = large_malloc(szone, num_kernel_pages, 0, 0);
 	}
 
 #if DEBUG_MALLOC
 	if (LOG(szone, ptr)) {
-		malloc_printf("szone_valloc returned %p\n", ptr);
+		malloc_report(ASL_LEVEL_INFO, "szone_valloc returned %p\n", ptr);
 	}
 #endif
 	return ptr;
@@ -579,7 +320,7 @@
 	SZONE_UNLOCK(szone);
 #if DEBUG_MALLOC
 	if (LOG(szone, ptr)) {
-		malloc_printf("szone_size for %p returned %d\n", ptr, (unsigned)size);
+		malloc_report(ASL_LEVEL_INFO, "szone_size for %p returned %d\n", ptr, (unsigned)size);
 	}
 #endif
 	return size;
@@ -588,15 +329,14 @@
 size_t
 szone_size(szone_t *szone, const void *ptr)
 {
-	boolean_t is_free;
-	msize_t msize, msize_and_free;
+	size_t sz = 0;
 
 	if (!ptr) {
 		return 0;
 	}
 #if DEBUG_MALLOC
 	if (LOG(szone, ptr)) {
-		malloc_printf("in szone_size for %p (szone=%p)\n", ptr, szone);
+		malloc_report(ASL_LEVEL_INFO, "in szone_size for %p (szone=%p)\n", ptr, szone);
 	}
 #endif
 
@@ -606,35 +346,10 @@
 	if ((uintptr_t)ptr & (TINY_QUANTUM - 1)) {
 		return 0;
 	}
-	if (tiny_region_for_ptr_no_lock(szone, ptr)) {
-		if (TINY_INDEX_FOR_PTR(ptr) >= NUM_TINY_BLOCKS) {
-			return 0;
-		}
-		msize = get_tiny_meta_header(ptr, &is_free);
-		if (is_free) {
-			return 0;
-		}
-#if CONFIG_TINY_CACHE
-		{
-			mag_index_t mag_index = MAGAZINE_INDEX_FOR_TINY_REGION(TINY_REGION_FOR_PTR(ptr));
-			if (DEPOT_MAGAZINE_INDEX != mag_index) {
-				magazine_t *tiny_mag_ptr = &(szone->tiny_magazines[mag_index]);
-
-				if (msize < TINY_QUANTUM && ptr == (void *)((uintptr_t)(tiny_mag_ptr->mag_last_free) & ~(TINY_QUANTUM - 1))) {
-					return 0;
-				}
-			} else {
-				for (mag_index = 0; mag_index < szone->num_tiny_magazines; mag_index++) {
-					magazine_t *tiny_mag_ptr = &(szone->tiny_magazines[mag_index]);
-
-					if (msize < TINY_QUANTUM && ptr == (void *)((uintptr_t)(tiny_mag_ptr->mag_last_free) & ~(TINY_QUANTUM - 1))) {
-						return 0;
-					}
-				}
-			}
-		}
-#endif
-		return TINY_BYTES_FOR_MSIZE(msize);
+
+	sz = tiny_size(&szone->tiny_rack, ptr);
+	if (sz) {
+		return sz;
 	}
 
 	/*
@@ -643,36 +358,23 @@
 	if ((uintptr_t)ptr & (SMALL_QUANTUM - 1)) {
 		return 0;
 	}
-	if (small_region_for_ptr_no_lock(szone, ptr)) {
-		if (SMALL_META_INDEX_FOR_PTR(ptr) >= NUM_SMALL_BLOCKS) {
-			return 0;
-		}
-		msize_and_free = *SMALL_METADATA_FOR_PTR(ptr);
-		if (msize_and_free & SMALL_IS_FREE) {
-			return 0;
-		}
-#if CONFIG_SMALL_CACHE
-		{
-			mag_index_t mag_index = MAGAZINE_INDEX_FOR_SMALL_REGION(SMALL_REGION_FOR_PTR(ptr));
-			if (DEPOT_MAGAZINE_INDEX != mag_index) {
-				magazine_t *small_mag_ptr = &(szone->small_magazines[mag_index]);
-
-				if (ptr == (void *)((uintptr_t)(small_mag_ptr->mag_last_free) & ~(SMALL_QUANTUM - 1))) {
-					return 0;
-				}
-			} else {
-				for (mag_index = 0; mag_index < szone->num_small_magazines; mag_index++) {
-					magazine_t *small_mag_ptr = &(szone->small_magazines[mag_index]);
-
-					if (ptr == (void *)((uintptr_t)(small_mag_ptr->mag_last_free) & ~(SMALL_QUANTUM - 1))) {
-						return 0;
-					}
-				}
-			}
-		}
-#endif
-		return SMALL_BYTES_FOR_MSIZE(msize_and_free);
-	}
+
+	sz = small_size(&szone->small_rack, ptr);
+	if (sz) {
+		return sz;
+	}
+
+#if CONFIG_MEDIUM_ALLOCATOR
+	/*
+	 * Look for it in a medium region.
+	 */
+	if (szone->is_medium_engaged) {
+		sz = medium_size(&szone->medium_rack, ptr);
+		if (sz) {
+			return sz;
+		}
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
 
 	/*
 	 * If not page-aligned, it cannot have come from a large allocation.
@@ -695,7 +397,7 @@
 
 #if DEBUG_MALLOC
 	if (LOG(szone, ptr)) {
-		malloc_printf("in szone_realloc for %p, %d\n", ptr, (unsigned)new_size);
+		malloc_report(ASL_LEVEL_INFO, "in szone_realloc for %p, %d\n", ptr, (unsigned)new_size);
 	}
 #endif
 	if (NULL == ptr) {
@@ -711,7 +413,7 @@
 
 	old_size = szone_size(szone, ptr);
 	if (!old_size) {
-		szone_error(szone, 1, "pointer being reallocated was not allocated", ptr, NULL);
+		malloc_zone_error(szone->debug_flags, true, "pointer %p being reallocated was not allocated\n", ptr);
 		return NULL;
 	}
 
@@ -724,13 +426,13 @@
 	 * If the new size suits the tiny allocator and the pointer being resized
 	 * belongs to a tiny region, try to reallocate in-place.
 	 */
-	if (new_good_size <= SMALL_THRESHOLD) {
-		if (old_size <= SMALL_THRESHOLD) {
+	if (new_good_size <= TINY_LIMIT_THRESHOLD) {
+		if (old_size <= TINY_LIMIT_THRESHOLD) {
 			if (new_good_size <= (old_size >> 1)) {
 				/*
 				 * Serious shrinkage (more than half). free() the excess.
 				 */
-				return tiny_try_shrink_in_place(szone, ptr, old_size, new_good_size);
+				return tiny_try_shrink_in_place(&szone->tiny_rack, ptr, old_size, new_good_size);
 			} else if (new_good_size <= old_size) {
 				/*
 				 * new_good_size smaller than old_size but not by much (less than half).
@@ -740,7 +442,7 @@
 					memset(ptr + new_size, SCRIBBLE_BYTE, old_size - new_size);
 				}
 				return ptr;
-			} else if (tiny_try_realloc_in_place(szone, ptr, old_size, new_good_size)) { // try to grow the allocation
+			} else if (tiny_try_realloc_in_place(&szone->tiny_rack, ptr, old_size, new_good_size)) { // try to grow the allocation
 				if (szone->debug_flags & MALLOC_DO_SCRIBBLE) {
 					memset(ptr + old_size, SCRIBBLE_BYTE, new_good_size - old_size);
 				}
@@ -753,27 +455,46 @@
 		 * belongs to a small region, and we're not protecting the small allocations
 		 * try to reallocate in-place.
 		 */
-	} else if (new_good_size <= szone->large_threshold) {
-		if (SMALL_THRESHOLD < old_size && old_size <= szone->large_threshold) {
+	} else if (new_good_size <= SMALL_LIMIT_THRESHOLD) {
+		if (TINY_LIMIT_THRESHOLD < old_size && old_size <= SMALL_LIMIT_THRESHOLD) {
 			if (new_good_size <= (old_size >> 1)) {
-				return small_try_shrink_in_place(szone, ptr, old_size, new_good_size);
+				return small_try_shrink_in_place(&szone->small_rack, ptr, old_size, new_good_size);
 			} else if (new_good_size <= old_size) {
 				if (szone->debug_flags & MALLOC_DO_SCRIBBLE) {
 					memset(ptr + new_size, SCRIBBLE_BYTE, old_size - new_size);
 				}
 				return ptr;
-			} else if (small_try_realloc_in_place(szone, ptr, old_size, new_good_size)) {
+			} else if (small_try_realloc_in_place(&szone->small_rack, ptr, old_size, new_good_size)) {
 				if (szone->debug_flags & MALLOC_DO_SCRIBBLE) {
 					memset(ptr + old_size, SCRIBBLE_BYTE, new_good_size - old_size);
 				}
 				return ptr;
 			}
 		}
+
+#if CONFIG_MEDIUM_ALLOCATOR
+	} else if (szone->is_medium_engaged && new_good_size <= MEDIUM_LIMIT_THRESHOLD) {
+		if (SMALL_LIMIT_THRESHOLD < old_size && old_size <= MEDIUM_LIMIT_THRESHOLD) {
+			if (new_good_size <= (old_size >> 1)) {
+				return medium_try_shrink_in_place(&szone->medium_rack, ptr, old_size, new_good_size);
+			} else if (new_good_size <= old_size) {
+				if (szone->debug_flags & MALLOC_DO_SCRIBBLE) {
+					memset(ptr + new_size, SCRIBBLE_BYTE, old_size - new_size);
+				}
+			} else if (medium_try_realloc_in_place(&szone->medium_rack, ptr, old_size, new_good_size)) {
+				if (szone->debug_flags & MALLOC_DO_SCRIBBLE) {
+					memset(ptr + old_size, SCRIBBLE_BYTE, new_good_size - old_size);
+				}
+				return ptr;
+			}
+		}
+#endif // CONFIG_MEDIUM_ALLOCATOR
+
 		/*
 		 * Else if the allocation's a large allocation, try to reallocate in-place there.
 		 */
 	} else if (!(szone->debug_flags & MALLOC_PURGEABLE) && // purgeable needs fresh allocation
-			   (old_size > szone->large_threshold) && (new_good_size > szone->large_threshold)) {
+			   (old_size > LARGE_THRESHOLD(szone)) && (new_good_size > LARGE_THRESHOLD(szone))) {
 		if (new_good_size <= (old_size >> 1)) {
 			return large_try_shrink_in_place(szone, ptr, old_size, new_good_size);
 		} else if (new_good_size <= old_size) {
@@ -811,15 +532,18 @@
 	 * if it's too small, just copy by hand.
 	 */
 	valid_size = MIN(old_size, new_size);
-	if ((valid_size < szone->vm_copy_threshold) ||
-			vm_copy(mach_task_self(), (vm_address_t)ptr, valid_size, (vm_address_t)new_ptr)) {
+#if CONFIG_REALLOC_CAN_USE_VMCOPY
+	if ((valid_size <= VM_COPY_THRESHOLD) ||
+			vm_copy(mach_task_self(), (vm_address_t)ptr, valid_size, (vm_address_t)new_ptr))
+#endif
+	{
 		memcpy(new_ptr, ptr, valid_size);
 	}
 	szone_free(szone, ptr);
 
 #if DEBUG_MALLOC
 	if (LOG(szone, ptr)) {
-		malloc_printf("szone_realloc returned %p for %d\n", new_ptr, (unsigned)new_size);
+		malloc_report(ASL_LEVEL_INFO, "szone_realloc returned %p for %d\n", new_ptr, (unsigned)new_size);
 	}
 #endif
 	return new_ptr;
@@ -835,98 +559,79 @@
 		return NULL;
 	}
 
-	// alignment is gauranteed a power of 2 at least as large as sizeof(void *), hence non-zero.
-	// Since size + alignment didn't wrap, 0 <= size + alignment - 1 < size + alignment
+	// alignment is a power of 2 at least as large as sizeof(void *), hence
+	// non-zero.  Since size + alignment didn't wrap, 0 <= size + alignment - 1
+	// < size + alignment
 	size_t span = size + alignment - 1;
 
 	if (alignment <= TINY_QUANTUM) {
-		return szone_malloc(szone, size); // Trivially satisfied by tiny, small, or large
-
-	} else if (span <= SMALL_THRESHOLD) {
+		// Trivially satisfied by tiny, small, medium, or large.
+		return szone_malloc(szone, size);
+	}
+	if (span <= TINY_LIMIT_THRESHOLD) {
 		return tiny_memalign(szone, alignment, size, span);
-
-	} else if (SMALL_THRESHOLD < size && alignment <= SMALL_QUANTUM) {
-		return szone_malloc(szone, size); // Trivially satisfied by small or large
-
-	} else if (span <= szone->large_threshold) {
+	}
+	if (TINY_LIMIT_THRESHOLD < size && alignment <= SMALL_QUANTUM) {
+		// Trivially satisfied by small, medium or large.
+		return szone_malloc(szone, size);
+	}
+	if (size <= TINY_LIMIT_THRESHOLD) {
+		// The allocation asked for a size that TINY would normally fulfill
+		// but it cannot guarantee the alignment. So bump it up to fit inside
+		// SMALL and try again.
+		size = TINY_LIMIT_THRESHOLD + TINY_QUANTUM;
+		span = size + alignment - 1;
+	}
+	if (span <= SMALL_LIMIT_THRESHOLD) {
 		return small_memalign(szone, alignment, size, span);
-
-	} else if (szone->large_threshold < size && alignment <= vm_page_quanta_size) {
-		return szone_malloc(szone, size); // Trivially satisfied by large
-
+	}
+#if CONFIG_MEDIUM_ALLOCATOR
+	if (szone->is_medium_engaged) {
+		if (size <= SMALL_LIMIT_THRESHOLD) {
+			size = SMALL_LIMIT_THRESHOLD + SMALL_QUANTUM;
+			span = size + alignment - 1;
+		}
+		if (szone->is_medium_engaged && span <= MEDIUM_LIMIT_THRESHOLD) {
+			return medium_memalign(szone, alignment, size, span);
+		}
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
+	if (LARGE_THRESHOLD(szone) < size && alignment <= vm_page_quanta_size) {
+		// Trivially satisfied by large (which rounds to a whole page).
+		return szone_malloc(szone, size);
+	}
+	// ensure block allocated by large does not have a small-possible size
+	size_t num_kernel_pages = round_large_page_quanta(MAX(LARGE_THRESHOLD(szone) + 1,
+			size)) >> large_vm_page_quanta_shift;
+	if (num_kernel_pages == 0) { /* Overflowed */
+		return NULL;
 	} else {
-		// ensure block allocated by large does not have a small-possible size
-		size_t num_kernel_pages = round_page_quanta(MAX(szone->large_threshold + 1, size)) >> vm_page_quanta_shift;
-		void *p;
-
-		if (num_kernel_pages == 0) { /* Overflowed */
-			p = NULL;
-		} else {
-			p = large_malloc(szone, num_kernel_pages, MAX(vm_page_quanta_shift, __builtin_ctz((unsigned)alignment)), 0);
-		}
-
-		return p;
+		return large_malloc(szone, num_kernel_pages,
+				MAX(vm_page_quanta_shift, __builtin_ctz((unsigned)alignment)), 0);
 	}
 	/* NOTREACHED */
-}
-
-// given a size, returns the number of pointers allocated capable of holding
+	__builtin_unreachable();
+}
+
+// Given a size, returns the number of pointers allocated capable of holding
 // that size, up to the limit specified by the 'count' argument.  These pointers
 // are stored in the 'results' array, which must be allocated by the caller.
-// may return zero, since this function is only a best attempt at allocating
-// the pointers.  clients should be prepared to call malloc for any additional
+// May return zero, since this function is only a best attempt at allocating
+// the pointers. Clients should be prepared to call malloc for any additional
 // blocks they need.
 unsigned
 szone_batch_malloc(szone_t *szone, size_t size, void **results, unsigned count)
 {
-	msize_t msize = TINY_MSIZE_FOR_BYTES(size + TINY_QUANTUM - 1);
-	unsigned found = 0;
-	mag_index_t mag_index = mag_get_thread_index(szone);
-	magazine_t *tiny_mag_ptr = &(szone->tiny_magazines[mag_index]);
-
 	// only bother implementing this for tiny
-	if (size > SMALL_THRESHOLD) {
-		return 0;
-	}
-	// make sure to return objects at least one quantum in size
-	if (!msize) {
-		msize = 1;
-	}
-
-	CHECK(szone, __PRETTY_FUNCTION__);
-
-	// We must lock the zone now, since tiny_malloc_from_free_list assumes that
-	// the caller has done so.
-	SZONE_MAGAZINE_PTR_LOCK(szone, tiny_mag_ptr);
-
-	// with the zone locked, allocate objects from the free list until all
-	// sufficiently large objects have been exhausted, or we have met our quota
-	// of objects to allocate.
-	while (found < count) {
-		void *ptr = tiny_malloc_from_free_list(szone, tiny_mag_ptr, mag_index, msize);
-		if (!ptr) {
-			break;
-		}
-
-		*results++ = ptr;
-		found++;
-	}
-	SZONE_MAGAZINE_PTR_UNLOCK(szone, tiny_mag_ptr);
-	return found;
-}
-
-/* Try caching the tiny_region and checking if the next ptr hits there. */
+	if (size <= TINY_LIMIT_THRESHOLD) {
+		return tiny_batch_malloc(szone, size, results, count);
+	}
+	return 0;
+}
+
 void
 szone_batch_free(szone_t *szone, void **to_be_freed, unsigned count)
 {
-	unsigned cc = 0;
-	void *ptr;
-	region_t tiny_region = NULL;
-	boolean_t is_free;
-	msize_t msize;
-	magazine_t *tiny_mag_ptr = NULL;
-	mag_index_t mag_index = -1;
-
 	// frees all the pointers in to_be_freed
 	// note that to_be_freed may be overwritten during the process
 	if (!count) {
@@ -934,54 +639,14 @@
 	}
 
 	CHECK(szone, __PRETTY_FUNCTION__);
-	while (cc < count) {
-		ptr = to_be_freed[cc];
-		if (ptr) {
-			if (NULL == tiny_region || tiny_region != TINY_REGION_FOR_PTR(ptr)) { // region same as last iteration?
-				if (tiny_mag_ptr) {												  // non-NULL iff magazine lock taken
-					SZONE_MAGAZINE_PTR_UNLOCK(szone, tiny_mag_ptr);
-					tiny_mag_ptr = NULL;
-				}
-
-				tiny_region = tiny_region_for_ptr_no_lock(szone, ptr);
-
-				if (tiny_region) {
-					tiny_mag_ptr = mag_lock_zine_for_region_trailer(szone, szone->tiny_magazines,
-							REGION_TRAILER_FOR_TINY_REGION(tiny_region), MAGAZINE_INDEX_FOR_TINY_REGION(tiny_region));
-					mag_index = MAGAZINE_INDEX_FOR_TINY_REGION(tiny_region);
-				}
-			}
-			if (tiny_region) {
-				// this is a tiny pointer
-				if (TINY_INDEX_FOR_PTR(ptr) >= NUM_TINY_BLOCKS) {
-					break; // pointer to metadata; let the standard free deal with it
-				}
-				msize = get_tiny_meta_header(ptr, &is_free);
-				if (is_free) {
-					break; // a double free; let the standard free deal with it
-				}
-				if (!tiny_free_no_lock(szone, tiny_mag_ptr, mag_index, tiny_region, ptr, msize)) {
-					// Arrange to re-acquire magazine lock
-					tiny_mag_ptr = NULL;
-					tiny_region = NULL;
-				}
-				to_be_freed[cc] = NULL;
-			} else {
-				// No region in this zone claims ptr; let the standard free deal with it
-				break;
-			}
-		}
-		cc++;
-	}
-
-	if (tiny_mag_ptr) {
-		SZONE_MAGAZINE_PTR_UNLOCK(szone, tiny_mag_ptr);
-		tiny_mag_ptr = NULL;
-	}
+
+	// We only support batch malloc in tiny. Let it free all of the pointers
+	// that belong to it, then let the standard free deal with the rest.
+	tiny_batch_free(szone, to_be_freed, count);
 
 	CHECK(szone, __PRETTY_FUNCTION__);
 	while (count--) {
-		ptr = to_be_freed[count];
+		void *ptr = to_be_freed[count];
 		if (ptr) {
 			szone_free(szone, ptr);
 		}
@@ -997,34 +662,36 @@
 	vm_range_t range_to_deallocate;
 
 #if CONFIG_LARGE_CACHE
-	SZONE_LOCK(szone);
-
-	/* disable any memory pressure responder */
-	szone->flotsam_enabled = FALSE;
-
-	// stack allocated copy of the death-row cache
-	int idx = szone->large_entry_cache_oldest, idx_max = szone->large_entry_cache_newest;
-	large_entry_t local_entry_cache[LARGE_ENTRY_CACHE_SIZE];
-
-	memcpy((void *)local_entry_cache, (void *)szone->large_entry_cache, sizeof(local_entry_cache));
-
-	szone->large_entry_cache_oldest = szone->large_entry_cache_newest = 0;
-	szone->large_entry_cache[0].address = 0x0;
-	szone->large_entry_cache[0].size = 0;
-	szone->large_entry_cache_bytes = 0;
-	szone->large_entry_cache_reserve_bytes = 0;
-
-	SZONE_UNLOCK(szone);
-
-	// deallocate the death-row cache outside the zone lock
-	while (idx != idx_max) {
-		deallocate_pages(szone, (void *)local_entry_cache[idx].address, local_entry_cache[idx].size, 0);
-		if (++idx == LARGE_ENTRY_CACHE_SIZE) {
-			idx = 0;
-		}
-	}
-	if (0 != local_entry_cache[idx].address && 0 != local_entry_cache[idx].size) {
-		deallocate_pages(szone, (void *)local_entry_cache[idx].address, local_entry_cache[idx].size, 0);
+	if (large_cache_enabled) {
+		SZONE_LOCK(szone);
+
+		/* disable any memory pressure responder */
+		szone->flotsam_enabled = FALSE;
+
+		// stack allocated copy of the death-row cache
+		int idx = szone->large_entry_cache_oldest, idx_max = szone->large_entry_cache_newest;
+		large_entry_t local_entry_cache[LARGE_ENTRY_CACHE_SIZE_HIGH];
+
+		memcpy((void *)local_entry_cache, (void *)szone->large_entry_cache, sizeof(local_entry_cache));
+
+		szone->large_entry_cache_oldest = szone->large_entry_cache_newest = 0;
+		szone->large_entry_cache[0].address = 0x0;
+		szone->large_entry_cache[0].size = 0;
+		szone->large_entry_cache_bytes = 0;
+		szone->large_entry_cache_reserve_bytes = 0;
+
+		SZONE_UNLOCK(szone);
+
+		// deallocate the death-row cache outside the zone lock
+		while (idx != idx_max) {
+			mvm_deallocate_pages((void *)local_entry_cache[idx].address, local_entry_cache[idx].size, szone->debug_flags);
+			if (++idx == szone->large_cache_depth) {
+				idx = 0;
+			}
+		}
+		if (0 != local_entry_cache[idx].address && 0 != local_entry_cache[idx].size) {
+			mvm_deallocate_pages((void *)local_entry_cache[idx].address, local_entry_cache[idx].size, szone->debug_flags);
+		}
 	}
 #endif
 
@@ -1034,44 +701,30 @@
 		large = szone->large_entries + index;
 		if (large->address) {
 			// we deallocate_pages, including guard pages
-			deallocate_pages(szone, (void *)(large->address), large->size, szone->debug_flags);
+			mvm_deallocate_pages((void *)(large->address), large->size, szone->debug_flags);
 		}
 	}
 	large_entries_free_no_lock(szone, szone->large_entries, szone->num_large_entries, &range_to_deallocate);
 	if (range_to_deallocate.size) {
-		deallocate_pages(szone, (void *)range_to_deallocate.address, (size_t)range_to_deallocate.size, 0);
-	}
-
-	/* destroy tiny regions */
-	for (index = 0; index < szone->tiny_region_generation->num_regions_allocated; ++index) {
-		if ((HASHRING_OPEN_ENTRY != szone->tiny_region_generation->hashed_regions[index]) &&
-				(HASHRING_REGION_DEALLOCATED != szone->tiny_region_generation->hashed_regions[index])) {
-			deallocate_pages(szone, szone->tiny_region_generation->hashed_regions[index], TINY_REGION_SIZE, 0);
-		}
-	}
-
-	/* destroy small regions */
-	for (index = 0; index < szone->small_region_generation->num_regions_allocated; ++index) {
-		if ((HASHRING_OPEN_ENTRY != szone->small_region_generation->hashed_regions[index]) &&
-				(HASHRING_REGION_DEALLOCATED != szone->small_region_generation->hashed_regions[index])) {
-			deallocate_pages(szone, szone->small_region_generation->hashed_regions[index], SMALL_REGION_SIZE, 0);
-		}
-	}
-
-	/* destroy region hash rings, if any */
-	if (szone->tiny_region_generation->hashed_regions != szone->initial_tiny_regions) {
-		size_t size = round_page_quanta(szone->tiny_region_generation->num_regions_allocated * sizeof(region_t));
-		deallocate_pages(szone, szone->tiny_region_generation->hashed_regions, size, 0);
-	}
-	if (szone->small_region_generation->hashed_regions != szone->initial_small_regions) {
-		size_t size = round_page_quanta(szone->small_region_generation->num_regions_allocated * sizeof(region_t));
-		deallocate_pages(szone, szone->small_region_generation->hashed_regions, size, 0);
-	}
-
-	/* Now destroy the separate szone region */
-	deallocate_pages(szone, (void *)&(szone->tiny_magazines[-1]), TINY_MAGAZINE_PAGED_SIZE, MALLOC_ADD_GUARD_PAGES);
-	deallocate_pages(szone, (void *)&(szone->small_magazines[-1]), SMALL_MAGAZINE_PAGED_SIZE, MALLOC_ADD_GUARD_PAGES);
-	deallocate_pages(szone, (void *)szone, SZONE_PAGED_SIZE, 0);
+		mvm_deallocate_pages((void *)range_to_deallocate.address, (size_t)range_to_deallocate.size, szone->debug_flags);
+	}
+
+	/* destroy allocator regions */
+	rack_destroy_regions(&szone->tiny_rack, TINY_REGION_SIZE);
+	rack_destroy_regions(&szone->small_rack, SMALL_REGION_SIZE);
+
+	/* destroy rack region hash rings and racks themselves */
+	rack_destroy(&szone->tiny_rack);
+	rack_destroy(&szone->small_rack);
+
+#if CONFIG_MEDIUM_ALLOCATOR
+	if (szone->is_medium_engaged) {
+		rack_destroy_regions(&szone->medium_rack, MEDIUM_REGION_SIZE);
+		rack_destroy(&szone->medium_rack);
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
+
+	mvm_deallocate_pages((void *)szone, SZONE_PAGED_SIZE, 0);
 }
 
 size_t
@@ -1080,7 +733,7 @@
 	msize_t msize;
 
 	// Find a good size for this tiny allocation.
-	if (size <= SMALL_THRESHOLD) {
+	if (size <= TINY_LIMIT_THRESHOLD) {
 		msize = TINY_MSIZE_FOR_BYTES(size + TINY_QUANTUM - 1);
 		if (!msize) {
 			msize = 1;
@@ -1089,7 +742,7 @@
 	}
 
 	// Find a good size for this small allocation.
-	if (size <= szone->large_threshold) {
+	if (size <= SMALL_LIMIT_THRESHOLD) {
 		msize = SMALL_MSIZE_FOR_BYTES(size + SMALL_QUANTUM - 1);
 		if (!msize) {
 			msize = 1;
@@ -1097,9 +750,19 @@
 		return SMALL_BYTES_FOR_MSIZE(msize);
 	}
 
+#if CONFIG_MEDIUM_ALLOCATOR
+	if (szone->is_medium_engaged && size <= MEDIUM_LIMIT_THRESHOLD) {
+		msize = MEDIUM_MSIZE_FOR_BYTES(size + MEDIUM_QUANTUM - 1);
+		if (!msize) {
+			msize = 1;
+		}
+		return MEDIUM_BYTES_FOR_MSIZE(msize);
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
+
 	// Check for integer overflow on the size, since unlike the two cases above,
 	// there is no upper bound on allocation size at this point.
-	if (size > round_page_quanta(size)) {
+	if (size > round_large_page_quanta(size)) {
 		return (size_t)(-1LL);
 	}
 
@@ -1108,10 +771,22 @@
 	// failed to catch a request for zero bytes in the tiny check, or the size
 	// overflowed to zero during some arithmetic.
 	if (size == 0) {
-		malloc_printf("szone_good_size() invariant broken %y\n", size);
-	}
-#endif
-	return round_page_quanta(size);
+		malloc_report(ASL_LEVEL_INFO, "szone_good_size() invariant broken %y\n", size);
+	}
+#endif
+	return round_large_page_quanta(size);
+}
+
+boolean_t
+szone_claimed_address(szone_t *szone, void *ptr)
+{
+	return tiny_claimed_address(&szone->tiny_rack, ptr)
+			|| small_claimed_address(&szone->small_rack, ptr)
+#if CONFIG_MEDIUM_ALLOCATOR
+			|| (szone->is_medium_engaged &&
+					medium_claimed_address(&szone->medium_rack, ptr))
+#endif // CONFIG_MEDIUM_ALLOCATOR
+			|| large_claimed_address(szone, ptr);
 }
 
 unsigned szone_check_counter = 0;
@@ -1124,70 +799,95 @@
 	size_t index;
 
 	/* check tiny regions - chould check region count */
-	for (index = 0; index < szone->tiny_region_generation->num_regions_allocated; ++index) {
-		region_t tiny = szone->tiny_region_generation->hashed_regions[index];
+	for (index = 0; index < szone->tiny_rack.region_generation->num_regions_allocated; ++index) {
+		region_t tiny = szone->tiny_rack.region_generation->hashed_regions[index];
 
 		if (HASHRING_REGION_DEALLOCATED == tiny) {
 			continue;
 		}
 
 		if (tiny) {
-			magazine_t *tiny_mag_ptr = mag_lock_zine_for_region_trailer(
-					szone, szone->tiny_magazines, REGION_TRAILER_FOR_TINY_REGION(tiny), MAGAZINE_INDEX_FOR_TINY_REGION(tiny));
-
-			if (!tiny_check_region(szone, tiny)) {
-				SZONE_MAGAZINE_PTR_UNLOCK(szone, tiny_mag_ptr);
+			magazine_t *tiny_mag_ptr = mag_lock_zine_for_region_trailer(szone->tiny_rack.magazines,
+					REGION_TRAILER_FOR_TINY_REGION(tiny),
+					MAGAZINE_INDEX_FOR_TINY_REGION(tiny));
+
+			if (!tiny_check_region(&szone->tiny_rack, tiny, index, szone_check_counter)) {
+				SZONE_MAGAZINE_PTR_UNLOCK(tiny_mag_ptr);
 				szone->debug_flags &= ~CHECK_REGIONS;
-				szone_error(szone, 1, "check: tiny region incorrect", NULL,
-						"*** tiny region %ld incorrect szone_check_all(%s) counter=%d\n", index, function, szone_check_counter);
 				return 0;
 			}
-			SZONE_MAGAZINE_PTR_UNLOCK(szone, tiny_mag_ptr);
+			SZONE_MAGAZINE_PTR_UNLOCK(tiny_mag_ptr);
 		}
 	}
 	/* check tiny free lists */
 	for (index = 0; index < NUM_TINY_SLOTS; ++index) {
-		if (!tiny_free_list_check(szone, (grain_t)index)) {
+		if (!tiny_free_list_check(&szone->tiny_rack, (grain_t)index, szone_check_counter)) {
 			szone->debug_flags &= ~CHECK_REGIONS;
-			szone_error(szone, 1, "check: tiny free list incorrect", NULL,
-					"*** tiny free list incorrect (slot=%ld) szone_check_all(%s) counter=%d\n", index, function,
-					szone_check_counter);
 			return 0;
 		}
 	}
 
 	/* check small regions - could check region count */
-	for (index = 0; index < szone->small_region_generation->num_regions_allocated; ++index) {
-		region_t small = szone->small_region_generation->hashed_regions[index];
+	for (index = 0; index < szone->small_rack.region_generation->num_regions_allocated; ++index) {
+		region_t small = szone->small_rack.region_generation->hashed_regions[index];
 
 		if (HASHRING_REGION_DEALLOCATED == small) {
 			continue;
 		}
 
 		if (small) {
-			magazine_t *small_mag_ptr = mag_lock_zine_for_region_trailer(
-					szone, szone->small_magazines, REGION_TRAILER_FOR_SMALL_REGION(small), MAGAZINE_INDEX_FOR_SMALL_REGION(small));
-
-			if (!small_check_region(szone, small)) {
-				SZONE_MAGAZINE_PTR_UNLOCK(szone, small_mag_ptr);
+			magazine_t *small_mag_ptr = mag_lock_zine_for_region_trailer(szone->small_rack.magazines,
+					REGION_TRAILER_FOR_SMALL_REGION(small),
+					MAGAZINE_INDEX_FOR_SMALL_REGION(small));
+
+			if (!small_check_region(&szone->small_rack, small, index, szone_check_counter)) {
+				SZONE_MAGAZINE_PTR_UNLOCK(small_mag_ptr);
 				szone->debug_flags &= ~CHECK_REGIONS;
-				szone_error(szone, 1, "check: small region incorrect", NULL,
-						"*** small region %ld incorrect szone_check_all(%s) counter=%d\n", index, function, szone_check_counter);
 				return 0;
 			}
-			SZONE_MAGAZINE_PTR_UNLOCK(szone, small_mag_ptr);
+			SZONE_MAGAZINE_PTR_UNLOCK(small_mag_ptr);
 		}
 	}
 	/* check small free lists */
-	for (index = 0; index < szone->num_small_slots; ++index) {
-		if (!small_free_list_check(szone, (grain_t)index)) {
+	for (index = 0; index < SMALL_FREE_SLOT_COUNT(&szone->small_rack); ++index) {
+		if (!small_free_list_check(&szone->small_rack, (grain_t)index, szone_check_counter)) {
 			szone->debug_flags &= ~CHECK_REGIONS;
-			szone_error(szone, 1, "check: small free list incorrect", NULL,
-					"*** small free list incorrect (slot=%ld) szone_check_all(%s) counter=%d\n", index, function,
-					szone_check_counter);
 			return 0;
 		}
 	}
+
+#if CONFIG_MEDIUM_ALLOCATOR
+	if (szone->is_medium_engaged) {
+		/* check medium regions - could check region count */
+		for (index = 0; index < szone->medium_rack.region_generation->num_regions_allocated; ++index) {
+			region_t medium = szone->medium_rack.region_generation->hashed_regions[index];
+
+			if (HASHRING_REGION_DEALLOCATED == medium) {
+				continue;
+			}
+
+			if (medium) {
+				magazine_t *medium_mag_ptr = mag_lock_zine_for_region_trailer(szone->medium_rack.magazines,
+						REGION_TRAILER_FOR_MEDIUM_REGION(medium),
+						MAGAZINE_INDEX_FOR_MEDIUM_REGION(medium));
+
+				if (!medium_check_region(&szone->medium_rack, medium, index, szone_check_counter)) {
+					SZONE_MAGAZINE_PTR_UNLOCK(medium_mag_ptr);
+					szone->debug_flags &= ~CHECK_REGIONS;
+					return 0;
+				}
+				SZONE_MAGAZINE_PTR_UNLOCK(medium_mag_ptr);
+			}
+		}
+		/* check medium free lists */
+		for (index = 0; index < MEDIUM_FREE_SLOT_COUNT(&szone->medium_rack); ++index) {
+			if (!medium_free_list_check(&szone->medium_rack, (grain_t)index, szone_check_counter)) {
+				szone->debug_flags &= ~CHECK_REGIONS;
+				return 0;
+			}
+		}
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
 
 	return 1;
 }
@@ -1196,7 +896,7 @@
 szone_check(szone_t *szone)
 {
 	if ((++szone_check_counter % 10000) == 0) {
-		_malloc_printf(ASL_LEVEL_NOTICE, "at szone_check counter=%d\n", szone_check_counter);
+		malloc_report(ASL_LEVEL_NOTICE, "at szone_check counter=%d\n", szone_check_counter);
 	}
 
 	if (szone_check_counter < szone_check_start) {
@@ -1222,7 +922,7 @@
 	kern_return_t err;
 
 	if (!reader) {
-		reader = _szone_default_reader;
+		reader = _malloc_default_reader;
 	}
 
 	err = reader(task, zone_address, sizeof(szone_t), (void **)&szone);
@@ -1240,14 +940,23 @@
 		return err;
 	}
 
+#if CONFIG_MEDIUM_ALLOCATOR
+	if (szone->is_medium_engaged) {
+		err = medium_in_use_enumerator(task, context, type_mask, szone, reader, recorder);
+		if (err) {
+			return err;
+		}
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
+
 	err = large_in_use_enumerator(
 			task, context, type_mask, (vm_address_t)szone->large_entries, szone->num_large_entries, reader, recorder);
 	return err;
 }
 
-// Following method is deprecated:  use scalable_zone_statistics instead
-void
-scalable_zone_info(malloc_zone_t *zone, unsigned *info_to_fill, unsigned count)
+static boolean_t
+scalable_zone_info_task(task_t task, memory_reader_t reader,
+		malloc_zone_t *zone, unsigned *info_to_fill, unsigned count)
 {
 	szone_t *szone = (void *)zone;
 	unsigned info[13];
@@ -1259,21 +968,30 @@
 	size_t u = 0;
 	mag_index_t mag_index;
 
-	for (mag_index = -1; mag_index < szone->num_tiny_magazines; mag_index++) {
-		s += szone->tiny_magazines[mag_index].mag_bytes_free_at_start;
-		s += szone->tiny_magazines[mag_index].mag_bytes_free_at_end;
-		t += szone->tiny_magazines[mag_index].mag_num_objects;
-		u += szone->tiny_magazines[mag_index].mag_num_bytes_in_objects;
+	magazine_t *mapped_magazines;
+	if (reader(task, (vm_address_t)szone->tiny_rack.magazines,
+			sizeof(magazine_t), (void **)&mapped_magazines)) {
+		return false;
+	}
+	for (mag_index = -1; mag_index < szone->tiny_rack.num_magazines; mag_index++) {
+		s += mapped_magazines[mag_index].mag_bytes_free_at_start;
+		s += mapped_magazines[mag_index].mag_bytes_free_at_end;
+		t += mapped_magazines[mag_index].mag_num_objects;
+		u += mapped_magazines[mag_index].mag_num_bytes_in_objects;
 	}
 
 	info[4] = (unsigned)t;
 	info[5] = (unsigned)u;
 
-	for (t = 0, u = 0, mag_index = -1; mag_index < szone->num_small_magazines; mag_index++) {
-		s += szone->small_magazines[mag_index].mag_bytes_free_at_start;
-		s += szone->small_magazines[mag_index].mag_bytes_free_at_end;
-		t += szone->small_magazines[mag_index].mag_num_objects;
-		u += szone->small_magazines[mag_index].mag_num_bytes_in_objects;
+	if (reader(task, (vm_address_t)szone->small_rack.magazines,
+			sizeof(magazine_t), (void **)&mapped_magazines)) {
+		return false;
+	}
+	for (t = 0, u = 0, mag_index = -1; mag_index < szone->small_rack.num_magazines; mag_index++) {
+		s += mapped_magazines[mag_index].mag_bytes_free_at_start;
+		s += mapped_magazines[mag_index].mag_bytes_free_at_end;
+		t += mapped_magazines[mag_index].mag_num_objects;
+		u += mapped_magazines[mag_index].mag_num_bytes_in_objects;
 	}
 
 	info[6] = (unsigned)t;
@@ -1290,69 +1008,271 @@
 	info[0] = info[4] + info[6] + info[8] + info[10];
 	info[1] = info[5] + info[7] + info[9] + info[11];
 
-	info[3] = (unsigned)(szone->num_tiny_regions - szone->num_tiny_regions_dealloc) * TINY_REGION_SIZE +
-			  (unsigned)(szone->num_small_regions - szone->num_small_regions_dealloc) * SMALL_REGION_SIZE + info[9] + info[11];
+	info[3] = (unsigned)(szone->tiny_rack.num_regions - szone->tiny_rack.num_regions_dealloc) * TINY_REGION_SIZE +
+			  (unsigned)(szone->small_rack.num_regions - szone->small_rack.num_regions_dealloc) * SMALL_REGION_SIZE + info[9] + info[11];
 
 	info[2] = info[3] - (unsigned)s;
 	memcpy(info_to_fill, info, sizeof(unsigned) * count);
+
+	return true;
+}
+
+// Following method is deprecated:  use scalable_zone_statistics instead
+// Required for backward compatibility.
+void
+scalable_zone_info(malloc_zone_t *zone, unsigned *info_to_fill, unsigned count) {
+	scalable_zone_info_task(mach_task_self(), _malloc_default_reader, zone,
+			info_to_fill, count);
 }
 
 // FIXME: consistent picture requires locking!
 static MALLOC_NOINLINE void
-szone_print(szone_t *szone, boolean_t verbose)
+szone_print(task_t task, unsigned level, vm_address_t zone_address,
+		memory_reader_t reader, print_task_printer_t printer)
 {
 	unsigned info[13];
 	size_t index;
 	region_t region;
-
-	scalable_zone_info((void *)szone, info, 13);
-	_malloc_printf(MALLOC_PRINTF_NOLOG | MALLOC_PRINTF_NOPREFIX,
-			"Scalable zone %p: inUse=%u(%y) touched=%y allocated=%y flags=%d\n", szone, info[0], info[1], info[2], info[3],
-			info[12]);
-	_malloc_printf(MALLOC_PRINTF_NOLOG | MALLOC_PRINTF_NOPREFIX, "\ttiny=%u(%y) small=%u(%y) large=%u(%y) huge=%u(%y)\n", info[4],
-			info[5], info[6], info[7], info[8], info[9], info[10], info[11]);
+	region_t mapped_region;
+
+	szone_t *szone = (szone_t *)zone_address;
+	szone_t *mapped_szone;
+	if (reader(task, zone_address, sizeof(szone_t), (void **)&mapped_szone)) {
+		printer("Failed to read szone structure\n");
+		return;
+	}
+
+	if (!scalable_zone_info_task(task, reader, (void *)mapped_szone, info, 13)) {
+		printer("Failed to get scalable zone info\n");
+		return;
+	}
+	printer("Scalable zone %p: inUse=%u(%u) touched=%u allocated=%u flags=0x%x\n",
+			zone_address, info[0], info[1], info[2], info[3], info[12]);
+	printer("\ttiny=%u(%u) small=%u(%u) large=%u(%u)\n", info[4],
+			info[5], info[6], info[7], info[8], info[9]);
 	// tiny
-	_malloc_printf(MALLOC_PRINTF_NOLOG | MALLOC_PRINTF_NOPREFIX, "%lu tiny regions:\n", szone->num_tiny_regions);
-	if (szone->num_tiny_regions_dealloc) {
-		_malloc_printf(MALLOC_PRINTF_NOLOG | MALLOC_PRINTF_NOPREFIX, "[%lu tiny regions have been vm_deallocate'd]\n",
-				szone->num_tiny_regions_dealloc);
-	}
-	for (index = 0; index < szone->tiny_region_generation->num_regions_allocated; ++index) {
-		region = szone->tiny_region_generation->hashed_regions[index];
+	printer("%lu tiny regions:\n", mapped_szone->tiny_rack.num_regions);
+	if (mapped_szone->tiny_rack.num_regions_dealloc) {
+		printer("[%lu tiny regions have been vm_deallocate'd]\n",
+				mapped_szone->tiny_rack.num_regions_dealloc);
+	}
+
+	region_hash_generation_t *mapped_region_generation;
+	region_t *mapped_hashed_regions;
+	magazine_t *mapped_magazines;
+	if (reader(task, (vm_address_t)mapped_szone->tiny_rack.region_generation,
+			sizeof(region_hash_generation_t), (void **)&mapped_region_generation)) {
+		printer("Failed to map tiny rack region_generation\n");
+		return;
+	}
+	if (reader(task, (vm_address_t)mapped_region_generation->hashed_regions,
+			sizeof(region_t), (void **)&mapped_hashed_regions)) {
+		printer("Failed to map tiny rack hashed_regions\n");
+		return;
+	}
+	if (reader(task, (vm_address_t)mapped_szone->tiny_rack.magazines,
+			mapped_szone->tiny_rack.num_magazines * sizeof(magazine_t),
+			(void **)&mapped_magazines)) {
+		printer("Failed to map tiny rack magazines\n");
+		return;
+	}
+
+	int recirc_regions = 0;
+	for (index = 0; index < mapped_region_generation->num_regions_allocated; ++index) {
+		region = mapped_hashed_regions[index];
 		if (HASHRING_OPEN_ENTRY != region && HASHRING_REGION_DEALLOCATED != region) {
-			mag_index_t mag_index = MAGAZINE_INDEX_FOR_TINY_REGION(region);
-			print_tiny_region(verbose, region, (region == szone->tiny_magazines[mag_index].mag_last_region)
-													   ? szone->tiny_magazines[mag_index].mag_bytes_free_at_start
-													   : 0,
-					(region == szone->tiny_magazines[mag_index].mag_last_region)
-							? szone->tiny_magazines[mag_index].mag_bytes_free_at_end
+			if (reader(task, (vm_address_t)region, sizeof(struct tiny_region),
+					(void **)&mapped_region)) {
+				printer("Failed to map region %p\n", region);
+				return;
+			}
+			mag_index_t mag_index = MAGAZINE_INDEX_FOR_TINY_REGION(mapped_region);
+			if (mag_index == DEPOT_MAGAZINE_INDEX) {
+				recirc_regions++;
+			}
+			print_tiny_region(task, reader, printer, level, region,
+					(region == mapped_magazines[mag_index].mag_last_region)
+						? mapped_magazines[mag_index].mag_bytes_free_at_start
+						: 0,
+					(region == mapped_magazines[mag_index].mag_last_region)
+						? mapped_magazines[mag_index].mag_bytes_free_at_end
+						: 0);
+		}
+	}
+
+#if CONFIG_RECIRC_DEPOT
+	magazine_t *mapped_recirc_depot = &mapped_magazines[DEPOT_MAGAZINE_INDEX];
+	if (mapped_recirc_depot->mag_num_bytes_in_objects) {
+		printer("Tiny recirc depot: total bytes: %llu, in-use bytes: %llu, "
+				"allocations: %llu, regions: %d (min # retained regions: %d)\n",
+				mapped_recirc_depot->num_bytes_in_magazine,
+				mapped_recirc_depot->mag_num_bytes_in_objects,
+				mapped_recirc_depot->mag_num_objects, recirc_regions,
+				recirc_retained_regions);
+	} else {
+		printer("Tiny recirc depot is empty\n");
+	}
+#else // CONFIG_RECIRC_DEPOT
+	printer("Tiny recirc depot not configured\n");
+#endif // CONFIG_RECIRC_DEPOT
+
+	if (level > 0) {
+		print_tiny_free_list(task, reader, printer, &szone->tiny_rack);
+	}
+
+	// small
+	printer("%lu small regions:\n", mapped_szone->small_rack.num_regions);
+	if (mapped_szone->small_rack.num_regions_dealloc) {
+		printer("[%lu small regions have been vm_deallocate'd]\n",
+				mapped_szone->small_rack.num_regions_dealloc);
+	}
+	if (reader(task, (vm_address_t)mapped_szone->small_rack.region_generation,
+			sizeof(region_hash_generation_t), (void **)&mapped_region_generation)) {
+		printer("Failed to map small rack region_generation\n");
+		return;
+	}
+	if (reader(task, (vm_address_t)mapped_region_generation->hashed_regions,
+			sizeof(region_t), (void **)&mapped_hashed_regions)) {
+		printer("Failed to map small rack hashed_regions\n");
+		return;
+	}
+	if (reader(task, (vm_address_t)mapped_szone->small_rack.magazines,
+			mapped_szone->small_rack.num_magazines * sizeof(magazine_t),
+			(void **)&mapped_magazines)) {
+		printer("Failed to map small rack magazines\n");
+		return;
+	}
+
+	recirc_regions = 0;
+	for (index = 0; index < mapped_region_generation->num_regions_allocated; ++index) {
+		region = mapped_hashed_regions[index];
+		if (HASHRING_OPEN_ENTRY != region && HASHRING_REGION_DEALLOCATED != region) {
+			if (reader(task, (vm_address_t)region, sizeof(struct small_region),
+					(void **)&mapped_region)) {
+				printer("Failed to map region %p\n", region);
+				return;
+			}
+			mag_index_t mag_index = MAGAZINE_INDEX_FOR_SMALL_REGION(mapped_region);
+			if (mag_index == DEPOT_MAGAZINE_INDEX) {
+				recirc_regions++;
+			}
+			print_small_region(task, reader, printer, mapped_szone, level, region,
+					(region == mapped_magazines[mag_index].mag_last_region)
+						? mapped_magazines[mag_index].mag_bytes_free_at_start
+						: 0,
+					(region == mapped_magazines[mag_index].mag_last_region)
+						? mapped_magazines[mag_index].mag_bytes_free_at_end
+						: 0);
+		}
+	}
+
+#if CONFIG_RECIRC_DEPOT
+	mapped_recirc_depot = &mapped_magazines[DEPOT_MAGAZINE_INDEX];
+	if (mapped_recirc_depot->mag_num_bytes_in_objects) {
+		printer("Small recirc depot: total bytes: %llu, in-use bytes: %llu, "
+				"allocations: %llu, regions: %d (min # retained regions: %d)\n",
+				mapped_recirc_depot->num_bytes_in_magazine,
+				mapped_recirc_depot->mag_num_bytes_in_objects,
+				mapped_recirc_depot->mag_num_objects, recirc_regions,
+				recirc_retained_regions);
+	} else {
+		printer("Small recirc depot is empty\n");
+	}
+#else // CONFIG_RECIRC_DEPOT
+	printer("Small recirc depot not configured\n");
+#endif // CONFIG_RECIRC_DEPOT
+
+	if (level > 0) {
+		print_small_free_list(task, reader, printer, &szone->small_rack);
+	}
+
+#if CONFIG_MEDIUM_ALLOCATOR
+	if (szone->is_medium_engaged) {
+		// medium
+		printer("%lu medium regions:\n", mapped_szone->medium_rack.num_regions);
+		if (mapped_szone->medium_rack.num_regions_dealloc) {
+			printer("[%lu medium regions have been vm_deallocate'd]\n",
+					mapped_szone->medium_rack.num_regions_dealloc);
+		}
+		if (reader(task, (vm_address_t)mapped_szone->medium_rack.region_generation,
+				sizeof(region_hash_generation_t), (void **)&mapped_region_generation)) {
+			printer("Failed to map medium rack region_generation\n");
+			return;
+		}
+		if (reader(task, (vm_address_t)mapped_region_generation->hashed_regions,
+				sizeof(region_t), (void **)&mapped_hashed_regions)) {
+			printer("Failed to map medium rack hashed_regions\n");
+			return;
+		}
+		if (reader(task, (vm_address_t)mapped_szone->medium_rack.magazines,
+				mapped_szone->medium_rack.num_magazines * sizeof(magazine_t),
+				(void **)&mapped_magazines)) {
+			printer("Failed to map medium rack magazines\n");
+			return;
+		}
+
+		recirc_regions = 0;
+		for (index = 0; index < mapped_region_generation->num_regions_allocated; ++index) {
+			region = mapped_hashed_regions[index];
+			if (HASHRING_OPEN_ENTRY != region && HASHRING_REGION_DEALLOCATED != region) {
+				if (reader(task, (vm_address_t)region, sizeof(struct medium_region),
+						(void **)&mapped_region)) {
+					printer("Failed to map region %p\n", region);
+					return;
+				}
+				mag_index_t mag_index = MAGAZINE_INDEX_FOR_MEDIUM_REGION(mapped_region);
+				if (mag_index == DEPOT_MAGAZINE_INDEX) {
+					recirc_regions++;
+				}
+				print_medium_region(task, reader, printer, mapped_szone, level,
+						region,
+						(region == mapped_magazines[mag_index].mag_last_region)
+							? mapped_magazines[mag_index].mag_bytes_free_at_start
+							: 0,
+						(region == mapped_magazines[mag_index].mag_last_region)
+							? mapped_magazines[mag_index].mag_bytes_free_at_end
 							: 0);
-		}
-	}
-	if (verbose) {
-		print_tiny_free_list(szone);
-	}
-	// small
-	_malloc_printf(MALLOC_PRINTF_NOLOG | MALLOC_PRINTF_NOPREFIX, "%lu small regions:\n", szone->num_small_regions);
-	if (szone->num_small_regions_dealloc) {
-		_malloc_printf(MALLOC_PRINTF_NOLOG | MALLOC_PRINTF_NOPREFIX, "[%lu small regions have been vm_deallocate'd]\n",
-				szone->num_small_regions_dealloc);
-	}
-	for (index = 0; index < szone->small_region_generation->num_regions_allocated; ++index) {
-		region = szone->small_region_generation->hashed_regions[index];
-		if (HASHRING_OPEN_ENTRY != region && HASHRING_REGION_DEALLOCATED != region) {
-			mag_index_t mag_index = MAGAZINE_INDEX_FOR_SMALL_REGION(region);
-			print_small_region(szone, verbose, region, (region == szone->small_magazines[mag_index].mag_last_region)
-															   ? szone->small_magazines[mag_index].mag_bytes_free_at_start
-															   : 0,
-					(region == szone->small_magazines[mag_index].mag_last_region)
-							? szone->small_magazines[mag_index].mag_bytes_free_at_end
-							: 0);
-		}
-	}
-	if (verbose) {
-		print_small_free_list(szone);
-	}
+			}
+		}
+
+#if CONFIG_RECIRC_DEPOT
+		mapped_recirc_depot = &mapped_magazines[DEPOT_MAGAZINE_INDEX];
+		if (mapped_recirc_depot->mag_num_bytes_in_objects) {
+			printer("Medium recirc depot: total bytes: %llu, in-use bytes: %llu, "
+					"allocations: %llu, regions: %d (min # retained regions: %d)\n",
+					mapped_recirc_depot->num_bytes_in_magazine,
+					mapped_recirc_depot->mag_num_bytes_in_objects,
+					mapped_recirc_depot->mag_num_objects, recirc_regions,
+					recirc_retained_regions);
+		} else {
+			printer("Medium recirc depot is empty\n");
+		}
+#else // CONFIG_RECIRC_DEPOT
+		printer("Medium recirc depot not configured\n");
+#endif // CONFIG_RECIRC_DEPOT
+
+		if (level > 0) {
+			print_medium_free_list(task, reader, printer, &szone->medium_rack);
+		}
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
+
+	// Large
+	large_debug_print(task, level, zone_address, reader, printer);
+}
+
+static void
+szone_print_self(szone_t *szone, boolean_t verbose)
+{
+	szone_print(mach_task_self(), verbose ? MALLOC_VERBOSE_PRINT_LEVEL : 0,
+			(vm_address_t)szone, _malloc_default_reader, malloc_report_simple);
+}
+
+static void
+szone_print_task(task_t task, unsigned level, vm_address_t zone_address,
+		memory_reader_t reader, print_task_printer_t printer)
+{
+	szone_print(task, level, zone_address, reader, printer);
 }
 
 static void
@@ -1369,12 +1289,12 @@
 szone_force_lock_magazine(szone_t *szone, magazine_t *mag)
 {
 	while (1) {
-		SZONE_MAGAZINE_PTR_LOCK(szone, mag);
+		SZONE_MAGAZINE_PTR_LOCK(mag);
 		if (!mag->alloc_underway) {
 			return;
 		}
 
-		SZONE_MAGAZINE_PTR_UNLOCK(szone, mag);
+		SZONE_MAGAZINE_PTR_UNLOCK(mag);
 		yield();
 	}
 }
@@ -1384,15 +1304,24 @@
 {
 	mag_index_t i;
 
-	for (i = 0; i < szone->num_tiny_magazines; ++i) {
-		szone_force_lock_magazine(szone, &szone->tiny_magazines[i]);
-	}
-	szone_force_lock_magazine(szone, &szone->tiny_magazines[DEPOT_MAGAZINE_INDEX]);
-
-	for (i = 0; i < szone->num_small_magazines; ++i) {
-		szone_force_lock_magazine(szone, &szone->small_magazines[i]);
-	}
-	szone_force_lock_magazine(szone, &szone->small_magazines[DEPOT_MAGAZINE_INDEX]);
+	for (i = 0; i < szone->tiny_rack.num_magazines; ++i) {
+		szone_force_lock_magazine(szone, &szone->tiny_rack.magazines[i]);
+	}
+	szone_force_lock_magazine(szone, &szone->tiny_rack.magazines[DEPOT_MAGAZINE_INDEX]);
+
+	for (i = 0; i < szone->small_rack.num_magazines; ++i) {
+		szone_force_lock_magazine(szone, &szone->small_rack.magazines[i]);
+	}
+	szone_force_lock_magazine(szone, &szone->small_rack.magazines[DEPOT_MAGAZINE_INDEX]);
+
+#if CONFIG_MEDIUM_ALLOCATOR
+	if (szone->is_medium_engaged) {
+		for (i = 0; i < szone->medium_rack.num_magazines; ++i) {
+			szone_force_lock_magazine(szone, &szone->medium_rack.magazines[i]);
+		}
+		szone_force_lock_magazine(szone, &szone->medium_rack.magazines[DEPOT_MAGAZINE_INDEX]);
+	}
+#endif
 
 	SZONE_LOCK(szone);
 }
@@ -1404,12 +1333,20 @@
 
 	SZONE_UNLOCK(szone);
 
-	for (i = -1; i < szone->num_small_magazines; ++i) {
-		SZONE_MAGAZINE_PTR_UNLOCK(szone, (&(szone->small_magazines[i])));
-	}
-
-	for (i = -1; i < szone->num_tiny_magazines; ++i) {
-		SZONE_MAGAZINE_PTR_UNLOCK(szone, (&(szone->tiny_magazines[i])));
+#if CONFIG_MEDIUM_ALLOCATOR
+	if (szone->is_medium_engaged) {
+		for (i = -1; i < szone->medium_rack.num_magazines; ++i) {
+			SZONE_MAGAZINE_PTR_UNLOCK((&(szone->medium_rack.magazines[i])));
+		}
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
+
+	for (i = -1; i < szone->small_rack.num_magazines; ++i) {
+		SZONE_MAGAZINE_PTR_UNLOCK((&(szone->small_rack.magazines[i])));
+	}
+
+	for (i = -1; i < szone->tiny_rack.num_magazines; ++i) {
+		SZONE_MAGAZINE_PTR_UNLOCK((&(szone->tiny_rack.magazines[i])));
 	}
 }
 
@@ -1420,12 +1357,20 @@
 
 	SZONE_REINIT_LOCK(szone);
 
-	for (i = -1; i < szone->num_small_magazines; ++i) {
-		SZONE_MAGAZINE_PTR_REINIT_LOCK(szone, (&(szone->small_magazines[i])));
-	}
-
-	for (i = -1; i < szone->num_tiny_magazines; ++i) {
-		SZONE_MAGAZINE_PTR_REINIT_LOCK(szone, (&(szone->tiny_magazines[i])));
+#if CONFIG_MEDIUM_ALLOCATOR
+	if (szone->is_medium_engaged) {
+		for (i = -1; i < szone->medium_rack.num_magazines; ++i) {
+			SZONE_MAGAZINE_PTR_REINIT_LOCK((&(szone->medium_rack.magazines[i])));
+		}
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
+
+	for (i = -1; i < szone->small_rack.num_magazines; ++i) {
+		SZONE_MAGAZINE_PTR_REINIT_LOCK((&(szone->small_rack.magazines[i])));
+	}
+
+	for (i = -1; i < szone->tiny_rack.num_magazines; ++i) {
+		SZONE_MAGAZINE_PTR_REINIT_LOCK((&(szone->tiny_rack.magazines[i])));
 	}
 }
 
@@ -1441,20 +1386,32 @@
 	}
 	SZONE_UNLOCK(szone);
 
-	for (i = -1; i < szone->num_small_magazines; ++i) {
-		tookLock = SZONE_MAGAZINE_PTR_TRY_LOCK(szone, (&(szone->small_magazines[i])));
+#if CONFIG_MEDIUM_ALLOCATOR
+	if (szone->is_medium_engaged) {
+		for (i = -1; i < szone->small_rack.num_magazines; ++i) {
+				tookLock = SZONE_MAGAZINE_PTR_TRY_LOCK((&(szone->small_rack.magazines[i])));
+				if (tookLock == 0) {
+					return 1;
+				}
+				SZONE_MAGAZINE_PTR_UNLOCK((&(szone->small_rack.magazines[i])));
+		}
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
+
+	for (i = -1; i < szone->small_rack.num_magazines; ++i) {
+		tookLock = SZONE_MAGAZINE_PTR_TRY_LOCK((&(szone->small_rack.magazines[i])));
 		if (tookLock == 0) {
 			return 1;
 		}
-		SZONE_MAGAZINE_PTR_UNLOCK(szone, (&(szone->small_magazines[i])));
-	}
-
-	for (i = -1; i < szone->num_tiny_magazines; ++i) {
-		tookLock = SZONE_MAGAZINE_PTR_TRY_LOCK(szone, (&(szone->tiny_magazines[i])));
+		SZONE_MAGAZINE_PTR_UNLOCK((&(szone->small_rack.magazines[i])));
+	}
+
+	for (i = -1; i < szone->tiny_rack.num_magazines; ++i) {
+		tookLock = SZONE_MAGAZINE_PTR_TRY_LOCK((&(szone->tiny_rack.magazines[i])));
 		if (tookLock == 0) {
 			return 1;
 		}
-		SZONE_MAGAZINE_PTR_UNLOCK(szone, (&(szone->tiny_magazines[i])));
+		SZONE_MAGAZINE_PTR_UNLOCK((&(szone->tiny_rack.magazines[i])));
 	}
 	return 0;
 }
@@ -1464,166 +1421,27 @@
 {
 	size_t total = 0;
 
+	MAGMALLOC_PRESSURERELIEFBEGIN((void *)szone, szone->basic_zone.zone_name, (int)goal); // DTrace USDT Probe
+	MALLOC_TRACE(TRACE_malloc_memory_pressure | DBG_FUNC_START, (uint64_t)szone, goal, 0, 0);
+
 #if CONFIG_MADVISE_PRESSURE_RELIEF
-	mag_index_t mag_index;
-
-	magazine_t *tiny_depot_ptr = (&szone->tiny_magazines[DEPOT_MAGAZINE_INDEX]);
-	magazine_t *small_depot_ptr = (&szone->small_magazines[DEPOT_MAGAZINE_INDEX]);
-
-	for (mag_index = 0; mag_index < szone->num_tiny_magazines; mag_index++) {
-		size_t index;
-		for (index = 0; index < szone->tiny_region_generation->num_regions_allocated; ++index) {
-			SZONE_LOCK(szone);
-
-			region_t tiny = szone->tiny_region_generation->hashed_regions[index];
-			if (!tiny || tiny == HASHRING_REGION_DEALLOCATED) {
-				SZONE_UNLOCK(szone);
-				continue;
-			}
-
-			magazine_t *mag_ptr = mag_lock_zine_for_region_trailer(
-					szone, szone->tiny_magazines, REGION_TRAILER_FOR_TINY_REGION(tiny), MAGAZINE_INDEX_FOR_TINY_REGION(tiny));
-			SZONE_UNLOCK(szone);
-
-			/* Ordering is important here, the magazine of a region may potentially change
-			 * during mag_lock_zine_for_region_trailer, so src_mag_index must be taken
-			 * after we've obtained the lock.
-			 */
-			mag_index_t src_mag_index = MAGAZINE_INDEX_FOR_TINY_REGION(tiny);
-
-			/* We can (and must) ignore magazines that are already in the recirc depot. */
-			if (src_mag_index == DEPOT_MAGAZINE_INDEX) {
-				SZONE_MAGAZINE_PTR_UNLOCK(szone, mag_ptr);
-				continue;
-			}
-
-			if (tiny == mag_ptr->mag_last_region && (mag_ptr->mag_bytes_free_at_end || mag_ptr->mag_bytes_free_at_start)) {
-				tiny_finalize_region(szone, mag_ptr);
-			}
-
-			/* Because this region is currently in use, we can't safely madvise it while
-			 * it's attached to the magazine. For this operation we have to remove it from
-			 * the current mag, attach it to the depot and then madvise.
-			 */
-
-			recirc_list_extract(szone, mag_ptr, REGION_TRAILER_FOR_TINY_REGION(tiny));
-			int objects_in_use = tiny_free_detach_region(szone, mag_ptr, tiny);
-
-			SZONE_MAGAZINE_PTR_LOCK(szone, tiny_depot_ptr);
-			MAGAZINE_INDEX_FOR_TINY_REGION(tiny) = DEPOT_MAGAZINE_INDEX;
-			REGION_TRAILER_FOR_TINY_REGION(tiny)->pinned_to_depot = 0;
-
-			size_t bytes_inplay = tiny_free_reattach_region(szone, tiny_depot_ptr, tiny);
-
-			/* Fix up the metadata of the target magazine while the region is in the depot. */
-			mag_ptr->mag_num_bytes_in_objects -= bytes_inplay;
-			mag_ptr->num_bytes_in_magazine -= TINY_REGION_PAYLOAD_BYTES;
-			mag_ptr->mag_num_objects -= objects_in_use;
-
-			/* Now we can drop the magazine lock of the source mag. */
-			SZONE_MAGAZINE_PTR_UNLOCK(szone, mag_ptr);
-
-			tiny_depot_ptr->mag_num_bytes_in_objects += bytes_inplay;
-			tiny_depot_ptr->num_bytes_in_magazine += TINY_REGION_PAYLOAD_BYTES;
-			tiny_depot_ptr->mag_num_objects -= objects_in_use;
-
-			recirc_list_splice_last(szone, tiny_depot_ptr, REGION_TRAILER_FOR_TINY_REGION(tiny));
-
-			/* Actually do the scan, done holding the depot lock, the call will drop the lock
-			 * around the actual madvise syscalls.
-			 */
-			tiny_free_scan_madvise_free(szone, tiny_depot_ptr, tiny);
-
-			/* Now the region is in the recirc depot, the next allocations to require more
-			 * blocks will come along and take one of these regions back out of the depot.
-			 * As OS X madvise's reuse on an per-region basis, we leave as many of these
-			 * regions in the depot as possible after memory pressure.
-			 */
-			SZONE_MAGAZINE_PTR_UNLOCK(szone, tiny_depot_ptr);
-		}
-	}
-
-	for (mag_index = 0; mag_index < szone->num_small_magazines; mag_index++) {
-		size_t index;
-		for (index = 0; index < szone->small_region_generation->num_regions_allocated; ++index) {
-			SZONE_LOCK(szone);
-
-			region_t small = szone->small_region_generation->hashed_regions[index];
-			if (!small || small == HASHRING_REGION_DEALLOCATED) {
-				SZONE_UNLOCK(szone);
-				continue;
-			}
-
-			magazine_t *mag_ptr = mag_lock_zine_for_region_trailer(
-					szone, szone->small_magazines, REGION_TRAILER_FOR_SMALL_REGION(small), MAGAZINE_INDEX_FOR_SMALL_REGION(small));
-			SZONE_UNLOCK(szone);
-
-			/* Ordering is important here, the magazine of a region may potentially change
-			 * during mag_lock_zine_for_region_trailer, so src_mag_index must be taken
-			 * after we've obtained the lock.
-			 */
-			mag_index_t src_mag_index = MAGAZINE_INDEX_FOR_SMALL_REGION(small);
-
-			/* We can (and must) ignore magazines that are already in the recirc depot. */
-			if (src_mag_index == DEPOT_MAGAZINE_INDEX) {
-				SZONE_MAGAZINE_PTR_UNLOCK(szone, mag_ptr);
-				continue;
-			}
-
-			if (small == mag_ptr->mag_last_region && (mag_ptr->mag_bytes_free_at_end || mag_ptr->mag_bytes_free_at_start)) {
-				small_finalize_region(szone, mag_ptr);
-			}
-
-			/* Because this region is currently in use, we can't safely madvise it while
-			 * it's attached to the magazine. For this operation we have to remove it from
-			 * the current mag, attach it to the depot and then madvise.
-			 */
-
-			recirc_list_extract(szone, mag_ptr, REGION_TRAILER_FOR_SMALL_REGION(small));
-			int objects_in_use = small_free_detach_region(szone, mag_ptr, small);
-
-			SZONE_MAGAZINE_PTR_LOCK(szone, small_depot_ptr);
-			MAGAZINE_INDEX_FOR_SMALL_REGION(small) = DEPOT_MAGAZINE_INDEX;
-			REGION_TRAILER_FOR_SMALL_REGION(small)->pinned_to_depot = 0;
-
-			size_t bytes_inplay = small_free_reattach_region(szone, small_depot_ptr, small);
-
-			/* Fix up the metadata of the target magazine while the region is in the depot. */
-			mag_ptr->mag_num_bytes_in_objects -= bytes_inplay;
-			mag_ptr->num_bytes_in_magazine -= SMALL_REGION_PAYLOAD_BYTES;
-			mag_ptr->mag_num_objects -= objects_in_use;
-
-			/* Now we can drop the magazine lock of the source mag. */
-			SZONE_MAGAZINE_PTR_UNLOCK(szone, mag_ptr);
-
-			small_depot_ptr->mag_num_bytes_in_objects += bytes_inplay;
-			small_depot_ptr->num_bytes_in_magazine += SMALL_REGION_PAYLOAD_BYTES;
-			small_depot_ptr->mag_num_objects -= objects_in_use;
-
-			recirc_list_splice_last(szone, small_depot_ptr, REGION_TRAILER_FOR_SMALL_REGION(small));
-
-			/* Actually do the scan, done holding the depot lock, the call will drop the lock
-			 * around the actual madvise syscalls.
-			 */
-			small_free_scan_madvise_free(szone, small_depot_ptr, small);
-
-			/* Now the region is in the recirc depot, the next allocations to require more
-			 * blocks will come along and take one of these regions back out of the depot.
-			 * As OS X madvise's reuse on an per-region basis, we leave as many of these
-			 * regions in the depot as possible after memory pressure.
-			 */
-			SZONE_MAGAZINE_PTR_UNLOCK(szone, small_depot_ptr);
-		}
-	}
-#endif
+	tiny_madvise_pressure_relief(&szone->tiny_rack);
+	small_madvise_pressure_relief(&szone->small_rack);
+
+#if CONFIG_MEDIUM_ALLOCATOR
+	if (szone->is_medium_engaged) {
+		medium_madvise_pressure_relief(&szone->medium_rack);
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
+#endif // CONFIG_MADVISE_PRESSURE_RELIEF
 
 #if CONFIG_LARGE_CACHE
-	if (szone->flotsam_enabled) {
+	if (large_cache_enabled && szone->flotsam_enabled) {
 		SZONE_LOCK(szone);
 
 		// stack allocated copy of the death-row cache
 		int idx = szone->large_entry_cache_oldest, idx_max = szone->large_entry_cache_newest;
-		large_entry_t local_entry_cache[LARGE_ENTRY_CACHE_SIZE];
+		large_entry_t local_entry_cache[LARGE_ENTRY_CACHE_SIZE_HIGH];
 
 		memcpy((void *)local_entry_cache, (void *)szone->large_entry_cache, sizeof(local_entry_cache));
 
@@ -1640,20 +1458,22 @@
 		// deallocate the death-row cache outside the zone lock
 		size_t total = 0;
 		while (idx != idx_max) {
-			deallocate_pages(szone, (void *)local_entry_cache[idx].address, local_entry_cache[idx].size, 0);
+			mvm_deallocate_pages((void *)local_entry_cache[idx].address, local_entry_cache[idx].size, szone->debug_flags);
 			total += local_entry_cache[idx].size;
-			if (++idx == LARGE_ENTRY_CACHE_SIZE) {
+			if (++idx == szone->large_cache_depth) {
 				idx = 0;
 			}
 		}
 		if (0 != local_entry_cache[idx].address && 0 != local_entry_cache[idx].size) {
-			deallocate_pages(szone, (void *)local_entry_cache[idx].address, local_entry_cache[idx].size, 0);
+			mvm_deallocate_pages((void *)local_entry_cache[idx].address, local_entry_cache[idx].size, szone->debug_flags);
 			total += local_entry_cache[idx].size;
 		}
 	}
 #endif
 
-	MAGMALLOC_PRESSURERELIEF((void *)szone, (int)goal, (int)total); // DTrace USDT Probe
+	MAGMALLOC_PRESSURERELIEFEND((void *)szone, szone->basic_zone.zone_name, (int)goal, (int)total); // DTrace USDT Probe
+	MALLOC_TRACE(TRACE_malloc_memory_pressure | DBG_FUNC_END, (uint64_t)szone, goal, total, 0);
+
 	return total;
 }
 
@@ -1669,16 +1489,16 @@
 		size_t u = 0;
 		mag_index_t mag_index;
 
-		for (mag_index = -1; mag_index < szone->num_tiny_magazines; mag_index++) {
-			s += szone->tiny_magazines[mag_index].mag_bytes_free_at_start;
-			s += szone->tiny_magazines[mag_index].mag_bytes_free_at_end;
-			t += szone->tiny_magazines[mag_index].mag_num_objects;
-			u += szone->tiny_magazines[mag_index].mag_num_bytes_in_objects;
+		for (mag_index = -1; mag_index < szone->tiny_rack.num_magazines; mag_index++) {
+			s += szone->tiny_rack.magazines[mag_index].mag_bytes_free_at_start;
+			s += szone->tiny_rack.magazines[mag_index].mag_bytes_free_at_end;
+			t += szone->tiny_rack.magazines[mag_index].mag_num_objects;
+			u += szone->tiny_rack.magazines[mag_index].mag_num_bytes_in_objects;
 		}
 
 		stats->blocks_in_use = t;
 		stats->size_in_use = u;
-		stats->size_allocated = (szone->num_tiny_regions - szone->num_tiny_regions_dealloc) * TINY_REGION_SIZE;
+		stats->size_allocated = (szone->tiny_rack.num_regions - szone->tiny_rack.num_regions_dealloc) * TINY_REGION_SIZE;
 		stats->max_size_in_use = stats->size_allocated - s;
 		return 1;
 	}
@@ -1688,16 +1508,16 @@
 		size_t u = 0;
 		mag_index_t mag_index;
 
-		for (mag_index = -1; mag_index < szone->num_small_magazines; mag_index++) {
-			s += szone->small_magazines[mag_index].mag_bytes_free_at_start;
-			s += szone->small_magazines[mag_index].mag_bytes_free_at_end;
-			t += szone->small_magazines[mag_index].mag_num_objects;
-			u += szone->small_magazines[mag_index].mag_num_bytes_in_objects;
+		for (mag_index = -1; mag_index < szone->small_rack.num_magazines; mag_index++) {
+			s += szone->small_rack.magazines[mag_index].mag_bytes_free_at_start;
+			s += szone->small_rack.magazines[mag_index].mag_bytes_free_at_end;
+			t += szone->small_rack.magazines[mag_index].mag_num_objects;
+			u += szone->small_rack.magazines[mag_index].mag_num_bytes_in_objects;
 		}
 
 		stats->blocks_in_use = t;
 		stats->size_in_use = u;
-		stats->size_allocated = (szone->num_small_regions - szone->num_small_regions_dealloc) * SMALL_REGION_SIZE;
+		stats->size_allocated = (szone->small_rack.num_regions - szone->small_rack.num_regions_dealloc) * SMALL_REGION_SIZE;
 		stats->max_size_in_use = stats->size_allocated - s;
 		return 1;
 	}
@@ -1711,50 +1531,118 @@
 		stats->size_in_use = 0;   // DEPRECATED szone->num_bytes_in_huge_objects;
 		stats->max_size_in_use = stats->size_allocated = 0;
 		return 1;
-	}
+	case 4: {
+		size_t s = 0;
+		unsigned t = 0;
+		size_t u = 0;
+		size_t sa = 0;
+
+#if CONFIG_MEDIUM_ALLOCATOR
+		mag_index_t mag_index;
+		if (szone->is_medium_engaged) {
+			for (mag_index = -1; mag_index < szone->medium_rack.num_magazines; mag_index++) {
+				s += szone->medium_rack.magazines[mag_index].mag_bytes_free_at_start;
+				s += szone->medium_rack.magazines[mag_index].mag_bytes_free_at_end;
+				t += szone->medium_rack.magazines[mag_index].mag_num_objects;
+				u += szone->medium_rack.magazines[mag_index].mag_num_bytes_in_objects;
+			}
+		}
+
+		sa = (szone->medium_rack.num_regions - szone->medium_rack.num_regions_dealloc) * MEDIUM_REGION_SIZE;
+#endif // CONFIG_MEDIUM_ALLOCATOR
+
+		stats->blocks_in_use = t;
+		stats->size_in_use = u;
+		stats->size_allocated = sa;
+		stats->max_size_in_use = stats->size_allocated - s;
+		return 1;
+	}}
 	return 0;
 }
 
-static void
-szone_statistics(szone_t *szone, malloc_statistics_t *stats)
-{
+static kern_return_t
+szone_statistics_task(task_t task, vm_address_t zone_address,
+					  memory_reader_t reader, malloc_statistics_t *stats)
+{
+	reader = !reader && task == mach_task_self() ? _malloc_default_reader : reader;
+
+	szone_t *szone;
+	kern_return_t err;
+
+	err = reader(task, zone_address, sizeof(szone_t), (void**)&szone);
+	if (err) return err;
+
 	size_t large;
-
 	size_t s = 0;
 	unsigned t = 0;
 	size_t u = 0;
 	mag_index_t mag_index;
 
-	for (mag_index = -1; mag_index < szone->num_tiny_magazines; mag_index++) {
-		s += szone->tiny_magazines[mag_index].mag_bytes_free_at_start;
-		s += szone->tiny_magazines[mag_index].mag_bytes_free_at_end;
-		t += szone->tiny_magazines[mag_index].mag_num_objects;
-		u += szone->tiny_magazines[mag_index].mag_num_bytes_in_objects;
-	}
-
-	for (mag_index = -1; mag_index < szone->num_small_magazines; mag_index++) {
-		s += szone->small_magazines[mag_index].mag_bytes_free_at_start;
-		s += szone->small_magazines[mag_index].mag_bytes_free_at_end;
-		t += szone->small_magazines[mag_index].mag_num_objects;
-		u += szone->small_magazines[mag_index].mag_num_bytes_in_objects;
-	}
-
-	large = szone->num_bytes_in_large_objects + 0; // DEPRECATED szone->num_bytes_in_huge_objects;
-
-	stats->blocks_in_use = t + szone->num_large_objects_in_use + 0; // DEPRECATED szone->num_huge_entries;
+	magazine_t *mags;
+	err = reader(task, (vm_address_t)szone->tiny_rack.magazines, sizeof(magazine_t) * szone->tiny_rack.num_magazines, (void**)&mags);
+	if (err) return err;
+
+	for (mag_index = -1; mag_index < szone->tiny_rack.num_magazines; mag_index++) {
+		s += mags[mag_index].mag_bytes_free_at_start;
+		s += mags[mag_index].mag_bytes_free_at_end;
+		t += mags[mag_index].mag_num_objects;
+		u += mags[mag_index].mag_num_bytes_in_objects;
+	}
+
+	err = reader(task, (vm_address_t)szone->small_rack.magazines, sizeof(magazine_t) * szone->small_rack.num_magazines, (void**)&mags);
+	if (err) return err;
+
+	for (mag_index = -1; mag_index < szone->small_rack.num_magazines; mag_index++) {
+		s += mags[mag_index].mag_bytes_free_at_start;
+		s += mags[mag_index].mag_bytes_free_at_end;
+		t += mags[mag_index].mag_num_objects;
+		u += mags[mag_index].mag_num_bytes_in_objects;
+	}
+
+#if CONFIG_MEDIUM_ALLOCATOR
+	if (szone->is_medium_engaged) {
+		for (mag_index = -1; mag_index < szone->medium_rack.num_magazines; mag_index++) {
+			s += szone->medium_rack.magazines[mag_index].mag_bytes_free_at_start;
+			s += szone->medium_rack.magazines[mag_index].mag_bytes_free_at_end;
+			t += szone->medium_rack.magazines[mag_index].mag_num_objects;
+			u += szone->medium_rack.magazines[mag_index].mag_num_bytes_in_objects;
+		}
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
+
+	large = szone->num_bytes_in_large_objects;
+
+	stats->blocks_in_use = t + szone->num_large_objects_in_use;
 	stats->size_in_use = u + large;
 	stats->max_size_in_use = stats->size_allocated =
-			(szone->num_tiny_regions - szone->num_tiny_regions_dealloc) * TINY_REGION_SIZE +
-			(szone->num_small_regions - szone->num_small_regions_dealloc) * SMALL_REGION_SIZE + large;
+			(szone->tiny_rack.num_regions - szone->tiny_rack.num_regions_dealloc) * TINY_REGION_SIZE +
+			(szone->small_rack.num_regions - szone->small_rack.num_regions_dealloc) * SMALL_REGION_SIZE + large;
+
+#if CONFIG_MEDIUM_ALLOCATOR
+	if (szone->is_medium_engaged) {
+		stats->max_size_in_use += (szone->medium_rack.num_regions -
+				szone->medium_rack.num_regions_dealloc) * MEDIUM_REGION_SIZE;
+	}
+#endif
 	// Now we account for the untouched areas
 	stats->max_size_in_use -= s;
+
+	return KERN_SUCCESS;
+}
+
+static void
+szone_statistics(szone_t *szone, malloc_statistics_t *stats)
+{
+	szone_statistics_task(mach_task_self(), (vm_address_t)szone, NULL, stats);
 }
 
 const struct malloc_introspection_t szone_introspect = {
-		(void *)szone_ptr_in_use_enumerator, (void *)szone_good_size, (void *)szone_check, (void *)szone_print, szone_log,
+		(void *)szone_ptr_in_use_enumerator, (void *)szone_good_size, (void *)szone_check, (void *)szone_print_self, szone_log,
 		(void *)szone_force_lock, (void *)szone_force_unlock, (void *)szone_statistics, (void *)szone_locked, NULL, NULL, NULL,
 		NULL, /* Zone enumeration version 7 and forward. */
-		(void *)szone_reinit_lock, // reinit_lock version 9 and foward
+		(void *)szone_reinit_lock, // reinit_lock version 9 and forward
+		(void *)szone_print_task,  // print task, version 11 and forward
+		(void *)szone_statistics_task // stats for task, version 12 and forward
 }; // marked as const to spare the DATA section
 
 szone_t *
@@ -1764,12 +1652,12 @@
 
 #if defined(__i386__) || defined(__x86_64__)
 	if (_COMM_PAGE_VERSION_REQD > (*((uint16_t *)_COMM_PAGE_VERSION))) {
-		MALLOC_PRINTF_FATAL_ERROR((*((uint16_t *)_COMM_PAGE_VERSION)), "comm page version mismatch");
+		MALLOC_REPORT_FATAL_ERROR((*((uint16_t *)_COMM_PAGE_VERSION)), "comm page version mismatch");
 	}
 #endif
 
 	/* get memory for the zone. */
-	szone = allocate_pages(NULL, SZONE_PAGED_SIZE, 0, 0, VM_MEMORY_MALLOC);
+	szone = mvm_allocate_pages(SZONE_PAGED_SIZE, 0, DISABLE_ASLR, VM_MEMORY_MALLOC);
 	if (!szone) {
 		return NULL;
 	}
@@ -1783,99 +1671,67 @@
 #warning LOG enabled
 	szone->log_address = ~0;
 #endif
-	szone->trg[0].nextgen = &(szone->trg[1]);
-	szone->trg[1].nextgen = &(szone->trg[0]);
-	szone->tiny_region_generation = &(szone->trg[0]);
-
-	szone->tiny_region_generation->hashed_regions = szone->initial_tiny_regions;
-	szone->tiny_region_generation->num_regions_allocated = INITIAL_NUM_REGIONS;
-	szone->tiny_region_generation->num_regions_allocated_shift = INITIAL_NUM_REGIONS_SHIFT;
-
-	szone->srg[0].nextgen = &(szone->srg[1]);
-	szone->srg[1].nextgen = &(szone->srg[0]);
-	szone->small_region_generation = &(szone->srg[0]);
-
-	szone->small_region_generation->hashed_regions = szone->initial_small_regions;
-	szone->small_region_generation->num_regions_allocated = INITIAL_NUM_REGIONS;
-	szone->small_region_generation->num_regions_allocated_shift = INITIAL_NUM_REGIONS_SHIFT;
-
-#if CONFIG_SMALL_CUTTOFF_127KB 
-	szone->is_largemem = 1;
-	szone->num_small_slots = NUM_SMALL_SLOTS_LARGEMEM;
-	szone->large_threshold = LARGE_THRESHOLD_LARGEMEM;
-	szone->vm_copy_threshold = VM_COPY_THRESHOLD_LARGEMEM;
-#else // CONFIG_SMALL_CUTTOFF_127KB
-	szone->is_largemem = 0;
-	szone->num_small_slots = NUM_SMALL_SLOTS;
-	szone->large_threshold = LARGE_THRESHOLD;
-	szone->vm_copy_threshold = VM_COPY_THRESHOLD;
-#endif // CONFIG_SMALL_CUTTOFF_127KB
-
-#if CONFIG_LARGE_CACHE
-	uint64_t hw_memsize = 0;
-
-#if CONFIG_HAS_COMMPAGE_MEMSIZE
-	hw_memsize = *(uint64_t *)(uintptr_t)_COMM_PAGE_MEMORY_SIZE;
-#else
-	size_t uint64_t_size = sizeof(hw_memsize);
-	// hw_memsize was always 0 if sysctlbyname failed, so preserve that behaviour
-	(void)sysctlbyname("hw.memsize", &hw_memsize, &uint64_t_size, 0, 0);
-#endif
-
-	// madvise(..., MADV_REUSABLE) death-row arrivals above this threshold [~0.1%]
-	szone->large_entry_cache_reserve_limit = hw_memsize >> 10; 
-
-	/* <rdar://problem/6610904> Reset protection when returning a previous large allocation? */
-	int32_t libSystemVersion = NSVersionOfLinkTimeLibrary("System");
-	if ((-1 != libSystemVersion) && ((libSystemVersion >> 16) < 112) /* CFSystemVersionSnowLeopard */) {
-		szone->large_legacy_reset_mprotect = TRUE;
-	} else {
-		szone->large_legacy_reset_mprotect = FALSE;
-	}
-#endif
-
-// Prepare ASLR
-#if __i386__ || __x86_64__ || __arm64__ || TARGET_OS_EMBEDDED
-#if __i386__
-	uintptr_t stackbase = 0x8fe00000;
-	int entropic_bits = 3;
-#elif __x86_64__
-	uintptr_t stackbase = USRSTACK64;
-	int entropic_bits = 16;
-#elif __arm64__
-	uintptr_t stackbase = USRSTACK64;
-	int entropic_bits = 7;
-#else
-	uintptr_t stackbase = USRSTACK;
-	int entropic_bits = 3;
-#endif
-
-	// assert(((1 << entropic_bits) - 1) << SMALL_BLOCKS_ALIGN < (stackbase - MAXSSIZ - ENTROPIC_KABILLION));
-
-	if (0 != _dyld_get_image_slide((const struct mach_header *)_NSGetMachExecuteHeader())) {
-		if (0 == entropic_address) {
-			uintptr_t t = stackbase - MAXSSIZ - ((uintptr_t)(malloc_entropy[1] & ((1 << entropic_bits) - 1)) << ENTROPIC_SHIFT);
-			(void)__sync_bool_compare_and_swap(&entropic_limit, 0, t);						  // Just one initialization please
-			(void)__sync_bool_compare_and_swap(&entropic_address, 0, t - ENTROPIC_KABILLION); // Just one initialization please
-		}
+
+	if (mvm_aslr_enabled()) {
 		debug_flags &= ~DISABLE_ASLR;
 	} else {
-		// zero slide when ASLR has been disabled by boot-arg. Eliminate cloaking.
-		malloc_entropy[0] = 0;
-		malloc_entropy[1] = 0;
 		debug_flags |= DISABLE_ASLR;
 	}
 
-#else
-	malloc_entropy[0] = 0;
-	malloc_entropy[1] = 0;
-	debug_flags |= DISABLE_ASLR;
+#if CONFIG_MEDIUM_ALLOCATOR || CONFIG_LARGE_CACHE
+	uint64_t memsize = platform_hw_memsize();
+#endif // CONFIG_MEDIUM_ALLOCATOR || CONFIG_LARGE_CACHE
+
+#if CONFIG_MEDIUM_ALLOCATOR
+	szone->is_medium_engaged = (magazine_medium_enabled &&
+			(memsize >= magazine_medium_active_threshold));
+#endif // CONFIG_MEDIUM_ALLOCATOR
+
+	// Query the number of configured processors.
+	// Uniprocessor case gets just one tiny and one small magazine (whose index is zero). This gives
+	// the same behavior as the original scalable malloc. MP gets per-CPU magazines
+	// that scale (way) better.
+	unsigned int max_mags = mag_max_magazines();
+	uint32_t num_magazines = (max_mags > 1) ? MIN(max_mags, TINY_MAX_MAGAZINES) : 1;
+	rack_init(&szone->tiny_rack, RACK_TYPE_TINY, num_magazines, debug_flags);
+	rack_init(&szone->small_rack, RACK_TYPE_SMALL, num_magazines, debug_flags);
+
+#if CONFIG_MEDIUM_ALLOCATOR
+	if (szone->is_medium_engaged) {
+		unsigned max_medium_mags = mag_max_medium_magazines();
+		uint32_t num_medium_mags = (max_medium_mags > 1) ?
+				MIN(max_medium_mags, TINY_MAX_MAGAZINES) : 1;
+		rack_init(&szone->medium_rack, RACK_TYPE_MEDIUM, num_medium_mags,
+				debug_flags);
+	}
+#endif // CONFIG_MEDIUM_ALLOCATOR
+
+#if CONFIG_LARGE_CACHE
+	if (large_cache_enabled) {
+		// madvise(..., MADV_REUSABLE) death-row arrivals above this threshold [~0.1%]
+		szone->large_entry_cache_reserve_limit = (size_t)(memsize >> 10);
+		if (memsize >= magazine_large_expanded_cache_threshold) {
+			szone->large_cache_depth = LARGE_ENTRY_CACHE_SIZE_HIGH;
+			szone->large_cache_entry_limit = LARGE_ENTRY_SIZE_ENTRY_LIMIT_HIGH;
+		} else {
+			szone->large_cache_depth = LARGE_ENTRY_CACHE_SIZE_LOW;
+			szone->large_cache_entry_limit = LARGE_ENTRY_SIZE_ENTRY_LIMIT_LOW;
+		}
+
+		/* <rdar://problem/6610904> Reset protection when returning a previous large allocation? */
+		int32_t libSystemVersion = NSVersionOfLinkTimeLibrary("System");
+		if ((-1 != libSystemVersion) && ((libSystemVersion >> 16) < 112) /* CFSystemVersionSnowLeopard */) {
+			szone->large_legacy_reset_mprotect = TRUE;
+		} else {
+			szone->large_legacy_reset_mprotect = FALSE;
+		}
+	}
 #endif
 
 	// Initialize the security token.
 	szone->cookie = (uintptr_t)malloc_entropy[0];
 
-	szone->basic_zone.version = 9;
+	szone->basic_zone.version = 12;
 	szone->basic_zone.size = (void *)szone_size;
 	szone->basic_zone.malloc = (void *)szone_malloc;
 	szone->basic_zone.calloc = (void *)szone_calloc;
@@ -1889,95 +1745,20 @@
 	szone->basic_zone.memalign = (void *)szone_memalign;
 	szone->basic_zone.free_definite_size = (void *)szone_free_definite_size;
 	szone->basic_zone.pressure_relief = (void *)szone_pressure_relief;
-
-	szone->basic_zone.reserved1 = 0;					   /* Set to zero once and for all as required by CFAllocator. */
-	szone->basic_zone.reserved2 = 0;					   /* Set to zero once and for all as required by CFAllocator. */
-	mprotect(szone, sizeof(szone->basic_zone), PROT_READ); /* Prevent overwriting the function pointers in basic_zone. */
+	szone->basic_zone.claimed_address = (void *)szone_claimed_address;
+
+	/* Set to zero once and for all as required by CFAllocator. */
+	szone->basic_zone.reserved1 = 0;
+	/* Set to zero once and for all as required by CFAllocator. */
+	szone->basic_zone.reserved2 = 0;
+
+	/* Prevent overwriting the function pointers in basic_zone. */
+	mprotect(szone, sizeof(szone->basic_zone), PROT_READ);
 
 	szone->debug_flags = debug_flags;
 	_malloc_lock_init(&szone->large_szone_lock);
 
 	szone->cpu_id_key = -1UL; // Unused.
-
-// Query the number of configured processors.
-// Uniprocessor case gets just one tiny and one small magazine (whose index is zero). This gives
-// the same behavior as the original scalable malloc. MP gets per-CPU magazines
-// that scale (way) better.
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__arm64__)
-	int nproc = *(uint8_t *)(uintptr_t)_COMM_PAGE_NCPUS;
-#else
-	int nproc = sysconf(_SC_NPROCESSORS_CONF);
-#endif
-	szone->num_tiny_magazines = (nproc > 1) ? MIN(nproc, TINY_MAX_MAGAZINES) : 1;
-
-	// FIXME vm_allocate() based on number of configured CPUs
-	magazine_t *tiny_magazines =
-			allocate_pages(NULL, TINY_MAGAZINE_PAGED_SIZE, 0, MALLOC_ADD_GUARD_PAGES, VM_MEMORY_MALLOC);
-	if (NULL == tiny_magazines) {
-		return NULL;
-	}
-
-	szone->tiny_magazines = &(tiny_magazines[1]); // szone->tiny_magazines[-1] is the Depot
-
-	// The magazines are indexed in [0 .. (num_tiny_magazines - 1)]
-	// Find the smallest power of 2 that exceeds (num_tiny_magazines - 1)
-	szone->num_tiny_magazines_mask_shift = 0;
-	int i = 1;
-	while (i <= (szone->num_tiny_magazines - 1)) {
-		szone->num_tiny_magazines_mask_shift++;
-		i <<= 1;
-	}
-
-	// Now if i <= TINY_MAX_MAGAZINES we'll never access tiny_magazines[] out of bounds.
-	if (i > TINY_MAX_MAGAZINES) {
-		MALLOC_PRINTF_FATAL_ERROR(i, "magazine mask exceeds allocated magazines");
-	}
-
-	// Reduce i by 1 to obtain a mask covering [0 .. (num_tiny_magazines - 1)]
-	szone->num_tiny_magazines_mask = i - 1; // A mask used for hashing to a magazine index (and a safety aid)
-	szone->last_tiny_advise = 0;
-
-	// Init the tiny_magazine locks
-	_malloc_lock_init(&szone->tiny_regions_lock);
-	_malloc_lock_init(&szone->tiny_magazines[DEPOT_MAGAZINE_INDEX].magazine_lock);
-	for (i = 0; i < szone->num_tiny_magazines; ++i) {
-		_malloc_lock_init(&szone->tiny_magazines[i].magazine_lock);
-	}
-
-	szone->num_small_magazines = (nproc > 1) ? MIN(nproc, SMALL_MAX_MAGAZINES) : 1;
-
-	// FIXME vm_allocate() based on number of configured CPUs
-	magazine_t *small_magazines =
-			allocate_pages(NULL, SMALL_MAGAZINE_PAGED_SIZE, 0, MALLOC_ADD_GUARD_PAGES, VM_MEMORY_MALLOC);
-	if (NULL == small_magazines) {
-		return NULL;
-	}
-
-	szone->small_magazines = &(small_magazines[1]); // szone->small_magazines[-1] is the Depot
-
-	// The magazines are indexed in [0 .. (num_small_magazines - 1)]
-	// Find the smallest power of 2 that exceeds (num_small_magazines - 1)
-	szone->num_small_magazines_mask_shift = 0;
-	while (i <= (szone->num_small_magazines - 1)) {
-		szone->num_small_magazines_mask_shift++;
-		i <<= 1;
-	}
-
-	// Now if i <= SMALL_MAX_MAGAZINES we'll never access small_magazines[] out of bounds.
-	if (i > SMALL_MAX_MAGAZINES) {
-		MALLOC_PRINTF_FATAL_ERROR(i, "magazine mask exceeds allocated magazines");
-	}
-
-	// Reduce i by 1 to obtain a mask covering [0 .. (num_small_magazines - 1)]
-	szone->num_small_magazines_mask = i - 1; // A mask used for hashing to a magazine index (and a safety aid)
-	szone->last_small_advise = 0;
-
-	// Init the small_magazine locks
-	_malloc_lock_init(&szone->small_regions_lock);
-	_malloc_lock_init(&szone->small_magazines[DEPOT_MAGAZINE_INDEX].magazine_lock);
-	for (i = 0; i < szone->num_small_magazines; ++i) {
-		_malloc_lock_init(&szone->small_magazines[i].magazine_lock);
-	}
 
 	CHECK(szone, __PRETTY_FUNCTION__);
 	return szone;