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

97 lines
3.4 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_PROF_EXTERNS_H
#define JEMALLOC_INTERNAL_PROF_EXTERNS_H
Header refactoring: unify and de-catchall mutex module
2017-05-24 03:28:19 +08:00
#include "jemalloc/internal/mutex.h"
Allow setting custom backtrace hook Existing backtrace implementations skip native stack frames from runtimes like Python. The hook allows to augment the backtraces to attribute allocations to native functions in heap profiles.
2021-08-31 05:05:56 +08:00
#include "jemalloc/internal/prof_hook.h"
Header refactoring: unify and de-catchall mutex module
2017-05-24 03:28:19 +08:00
Get rid of old indentation style for prof
2019-12-07 01:45:40 +08:00
extern bool opt_prof;
extern bool opt_prof_active;
extern bool opt_prof_thread_active_init;
Making jemalloc max stack depth a runtime option
2022-08-20 03:17:10 +08:00
extern unsigned opt_prof_bt_max;
Get rid of old indentation style for prof
2019-12-07 01:45:40 +08:00
extern size_t opt_lg_prof_sample; /* Mean bytes between samples. */
extern ssize_t opt_lg_prof_interval; /* lg(prof_interval). */
extern bool opt_prof_gdump; /* High-water memory dumping. */
extern bool opt_prof_final; /* Final profile dumping. */
extern bool opt_prof_leak; /* Dump leak summary at exit. */
Add prof_leak_error option The option makes the process to exit with error code 1 if a memory leak is detected. This is useful for implementing automated tools that rely on leak detection.
2022-01-12 18:46:34 +08:00
extern bool opt_prof_leak_error; /* Exit with error code if memory leaked */
Get rid of old indentation style for prof
2019-12-07 01:45:40 +08:00
extern bool opt_prof_accum; /* Report cumulative bytes. */
extern bool opt_prof_log; /* Turn logging on at boot. */
extern char opt_prof_prefix[
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
/* Minimize memory bloat for non-prof builds. */
#ifdef JEMALLOC_PROF
PATH_MAX +
#endif
1];
Prof: Add prof_unbias. This gives more accurate attribution of bytes and counts to stack traces, without introducing backwards incompatibilities in heap-profile parsing tools. We track the ideal reported (to the end user) number of bytes more carefully inside core jemalloc. When dumping heap profiles, insteading of outputting our counts directly, we output counts that will cause parsing tools to give a result close to the value we want. We retain the old version as an opt setting, to let users who are tracking values on a per-component basis to keep their metrics stable until they decide to switch.
2020-08-04 04:05:34 +08:00
extern bool opt_prof_unbias;
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
Last-N profiling mode
2019-12-19 05:38:14 +08:00
/* For recording recent allocations */
extern ssize_t opt_prof_recent_alloc_max;
Add option to fetch system thread name on each prof sample
2020-03-25 08:53:41 +08:00
/* Whether to use thread name provided by the system or by mallctl. */
Improve naming for prof system thread name option
2020-06-20 06:16:53 +08:00
extern bool opt_prof_sys_thread_name;
Add option to fetch system thread name on each prof sample
2020-03-25 08:53:41 +08:00
Track per size class internal fragmentation
2020-12-19 09:14:59 +08:00
/* Whether to record per size class counts and request size totals. */
extern bool opt_prof_stats;
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
/* Accessed via prof_active_[gs]et{_unlocked,}(). */
Fix shadowed variable usage. Verified with EXTRA_CFLAGS=-Wshadow.
2021-12-23 09:24:58 +08:00
extern bool prof_active_state;
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
/* Accessed via prof_gdump_[gs]et{_unlocked,}(). */
Get rid of old indentation style for prof
2019-12-07 01:45:40 +08:00
extern bool prof_gdump_val;
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
Pull prof_accumbytes into thread event handler
2019-10-15 00:35:51 +08:00
/* Profile dump interval, measured in bytes allocated. */
Get rid of old indentation style for prof
2019-12-07 01:45:40 +08:00
extern uint64_t prof_interval;
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
/*
* Initialized as opt_lg_prof_sample, and potentially modified during profiling
* resets.
*/
Get rid of old indentation style for prof
2019-12-07 01:45:40 +08:00
extern size_t lg_prof_sample;
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
Get rid of old indentation style for prof
2019-12-07 01:45:40 +08:00
extern bool prof_booted;
Refactor prof log Prof logging is conceptually seperate from core profiling, so split it out as a module of its own. There are a few internal functions that had to be exposed but I think it is a fair trade-off.
2019-07-13 07:37:37 +08:00
Allow setting custom backtrace hook Existing backtrace implementations skip native stack frames from runtimes like Python. The hook allows to augment the backtraces to attribute allocations to native functions in heap profiles.
2021-08-31 05:05:56 +08:00
void prof_backtrace_hook_set(prof_backtrace_hook_t hook);
prof_backtrace_hook_t prof_backtrace_hook_get();
Add a simple utility to detect profiling bias.
2020-08-04 06:27:08 +08:00
Allow setting a dump hook If users want to be notified when a heap dump occurs, they can set this hook.
2021-09-02 04:00:01 +08:00
void prof_dump_hook_set(prof_dump_hook_t hook);
prof_dump_hook_t prof_dump_hook_get();
Consolidate prof inline function headers The prof inline functions are no longer involved in a circular dependency, so consolidate the two headers into one.
2020-04-29 00:59:37 +08:00
/* Functions only accessed in prof_inlines.h */
Refactor profiling headers
2019-12-19 07:15:31 +08:00
prof_tdata_t *prof_tdata_init(tsd_t *tsd);
prof_tdata_t *prof_tdata_reinit(tsd_t *tsd, prof_tdata_t *tdata);
Rewrite profiling thread event
2020-03-10 06:49:15 +08:00
void prof_alloc_rollback(tsd_t *tsd, prof_tctx_t *tctx);
Record request size in prof recent entries
2020-01-10 02:20:34 +08:00
void prof_malloc_sample_object(tsd_t *tsd, const void *ptr, size_t size,
size_t usize, prof_tctx_t *tctx);
Restructure profiling Develop new data structure and code logic for holding profiling related information stored in the extent that may be needed after the extent is released, which in particular is the case for the reallocation code path (e.g. in `rallocx()` and `xallocx()`). The data structure is a generalization of `prof_tctx_t`: we previously only copy out the `prof_tctx` before the extent is released, but we may be in need of additional fields. Currently the only additional field is the allocation time field, but there may be more fields in the future. The restructuring also resolved a bug: `prof_realloc()` mistakenly passed the new `ptr` to `prof_free_sampled_object()`, but passing in the `old_ptr` would crash because it's already been released. Now the essential profiling information is collectively copied out early and safely passed to `prof_free_sampled_object()` after the extent is released.
2019-11-20 08:24:57 +08:00
void prof_free_sampled_object(tsd_t *tsd, size_t usize, prof_info_t *prof_info);
Refactor prof_tctx_t creation
2019-12-06 07:52:54 +08:00
prof_tctx_t *prof_tctx_create(tsd_t *tsd);
Stop depending on JEMALLOC_N() for function interception during testing. Instead, always define function pointers for interceptable functions, but mark them const unless testing, so that the compiler can optimize out the pointer dereferences.
2017-05-02 14:10:42 +08:00
void prof_idump(tsdn_t *tsdn);
bool prof_mdump(tsd_t *tsd, const char *filename);
void prof_gdump(tsdn_t *tsdn);
Refactor prof log Prof logging is conceptually seperate from core profiling, so split it out as a module of its own. There are a few internal functions that had to be exposed but I think it is a fair trade-off.
2019-07-13 07:37:37 +08:00
Stop depending on JEMALLOC_N() for function interception during testing. Instead, always define function pointers for interceptable functions, but mark them const unless testing, so that the compiler can optimize out the pointer dereferences.
2017-05-02 14:10:42 +08:00
void prof_tdata_cleanup(tsd_t *tsd);
bool prof_active_get(tsdn_t *tsdn);
bool prof_active_set(tsdn_t *tsdn, bool active);
const char *prof_thread_name_get(tsd_t *tsd);
int prof_thread_name_set(tsd_t *tsd, const char *thread_name);
bool prof_thread_active_get(tsd_t *tsd);
bool prof_thread_active_set(tsd_t *tsd, bool active);
bool prof_thread_active_init_get(tsdn_t *tsdn);
bool prof_thread_active_init_set(tsdn_t *tsdn, bool active_init);
bool prof_gdump_get(tsdn_t *tsdn);
bool prof_gdump_set(tsdn_t *tsdn, bool active);
void prof_boot0(void);
void prof_boot1(void);
Break prof and tcache knowledge of b0.
2020-02-18 06:09:29 +08:00
bool prof_boot2(tsd_t *tsd, base_t *base);
Stop depending on JEMALLOC_N() for function interception during testing. Instead, always define function pointers for interceptable functions, but mark them const unless testing, so that the compiler can optimize out the pointer dereferences.
2017-05-02 14:10:42 +08:00
void prof_prefork0(tsdn_t *tsdn);
void prof_prefork1(tsdn_t *tsdn);
void prof_postfork_parent(tsdn_t *tsdn);
void prof_postfork_child(tsdn_t *tsdn);
Extract out per event postponed wait time fetching
2020-04-17 04:33:56 +08:00
Extract out per event new wait time fetching
2020-04-16 01:49:08 +08:00
/* Only accessed by thread event. */
uint64_t prof_sample_new_event_wait(tsd_t *tsd);
Extract out per event postponed wait time fetching
2020-04-17 04:33:56 +08:00
uint64_t prof_sample_postponed_event_wait(tsd_t *tsd);
Push event handlers to constituent modules
2020-04-18 01:38:06 +08:00
void prof_sample_event_handler(tsd_t *tsd, uint64_t elapsed);
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_PROF_EXTERNS_H */
Reference in New Issue Copy Permalink