d27f29b468
Refactor arena and extent locking protocols such that arena and
extent locks are never held when calling into the extent_*_wrapper()
API. This requires extra care during purging since the arena lock no
longer protects the inner purging logic. It also requires extra care to
protect extents from being merged with adjacent extents.
Convert extent_t's 'active' flag to an enumerated 'state', so that
retained extents are explicitly marked as such, rather than depending on
ring linkage state.
Refactor the extent collections (and their synchronization) for cached
and retained extents into extents_t. Incorporate LRU functionality to
support purging. Incorporate page count accounting, which replaces
arena->ndirty and arena->stats.retained.
Assert that no core locks are held when entering any internal
[de]allocation functions. This is in addition to existing assertions
that no locks are held when entering external [de]allocation functions.
Audit and document synchronization protocols for all arena_t fields.
This fixes a potential deadlock due to recursive allocation during
gdump, in a similar fashion to b49c649bc1
(Fix lock order reversal during gdump.), but with a necessarily much
broader code impact.
242 lines
6.3 KiB
C
242 lines
6.3 KiB
C
#ifndef JEMALLOC_INTERNAL_ARENA_STRUCTS_B_H
|
|
#define JEMALLOC_INTERNAL_ARENA_STRUCTS_B_H
|
|
/*
|
|
* Read-only information associated with each element of arena_t's bins array
|
|
* is stored separately, partly to reduce memory usage (only one copy, rather
|
|
* than one per arena), but mainly to avoid false cacheline sharing.
|
|
*
|
|
* Each slab has the following layout:
|
|
*
|
|
* /--------------------\
|
|
* | region 0 |
|
|
* |--------------------|
|
|
* | region 1 |
|
|
* |--------------------|
|
|
* | ... |
|
|
* | ... |
|
|
* | ... |
|
|
* |--------------------|
|
|
* | region nregs-1 |
|
|
* \--------------------/
|
|
*/
|
|
struct arena_bin_info_s {
|
|
/* Size of regions in a slab for this bin's size class. */
|
|
size_t reg_size;
|
|
|
|
/* Total size of a slab for this bin's size class. */
|
|
size_t slab_size;
|
|
|
|
/* Total number of regions in a slab for this bin's size class. */
|
|
uint32_t nregs;
|
|
|
|
/*
|
|
* Metadata used to manipulate bitmaps for slabs associated with this
|
|
* bin.
|
|
*/
|
|
bitmap_info_t bitmap_info;
|
|
};
|
|
|
|
struct arena_decay_s {
|
|
/*
|
|
* Approximate time in seconds from the creation of a set of unused
|
|
* dirty pages until an equivalent set of unused dirty pages is purged
|
|
* and/or reused.
|
|
*/
|
|
ssize_t time;
|
|
/* time / SMOOTHSTEP_NSTEPS. */
|
|
nstime_t interval;
|
|
/*
|
|
* Time at which the current decay interval logically started. We do
|
|
* not actually advance to a new epoch until sometime after it starts
|
|
* because of scheduling and computation delays, and it is even possible
|
|
* to completely skip epochs. In all cases, during epoch advancement we
|
|
* merge all relevant activity into the most recently recorded epoch.
|
|
*/
|
|
nstime_t epoch;
|
|
/* Deadline randomness generator. */
|
|
uint64_t jitter_state;
|
|
/*
|
|
* Deadline for current epoch. This is the sum of interval and per
|
|
* epoch jitter which is a uniform random variable in [0..interval).
|
|
* Epochs always advance by precise multiples of interval, but we
|
|
* randomize the deadline to reduce the likelihood of arenas purging in
|
|
* lockstep.
|
|
*/
|
|
nstime_t deadline;
|
|
/*
|
|
* Number of dirty pages at beginning of current epoch. During epoch
|
|
* advancement we use the delta between arena->decay.ndirty and
|
|
* extents_npages_get(&arena->extents_cached) to determine how many
|
|
* dirty pages, if any, were generated.
|
|
*/
|
|
size_t nunpurged;
|
|
/*
|
|
* Trailing log of how many unused dirty pages were generated during
|
|
* each of the past SMOOTHSTEP_NSTEPS decay epochs, where the last
|
|
* element is the most recent epoch. Corresponding epoch times are
|
|
* relative to epoch.
|
|
*/
|
|
size_t backlog[SMOOTHSTEP_NSTEPS];
|
|
};
|
|
|
|
struct arena_bin_s {
|
|
/* All operations on arena_bin_t fields require lock ownership. */
|
|
malloc_mutex_t lock;
|
|
|
|
/*
|
|
* Current slab being used to service allocations of this bin's size
|
|
* class. slabcur is independent of slabs_{nonfull,full}; whenever
|
|
* slabcur is reassigned, the previous slab must be deallocated or
|
|
* inserted into slabs_{nonfull,full}.
|
|
*/
|
|
extent_t *slabcur;
|
|
|
|
/*
|
|
* Heap of non-full slabs. This heap is used to assure that new
|
|
* allocations come from the non-full slab that is oldest/lowest in
|
|
* memory.
|
|
*/
|
|
extent_heap_t slabs_nonfull;
|
|
|
|
/* List used to track full slabs. */
|
|
extent_list_t slabs_full;
|
|
|
|
/* Bin statistics. */
|
|
malloc_bin_stats_t stats;
|
|
};
|
|
|
|
struct arena_s {
|
|
/*
|
|
* Number of threads currently assigned to this arena. Each thread has
|
|
* two distinct assignments, one for application-serving allocation, and
|
|
* the other for internal metadata allocation. Internal metadata must
|
|
* not be allocated from arenas explicitly created via the arenas.create
|
|
* mallctl, because the arena.<i>.reset mallctl indiscriminately
|
|
* discards all allocations for the affected arena.
|
|
*
|
|
* 0: Application allocation.
|
|
* 1: Internal metadata allocation.
|
|
*
|
|
* Synchronization: atomic.
|
|
*/
|
|
unsigned nthreads[2];
|
|
|
|
/*
|
|
* Synchronizes various arena operations, as indicated in field-specific
|
|
* comments.
|
|
*/
|
|
malloc_mutex_t lock;
|
|
|
|
/* Synchronization: lock. */
|
|
arena_stats_t stats;
|
|
/*
|
|
* List of tcaches for extant threads associated with this arena.
|
|
* Stats from these are merged incrementally, and at exit if
|
|
* opt_stats_print is enabled.
|
|
*
|
|
* Synchronization: lock.
|
|
*/
|
|
ql_head(tcache_t) tcache_ql;
|
|
|
|
/* Synchronization: lock. */
|
|
uint64_t prof_accumbytes;
|
|
|
|
/*
|
|
* PRNG state for cache index randomization of large allocation base
|
|
* pointers.
|
|
*
|
|
* Synchronization: atomic.
|
|
*/
|
|
size_t offset_state;
|
|
|
|
/*
|
|
* Extent serial number generator state.
|
|
*
|
|
* Synchronization: atomic.
|
|
*/
|
|
size_t extent_sn_next;
|
|
|
|
/* Synchronization: lock. */
|
|
dss_prec_t dss_prec;
|
|
|
|
/*
|
|
* 1/0 (true/false) if a thread is currently executing
|
|
* arena_purge_to_limit().
|
|
*
|
|
* Synchronization: atomic.
|
|
*/
|
|
unsigned purging;
|
|
|
|
/*
|
|
* Number of pages in active extents.
|
|
*
|
|
* Synchronization: atomic.
|
|
*/
|
|
size_t nactive;
|
|
|
|
/*
|
|
* Decay-based purging state.
|
|
*
|
|
* Synchronization: lock.
|
|
*/
|
|
arena_decay_t decay;
|
|
|
|
/*
|
|
* Extant large allocations.
|
|
*
|
|
* Synchronization: large_mtx.
|
|
*/
|
|
extent_list_t large;
|
|
/* Synchronizes all large allocation/update/deallocation. */
|
|
malloc_mutex_t large_mtx;
|
|
|
|
/*
|
|
* Collections of extents that were previously allocated. These are
|
|
* used when allocating extents, in an attempt to re-use address space.
|
|
*
|
|
* Synchronization: internal.
|
|
*/
|
|
extents_t extents_cached;
|
|
extents_t extents_retained;
|
|
|
|
/*
|
|
* Next extent size class in a growing series to use when satisfying a
|
|
* request via the extent hooks (only if !config_munmap). This limits
|
|
* the number of disjoint virtual memory ranges so that extent merging
|
|
* can be effective even if multiple arenas' extent allocation requests
|
|
* are highly interleaved.
|
|
*
|
|
* Synchronization: atomic.
|
|
*/
|
|
pszind_t extent_grow_next;
|
|
|
|
/*
|
|
* Freelist of extent structures that were allocated via base_alloc().
|
|
*
|
|
* Synchronization: extent_freelist_mtx.
|
|
*/
|
|
extent_list_t extent_freelist;
|
|
malloc_mutex_t extent_freelist_mtx;
|
|
|
|
/*
|
|
* bins is used to store heaps of free regions.
|
|
*
|
|
* Synchronization: internal.
|
|
*/
|
|
arena_bin_t bins[NBINS];
|
|
|
|
/*
|
|
* Base allocator, from which arena metadata are allocated.
|
|
*
|
|
* Synchronization: internal.
|
|
*/
|
|
base_t *base;
|
|
};
|
|
|
|
/* Used in conjunction with tsd for fast arena-related context lookup. */
|
|
struct arena_tdata_s {
|
|
ticker_t decay_ticker;
|
|
};
|
|
|
|
#endif /* JEMALLOC_INTERNAL_ARENA_STRUCTS_B_H */
|