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. */
size_t prof_tdata_count(void);
size_t prof_bt_count(void);
typedef void (prof_dump_header_t)(tsdn_t *, write_cb_t *, void *,
const prof_cnt_t *);
typedef void (prof_dump_header_t)(void *, const prof_cnt_t *);
extern prof_dump_header_t *JET_MUTABLE prof_dump_header;
void prof_cnt_all(uint64_t *curobjs, uint64_t *curbytes, uint64_t *accumobjs,
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;
struct prof_gctx_merge_iter_arg_s {
tsdn_t *tsdn;
size_t leak_ngctx;
tsdn_t *tsdn;
size_t *leak_ngctx;
};
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,
(void *)arg->tsdn);
if (gctx->cnt_summed.curobjs != 0) {
arg->leak_ngctx++;
(*arg->leak_ngctx)++;
}
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;
struct prof_tdata_merge_iter_arg_s {
tsdn_t *tsdn;
prof_cnt_t cnt_all;
tsdn_t *tsdn;
prof_cnt_t *cnt_all;
};
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);
}
arg->cnt_all.curobjs += tdata->cnt_summed.curobjs;
arg->cnt_all.curbytes += tdata->cnt_summed.curbytes;
arg->cnt_all->curobjs += tdata->cnt_summed.curobjs;
arg->cnt_all->curbytes += tdata->cnt_summed.curbytes;
if (opt_prof_accum) {
arg->cnt_all.accumobjs += tdata->cnt_summed.accumobjs;
arg->cnt_all.accumbytes += tdata->cnt_summed.accumbytes;
arg->cnt_all->accumobjs += tdata->cnt_summed.accumobjs;
arg->cnt_all->accumbytes +=
tdata->cnt_summed.accumbytes;
}
} else {
tdata->dumping = false;
@ -791,25 +792,24 @@ prof_tdata_dump_iter(prof_tdata_tree_t *tdatas, prof_tdata_t *tdata,
}
static void
prof_dump_header_impl(tsdn_t *tsdn, write_cb_t *prof_dump_write,
void *cbopaque, const prof_cnt_t *cnt_all) {
prof_dump_printf(prof_dump_write, cbopaque,
prof_dump_header_impl(void *opaque, const prof_cnt_t *cnt_all) {
prof_dump_iter_arg_t *arg = (prof_dump_iter_arg_t *)opaque;
prof_dump_printf(arg->prof_dump_write, arg->cbopaque,
"heap_v2/%"FMTu64"\n t*: ", ((uint64_t)1U << lg_prof_sample));
prof_dump_print_cnts(prof_dump_write, cbopaque, cnt_all);
prof_dump_write(cbopaque, "\n");
prof_dump_print_cnts(arg->prof_dump_write, arg->cbopaque, cnt_all);
arg->prof_dump_write(arg->cbopaque, "\n");
prof_dump_iter_arg_t arg = {tsdn, prof_dump_write, cbopaque};
malloc_mutex_lock(tsdn, &tdatas_mtx);
tdata_tree_iter(&tdatas, NULL, prof_tdata_dump_iter, &arg);
malloc_mutex_unlock(tsdn, &tdatas_mtx);
malloc_mutex_lock(arg->tsdn, &tdatas_mtx);
tdata_tree_iter(&tdatas, NULL, prof_tdata_dump_iter, arg);
malloc_mutex_unlock(arg->tsdn, &tdatas_mtx);
}
prof_dump_header_t *JET_MUTABLE prof_dump_header = prof_dump_header_impl;
static void
prof_dump_gctx(tsdn_t *tsdn, write_cb_t *prof_dump_write, void *cbopaque,
prof_gctx_t *gctx, const prof_bt_t *bt, prof_gctx_tree_t *gctxs) {
prof_dump_gctx(prof_dump_iter_arg_t *arg, prof_gctx_t *gctx,
const prof_bt_t *bt, prof_gctx_tree_t *gctxs) {
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. */
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;
}
prof_dump_write(cbopaque, "@");
arg->prof_dump_write(arg->cbopaque, "@");
for (unsigned i = 0; i < bt->len; i++) {
prof_dump_printf(prof_dump_write, cbopaque, " %#"FMTxPTR,
(uintptr_t)bt->vec[i]);
prof_dump_printf(arg->prof_dump_write, arg->cbopaque,
" %#"FMTxPTR, (uintptr_t)bt->vec[i]);
}
prof_dump_write(cbopaque, "\n t*: ");
prof_dump_print_cnts(prof_dump_write, cbopaque, &gctx->cnt_summed);
prof_dump_write(cbopaque, "\n");
arg->prof_dump_write(arg->cbopaque, "\n t*: ");
prof_dump_print_cnts(arg->prof_dump_write, arg->cbopaque,
&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_dump_iter_arg_t *arg = (prof_dump_iter_arg_t *)opaque;
malloc_mutex_lock(arg->tsdn, gctx->lock);
prof_dump_gctx(arg->tsdn, arg->prof_dump_write, arg->cbopaque, gctx,
&gctx->bt, gctxs);
prof_dump_gctx(arg, gctx, &gctx->bt, gctxs);
malloc_mutex_unlock(arg->tsdn, gctx->lock);
return NULL;
}
static void
prof_dump_prep(tsd_t *tsd, prof_tdata_t *tdata,
prof_tdata_merge_iter_arg_t *prof_tdata_merge_iter_arg,
prof_gctx_merge_iter_arg_t *prof_gctx_merge_iter_arg,
prof_gctx_tree_t *gctxs) {
prof_dump_prep(tsd_t *tsd, prof_tdata_t *tdata, prof_cnt_t *cnt_all,
size_t *leak_ngctx, prof_gctx_tree_t *gctxs) {
size_t tabind;
union {
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
* stats and merge them into the associated gctx's.
*/
prof_tdata_merge_iter_arg->tsdn = tsd_tsdn(tsd);
memset(&prof_tdata_merge_iter_arg->cnt_all, 0, sizeof(prof_cnt_t));
memset(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);
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);
/* Merge tctx stats into gctx's. */
prof_gctx_merge_iter_arg->tsdn = tsd_tsdn(tsd);
prof_gctx_merge_iter_arg->leak_ngctx = 0;
*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,
(void *)prof_gctx_merge_iter_arg);
&prof_gctx_merge_iter_arg);
prof_leave(tsd, tdata);
}
@ -924,20 +923,17 @@ void
prof_dump_impl(tsd_t *tsd, write_cb_t *prof_dump_write, void *cbopaque,
prof_tdata_t *tdata, bool leakcheck) {
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_tdata_merge_iter_arg_t prof_tdata_merge_iter_arg;
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_prep(tsd, tdata, &cnt_all, &leak_ngctx, &gctxs);
prof_dump_iter_arg_t prof_dump_iter_arg = {tsd_tsdn(tsd),
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);
prof_gctx_finish(tsd, &gctxs);
if (leakcheck) {
prof_leakcheck(&prof_tdata_merge_iter_arg.cnt_all,
prof_gctx_merge_iter_arg.leak_ngctx);
prof_leakcheck(&cnt_all, leak_ngctx);
}
}
@ -947,8 +943,8 @@ prof_cnt_all(uint64_t *curobjs, uint64_t *curbytes, uint64_t *accumobjs,
uint64_t *accumbytes) {
tsd_t *tsd;
prof_tdata_t *tdata;
prof_tdata_merge_iter_arg_t prof_tdata_merge_iter_arg;
prof_gctx_merge_iter_arg_t prof_gctx_merge_iter_arg;
prof_cnt_t cnt_all;
size_t leak_ngctx;
prof_gctx_tree_t gctxs;
tsd = tsd_fetch();
@ -969,21 +965,20 @@ prof_cnt_all(uint64_t *curobjs, uint64_t *curbytes, uint64_t *accumobjs,
return;
}
prof_dump_prep(tsd, tdata, &prof_tdata_merge_iter_arg,
&prof_gctx_merge_iter_arg, &gctxs);
prof_dump_prep(tsd, tdata, &cnt_all, &leak_ngctx, &gctxs);
prof_gctx_finish(tsd, &gctxs);
if (curobjs != NULL) {
*curobjs = prof_tdata_merge_iter_arg.cnt_all.curobjs;
*curobjs = cnt_all.curobjs;
}
if (curbytes != NULL) {
*curbytes = prof_tdata_merge_iter_arg.cnt_all.curbytes;
*curbytes = cnt_all.curbytes;
}
if (accumobjs != NULL) {
*accumobjs = prof_tdata_merge_iter_arg.cnt_all.accumobjs;
*accumobjs = cnt_all.accumobjs;
}
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;
prof_cnt_t cnt_all_copy = {0, 0, 0, 0};
static void
prof_dump_header_intercept(tsdn_t *tsdn, write_cb_t *cb, void *cbopaque,
const prof_cnt_t *cnt_all) {
prof_dump_header_intercept(void *opaque, const prof_cnt_t *cnt_all) {
prof_dump_header_intercepted = true;
memcpy(&cnt_all_copy, cnt_all, sizeof(prof_cnt_t));
}