From d4259ea53bb842169688f5fcda1053fbbaf021a8 Mon Sep 17 00:00:00 2001 From: Yinan Zhang Date: Mon, 20 Apr 2020 14:52:05 -0700 Subject: [PATCH] Simplify signatures for prof dump functions --- include/jemalloc/internal/prof_data.h | 3 +- src/prof_data.c | 109 ++++++++++++-------------- test/unit/prof_reset.c | 3 +- 3 files changed, 54 insertions(+), 61 deletions(-) diff --git a/include/jemalloc/internal/prof_data.h b/include/jemalloc/internal/prof_data.h index a0448d0b..039c2a8a 100644 --- a/include/jemalloc/internal/prof_data.h +++ b/include/jemalloc/internal/prof_data.h @@ -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); diff --git a/src/prof_data.c b/src/prof_data.c index 8cf7228c..1d501406 100644 --- a/src/prof_data.c +++ b/src/prof_data.c @@ -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; } } diff --git a/test/unit/prof_reset.c b/test/unit/prof_reset.c index 5916bd1e..8c82e6d5 100644 --- a/test/unit/prof_reset.c +++ b/test/unit/prof_reset.c @@ -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)); }