project-base/server-skynet-source-3rd-jemalloc
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Simplify signatures for prof dump functions

Browse Source
This commit is contained in:
Yinan Zhang 2020-04-20 14:52:05 -07:00
parent 5d823f3a91
commit d4259ea53b
3 changed files with 54 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/jemalloc/internal/prof_data.h
View File

@ -28,8 +28,7 @@ void prof_tctx_try_destroy(tsd_t *tsd, prof_tctx_t *tctx);
/* Used in unit tests. */ /* Used in unit tests. */
size_t prof_tdata_count(void); size_t prof_tdata_count(void);
size_t prof_bt_count(void); size_t prof_bt_count(void);
typedef void (prof_dump_header_t)(tsdn_t *, write_cb_t *, void *, typedef void (prof_dump_header_t)(void *, const prof_cnt_t *);
const prof_cnt_t *);
extern prof_dump_header_t *JET_MUTABLE prof_dump_header; extern prof_dump_header_t *JET_MUTABLE prof_dump_header;
void prof_cnt_all(uint64_t *curobjs, uint64_t *curbytes, uint64_t *accumobjs, void prof_cnt_all(uint64_t *curobjs, uint64_t *curbytes, uint64_t *accumobjs,
uint64_t *accumbytes); uint64_t *accumbytes);

109
src/prof_data.c
View File

