diff options
Diffstat (limited to 'deps/jemalloc/src/zone.c')
-rw-r--r-- | deps/jemalloc/src/zone.c | 469 |
1 files changed, 0 insertions, 469 deletions
diff --git a/deps/jemalloc/src/zone.c b/deps/jemalloc/src/zone.c deleted file mode 100644 index 23dfdd04a..000000000 --- a/deps/jemalloc/src/zone.c +++ /dev/null @@ -1,469 +0,0 @@ -#include "jemalloc/internal/jemalloc_preamble.h" -#include "jemalloc/internal/jemalloc_internal_includes.h" - -#include "jemalloc/internal/assert.h" - -#ifndef JEMALLOC_ZONE -# error "This source file is for zones on Darwin (OS X)." -#endif - -/* Definitions of the following structs in malloc/malloc.h might be too old - * for the built binary to run on newer versions of OSX. So use the newest - * possible version of those structs. - */ -typedef struct _malloc_zone_t { - void *reserved1; - void *reserved2; - size_t (*size)(struct _malloc_zone_t *, const void *); - void *(*malloc)(struct _malloc_zone_t *, size_t); - void *(*calloc)(struct _malloc_zone_t *, size_t, size_t); - void *(*valloc)(struct _malloc_zone_t *, size_t); - void (*free)(struct _malloc_zone_t *, void *); - void *(*realloc)(struct _malloc_zone_t *, void *, size_t); - void (*destroy)(struct _malloc_zone_t *); - const char *zone_name; - unsigned (*batch_malloc)(struct _malloc_zone_t *, size_t, void **, unsigned); - void (*batch_free)(struct _malloc_zone_t *, void **, unsigned); - struct malloc_introspection_t *introspect; - unsigned version; - void *(*memalign)(struct _malloc_zone_t *, size_t, size_t); - void (*free_definite_size)(struct _malloc_zone_t *, void *, size_t); - size_t (*pressure_relief)(struct _malloc_zone_t *, size_t); -} malloc_zone_t; - -typedef struct { - vm_address_t address; - vm_size_t size; -} vm_range_t; - -typedef struct malloc_statistics_t { - unsigned blocks_in_use; - size_t size_in_use; - size_t max_size_in_use; - size_t size_allocated; -} malloc_statistics_t; - -typedef kern_return_t memory_reader_t(task_t, vm_address_t, vm_size_t, void **); - -typedef void vm_range_recorder_t(task_t, void *, unsigned type, vm_range_t *, unsigned); - -typedef struct malloc_introspection_t { - kern_return_t (*enumerator)(task_t, void *, unsigned, vm_address_t, memory_reader_t, vm_range_recorder_t); - size_t (*good_size)(malloc_zone_t *, size_t); - boolean_t (*check)(malloc_zone_t *); - void (*print)(malloc_zone_t *, boolean_t); - void (*log)(malloc_zone_t *, void *); - void (*force_lock)(malloc_zone_t *); - void (*force_unlock)(malloc_zone_t *); - void (*statistics)(malloc_zone_t *, malloc_statistics_t *); - boolean_t (*zone_locked)(malloc_zone_t *); - boolean_t (*enable_discharge_checking)(malloc_zone_t *); - boolean_t (*disable_discharge_checking)(malloc_zone_t *); - void (*discharge)(malloc_zone_t *, void *); -#ifdef __BLOCKS__ - void (*enumerate_discharged_pointers)(malloc_zone_t *, void (^)(void *, void *)); -#else - void *enumerate_unavailable_without_blocks; -#endif - void (*reinit_lock)(malloc_zone_t *); -} malloc_introspection_t; - -extern kern_return_t malloc_get_all_zones(task_t, memory_reader_t, vm_address_t **, unsigned *); - -extern malloc_zone_t *malloc_default_zone(void); - -extern void malloc_zone_register(malloc_zone_t *zone); - -extern void malloc_zone_unregister(malloc_zone_t *zone); - -/* - * The malloc_default_purgeable_zone() function is only available on >= 10.6. - * We need to check whether it is present at runtime, thus the weak_import. - */ -extern malloc_zone_t *malloc_default_purgeable_zone(void) -JEMALLOC_ATTR(weak_import); - -/******************************************************************************/ -/* Data. */ - -static malloc_zone_t *default_zone, *purgeable_zone; -static malloc_zone_t jemalloc_zone; -static struct malloc_introspection_t jemalloc_zone_introspect; -static pid_t zone_force_lock_pid = -1; - -/******************************************************************************/ -/* Function prototypes for non-inline static functions. */ - -static size_t zone_size(malloc_zone_t *zone, const void *ptr); -static void *zone_malloc(malloc_zone_t *zone, size_t size); -static void *zone_calloc(malloc_zone_t *zone, size_t num, size_t size); -static void *zone_valloc(malloc_zone_t *zone, size_t size); -static void zone_free(malloc_zone_t *zone, void *ptr); -static void *zone_realloc(malloc_zone_t *zone, void *ptr, size_t size); -static void *zone_memalign(malloc_zone_t *zone, size_t alignment, - size_t size); -static void zone_free_definite_size(malloc_zone_t *zone, void *ptr, - size_t size); -static void zone_destroy(malloc_zone_t *zone); -static unsigned zone_batch_malloc(struct _malloc_zone_t *zone, size_t size, - void **results, unsigned num_requested); -static void zone_batch_free(struct _malloc_zone_t *zone, - void **to_be_freed, unsigned num_to_be_freed); -static size_t zone_pressure_relief(struct _malloc_zone_t *zone, size_t goal); -static size_t zone_good_size(malloc_zone_t *zone, size_t size); -static kern_return_t zone_enumerator(task_t task, void *data, unsigned type_mask, - vm_address_t zone_address, memory_reader_t reader, - vm_range_recorder_t recorder); -static boolean_t zone_check(malloc_zone_t *zone); -static void zone_print(malloc_zone_t *zone, boolean_t verbose); -static void zone_log(malloc_zone_t *zone, void *address); -static void zone_force_lock(malloc_zone_t *zone); -static void zone_force_unlock(malloc_zone_t *zone); -static void zone_statistics(malloc_zone_t *zone, - malloc_statistics_t *stats); -static boolean_t zone_locked(malloc_zone_t *zone); -static void zone_reinit_lock(malloc_zone_t *zone); - -/******************************************************************************/ -/* - * Functions. - */ - -static size_t -zone_size(malloc_zone_t *zone, const void *ptr) { - /* - * There appear to be places within Darwin (such as setenv(3)) that - * cause calls to this function with pointers that *no* zone owns. If - * we knew that all pointers were owned by *some* zone, we could split - * our zone into two parts, and use one as the default allocator and - * the other as the default deallocator/reallocator. Since that will - * not work in practice, we must check all pointers to assure that they - * reside within a mapped extent before determining size. - */ - return ivsalloc(tsdn_fetch(), ptr); -} - -static void * -zone_malloc(malloc_zone_t *zone, size_t size) { - return je_malloc(size); -} - -static void * -zone_calloc(malloc_zone_t *zone, size_t num, size_t size) { - return je_calloc(num, size); -} - -static void * -zone_valloc(malloc_zone_t *zone, size_t size) { - void *ret = NULL; /* Assignment avoids useless compiler warning. */ - - je_posix_memalign(&ret, PAGE, size); - - return ret; -} - -static void -zone_free(malloc_zone_t *zone, void *ptr) { - if (ivsalloc(tsdn_fetch(), ptr) != 0) { - je_free(ptr); - return; - } - - free(ptr); -} - -static void * -zone_realloc(malloc_zone_t *zone, void *ptr, size_t size) { - if (ivsalloc(tsdn_fetch(), ptr) != 0) { - return je_realloc(ptr, size); - } - - return realloc(ptr, size); -} - -static void * -zone_memalign(malloc_zone_t *zone, size_t alignment, size_t size) { - void *ret = NULL; /* Assignment avoids useless compiler warning. */ - - je_posix_memalign(&ret, alignment, size); - - return ret; -} - -static void -zone_free_definite_size(malloc_zone_t *zone, void *ptr, size_t size) { - size_t alloc_size; - - alloc_size = ivsalloc(tsdn_fetch(), ptr); - if (alloc_size != 0) { - assert(alloc_size == size); - je_free(ptr); - return; - } - - free(ptr); -} - -static void -zone_destroy(malloc_zone_t *zone) { - /* This function should never be called. */ - not_reached(); -} - -static unsigned -zone_batch_malloc(struct _malloc_zone_t *zone, size_t size, void **results, - unsigned num_requested) { - unsigned i; - - for (i = 0; i < num_requested; i++) { - results[i] = je_malloc(size); - if (!results[i]) - break; - } - - return i; -} - -static void -zone_batch_free(struct _malloc_zone_t *zone, void **to_be_freed, - unsigned num_to_be_freed) { - unsigned i; - - for (i = 0; i < num_to_be_freed; i++) { - zone_free(zone, to_be_freed[i]); - to_be_freed[i] = NULL; - } -} - -static size_t -zone_pressure_relief(struct _malloc_zone_t *zone, size_t goal) { - return 0; -} - -static size_t -zone_good_size(malloc_zone_t *zone, size_t size) { - if (size == 0) { - size = 1; - } - return sz_s2u(size); -} - -static kern_return_t -zone_enumerator(task_t task, void *data, unsigned type_mask, - vm_address_t zone_address, memory_reader_t reader, - vm_range_recorder_t recorder) { - return KERN_SUCCESS; -} - -static boolean_t -zone_check(malloc_zone_t *zone) { - return true; -} - -static void -zone_print(malloc_zone_t *zone, boolean_t verbose) { -} - -static void -zone_log(malloc_zone_t *zone, void *address) { -} - -static void -zone_force_lock(malloc_zone_t *zone) { - if (isthreaded) { - /* - * See the note in zone_force_unlock, below, to see why we need - * this. - */ - assert(zone_force_lock_pid == -1); - zone_force_lock_pid = getpid(); - jemalloc_prefork(); - } -} - -static void -zone_force_unlock(malloc_zone_t *zone) { - /* - * zone_force_lock and zone_force_unlock are the entry points to the - * forking machinery on OS X. The tricky thing is, the child is not - * allowed to unlock mutexes locked in the parent, even if owned by the - * forking thread (and the mutex type we use in OS X will fail an assert - * if we try). In the child, we can get away with reinitializing all - * the mutexes, which has the effect of unlocking them. In the parent, - * doing this would mean we wouldn't wake any waiters blocked on the - * mutexes we unlock. So, we record the pid of the current thread in - * zone_force_lock, and use that to detect if we're in the parent or - * child here, to decide which unlock logic we need. - */ - if (isthreaded) { - assert(zone_force_lock_pid != -1); - if (getpid() == zone_force_lock_pid) { - jemalloc_postfork_parent(); - } else { - jemalloc_postfork_child(); - } - zone_force_lock_pid = -1; - } -} - -static void -zone_statistics(malloc_zone_t *zone, malloc_statistics_t *stats) { - /* We make no effort to actually fill the values */ - stats->blocks_in_use = 0; - stats->size_in_use = 0; - stats->max_size_in_use = 0; - stats->size_allocated = 0; -} - -static boolean_t -zone_locked(malloc_zone_t *zone) { - /* Pretend no lock is being held */ - return false; -} - -static void -zone_reinit_lock(malloc_zone_t *zone) { - /* As of OSX 10.12, this function is only used when force_unlock would - * be used if the zone version were < 9. So just use force_unlock. */ - zone_force_unlock(zone); -} - -static void -zone_init(void) { - jemalloc_zone.size = zone_size; - jemalloc_zone.malloc = zone_malloc; - jemalloc_zone.calloc = zone_calloc; - jemalloc_zone.valloc = zone_valloc; - jemalloc_zone.free = zone_free; - jemalloc_zone.realloc = zone_realloc; - jemalloc_zone.destroy = zone_destroy; - jemalloc_zone.zone_name = "jemalloc_zone"; - jemalloc_zone.batch_malloc = zone_batch_malloc; - jemalloc_zone.batch_free = zone_batch_free; - jemalloc_zone.introspect = &jemalloc_zone_introspect; - jemalloc_zone.version = 9; - jemalloc_zone.memalign = zone_memalign; - jemalloc_zone.free_definite_size = zone_free_definite_size; - jemalloc_zone.pressure_relief = zone_pressure_relief; - - jemalloc_zone_introspect.enumerator = zone_enumerator; - jemalloc_zone_introspect.good_size = zone_good_size; - jemalloc_zone_introspect.check = zone_check; - jemalloc_zone_introspect.print = zone_print; - jemalloc_zone_introspect.log = zone_log; - jemalloc_zone_introspect.force_lock = zone_force_lock; - jemalloc_zone_introspect.force_unlock = zone_force_unlock; - jemalloc_zone_introspect.statistics = zone_statistics; - jemalloc_zone_introspect.zone_locked = zone_locked; - jemalloc_zone_introspect.enable_discharge_checking = NULL; - jemalloc_zone_introspect.disable_discharge_checking = NULL; - jemalloc_zone_introspect.discharge = NULL; -#ifdef __BLOCKS__ - jemalloc_zone_introspect.enumerate_discharged_pointers = NULL; -#else - jemalloc_zone_introspect.enumerate_unavailable_without_blocks = NULL; -#endif - jemalloc_zone_introspect.reinit_lock = zone_reinit_lock; -} - -static malloc_zone_t * -zone_default_get(void) { - malloc_zone_t **zones = NULL; - unsigned int num_zones = 0; - - /* - * On OSX 10.12, malloc_default_zone returns a special zone that is not - * present in the list of registered zones. That zone uses a "lite zone" - * if one is present (apparently enabled when malloc stack logging is - * enabled), or the first registered zone otherwise. In practice this - * means unless malloc stack logging is enabled, the first registered - * zone is the default. So get the list of zones to get the first one, - * instead of relying on malloc_default_zone. - */ - if (KERN_SUCCESS != malloc_get_all_zones(0, NULL, - (vm_address_t**)&zones, &num_zones)) { - /* - * Reset the value in case the failure happened after it was - * set. - */ - num_zones = 0; - } - - if (num_zones) { - return zones[0]; - } - - return malloc_default_zone(); -} - -/* As written, this function can only promote jemalloc_zone. */ -static void -zone_promote(void) { - malloc_zone_t *zone; - - do { - /* - * Unregister and reregister the default zone. On OSX >= 10.6, - * unregistering takes the last registered zone and places it - * at the location of the specified zone. Unregistering the - * default zone thus makes the last registered one the default. - * On OSX < 10.6, unregistering shifts all registered zones. - * The first registered zone then becomes the default. - */ - malloc_zone_unregister(default_zone); - malloc_zone_register(default_zone); - - /* - * On OSX 10.6, having the default purgeable zone appear before - * the default zone makes some things crash because it thinks it - * owns the default zone allocated pointers. We thus - * unregister/re-register it in order to ensure it's always - * after the default zone. On OSX < 10.6, there is no purgeable - * zone, so this does nothing. On OSX >= 10.6, unregistering - * replaces the purgeable zone with the last registered zone - * above, i.e. the default zone. Registering it again then puts - * it at the end, obviously after the default zone. - */ - if (purgeable_zone != NULL) { - malloc_zone_unregister(purgeable_zone); - malloc_zone_register(purgeable_zone); - } - - zone = zone_default_get(); - } while (zone != &jemalloc_zone); -} - -JEMALLOC_ATTR(constructor) -void -zone_register(void) { - /* - * If something else replaced the system default zone allocator, don't - * register jemalloc's. - */ - default_zone = zone_default_get(); - if (!default_zone->zone_name || strcmp(default_zone->zone_name, - "DefaultMallocZone") != 0) { - return; - } - - /* - * The default purgeable zone is created lazily by OSX's libc. It uses - * the default zone when it is created for "small" allocations - * (< 15 KiB), but assumes the default zone is a scalable_zone. This - * obviously fails when the default zone is the jemalloc zone, so - * malloc_default_purgeable_zone() is called beforehand so that the - * default purgeable zone is created when the default zone is still - * a scalable_zone. As purgeable zones only exist on >= 10.6, we need - * to check for the existence of malloc_default_purgeable_zone() at - * run time. - */ - purgeable_zone = (malloc_default_purgeable_zone == NULL) ? NULL : - malloc_default_purgeable_zone(); - - /* Register the custom zone. At this point it won't be the default. */ - zone_init(); - malloc_zone_register(&jemalloc_zone); - - /* Promote the custom zone to be default. */ - zone_promote(); -} |