project-base/server-skynet-source-3rd-jemalloc
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ffe552223c
server-skynet-source-3rd-je.../include/jemalloc/internal/tcache_externs.h

74 lines
2.9 KiB
C
Raw Normal View History

Break up headers into constituent parts This is part of a broader change to make header files better represent the dependencies between one another (see https://github.com/jemalloc/jemalloc/issues/533). It breaks up component headers into smaller parts that can be made to have a simpler dependency graph. For the autogenerated headers (smoothstep.h and size_classes.h), no splitting was necessary, so I didn't add support to emit multiple headers.
2017-01-11 10:06:31 +08:00
#ifndef JEMALLOC_INTERNAL_TCACHE_EXTERNS_H
#define JEMALLOC_INTERNAL_TCACHE_EXTERNS_H
Tcache: make slot sizing configurable.
2020-05-12 06:03:06 +08:00
extern bool opt_tcache;
extern ssize_t opt_lg_tcache_max;
Tcache: Make size computation configurable.
2020-05-12 03:08:19 +08:00
extern ssize_t opt_lg_tcache_nslots_mul;
Tcache: make slot sizing configurable.
2020-05-12 06:03:06 +08:00
extern unsigned opt_tcache_nslots_small_min;
extern unsigned opt_tcache_nslots_small_max;
extern unsigned opt_tcache_nslots_large;
extern ssize_t opt_lg_tcache_shift;
Tcache: Make incremental gc bytes configurable.
2020-05-12 06:53:30 +08:00
extern size_t opt_tcache_gc_incr_bytes;
Tcache: Add tcache gc delay option. This can reduce flushing frequency for small size classes.
2020-05-12 07:24:17 +08:00
extern size_t opt_tcache_gc_delay_bytes;
Tcache: Make flush fractions configurable.
2020-05-14 06:32:18 +08:00
extern unsigned opt_lg_tcache_flush_small_div;
extern unsigned opt_lg_tcache_flush_large_div;
Break up headers into constituent parts This is part of a broader change to make header files better represent the dependencies between one another (see https://github.com/jemalloc/jemalloc/issues/533). It breaks up component headers into smaller parts that can be made to have a simpler dependency graph. For the autogenerated headers (smoothstep.h and size_classes.h), no splitting was necessary, so I didn't add support to emit multiple headers.
2017-01-11 10:06:31 +08:00
/*
Hide size class computation behind a layer of indirection. This class removes almost all the dependencies on size_classes.h, accessing the data there only via the new module sc.h, which does not depend on any configuration options. In a subsequent commit, we'll remove the configure-time size class computations, doing them at boot time, instead.
2017-12-15 04:46:39 +08:00
* Number of tcache bins. There are SC_NBINS small-object bins, plus 0 or more
Break up headers into constituent parts This is part of a broader change to make header files better represent the dependencies between one another (see https://github.com/jemalloc/jemalloc/issues/533). It breaks up component headers into smaller parts that can be made to have a simpler dependency graph. For the autogenerated headers (smoothstep.h and size_classes.h), no splitting was necessary, so I didn't add support to emit multiple headers.
2017-01-11 10:06:31 +08:00
* large-object bins.
*/
extern unsigned nhbins;
/* Maximum cached size class. */
extern size_t tcache_maxclass;
Cache_bin: Shouldn't know about tcache. Instead, have it take the cache_bin_info_ts to use by pointer. While we're here, add a src file for the cache bin.
2020-02-26 04:14:48 +08:00
extern cache_bin_info_t *tcache_bin_info;
Break up headers into constituent parts This is part of a broader change to make header files better represent the dependencies between one another (see https://github.com/jemalloc/jemalloc/issues/533). It breaks up component headers into smaller parts that can be made to have a simpler dependency graph. For the autogenerated headers (smoothstep.h and size_classes.h), no splitting was necessary, so I didn't add support to emit multiple headers.
2017-01-11 10:06:31 +08:00
/*
* Explicit tcaches, managed via the tcache.{create,flush,destroy} mallctls and
* usable via the MALLOCX_TCACHE() flag. The automatic per thread tcaches are
* completely disjoint from this data structure. tcaches starts off as a sparse
* array, so it has no physical memory footprint until individual pages are
* touched. This allows the entire array to be allocated the first time an
* explicit tcache is created without a disproportionate impact on memory usage.
*/
extern tcaches_t *tcaches;
Revert "Use trylock in tcache_bin_flush when possible." This reverts commit 8584adc451f31adfc4ab8693d9189cf3a7e5d858. Production results not favorable. Will investigate separately.
2017-04-29 04:31:09 +08:00
size_t tcache_salloc(tsdn_t *tsdn, const void *ptr);
void *tcache_alloc_small_hard(tsdn_t *tsdn, arena_t *arena, tcache_t *tcache,
Pull out caching for a bin into its own file. This is the first step towards breaking up the tcache and arena (since they interact primarily at the bin level). It should also make a future arena caching implementation more straightforward.
2017-08-11 05:27:58 +08:00
cache_bin_t *tbin, szind_t binind, bool *tcache_success);
Tcache: split up fast and slow path data.
2020-04-08 08:48:35 +08:00
Pull out caching for a bin into its own file. This is the first step towards breaking up the tcache and arena (since they interact primarily at the bin level). It should also make a future arena caching implementation more straightforward.
2017-08-11 05:27:58 +08:00
void tcache_bin_flush_small(tsd_t *tsd, tcache_t *tcache, cache_bin_t *tbin,
Break up headers into constituent parts This is part of a broader change to make header files better represent the dependencies between one another (see https://github.com/jemalloc/jemalloc/issues/533). It breaks up component headers into smaller parts that can be made to have a simpler dependency graph. For the autogenerated headers (smoothstep.h and size_classes.h), no splitting was necessary, so I didn't add support to emit multiple headers.
2017-01-11 10:06:31 +08:00
szind_t binind, unsigned rem);
Unify the signature of tcache_flush small and large.
2019-08-13 02:08:39 +08:00
void tcache_bin_flush_large(tsd_t *tsd, tcache_t *tcache, cache_bin_t *tbin,
szind_t binind, unsigned rem);
Tcache: split up fast and slow path data.
2020-04-08 08:48:35 +08:00
void tcache_arena_reassociate(tsdn_t *tsdn, tcache_slow_t *tcache_slow,
tcache_t *tcache, arena_t *arena);
Integrate auto tcache into TSD. The embedded tcache is initialized upon tsd initialization. The avail arrays for the tbins will be allocated / deallocated accordingly during init / cleanup. With this change, the pointer to the auto tcache will always be available, as long as we have access to the TSD. tcache_available() (called in tcache_get()) is provided to check if we should use tcache.
2017-03-28 12:50:38 +08:00
tcache_t *tcache_create_explicit(tsd_t *tsd);
Revert "Use trylock in tcache_bin_flush when possible." This reverts commit 8584adc451f31adfc4ab8693d9189cf3a7e5d858. Production results not favorable. Will investigate separately.
2017-04-29 04:31:09 +08:00
void tcache_cleanup(tsd_t *tsd);
void tcache_stats_merge(tsdn_t *tsdn, tcache_t *tcache, arena_t *arena);
Break prof and tcache knowledge of b0.
2020-02-18 06:09:29 +08:00
bool tcaches_create(tsd_t *tsd, base_t *base, unsigned *r_ind);
Revert "Use trylock in tcache_bin_flush when possible." This reverts commit 8584adc451f31adfc4ab8693d9189cf3a7e5d858. Production results not favorable. Will investigate separately.
2017-04-29 04:31:09 +08:00
void tcaches_flush(tsd_t *tsd, unsigned ind);
void tcaches_destroy(tsd_t *tsd, unsigned ind);
Break prof and tcache knowledge of b0.
2020-02-18 06:09:29 +08:00
bool tcache_boot(tsdn_t *tsdn, base_t *base);
Tcache: split up fast and slow path data.
2020-04-08 08:48:35 +08:00
void tcache_arena_associate(tsdn_t *tsdn, tcache_slow_t *tcache_slow,
tcache_t *tcache, arena_t *arena);
Fix/refactor tcaches synchronization. Synchronize tcaches with tcaches_mtx rather than ctl_mtx. Add missing synchronization for tcache flushing. This bug was introduced by 1cb181ed632e7573fb4eab194e4d216867222d27 (Implement explicit tcache support.), which was first released in 4.0.0.
2017-01-30 13:32:39 +08:00
void tcache_prefork(tsdn_t *tsdn);
void tcache_postfork_parent(tsdn_t *tsdn);
void tcache_postfork_child(tsdn_t *tsdn);
Pass tsd to tcache_flush().
2017-06-16 06:16:18 +08:00
void tcache_flush(tsd_t *tsd);
Integrate auto tcache into TSD. The embedded tcache is initialized upon tsd initialization. The avail arrays for the tbins will be allocated / deallocated accordingly during init / cleanup. With this change, the pointer to the auto tcache will always be available, as long as we have access to the TSD. tcache_available() (called in tcache_get()) is provided to check if we should use tcache.
2017-03-28 12:50:38 +08:00
bool tsd_tcache_data_init(tsd_t *tsd);
bool tsd_tcache_enabled_data_init(tsd_t *tsd);
Break up headers into constituent parts This is part of a broader change to make header files better represent the dependencies between one another (see https://github.com/jemalloc/jemalloc/issues/533). It breaks up component headers into smaller parts that can be made to have a simpler dependency graph. For the autogenerated headers (smoothstep.h and size_classes.h), no splitting was necessary, so I didn't add support to emit multiple headers.
2017-01-11 10:06:31 +08:00
Tcache: treat small and large cache bins uniformly
2020-04-08 11:04:46 +08:00
void tcache_assert_initialized(tcache_t *tcache);
Extract out per event new wait time fetching
2020-04-16 01:49:08 +08:00
/* Only accessed by thread event. */
uint64_t tcache_gc_new_event_wait(tsd_t *tsd);
Extract out per event postponed wait time fetching
2020-04-17 04:33:56 +08:00
uint64_t tcache_gc_postponed_event_wait(tsd_t *tsd);
Push event handlers to constituent modules
2020-04-18 01:38:06 +08:00
void tcache_gc_event_handler(tsd_t *tsd, uint64_t elapsed);
Extract out per event new wait time fetching
2020-04-16 01:49:08 +08:00
uint64_t tcache_gc_dalloc_new_event_wait(tsd_t *tsd);
Extract out per event postponed wait time fetching
2020-04-17 04:33:56 +08:00
uint64_t tcache_gc_dalloc_postponed_event_wait(tsd_t *tsd);
Push event handlers to constituent modules
2020-04-18 01:38:06 +08:00
void tcache_gc_dalloc_event_handler(tsd_t *tsd, uint64_t elapsed);
Extract out per event new wait time fetching
2020-04-16 01:49:08 +08:00
Break up headers into constituent parts This is part of a broader change to make header files better represent the dependencies between one another (see https://github.com/jemalloc/jemalloc/issues/533). It breaks up component headers into smaller parts that can be made to have a simpler dependency graph. For the autogenerated headers (smoothstep.h and size_classes.h), no splitting was necessary, so I didn't add support to emit multiple headers.
2017-01-11 10:06:31 +08:00
#endif /* JEMALLOC_INTERNAL_TCACHE_EXTERNS_H */
Reference in New Issue Copy Permalink