@ -664,8 +664,8 @@ prof_dump_gctx_prep(tsdn_t *tsdn, prof_gctx_t *gctx, prof_gctx_tree_t *gctxs) {
typedef struct prof_gctx_merge_iter_arg_s prof_gctx_merge_iter_arg_t; typedef struct prof_gctx_merge_iter_arg_s prof_gctx_merge_iter_arg_t;
struct prof_gctx_merge_iter_arg_s { struct prof_gctx_merge_iter_arg_s {
tsdn_t *tsdn; tsdn_t *tsdn;
size_t leak_ngctx; size_t *leak_ngctx;
}; };
static prof_gctx_t * static prof_gctx_t *
@ -676,7 +676,7 @@ prof_gctx_merge_iter(prof_gctx_tree_t *gctxs, prof_gctx_t *gctx, void *opaque) {
tctx_tree_iter(&gctx->tctxs, NULL, prof_tctx_merge_iter, tctx_tree_iter(&gctx->tctxs, NULL, prof_tctx_merge_iter,
(void *)arg->tsdn); (void *)arg->tsdn);
if (gctx->cnt_summed.curobjs != 0) { if (gctx->cnt_summed.curobjs != 0) {
arg->leak_ngctx++; (*arg->leak_ngctx)++;
} }
malloc_mutex_unlock(arg->tsdn, gctx->lock); malloc_mutex_unlock(arg->tsdn, gctx->lock);
@ -731,8 +731,8 @@ prof_gctx_finish(tsd_t *tsd, prof_gctx_tree_t *gctxs) {
typedef struct prof_tdata_merge_iter_arg_s prof_tdata_merge_iter_arg_t; typedef struct prof_tdata_merge_iter_arg_s prof_tdata_merge_iter_arg_t;
struct prof_tdata_merge_iter_arg_s { struct prof_tdata_merge_iter_arg_s {
tsdn_t *tsdn; tsdn_t *tsdn;
prof_cnt_t cnt_all; prof_cnt_t *cnt_all;
}; };
static prof_tdata_t * static prof_tdata_t *
@ -756,11 +756,12 @@ prof_tdata_merge_iter(prof_tdata_tree_t *tdatas, prof_tdata_t *tdata,
prof_tctx_merge_tdata(arg->tsdn, tctx.p, tdata); prof_tctx_merge_tdata(arg->tsdn, tctx.p, tdata);
} }
arg->cnt_all.curobjs += tdata->cnt_summed.curobjs; arg->cnt_all->curobjs += tdata->cnt_summed.curobjs;
arg->cnt_all.curbytes += tdata->cnt_summed.curbytes; arg->cnt_all->curbytes += tdata->cnt_summed.curbytes;
if (opt_prof_accum) { if (opt_prof_accum) {
arg->cnt_all.accumobjs += tdata->cnt_summed.accumobjs; arg->cnt_all->accumobjs += tdata->cnt_summed.accumobjs;
arg->cnt_all.accumbytes += tdata->cnt_summed.accumbytes; arg->cnt_all->accumbytes +=
tdata->cnt_summed.accumbytes;
} }
} else { } else {
tdata->dumping = false; tdata->dumping = false;
@ -791,25 +792,24 @@ prof_tdata_dump_iter(prof_tdata_tree_t *tdatas, prof_tdata_t *tdata,
} }
static void static void
prof_dump_header_impl(tsdn_t *tsdn, write_cb_t *prof_dump_write, prof_dump_header_impl(void *opaque, const prof_cnt_t *cnt_all) {
void *cbopaque, const prof_cnt_t *cnt_all) { prof_dump_iter_arg_t *arg = (prof_dump_iter_arg_t *)opaque;
prof_dump_printf(prof_dump_write, cbopaque, prof_dump_printf(arg->prof_dump_write, arg->cbopaque,
"heap_v2/%"FMTu64"\n t*: ", ((uint64_t)1U << lg_prof_sample)); "heap_v2/%"FMTu64"\n t*: ", ((uint64_t)1U << lg_prof_sample));
prof_dump_print_cnts(prof_dump_write, cbopaque, cnt_all); prof_dump_print_cnts(arg->prof_dump_write, arg->cbopaque, cnt_all);
prof_dump_write(cbopaque, "\n"); arg->prof_dump_write(arg->cbopaque, "\n");
prof_dump_iter_arg_t arg = {tsdn, prof_dump_write, cbopaque}; malloc_mutex_lock(arg->tsdn, &tdatas_mtx);
malloc_mutex_lock(tsdn, &tdatas_mtx); tdata_tree_iter(&tdatas, NULL, prof_tdata_dump_iter, arg);
tdata_tree_iter(&tdatas, NULL, prof_tdata_dump_iter, &arg); malloc_mutex_unlock(arg->tsdn, &tdatas_mtx);
malloc_mutex_unlock(tsdn, &tdatas_mtx);
} }
prof_dump_header_t *JET_MUTABLE prof_dump_header = prof_dump_header_impl; prof_dump_header_t *JET_MUTABLE prof_dump_header = prof_dump_header_impl;
static void static void
prof_dump_gctx(tsdn_t *tsdn, write_cb_t *prof_dump_write, void *cbopaque, prof_dump_gctx(prof_dump_iter_arg_t *arg, prof_gctx_t *gctx,
prof_gctx_t *gctx, const prof_bt_t *bt, prof_gctx_tree_t *gctxs) { const prof_bt_t *bt, prof_gctx_tree_t *gctxs) {
cassert(config_prof); cassert(config_prof);
malloc_mutex_assert_owner(tsdn, gctx->lock); malloc_mutex_assert_owner(arg->tsdn, gctx->lock);
/* Avoid dumping such gctx's that have no useful data. */ /* Avoid dumping such gctx's that have no useful data. */
if ((!opt_prof_accum && gctx->cnt_summed.curobjs == 0) || if ((!opt_prof_accum && gctx->cnt_summed.curobjs == 0) ||
@ -821,18 +821,18 @@ prof_dump_gctx(tsdn_t *tsdn, write_cb_t *prof_dump_write, void *cbopaque,
return; return;
} }
prof_dump_write(cbopaque, "@"); arg->prof_dump_write(arg->cbopaque, "@");
for (unsigned i = 0; i < bt->len; i++) { for (unsigned i = 0; i < bt->len; i++) {
prof_dump_printf(prof_dump_write, cbopaque, " %#"FMTxPTR, prof_dump_printf(arg->prof_dump_write, arg->cbopaque,
(uintptr_t)bt->vec[i]); " %#"FMTxPTR, (uintptr_t)bt->vec[i]);
} }
prof_dump_write(cbopaque, "\n t*: "); arg->prof_dump_write(arg->cbopaque, "\n t*: ");
prof_dump_print_cnts(prof_dump_write, cbopaque, &gctx->cnt_summed); prof_dump_print_cnts(arg->prof_dump_write, arg->cbopaque,
prof_dump_write(cbopaque, "\n"); &gctx->cnt_summed);
arg->prof_dump_write(arg->cbopaque, "\n");
prof_dump_iter_arg_t arg = {tsdn, prof_dump_write, cbopaque}; tctx_tree_iter(&gctx->tctxs, NULL, prof_tctx_dump_iter, arg);
tctx_tree_iter(&gctx->tctxs, NULL, prof_tctx_dump_iter, &arg);
} }
/* /*
@ -872,17 +872,14 @@ static prof_gctx_t *
prof_gctx_dump_iter(prof_gctx_tree_t *gctxs, prof_gctx_t *gctx, void *opaque) { prof_gctx_dump_iter(prof_gctx_tree_t *gctxs, prof_gctx_t *gctx, void *opaque) {
prof_dump_iter_arg_t *arg = (prof_dump_iter_arg_t *)opaque; prof_dump_iter_arg_t *arg = (prof_dump_iter_arg_t *)opaque;
malloc_mutex_lock(arg->tsdn, gctx->lock); malloc_mutex_lock(arg->tsdn, gctx->lock);
prof_dump_gctx(arg->tsdn, arg->prof_dump_write, arg->cbopaque, gctx, prof_dump_gctx(arg, gctx, &gctx->bt, gctxs);
&gctx->bt, gctxs);
malloc_mutex_unlock(arg->tsdn, gctx->lock); malloc_mutex_unlock(arg->tsdn, gctx->lock);
return NULL; return NULL;
} }
static void static void
prof_dump_prep(tsd_t *tsd, prof_tdata_t *tdata, prof_dump_prep(tsd_t *tsd, prof_tdata_t *tdata, prof_cnt_t *cnt_all,
prof_tdata_merge_iter_arg_t *prof_tdata_merge_iter_arg, size_t *leak_ngctx, prof_gctx_tree_t *gctxs) {
prof_gctx_merge_iter_arg_t *prof_gctx_merge_iter_arg,
prof_gctx_tree_t *gctxs) {
size_t tabind; size_t tabind;
union { union {
prof_gctx_t *p; prof_gctx_t *p;
@ -904,18 +901,20 @@ prof_dump_prep(tsd_t *tsd, prof_tdata_t *tdata,
* Iterate over tdatas, and for the non-expired ones snapshot their tctx * Iterate over tdatas, and for the non-expired ones snapshot their tctx
* stats and merge them into the associated gctx's. * stats and merge them into the associated gctx's.
*/ */
prof_tdata_merge_iter_arg->tsdn = tsd_tsdn(tsd); memset(cnt_all, 0, sizeof(prof_cnt_t));
memset(&prof_tdata_merge_iter_arg->cnt_all, 0, sizeof(prof_cnt_t)); prof_tdata_merge_iter_arg_t prof_tdata_merge_iter_arg = {tsd_tsdn(tsd),
cnt_all};
malloc_mutex_lock(tsd_tsdn(tsd), &tdatas_mtx); malloc_mutex_lock(tsd_tsdn(tsd), &tdatas_mtx);
tdata_tree_iter(&tdatas, NULL, prof_tdata_merge_iter, tdata_tree_iter(&tdatas, NULL, prof_tdata_merge_iter,
(void *)prof_tdata_merge_iter_arg); &prof_tdata_merge_iter_arg);
malloc_mutex_unlock(tsd_tsdn(tsd), &tdatas_mtx); malloc_mutex_unlock(tsd_tsdn(tsd), &tdatas_mtx);
/* Merge tctx stats into gctx's. */ /* Merge tctx stats into gctx's. */
prof_gctx_merge_iter_arg->tsdn = tsd_tsdn(tsd); *leak_ngctx = 0;
prof_gctx_merge_iter_arg->leak_ngctx = 0; prof_gctx_merge_iter_arg_t prof_gctx_merge_iter_arg = {tsd_tsdn(tsd),
leak_ngctx};
gctx_tree_iter(gctxs, NULL, prof_gctx_merge_iter, gctx_tree_iter(gctxs, NULL, prof_gctx_merge_iter,
(void *)prof_gctx_merge_iter_arg); &prof_gctx_merge_iter_arg);
prof_leave(tsd, tdata); prof_leave(tsd, tdata);
} }
@ -924,20 +923,17 @@ void
prof_dump_impl(tsd_t *tsd, write_cb_t *prof_dump_write, void *cbopaque, prof_dump_impl(tsd_t *tsd, write_cb_t *prof_dump_write, void *cbopaque,
prof_tdata_t *tdata, bool leakcheck) { prof_tdata_t *tdata, bool leakcheck) {
malloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_dump_mtx); malloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_dump_mtx);
prof_cnt_t cnt_all;
size_t leak_ngctx;
prof_gctx_tree_t gctxs; prof_gctx_tree_t gctxs;
prof_tdata_merge_iter_arg_t prof_tdata_merge_iter_arg; prof_dump_prep(tsd, tdata, &cnt_all, &leak_ngctx, &gctxs);
prof_gctx_merge_iter_arg_t prof_gctx_merge_iter_arg;
prof_dump_prep(tsd, tdata, &prof_tdata_merge_iter_arg,
&prof_gctx_merge_iter_arg, &gctxs);
prof_dump_header(tsd_tsdn(tsd), prof_dump_write, cbopaque,
&prof_tdata_merge_iter_arg.cnt_all);
prof_dump_iter_arg_t prof_dump_iter_arg = {tsd_tsdn(tsd), prof_dump_iter_arg_t prof_dump_iter_arg = {tsd_tsdn(tsd),
prof_dump_write, cbopaque}; prof_dump_write, cbopaque};
prof_dump_header(&prof_dump_iter_arg, &cnt_all);
gctx_tree_iter(&gctxs, NULL, prof_gctx_dump_iter, &prof_dump_iter_arg); gctx_tree_iter(&gctxs, NULL, prof_gctx_dump_iter, &prof_dump_iter_arg);
prof_gctx_finish(tsd, &gctxs); prof_gctx_finish(tsd, &gctxs);
if (leakcheck) { if (leakcheck) {
prof_leakcheck(&prof_tdata_merge_iter_arg.cnt_all, prof_leakcheck(&cnt_all, leak_ngctx);
prof_gctx_merge_iter_arg.leak_ngctx);
} }
} }
@ -947,8 +943,8 @@ prof_cnt_all(uint64_t *curobjs, uint64_t *curbytes, uint64_t *accumobjs,
uint64_t *accumbytes) { uint64_t *accumbytes) {
tsd_t *tsd; tsd_t *tsd;
prof_tdata_t *tdata; prof_tdata_t *tdata;
prof_tdata_merge_iter_arg_t prof_tdata_merge_iter_arg; prof_cnt_t cnt_all;
prof_gctx_merge_iter_arg_t prof_gctx_merge_iter_arg; size_t leak_ngctx;
prof_gctx_tree_t gctxs; prof_gctx_tree_t gctxs;
tsd = tsd_fetch(); tsd = tsd_fetch();
@ -969,21 +965,20 @@ prof_cnt_all(uint64_t *curobjs, uint64_t *curbytes, uint64_t *accumobjs,
return; return;
} }
prof_dump_prep(tsd, tdata, &prof_tdata_merge_iter_arg, prof_dump_prep(tsd, tdata, &cnt_all, &leak_ngctx, &gctxs);
&prof_gctx_merge_iter_arg, &gctxs);
prof_gctx_finish(tsd, &gctxs); prof_gctx_finish(tsd, &gctxs);
if (curobjs != NULL) { if (curobjs != NULL) {
*curobjs = prof_tdata_merge_iter_arg.cnt_all.curobjs; *curobjs = cnt_all.curobjs;
} }
if (curbytes != NULL) { if (curbytes != NULL) {
*curbytes = prof_tdata_merge_iter_arg.cnt_all.curbytes; *curbytes = cnt_all.curbytes;
} }
if (accumobjs != NULL) { if (accumobjs != NULL) {
*accumobjs = prof_tdata_merge_iter_arg.cnt_all.accumobjs; *accumobjs = cnt_all.accumobjs;
} }
if (accumbytes != NULL) { if (accumbytes != NULL) {
*accumbytes = prof_tdata_merge_iter_arg.cnt_all.accumbytes; *accumbytes = cnt_all.accumbytes;
} }
} }

3
test/unit/prof_reset.c
View File

@ -87,8 +87,7 @@ TEST_END
bool prof_dump_header_intercepted = false; bool prof_dump_header_intercepted = false;
prof_cnt_t cnt_all_copy = {0, 0, 0, 0}; prof_cnt_t cnt_all_copy = {0, 0, 0, 0};
static void static void
prof_dump_header_intercept(tsdn_t *tsdn, write_cb_t *cb, void *cbopaque, prof_dump_header_intercept(void *opaque, const prof_cnt_t *cnt_all) {
const prof_cnt_t *cnt_all) {
prof_dump_header_intercepted = true; prof_dump_header_intercepted = true;
memcpy(&cnt_all_copy, cnt_all, sizeof(prof_cnt_t)); memcpy(&cnt_all_copy, cnt_all, sizeof(prof_cnt_t));
} }