Loading...
--- libmalloc/libmalloc-140.40.1/src/magazine_malloc.c
+++ libmalloc/libmalloc-166.251.2/src/magazine_malloc.c
@@ -41,69 +41,25 @@
#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(uint32_t debug_flags, 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();
- 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 && (debug_flags & MALLOC_ABORT_ON_CORRUPTION)) ||
- (debug_flags & MALLOC_ABORT_ON_ERROR)) {
- _os_set_crash_log_message_dynamic(b ? _simple_string(b) : msg);
- abort();
- } else if (b) {
- _simple_sfree(b);
- }
-}
+// 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;
+
+// <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 ************************/
/*
@@ -117,7 +73,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) {
@@ -127,12 +83,12 @@
* Try to free to a tiny region.
*/
if ((uintptr_t)ptr & (TINY_QUANTUM - 1)) {
- szone_error(szone->debug_flags, 1, "Non-aligned pointer being freed", 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->debug_flags, 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->tiny_rack, ptr, tiny_region, 0);
@@ -143,21 +99,35 @@
* Try to free to a small region.
*/
if ((uintptr_t)ptr & (SMALL_QUANTUM - 1)) {
- szone_error(szone->debug_flags, 1, "Non-aligned pointer being freed (2)", 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->debug_flags, 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->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->debug_flags, 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);
@@ -168,11 +138,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->debug_flags, 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;
}
@@ -185,12 +155,12 @@
* Try to free to a tiny region.
*/
if ((uintptr_t)ptr & (TINY_QUANTUM - 1)) {
- szone_error(szone->debug_flags, 1, "Non-aligned pointer being freed", ptr, NULL);
+ malloc_zone_error(szone->debug_flags, true, "Non-aligned pointer %p being freed\n", ptr);
return;
}
- if (size <= SMALL_THRESHOLD) {
+ if (size <= TINY_LIMIT_THRESHOLD) {
if (TINY_INDEX_FOR_PTR(ptr) >= NUM_TINY_BLOCKS) {
- szone_error(szone->debug_flags, 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->tiny_rack, ptr, TINY_REGION_FOR_PTR(ptr), size);
@@ -201,21 +171,35 @@
* Try to free to a small region.
*/
if ((uintptr_t)ptr & (SMALL_QUANTUM - 1)) {
- szone_error(szone->debug_flags, 1, "Non-aligned pointer being freed (2)", ptr, NULL);
+ malloc_zone_error(szone->debug_flags, true, "Non-aligned pointer %p being freed (2)\n", ptr);
return;
}
- if (size <= szone->large_threshold) {
+ if (size <= SMALL_LIMIT_THRESHOLD) {
if (SMALL_META_INDEX_FOR_PTR(ptr) >= NUM_SMALL_BLOCKS) {
- szone_error(szone->debug_flags, 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->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->debug_flags, 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);
@@ -227,24 +211,27 @@
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->tiny_rack, msize, cleared_requested);
- } else if (size <= szone->large_threshold) {
- // small size: <15k (<1GB machines), <127k (>1GB machines)
- // think small
+ } 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->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;
if (num_kernel_pages == 0) { /* Overflowed */
ptr = 0;
@@ -254,7 +241,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
/*
@@ -276,29 +263,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);
}
@@ -307,7 +275,7 @@
{
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;
@@ -318,7 +286,7 @@
#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;
@@ -339,7 +307,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;
@@ -355,7 +323,7 @@
}
#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
@@ -383,6 +351,18 @@
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.
*/
@@ -404,7 +384,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) {
@@ -420,7 +400,7 @@
old_size = szone_size(szone, ptr);
if (!old_size) {
- szone_error(szone->debug_flags, 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;
}
@@ -433,8 +413,8 @@
* 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.
@@ -462,8 +442,8 @@
* 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->small_rack, ptr, old_size, new_good_size);
} else if (new_good_size <= old_size) {
@@ -478,11 +458,30 @@
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) {
@@ -520,15 +519,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;
@@ -544,98 +546,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_page_quanta(MAX(LARGE_THRESHOLD(szone) + 1,
+ size)) >> 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->tiny_rack.num_magazines;
- magazine_t *tiny_mag_ptr = &(szone->tiny_rack.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(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_rack, tiny_mag_ptr, mag_index, msize);
- if (!ptr) {
- break;
- }
-
- *results++ = ptr;
- found++;
- }
- SZONE_MAGAZINE_PTR_UNLOCK(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) {
@@ -643,55 +626,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(tiny_mag_ptr);
- tiny_mag_ptr = NULL;
- }
-
- tiny_region = tiny_region_for_ptr_no_lock(&szone->tiny_rack, ptr);
-
- if (tiny_region) {
- tiny_mag_ptr = mag_lock_zine_for_region_trailer(szone->tiny_rack.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_rack, 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(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);
}
@@ -760,6 +702,13 @@
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);
}
@@ -769,7 +718,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;
@@ -778,13 +727,23 @@
}
// 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;
}
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.
@@ -797,10 +756,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);
+ malloc_report(ASL_LEVEL_INFO, "szone_good_size() invariant broken %y\n", size);
}
#endif
return round_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;
@@ -825,11 +796,9 @@
REGION_TRAILER_FOR_TINY_REGION(tiny),
MAGAZINE_INDEX_FOR_TINY_REGION(tiny));
- if (!tiny_check_region(&szone->tiny_rack, 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->debug_flags, 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(tiny_mag_ptr);
@@ -837,11 +806,8 @@
}
/* check tiny free lists */
for (index = 0; index < NUM_TINY_SLOTS; ++index) {
- if (!tiny_free_list_check(&szone->tiny_rack, (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->debug_flags, 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;
}
}
@@ -859,11 +825,9 @@
REGION_TRAILER_FOR_SMALL_REGION(small),
MAGAZINE_INDEX_FOR_SMALL_REGION(small));
- if (!small_check_region(&szone->small_rack, 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->debug_flags, 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(small_mag_ptr);
@@ -871,14 +835,44 @@
}
/* check small free lists */
for (index = 0; index < SMALL_FREE_SLOT_COUNT(&szone->small_rack); ++index) {
- if (!small_free_list_check(&szone->small_rack, (grain_t)index)) {
+ if (!small_free_list_check(&szone->small_rack, (grain_t)index, szone_check_counter)) {
szone->debug_flags &= ~CHECK_REGIONS;
- szone_error(szone->debug_flags, 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;
}
@@ -887,7 +881,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) {
@@ -931,6 +925,15 @@
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;
@@ -997,15 +1000,15 @@
region_t region;
scalable_zone_info((void *)szone, info, 13);
- _malloc_printf(MALLOC_PRINTF_NOLOG | MALLOC_PRINTF_NOPREFIX,
+ malloc_report(MALLOC_REPORT_NOLOG | MALLOC_REPORT_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],
+ malloc_report(MALLOC_REPORT_NOLOG | MALLOC_REPORT_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]);
// tiny
- _malloc_printf(MALLOC_PRINTF_NOLOG | MALLOC_PRINTF_NOPREFIX, "%lu tiny regions:\n", szone->tiny_rack.num_regions);
+ malloc_report(MALLOC_REPORT_NOLOG | MALLOC_REPORT_NOPREFIX, "%lu tiny regions:\n", szone->tiny_rack.num_regions);
if (szone->tiny_rack.num_regions_dealloc) {
- _malloc_printf(MALLOC_PRINTF_NOLOG | MALLOC_PRINTF_NOPREFIX, "[%lu tiny regions have been vm_deallocate'd]\n",
+ malloc_report(MALLOC_REPORT_NOLOG | MALLOC_REPORT_NOPREFIX, "[%lu tiny regions have been vm_deallocate'd]\n",
szone->tiny_rack.num_regions_dealloc);
}
for (index = 0; index < szone->tiny_rack.region_generation->num_regions_allocated; ++index) {
@@ -1024,9 +1027,9 @@
print_tiny_free_list(&szone->tiny_rack);
}
// small
- _malloc_printf(MALLOC_PRINTF_NOLOG | MALLOC_PRINTF_NOPREFIX, "%lu small regions:\n", szone->small_rack.num_regions);
+ malloc_report(MALLOC_REPORT_NOLOG | MALLOC_REPORT_NOPREFIX, "%lu small regions:\n", szone->small_rack.num_regions);
if (szone->small_rack.num_regions_dealloc) {
- _malloc_printf(MALLOC_PRINTF_NOLOG | MALLOC_PRINTF_NOPREFIX, "[%lu small regions have been vm_deallocate'd]\n",
+ malloc_report(MALLOC_REPORT_NOLOG | MALLOC_REPORT_NOPREFIX, "[%lu small regions have been vm_deallocate'd]\n",
szone->small_rack.num_regions_dealloc);
}
for (index = 0; index < szone->small_rack.region_generation->num_regions_allocated; ++index) {
@@ -1041,6 +1044,28 @@
: 0);
}
}
+#if CONFIG_MEDIUM_ALLOCATOR
+ if (szone->is_medium_engaged) {
+ // medium
+ malloc_report(MALLOC_REPORT_NOLOG | MALLOC_REPORT_NOPREFIX, "%lu medium regions:\n", szone->medium_rack.num_regions);
+ if (szone->medium_rack.num_regions_dealloc) {
+ malloc_report(MALLOC_REPORT_NOLOG | MALLOC_REPORT_NOPREFIX, "[%lu medium regions have been vm_deallocate'd]\n",
+ szone->medium_rack.num_regions_dealloc);
+ }
+ for (index = 0; index < szone->medium_rack.region_generation->num_regions_allocated; ++index) {
+ region = szone->medium_rack.region_generation->hashed_regions[index];
+ if (HASHRING_OPEN_ENTRY != region && HASHRING_REGION_DEALLOCATED != region) {
+ mag_index_t mag_index = MAGAZINE_INDEX_FOR_MEDIUM_REGION(region);
+ print_medium_region(szone, verbose, region, (region == szone->medium_rack.magazines[mag_index].mag_last_region)
+ ? szone->medium_rack.magazines[mag_index].mag_bytes_free_at_start
+ : 0,
+ (region == szone->medium_rack.magazines[mag_index].mag_last_region)
+ ? szone->medium_rack.magazines[mag_index].mag_bytes_free_at_end
+ : 0);
+ }
+ }
+ }
+#endif // CONFIG_MEDIUM_ALLOCATOR
if (verbose) {
print_small_free_list(&szone->small_rack);
}
@@ -1085,6 +1110,15 @@
}
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);
}
@@ -1095,6 +1129,14 @@
SZONE_UNLOCK(szone);
+#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])));
}
@@ -1110,6 +1152,14 @@
mag_index_t i;
SZONE_REINIT_LOCK(szone);
+
+#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])));
@@ -1131,6 +1181,18 @@
return 1;
}
SZONE_UNLOCK(szone);
+
+#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])));
@@ -1155,160 +1217,19 @@
{
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_rack.magazines[DEPOT_MAGAZINE_INDEX]);
- magazine_t *small_depot_ptr = (&szone->small_rack.magazines[DEPOT_MAGAZINE_INDEX]);
-
- for (mag_index = 0; mag_index < szone->tiny_rack.num_magazines; mag_index++) {
- size_t index;
- for (index = 0; index < szone->tiny_rack.region_generation->num_regions_allocated; ++index) {
- SZONE_LOCK(szone);
-
- region_t tiny = szone->tiny_rack.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->tiny_rack.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(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->tiny_rack, 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->tiny_rack, mag_ptr, REGION_TRAILER_FOR_TINY_REGION(tiny));
- int objects_in_use = tiny_free_detach_region(&szone->tiny_rack, mag_ptr, tiny);
-
- SZONE_MAGAZINE_PTR_LOCK(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_rack, 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(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_rack, 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_rack, 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(tiny_depot_ptr);
- }
- }
-
- for (mag_index = 0; mag_index < szone->small_rack.num_magazines; mag_index++) {
- size_t index;
- for (index = 0; index < szone->small_rack.region_generation->num_regions_allocated; ++index) {
- SZONE_LOCK(szone);
-
- region_t small = szone->small_rack.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->small_rack.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(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->small_rack, 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->small_rack, mag_ptr, REGION_TRAILER_FOR_SMALL_REGION(small));
- int objects_in_use = small_free_detach_region(&szone->small_rack, mag_ptr, small);
-
- SZONE_MAGAZINE_PTR_LOCK(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_rack, 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(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_rack, 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_rack, 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(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) {
@@ -1346,7 +1267,9 @@
}
#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;
}
@@ -1404,7 +1327,32 @@
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;
}
@@ -1432,6 +1380,17 @@
u += szone->small_rack.magazines[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 + 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;
@@ -1439,6 +1398,13 @@
stats->max_size_in_use = stats->size_allocated =
(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;
}
@@ -1457,7 +1423,7 @@
#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
@@ -1483,30 +1449,37 @@
debug_flags |= DISABLE_ASLR;
}
-#if CONFIG_SMALL_CUTTOFF_127KB
- debug_flags |= MALLOC_EXTENDED_SMALL_SLOTS;
- szone->is_largemem = 1;
- szone->large_threshold = LARGE_THRESHOLD_LARGEMEM;
- szone->vm_copy_threshold = VM_COPY_THRESHOLD_LARGEMEM;
-#else // CONFIG_SMALL_CUTTOFF_127KB
- debug_flags &= ~MALLOC_EXTENDED_SMALL_SLOTS;
- szone->is_largemem = 0;
- szone->large_threshold = LARGE_THRESHOLD;
- szone->vm_copy_threshold = VM_COPY_THRESHOLD;
-#endif // CONFIG_SMALL_CUTTOFF_127KB
+#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.
- uint32_t nproc = platform_cpu_count();
- uint32_t num_magazines = (nproc > 1) ? MIN(nproc, TINY_MAX_MAGAZINES) : 1;
+ 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
// madvise(..., MADV_REUSABLE) death-row arrivals above this threshold [~0.1%]
- szone->large_entry_cache_reserve_limit = (size_t)(platform_hw_memsize() >> 10);
+ szone->large_entry_cache_reserve_limit = (size_t)(memsize >> 10);
/* <rdar://problem/6610904> Reset protection when returning a previous large allocation? */
int32_t libSystemVersion = NSVersionOfLinkTimeLibrary("System");
@@ -1520,7 +1493,7 @@
// Initialize the security token.
szone->cookie = (uintptr_t)malloc_entropy[0];
- szone->basic_zone.version = 9;
+ szone->basic_zone.version = 10;
szone->basic_zone.size = (void *)szone_size;
szone->basic_zone.malloc = (void *)szone_malloc;
szone->basic_zone.calloc = (void *)szone_calloc;
@@ -1534,6 +1507,7 @@
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.claimed_address = (void *)szone_claimed_address;
/* Set to zero once and for all as required by CFAllocator. */
szone->basic_zone.reserved1 = 0;