Github/littlefs
1
Fork 0
Code Actions Activity

runners: A number of stack/heap measurement tweaks

Browse Source 
- Renamed BENCH_STACK/HEAP -> BENCH_STACK/HEAP_WATERMARK

- Renamed BENCH_YES_STACK/HEAP -> BENCH_STACK/HEAP

- Tweaked stack/heap watermarks to hopefully be easier to access when
  debugging. Now also exposed as global variables
  (bench_stack/heap_watermark).

  I considered changing BENCH_STACK/HEAP_WATERMARK to be the variable
  itself, to be consistent with TEST_PLS, but decided against it:

  1. BENCH_STACK_CURRENT() is a bit magic in that it relies on
     __attribute__((noinline)) to force a new stack frame. This wouldn't
     really be possible with a variable.

  2. TEST_PLS is at least constant from the _current run_'s perspective.
     This isn't true for the stack/heap watermarks.

- Reworked internals a bit to hopefully be simpler
This commit is contained in:
Christopher Haster
2026-02-05 23:24:32 -06:00
parent a914057407
commit c1b86ac9db
7 changed files with 168 additions and 318 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Makefile
+4 -4
View File
@@ -104,10 +104,10 @@ CFLAGS += $(foreach d,$(filter LFS3_%,$(.VARIABLES)),-D$d=$($d))
TEST_CFLAGS += -Wno-unused-function TEST_CFLAGS += -Wno-unused-function
TEST_CFLAGS += -Wno-format-overflow TEST_CFLAGS += -Wno-format-overflow
ifdef STACK ifdef STACK
TEST_CFLAGS += -DTEST_YES_STACK TEST_CFLAGS += -DTEST_STACK
endif endif
ifdef HEAP ifdef HEAP
TEST_CFLAGS += -DTEST_YES_HEAP TEST_CFLAGS += -DTEST_HEAP
TEST_CFLAGS += -Wl,--wrap=malloc TEST_CFLAGS += -Wl,--wrap=malloc
TEST_CFLAGS += -Wl,--wrap=free TEST_CFLAGS += -Wl,--wrap=free
TEST_CFLAGS += -Wl,--wrap=realloc TEST_CFLAGS += -Wl,--wrap=realloc
@@ -116,10 +116,10 @@ endif
BENCH_CFLAGS += -Wno-unused-function BENCH_CFLAGS += -Wno-unused-function
BENCH_CFLAGS += -Wno-format-overflow BENCH_CFLAGS += -Wno-format-overflow
ifndef NO_STACK ifndef NO_STACK
BENCH_CFLAGS += -DBENCH_YES_STACK BENCH_CFLAGS += -DBENCH_STACK
endif endif
ifndef NO_HEAP ifndef NO_HEAP
BENCH_CFLAGS += -DBENCH_YES_HEAP BENCH_CFLAGS += -DBENCH_HEAP
BENCH_CFLAGS += -Wl,--wrap=malloc BENCH_CFLAGS += -Wl,--wrap=malloc
BENCH_CFLAGS += -Wl,--wrap=free BENCH_CFLAGS += -Wl,--wrap=free
BENCH_CFLAGS += -Wl,--wrap=realloc BENCH_CFLAGS += -Wl,--wrap=realloc
benches/bench_helpers.c
-16
View File
@@ -10,12 +10,8 @@
// this writes a 1 block file 2*block_count times to get it into a good // this writes a 1 block file 2*block_count times to get it into a good
// state for benchmarking // state for benchmarking
int bench_helpers_warmup(lfs3_t *lfs3) { int bench_helpers_warmup(lfs3_t *lfs3) {
#ifdef BENCH_YES_STACK
BENCH_STACK_PAUSE(); BENCH_STACK_PAUSE();
#endif
#ifdef BENCH_YES_HEAP
BENCH_HEAP_PAUSE(); BENCH_HEAP_PAUSE();
#endif
uint8_t *wbuf = malloc(BLOCK_SIZE); uint8_t *wbuf = malloc(BLOCK_SIZE);
memset(wbuf, '1', BLOCK_SIZE); memset(wbuf, '1', BLOCK_SIZE);
@@ -34,24 +30,16 @@ int bench_helpers_warmup(lfs3_t *lfs3) {
free(wbuf); free(wbuf);
#ifdef BENCH_YES_HEAP
BENCH_HEAP_RESUME(); BENCH_HEAP_RESUME();
#endif
#ifdef BENCH_YES_STACK
BENCH_STACK_RESUME(); BENCH_STACK_RESUME();
#endif
return 0; return 0;
} }
// find tight disk usage // find tight disk usage
uintmax_t bench_helpers_usage(lfs3_t *lfs3) { uintmax_t bench_helpers_usage(lfs3_t *lfs3) {
#ifdef BENCH_YES_STACK
BENCH_STACK_PAUSE(); BENCH_STACK_PAUSE();
#endif
#ifdef BENCH_YES_HEAP
BENCH_HEAP_PAUSE(); BENCH_HEAP_PAUSE();
#endif
// measure disk usage // measure disk usage
// //
@@ -83,12 +71,8 @@ uintmax_t bench_helpers_usage(lfs3_t *lfs3) {
free(usage_bmap); free(usage_bmap);
#ifdef BENCH_YES_HEAP
BENCH_HEAP_RESUME(); BENCH_HEAP_RESUME();
#endif
#ifdef BENCH_YES_STACK
BENCH_STACK_RESUME(); BENCH_STACK_RESUME();
#endif
return (uintmax_t)usage * (uintmax_t)BLOCK_SIZE; return (uintmax_t)usage * (uintmax_t)BLOCK_SIZE;
} }
benches/bench_wt.toml
+16 -16
View File
@@ -83,11 +83,11 @@ code = '''
BENCH_STOP("write", written); BENCH_STOP("write", written);
// report the total stack/heap usage after the benchmark // report the total stack/heap usage after the benchmark
#ifdef BENCH_YES_STACK #ifdef BENCH_STACK
BENCH_RESULT("stack", written, BENCH_STACK()); BENCH_RESULT("stack", written, BENCH_STACK_WATERMARK());
#endif #endif
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
BENCH_RESULT("heap", written, BENCH_HEAP()); BENCH_RESULT("heap", written, BENCH_HEAP_WATERMARK());
#endif #endif
// find the total disk usage after the benchmark // find the total disk usage after the benchmark
@@ -144,11 +144,11 @@ code = '''
BENCH_STOP("write", written); BENCH_STOP("write", written);
// report the total stack/heap usage after the benchmark // report the total stack/heap usage after the benchmark
#ifdef BENCH_YES_STACK #ifdef BENCH_STACK
BENCH_RESULT("stack", written, BENCH_STACK()); BENCH_RESULT("stack", written, BENCH_STACK_WATERMARK());
#endif #endif
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
BENCH_RESULT("heap", written, BENCH_HEAP()); BENCH_RESULT("heap", written, BENCH_HEAP_WATERMARK());
#endif #endif
// find the total disk usage after the benchmark // find the total disk usage after the benchmark
@@ -223,11 +223,11 @@ code = '''
BENCH_STOP("write", written); BENCH_STOP("write", written);
// report the total stack/heap usage after the benchmark // report the total stack/heap usage after the benchmark
#ifdef BENCH_YES_STACK #ifdef BENCH_STACK
BENCH_RESULT("stack", written, BENCH_STACK()); BENCH_RESULT("stack", written, BENCH_STACK_WATERMARK());
#endif #endif
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
BENCH_RESULT("heap", written, BENCH_HEAP()); BENCH_RESULT("heap", written, BENCH_HEAP_WATERMARK());
#endif #endif
// find the total disk usage after the benchmark // find the total disk usage after the benchmark
@@ -292,11 +292,11 @@ code = '''
BENCH_STOP("write", written); BENCH_STOP("write", written);
// report the total stack/heap usage after the benchmark // report the total stack/heap usage after the benchmark
#ifdef BENCH_YES_STACK #ifdef BENCH_STACK
BENCH_RESULT("stack", written, BENCH_STACK()); BENCH_RESULT("stack", written, BENCH_STACK_WATERMARK());
#endif #endif
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
BENCH_RESULT("heap", written, BENCH_HEAP()); BENCH_RESULT("heap", written, BENCH_HEAP_WATERMARK());
#endif #endif
// find the total disk usage after the benchmark // find the total disk usage after the benchmark
runners/bench_runner.c
+46 -137
View File
@@ -617,98 +617,85 @@ void bench_permutation(size_t i, uint32_t *buffer, size_t size) {
// stack hooks // stack hooks
#ifdef BENCH_YES_STACK #ifdef BENCH_STACK
uint8_t *bench_stack_watermark_enter; uint8_t *bench_stack_entrance = NULL;
uint8_t *bench_stack_watermark_depth; size_t bench_stack_watermark = 0;
#endif #endif
// call me when entering/exiting a bench! // call me when entering/exiting a bench!
#ifdef BENCH_YES_STACK #ifdef BENCH_STACK
__attribute__((noinline)) __attribute__((noinline))
void bench_stack_enter(void) { void bench_stack_enter(void) {
bench_stack_watermark_enter = __builtin_frame_address(0); bench_stack_entrance = __builtin_frame_address(0);
bench_stack_watermark_depth = bench_stack_watermark_enter; bench_stack_watermark = 0;
} }
#endif #endif
#ifdef BENCH_YES_STACK #ifdef BENCH_STACK
void bench_stack_exit(void) { void bench_stack_exit(void) {
// do nothing // do nothing
} }
#endif #endif
// call me when entering/exiting a bd op! // call me when entering/exiting a bd op!
#ifdef BENCH_YES_STACK #ifdef BENCH_STACK
__attribute__((noinline)) __attribute__((noinline))
void bench_stack_pause(void) { void bench_stack_pause(void) {
uint8_t *watermark = __builtin_frame_address(0); uint8_t *current = __builtin_frame_address(0);
// keep track of the deepest stack // keep track of the deepest stack
ssize_t depth = bench_stack_watermark_depth - bench_stack_watermark_enter; ssize_t depth = current - bench_stack_entrance;
if (depth < 0) { if (depth < 0) {
depth = -depth; depth = -depth;
} }
ssize_t depth_ = watermark - bench_stack_watermark_enter;
if (depth_ < 0) { if ((size_t)depth > bench_stack_watermark) {
depth_ = -depth_; bench_stack_watermark = depth;
}
if (depth_ > depth) {
bench_stack_watermark_depth = watermark;
} }
} }
#endif #endif
#ifdef BENCH_YES_STACK #ifdef BENCH_STACK
void bench_stack_resume(void) { void bench_stack_resume(void) {
// do nothing // do nothing
} }
#endif #endif
// get the worst-case stack usage // get the current stack usage
#ifdef BENCH_YES_STACK
size_t bench_stack(void) {
ssize_t depth = bench_stack_watermark_depth - bench_stack_watermark_enter;
if (depth < 0) {
depth = -depth;
}
return depth;
}
#endif
// get the current stack usage, note this is included in bench_stack
// //
// note note the noinline here is important for forcing a new stack frame // note the noinline here is important for forcing a new stack frame
#ifdef BENCH_YES_STACK #ifdef BENCH_STACK
__attribute__((noinline)) __attribute__((noinline))
size_t bench_stack_current(void) { size_t bench_stack_current(void) {
uint8_t *watermark = __builtin_frame_address(0); uint8_t *current = __builtin_frame_address(0);
ssize_t depth = watermark - bench_stack_watermark_enter; ssize_t depth = current - bench_stack_entrance;
if (depth < 0) { if (depth < 0) {
depth = -depth; depth = -depth;
} }
return depth; return depth;
} }
#endif #endif
// heap hooks // heap hooks
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
uint32_t bench_heap_entered = 0; uint32_t bench_heap_entered = 0;
size_t bench_heap_current = 0;
size_t bench_heap_watermark = 0; size_t bench_heap_watermark = 0;
size_t bench_heap_watermark_depth = 0;
#endif #endif
// call me when entering/exiting a bench! // call me when entering/exiting a bench!
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
void bench_heap_enter(void) { void bench_heap_enter(void) {
bench_heap_entered = 1; bench_heap_entered = 1;
bench_heap_current = 0;
bench_heap_watermark = 0; bench_heap_watermark = 0;
bench_heap_watermark_depth = 0;
} }
#endif #endif
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
void bench_heap_exit(void) { void bench_heap_exit(void) {
bench_heap_entered = 0; bench_heap_entered = 0;
if (bench_heap_watermark != 0) { if (bench_heap_watermark != 0) {
@@ -719,56 +706,42 @@ void bench_heap_exit(void) {
#endif #endif
// call me when entering/exiting a bd op! // call me when entering/exiting a bd op!
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
void bench_heap_pause(void) { void bench_heap_pause(void) {
// haha, a little 32-bit stack // haha, a little 32-bit stack
bench_heap_entered <<= 1; bench_heap_entered <<= 1;
} }
#endif #endif
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
void bench_heap_resume(void) { void bench_heap_resume(void) {
bench_heap_entered >>= 1; bench_heap_entered >>= 1;
} }
#endif #endif
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
void bench_heap_inc(size_t size) { void bench_heap_inc(size_t size) {
if (bench_heap_entered & 1) { if (bench_heap_entered & 1) {
bench_heap_watermark += size; bench_heap_current += size;
// keep track of the deepest heap // keep track of the deepest heap
if (bench_heap_watermark > bench_heap_watermark_depth) { if (bench_heap_current > bench_heap_watermark) {
bench_heap_watermark_depth = bench_heap_watermark; bench_heap_watermark = bench_heap_current;
} }
} }
} }
#endif #endif
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
void bench_heap_dec(size_t size) { void bench_heap_dec(size_t size) {
if (bench_heap_entered & 1) { if (bench_heap_entered & 1) {
assert(bench_heap_watermark >= size); assert(bench_heap_current >= size);
bench_heap_watermark -= size; bench_heap_current -= size;
} }
} }
#endif #endif
// get the worst-case heap usage
#ifdef BENCH_YES_HEAP
size_t bench_heap(void) {
return bench_heap_watermark_depth;
}
#endif
// get the current heap usage
#ifdef BENCH_YES_HEAP
size_t bench_heap_current(void) {
return bench_heap_watermark;
}
#endif
// __real_malloc stubs, gcc's --wrap wraps these over the original symbols // __real_malloc stubs, gcc's --wrap wraps these over the original symbols
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
extern void *__real_malloc(size_t size); extern void *__real_malloc(size_t size);
extern void __real_free(void *p); extern void __real_free(void *p);
extern void *__real_realloc(void *p, size_t size); extern void *__real_realloc(void *p, size_t size);
@@ -777,7 +750,7 @@ extern void *__real_realloc(void *p, size_t size);
// the actual malloc hooks // the actual malloc hooks
// //
// these only work if wrapped via gcc's --wrap // these only work if wrapped via gcc's --wrap
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
void *__wrap_malloc(size_t size) { void *__wrap_malloc(size_t size) {
// prefix with allocation size, note we use uintptr_t to hopefully // prefix with allocation size, note we use uintptr_t to hopefully
// keep things aligned // keep things aligned
@@ -786,13 +759,13 @@ void *__wrap_malloc(size_t size) {
return NULL; return NULL;
} }
bench_heap_inc(size); BENCH_HEAP_INC(size);
*p_ = size; *p_ = size;
return p_ + 1; return p_ + 1;
} }
#endif #endif
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
void __wrap_free(void *p) { void __wrap_free(void *p) {
if (!p) { if (!p) {
return; return;
@@ -800,13 +773,13 @@ void __wrap_free(void *p) {
uintptr_t *p_ = ((uintptr_t*)p) - 1; uintptr_t *p_ = ((uintptr_t*)p) - 1;
size_t size = *p_; size_t size = *p_;
bench_heap_dec(size); BENCH_HEAP_DEC(size);
__real_free(p_); __real_free(p_);
} }
#endif #endif
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
void *__wrap_realloc(void *p, size_t size) { void *__wrap_realloc(void *p, size_t size) {
uintptr_t *p_; uintptr_t *p_;
size_t old; size_t old;
@@ -824,8 +797,8 @@ void *__wrap_realloc(void *p, size_t size) {
return NULL; return NULL;
} }
bench_heap_dec(old); BENCH_HEAP_DEC(old);
bench_heap_inc(size); BENCH_HEAP_INC(size);
*p_ = size; *p_ = size;
return p_ + 1; return p_ + 1;
} }
@@ -862,12 +835,8 @@ void bench_reset(const struct lfs3_cfg *cfg) {
} }
void bench_start(const char *probe) { void bench_start(const char *probe) {
#ifdef BENCH_YES_STACK
BENCH_STACK_PAUSE(); BENCH_STACK_PAUSE();
#endif
#ifdef BENCH_YES_HEAP
BENCH_HEAP_PAUSE(); BENCH_HEAP_PAUSE();
#endif
// measure current read/prog/erase // measure current read/prog/erase
assert(bench_cfg); assert(bench_cfg);
@@ -936,21 +905,13 @@ void bench_start(const char *probe) {
record->last_erased = erased; record->last_erased = erased;
record->last_simtime = simtime; record->last_simtime = simtime;
#ifdef BENCH_YES_HEAP
BENCH_HEAP_RESUME(); BENCH_HEAP_RESUME();
#endif
#ifdef BENCH_YES_STACK
BENCH_STACK_RESUME(); BENCH_STACK_RESUME();
#endif
} }
void bench_stop(const char *probe, uintmax_t n) { void bench_stop(const char *probe, uintmax_t n) {
#ifdef BENCH_YES_STACK
BENCH_STACK_PAUSE(); BENCH_STACK_PAUSE();
#endif
#ifdef BENCH_YES_HEAP
BENCH_HEAP_PAUSE(); BENCH_HEAP_PAUSE();
#endif
// measure current read/prog/erase // measure current read/prog/erase
assert(bench_cfg); assert(bench_cfg);
@@ -1042,21 +1003,13 @@ void bench_stop(const char *probe, uintmax_t n) {
} }
done:; done:;
#ifdef BENCH_YES_HEAP
BENCH_HEAP_RESUME(); BENCH_HEAP_RESUME();
#endif
#ifdef BENCH_YES_STACK
BENCH_STACK_RESUME(); BENCH_STACK_RESUME();
#endif
} }
void bench_result(const char *probe, uintmax_t n, uintmax_t result) { void bench_result(const char *probe, uintmax_t n, uintmax_t result) {
#ifdef BENCH_YES_STACK
BENCH_STACK_PAUSE(); BENCH_STACK_PAUSE();
#endif
#ifdef BENCH_YES_HEAP
BENCH_HEAP_PAUSE(); BENCH_HEAP_PAUSE();
#endif
// we just print these directly // we just print these directly
printf("benched %s %jd %"PRIu64"\n", printf("benched %s %jd %"PRIu64"\n",
@@ -1064,21 +1017,13 @@ void bench_result(const char *probe, uintmax_t n, uintmax_t result) {
n, n,
result); result);
#ifdef BENCH_YES_HEAP
BENCH_HEAP_RESUME(); BENCH_HEAP_RESUME();
#endif
#ifdef BENCH_YES_STACK
BENCH_STACK_RESUME(); BENCH_STACK_RESUME();
#endif
} }
void bench_fresult(const char *probe, uintmax_t n, double result) { void bench_fresult(const char *probe, uintmax_t n, double result) {
#ifdef BENCH_YES_STACK
BENCH_STACK_PAUSE(); BENCH_STACK_PAUSE();
#endif
#ifdef BENCH_YES_HEAP
BENCH_HEAP_PAUSE(); BENCH_HEAP_PAUSE();
#endif
// we just print these directly // we just print these directly
printf("benched %s %jd %.6f\n", printf("benched %s %jd %.6f\n",
@@ -1086,12 +1031,8 @@ void bench_fresult(const char *probe, uintmax_t n, double result) {
n, n,
result); result);
#ifdef BENCH_YES_HEAP
BENCH_HEAP_RESUME(); BENCH_HEAP_RESUME();
#endif
#ifdef BENCH_YES_STACK
BENCH_STACK_RESUME(); BENCH_STACK_RESUME();
#endif
} }
@@ -1730,12 +1671,8 @@ static void list_implicit_defines(void) {
// bench bd wrappers for heap/stack tracking // bench bd wrappers for heap/stack tracking
int bench_bd_read(const struct lfs3_cfg *cfg, lfs3_block_t block, int bench_bd_read(const struct lfs3_cfg *cfg, lfs3_block_t block,
lfs3_off_t off, void *buffer, lfs3_size_t size) { lfs3_off_t off, void *buffer, lfs3_size_t size) {
#ifdef BENCH_YES_STACK
BENCH_STACK_PAUSE(); BENCH_STACK_PAUSE();
#endif
#ifdef BENCH_YES_HEAP
BENCH_HEAP_PAUSE(); BENCH_HEAP_PAUSE();
#endif
#ifdef BENCH_KIWIBD #ifdef BENCH_KIWIBD
int err = lfs3_kiwibd_read(cfg, block, off, buffer, size); int err = lfs3_kiwibd_read(cfg, block, off, buffer, size);
@@ -1743,23 +1680,15 @@ int bench_bd_read(const struct lfs3_cfg *cfg, lfs3_block_t block,
int err = lfs3_emubd_read(cfg, block, off, buffer, size); int err = lfs3_emubd_read(cfg, block, off, buffer, size);
#endif #endif
#ifdef BENCH_YES_HEAP
BENCH_HEAP_RESUME(); BENCH_HEAP_RESUME();
#endif
#ifdef BENCH_YES_STACK
BENCH_STACK_RESUME(); BENCH_STACK_RESUME();
#endif
return err; return err;
} }
int bench_bd_prog(const struct lfs3_cfg *cfg, lfs3_block_t block, int bench_bd_prog(const struct lfs3_cfg *cfg, lfs3_block_t block,
lfs3_off_t off, const void *buffer, lfs3_size_t size) { lfs3_off_t off, const void *buffer, lfs3_size_t size) {
#ifdef BENCH_YES_STACK
BENCH_STACK_PAUSE(); BENCH_STACK_PAUSE();
#endif
#ifdef BENCH_YES_HEAP
BENCH_HEAP_PAUSE(); BENCH_HEAP_PAUSE();
#endif
#ifdef BENCH_KIWIBD #ifdef BENCH_KIWIBD
int err = lfs3_kiwibd_prog(cfg, block, off, buffer, size); int err = lfs3_kiwibd_prog(cfg, block, off, buffer, size);
@@ -1767,22 +1696,14 @@ int bench_bd_prog(const struct lfs3_cfg *cfg, lfs3_block_t block,
int err = lfs3_emubd_prog(cfg, block, off, buffer, size); int err = lfs3_emubd_prog(cfg, block, off, buffer, size);
#endif #endif
#ifdef BENCH_YES_HEAP
BENCH_HEAP_RESUME(); BENCH_HEAP_RESUME();
#endif
#ifdef BENCH_YES_STACK
BENCH_STACK_RESUME(); BENCH_STACK_RESUME();
#endif
return err; return err;
} }
int bench_bd_erase(const struct lfs3_cfg *cfg, lfs3_block_t block) { int bench_bd_erase(const struct lfs3_cfg *cfg, lfs3_block_t block) {
#ifdef BENCH_YES_STACK
BENCH_STACK_PAUSE(); BENCH_STACK_PAUSE();
#endif
#ifdef BENCH_YES_HEAP
BENCH_HEAP_PAUSE(); BENCH_HEAP_PAUSE();
#endif
#ifdef BENCH_KIWIBD #ifdef BENCH_KIWIBD
int err = lfs3_kiwibd_erase(cfg, block); int err = lfs3_kiwibd_erase(cfg, block);
@@ -1790,22 +1711,14 @@ int bench_bd_erase(const struct lfs3_cfg *cfg, lfs3_block_t block) {
int err = lfs3_emubd_erase(cfg, block); int err = lfs3_emubd_erase(cfg, block);
#endif #endif
#ifdef BENCH_YES_HEAP
BENCH_HEAP_RESUME(); BENCH_HEAP_RESUME();
#endif
#ifdef BENCH_YES_STACK
BENCH_STACK_RESUME(); BENCH_STACK_RESUME();
#endif
return err; return err;
} }
int bench_bd_sync(const struct lfs3_cfg *cfg) { int bench_bd_sync(const struct lfs3_cfg *cfg) {
#ifdef BENCH_YES_STACK
BENCH_STACK_PAUSE(); BENCH_STACK_PAUSE();
#endif
#ifdef BENCH_YES_HEAP
BENCH_HEAP_PAUSE(); BENCH_HEAP_PAUSE();
#endif
#ifdef BENCH_KIWIBD #ifdef BENCH_KIWIBD
int err = lfs3_kiwibd_sync(cfg); int err = lfs3_kiwibd_sync(cfg);
@@ -1813,12 +1726,8 @@ int bench_bd_sync(const struct lfs3_cfg *cfg) {
int err = lfs3_emubd_sync(cfg); int err = lfs3_emubd_sync(cfg);
#endif #endif
#ifdef BENCH_YES_HEAP
BENCH_HEAP_RESUME(); BENCH_HEAP_RESUME();
#endif
#ifdef BENCH_YES_STACK
BENCH_STACK_RESUME(); BENCH_STACK_RESUME();
#endif
return err; return err;
} }
@@ -1901,19 +1810,19 @@ void perm_run(
perm_printid(suite, case_); perm_printid(suite, case_);
printf("\n"); printf("\n");
bench_reset(CFG); bench_reset(CFG);
#ifdef BENCH_YES_STACK #ifdef BENCH_STACK
bench_stack_enter(); bench_stack_enter();
#endif #endif
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
bench_heap_enter(); bench_heap_enter();
#endif #endif
case_->run(CFG); case_->run(CFG);
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
bench_heap_exit(); bench_heap_exit();
#endif #endif
#ifdef BENCH_YES_STACK #ifdef BENCH_STACK
bench_stack_exit(); bench_stack_exit();
#endif #endif
printf("finished "); printf("finished ");
runners/bench_runner.h
+20 -12
View File
@@ -148,36 +148,44 @@ void bench_permutation(size_t i, uint32_t *buffer, size_t size);
#define BENCH_FACTORIAL(x) bench_factorial(x) #define BENCH_FACTORIAL(x) bench_factorial(x)
#define BENCH_PERMUTATION(i, buffer, size) bench_permutation(i, buffer, size) #define BENCH_PERMUTATION(i, buffer, size) bench_permutation(i, buffer, size)
#ifdef BENCH_YES_STACK #ifdef BENCH_STACK
// get the maximum/current stack usage for this run // get the maximum/current stack usage for this run
size_t bench_stack(void); extern size_t bench_stack_watermark;
__attribute__((noinline)) __attribute__((noinline)) size_t bench_stack_current(void);
size_t bench_stack_current(void); __attribute__((noinline)) void bench_stack_pause(void);
__attribute__((noinline))
void bench_stack_pause(void);
void bench_stack_resume(void); void bench_stack_resume(void);
#define BENCH_STACK() bench_stack() #define BENCH_STACK_WATERMARK() bench_stack_watermark
#define BENCH_STACK_CURRENT() bench_stack_current() #define BENCH_STACK_CURRENT() bench_stack_current()
#define BENCH_STACK_PAUSE() bench_stack_pause() #define BENCH_STACK_PAUSE() bench_stack_pause()
#define BENCH_STACK_RESUME() bench_stack_resume() #define BENCH_STACK_RESUME() bench_stack_resume()
#else
// stubs if not measuring stack
#define BENCH_STACK_PAUSE()
#define BENCH_STACK_RESUME()
#endif #endif
#ifdef BENCH_YES_HEAP #ifdef BENCH_HEAP
// get the maximum/current heap usage for this run // get the maximum/current heap usage for this run
size_t bench_heap(void); extern size_t bench_heap_watermark;
size_t bench_heap_current(void); extern size_t bench_heap_current;
void bench_heap_pause(void); void bench_heap_pause(void);
void bench_heap_resume(void); void bench_heap_resume(void);
void bench_heap_inc(size_t size); void bench_heap_inc(size_t size);
void bench_heap_dec(size_t size); void bench_heap_dec(size_t size);
#define BENCH_HEAP() bench_heap() #define BENCH_HEAP_WATERMARK() bench_heap_watermark
#define BENCH_HEAP_CURRENT() bench_heap_current() #define BENCH_HEAP_CURRENT() bench_heap_current
#define BENCH_HEAP_PAUSE() bench_heap_pause() #define BENCH_HEAP_PAUSE() bench_heap_pause()
#define BENCH_HEAP_RESUME() bench_heap_resume() #define BENCH_HEAP_RESUME() bench_heap_resume()
#define BENCH_HEAP_INC(size) bench_heap_inc(size) #define BENCH_HEAP_INC(size) bench_heap_inc(size)
#define BENCH_HEAP_DEC(size) bench_heap_dec(size) #define BENCH_HEAP_DEC(size) bench_heap_dec(size)
#else
// stubs if not measuring heap
#define BENCH_HEAP_PAUSE()
#define BENCH_HEAP_RESUME()
#define BENCH_HEAP_INC(size)
#define BENCH_HEAP_DEC(size)
#endif #endif
runners/test_runner.c
+62 -121
View File
@@ -633,98 +633,85 @@ void test_permutation(size_t i, uint32_t *buffer, size_t size) {
// stack hooks // stack hooks
#ifdef TEST_YES_STACK #ifdef TEST_STACK
uint8_t *test_stack_watermark_enter; uint8_t *test_stack_entrance = NULL;
uint8_t *test_stack_watermark_depth; size_t test_stack_watermark = 0;
#endif #endif
// call me when entering/exiting a test! // call me when entering/exiting a test!
#ifdef TEST_YES_STACK #ifdef TEST_STACK
__attribute__((noinline)) __attribute__((noinline))
void test_stack_enter(void) { void test_stack_enter(void) {
test_stack_watermark_enter = __builtin_frame_address(0); test_stack_entrance = __builtin_frame_address(0);
test_stack_watermark_depth = test_stack_watermark_enter; test_stack_watermark = 0;
} }
#endif #endif
#ifdef TEST_YES_STACK #ifdef TEST_STACK
void test_stack_exit(void) { void test_stack_exit(void) {
// do nothing // do nothing
} }
#endif #endif
// call me when entering/exiting a bd op! // call me when entering/exiting a bd op!
#ifdef TEST_YES_STACK #ifdef TEST_STACK
__attribute__((noinline)) __attribute__((noinline))
void test_stack_pause(void) { void test_stack_pause(void) {
uint8_t *watermark = __builtin_frame_address(0); uint8_t *current = __builtin_frame_address(0);
// keep track of the deepest stack // keep track of the deepest stack
ssize_t depth = test_stack_watermark_depth - test_stack_watermark_enter; ssize_t depth = current - test_stack_entrance;
if (depth < 0) { if (depth < 0) {
depth = -depth; depth = -depth;
} }
ssize_t depth_ = watermark - test_stack_watermark_enter;
if (depth_ < 0) { if ((size_t)depth > test_stack_watermark) {
depth_ = -depth_; test_stack_watermark = depth;
}
if (depth_ > depth) {
test_stack_watermark_depth = watermark;
} }
} }
#endif #endif
#ifdef TEST_YES_STACK #ifdef TEST_STACK
void test_stack_resume(void) { void test_stack_resume(void) {
// do nothing // do nothing
} }
#endif #endif
// get the worst-case stack usage // get the current stack usage
#ifdef TEST_YES_STACK
size_t test_stack(void) {
ssize_t depth = test_stack_watermark_depth - test_stack_watermark_enter;
if (depth < 0) {
depth = -depth;
}
return depth;
}
#endif
// get the current stack usage, note this is included in test_stack
// //
// note note the noinline here is important for forcing a new stack frame // note the noinline here is important for forcing a new stack frame
#ifdef TEST_YES_STACK #ifdef TEST_STACK
__attribute__((noinline)) __attribute__((noinline))
size_t test_stack_current(void) { size_t test_stack_current(void) {
uint8_t *watermark = __builtin_frame_address(0); uint8_t *current = __builtin_frame_address(0);
ssize_t depth = watermark - test_stack_watermark_enter; ssize_t depth = current - test_stack_entrance;
if (depth < 0) { if (depth < 0) {
depth = -depth; depth = -depth;
} }
return depth; return depth;
} }
#endif #endif
// heap hooks // heap hooks
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
uint32_t test_heap_entered = 0; uint32_t test_heap_entered = 0;
size_t test_heap_current = 0;
size_t test_heap_watermark = 0; size_t test_heap_watermark = 0;
size_t test_heap_watermark_depth = 0;
#endif #endif
// call me when entering/exiting a test! // call me when entering/exiting a test!
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
void test_heap_enter(void) { void test_heap_enter(void) {
test_heap_entered = 1; test_heap_entered = 1;
test_heap_current = 0;
test_heap_watermark = 0; test_heap_watermark = 0;
test_heap_watermark_depth = 0;
} }
#endif #endif
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
void test_heap_exit(void) { void test_heap_exit(void) {
test_heap_entered = 0; test_heap_entered = 0;
if (test_heap_watermark != 0) { if (test_heap_watermark != 0) {
@@ -735,56 +722,42 @@ void test_heap_exit(void) {
#endif #endif
// call me when entering/exiting a bd op! // call me when entering/exiting a bd op!
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
void test_heap_pause(void) { void test_heap_pause(void) {
// haha, a little 32-bit stack // haha, a little 32-bit stack
test_heap_entered <<= 1; test_heap_entered <<= 1;
} }
#endif #endif
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
void test_heap_resume(void) { void test_heap_resume(void) {
test_heap_entered >>= 1; test_heap_entered >>= 1;
} }
#endif #endif
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
void test_heap_inc(size_t size) { void test_heap_inc(size_t size) {
if (test_heap_entered & 1) { if (test_heap_entered & 1) {
test_heap_watermark += size; test_heap_current += size;
// keep track of the deepest heap // keep track of the deepest heap
if (test_heap_watermark > test_heap_watermark_depth) { if (test_heap_current > test_heap_watermark) {
test_heap_watermark_depth = test_heap_watermark; test_heap_watermark = test_heap_current;
} }
} }
} }
#endif #endif
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
void test_heap_dec(size_t size) { void test_heap_dec(size_t size) {
if (test_heap_entered & 1) { if (test_heap_entered & 1) {
assert(test_heap_watermark >= size); assert(test_heap_current >= size);
test_heap_watermark -= size; test_heap_current -= size;
} }
} }
#endif #endif
// get the worst-case heap usage
#ifdef TEST_YES_HEAP
size_t test_heap(void) {
return test_heap_watermark_depth;
}
#endif
// get the current heap usage
#ifdef TEST_YES_HEAP
size_t test_heap_current(void) {
return test_heap_watermark;
}
#endif
// __real_malloc stubs, gcc's --wrap wraps these over the original symbols // __real_malloc stubs, gcc's --wrap wraps these over the original symbols
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
extern void *__real_malloc(size_t size); extern void *__real_malloc(size_t size);
extern void __real_free(void *p); extern void __real_free(void *p);
extern void *__real_realloc(void *p, size_t size); extern void *__real_realloc(void *p, size_t size);
@@ -793,7 +766,7 @@ extern void *__real_realloc(void *p, size_t size);
// the actual malloc hooks // the actual malloc hooks
// //
// these only work if wrapped via gcc's --wrap // these only work if wrapped via gcc's --wrap
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
void *__wrap_malloc(size_t size) { void *__wrap_malloc(size_t size) {
// prefix with allocation size, note we use uintptr_t to hopefully // prefix with allocation size, note we use uintptr_t to hopefully
// keep things aligned // keep things aligned
@@ -802,13 +775,13 @@ void *__wrap_malloc(size_t size) {
return NULL; return NULL;
} }
test_heap_inc(size); TEST_HEAP_INC(size);
*p_ = size; *p_ = size;
return p_ + 1; return p_ + 1;
} }
#endif #endif
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
void __wrap_free(void *p) { void __wrap_free(void *p) {
if (!p) { if (!p) {
return; return;
@@ -816,13 +789,13 @@ void __wrap_free(void *p) {
uintptr_t *p_ = ((uintptr_t*)p) - 1; uintptr_t *p_ = ((uintptr_t*)p) - 1;
size_t size = *p_; size_t size = *p_;
test_heap_dec(size); TEST_HEAP_DEC(size);
__real_free(p_); __real_free(p_);
} }
#endif #endif
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
void *__wrap_realloc(void *p, size_t size) { void *__wrap_realloc(void *p, size_t size) {
uintptr_t *p_; uintptr_t *p_;
size_t old; size_t old;
@@ -840,8 +813,8 @@ void *__wrap_realloc(void *p, size_t size) {
return NULL; return NULL;
} }
test_heap_dec(old); TEST_HEAP_DEC(old);
test_heap_inc(size); TEST_HEAP_INC(size);
*p_ = size; *p_ = size;
return p_ + 1; return p_ + 1;
} }
@@ -1551,12 +1524,8 @@ static void list_implicit_defines(void) {
// test bd wrappers for heap/stack tracking // test bd wrappers for heap/stack tracking
int test_bd_read(const struct lfs3_cfg *cfg, lfs3_block_t block, int test_bd_read(const struct lfs3_cfg *cfg, lfs3_block_t block,
lfs3_off_t off, void *buffer, lfs3_size_t size) { lfs3_off_t off, void *buffer, lfs3_size_t size) {
#ifdef TEST_YES_STACK
TEST_STACK_PAUSE(); TEST_STACK_PAUSE();
#endif
#ifdef TEST_YES_HEAP
TEST_HEAP_PAUSE(); TEST_HEAP_PAUSE();
#endif
#ifdef TEST_KIWIBD #ifdef TEST_KIWIBD
int err = lfs3_kiwibd_read(cfg, block, off, buffer, size); int err = lfs3_kiwibd_read(cfg, block, off, buffer, size);
@@ -1564,23 +1533,15 @@ int test_bd_read(const struct lfs3_cfg *cfg, lfs3_block_t block,
int err = lfs3_emubd_read(cfg, block, off, buffer, size); int err = lfs3_emubd_read(cfg, block, off, buffer, size);
#endif #endif
#ifdef TEST_YES_HEAP
TEST_HEAP_RESUME(); TEST_HEAP_RESUME();
#endif
#ifdef TEST_YES_STACK
TEST_STACK_RESUME(); TEST_STACK_RESUME();
#endif
return err; return err;
} }
int test_bd_prog(const struct lfs3_cfg *cfg, lfs3_block_t block, int test_bd_prog(const struct lfs3_cfg *cfg, lfs3_block_t block,
lfs3_off_t off, const void *buffer, lfs3_size_t size) { lfs3_off_t off, const void *buffer, lfs3_size_t size) {
#ifdef TEST_YES_STACK
TEST_STACK_PAUSE(); TEST_STACK_PAUSE();
#endif
#ifdef TEST_YES_HEAP
TEST_HEAP_PAUSE(); TEST_HEAP_PAUSE();
#endif
#ifdef TEST_KIWIBD #ifdef TEST_KIWIBD
int err = lfs3_kiwibd_prog(cfg, block, off, buffer, size); int err = lfs3_kiwibd_prog(cfg, block, off, buffer, size);
@@ -1588,22 +1549,14 @@ int test_bd_prog(const struct lfs3_cfg *cfg, lfs3_block_t block,
int err = lfs3_emubd_prog(cfg, block, off, buffer, size); int err = lfs3_emubd_prog(cfg, block, off, buffer, size);
#endif #endif
#ifdef TEST_YES_HEAP
TEST_HEAP_RESUME(); TEST_HEAP_RESUME();
#endif
#ifdef TEST_YES_STACK
TEST_STACK_RESUME(); TEST_STACK_RESUME();
#endif
return err; return err;
} }
int test_bd_erase(const struct lfs3_cfg *cfg, lfs3_block_t block) { int test_bd_erase(const struct lfs3_cfg *cfg, lfs3_block_t block) {
#ifdef TEST_YES_STACK
TEST_STACK_PAUSE(); TEST_STACK_PAUSE();
#endif
#ifdef TEST_YES_HEAP
TEST_HEAP_PAUSE(); TEST_HEAP_PAUSE();
#endif
#ifdef TEST_KIWIBD #ifdef TEST_KIWIBD
int err = lfs3_kiwibd_erase(cfg, block); int err = lfs3_kiwibd_erase(cfg, block);
@@ -1611,22 +1564,14 @@ int test_bd_erase(const struct lfs3_cfg *cfg, lfs3_block_t block) {
int err = lfs3_emubd_erase(cfg, block); int err = lfs3_emubd_erase(cfg, block);
#endif #endif
#ifdef TEST_YES_HEAP
TEST_HEAP_RESUME(); TEST_HEAP_RESUME();
#endif
#ifdef TEST_YES_STACK
TEST_STACK_RESUME(); TEST_STACK_RESUME();
#endif
return err; return err;
} }
int test_bd_sync(const struct lfs3_cfg *cfg) { int test_bd_sync(const struct lfs3_cfg *cfg) {
#ifdef TEST_YES_STACK
TEST_STACK_PAUSE(); TEST_STACK_PAUSE();
#endif
#ifdef TEST_YES_HEAP
TEST_HEAP_PAUSE(); TEST_HEAP_PAUSE();
#endif
#ifdef TEST_KIWIBD #ifdef TEST_KIWIBD
int err = lfs3_kiwibd_sync(cfg); int err = lfs3_kiwibd_sync(cfg);
@@ -1634,12 +1579,8 @@ int test_bd_sync(const struct lfs3_cfg *cfg) {
int err = lfs3_emubd_sync(cfg); int err = lfs3_emubd_sync(cfg);
#endif #endif
#ifdef TEST_YES_HEAP
TEST_HEAP_RESUME(); TEST_HEAP_RESUME();
#endif
#ifdef TEST_YES_STACK
TEST_STACK_RESUME(); TEST_STACK_RESUME();
#endif
return err; return err;
} }
@@ -1703,19 +1644,19 @@ static void run_powerloss_none(
printf("running "); printf("running ");
perm_printid(suite, case_, NULL, 0); perm_printid(suite, case_, NULL, 0);
printf("\n"); printf("\n");
#ifdef TEST_YES_STACK #ifdef TEST_STACK
test_stack_enter(); test_stack_enter();
#endif #endif
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
test_heap_enter(); test_heap_enter();
#endif #endif
case_->run(CFG); case_->run(CFG);
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
test_heap_exit(); test_heap_exit();
#endif #endif
#ifdef TEST_YES_STACK #ifdef TEST_STACK
test_stack_exit(); test_stack_exit();
#endif #endif
printf("finished "); printf("finished ");
@@ -1795,20 +1736,20 @@ static void run_powerloss_linear(
while (true) { while (true) {
if (!setjmp(powerloss_jmp)) { if (!setjmp(powerloss_jmp)) {
#ifdef TEST_YES_STACK #ifdef TEST_STACK
test_stack_enter(); test_stack_enter();
#endif #endif
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
test_heap_enter(); test_heap_enter();
#endif #endif
// run the test // run the test
case_->run(CFG); case_->run(CFG);
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
test_heap_exit(); test_heap_exit();
#endif #endif
#ifdef TEST_YES_STACK #ifdef TEST_STACK
test_stack_exit(); test_stack_exit();
#endif #endif
break; break;
@@ -1891,20 +1832,20 @@ static void run_powerloss_log(
while (true) { while (true) {
if (!setjmp(powerloss_jmp)) { if (!setjmp(powerloss_jmp)) {
#ifdef TEST_YES_STACK #ifdef TEST_STACK
test_stack_enter(); test_stack_enter();
#endif #endif
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
test_heap_enter(); test_heap_enter();
#endif #endif
// run the test // run the test
case_->run(CFG); case_->run(CFG);
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
test_heap_exit(); test_heap_exit();
#endif #endif
#ifdef TEST_YES_STACK #ifdef TEST_STACK
test_stack_exit(); test_stack_exit();
#endif #endif
break; break;
@@ -1987,20 +1928,20 @@ static void run_powerloss_cycles(
while (true) { while (true) {
if (!setjmp(powerloss_jmp)) { if (!setjmp(powerloss_jmp)) {
#ifdef TEST_YES_STACK #ifdef TEST_STACK
test_stack_enter(); test_stack_enter();
#endif #endif
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
test_heap_enter(); test_heap_enter();
#endif #endif
// run the test // run the test
case_->run(CFG); case_->run(CFG);
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
test_heap_exit(); test_heap_exit();
#endif #endif
#ifdef TEST_YES_STACK #ifdef TEST_STACK
test_stack_exit(); test_stack_exit();
#endif #endif
break; break;
@@ -2100,20 +2041,20 @@ static void run_powerloss_exhaustive_layer(
lfs3_emubd_setpowercycles(state.cfg, (depth > 0) ? 1 : 0); lfs3_emubd_setpowercycles(state.cfg, (depth > 0) ? 1 : 0);
bdcfg->powerloss_data = &state; bdcfg->powerloss_data = &state;
#ifdef TEST_YES_STACK #ifdef TEST_STACK
test_stack_enter(); test_stack_enter();
#endif #endif
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
test_heap_enter(); test_heap_enter();
#endif #endif
// run the tests // run the tests
case_->run(cfg); case_->run(cfg);
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
test_heap_exit(); test_heap_exit();
#endif #endif
#ifdef TEST_YES_STACK #ifdef TEST_STACK
test_stack_exit(); test_stack_exit();
#endif #endif
runners/test_runner.h
+20 -12
View File
@@ -138,36 +138,44 @@ void test_permutation(size_t i, uint32_t *buffer, size_t size);
#define TEST_FACTORIAL(x) test_factorial(x) #define TEST_FACTORIAL(x) test_factorial(x)
#define TEST_PERMUTATION(i, buffer, size) test_permutation(i, buffer, size) #define TEST_PERMUTATION(i, buffer, size) test_permutation(i, buffer, size)
#ifdef TEST_YES_STACK #ifdef TEST_STACK
// get the maximum/current stack usage for this run // get the maximum/current stack usage for this run
size_t test_stack(void); extern size_t test_stack_watermark;
__attribute__((noinline)) __attribute__((noinline)) size_t test_stack_current(void);
size_t test_stack_current(void); __attribute__((noinline)) void test_stack_pause(void);
__attribute__((noinline))
void test_stack_pause(void);
void test_stack_resume(void); void test_stack_resume(void);
#define TEST_STACK() test_stack() #define TEST_STACK_WATERMARK() test_stack_watermark
#define TEST_STACK_CURRENT() test_stack_current() #define TEST_STACK_CURRENT() test_stack_current()
#define TEST_STACK_PAUSE() test_stack_pause() #define TEST_STACK_PAUSE() test_stack_pause()
#define TEST_STACK_RESUME() test_stack_resume() #define TEST_STACK_RESUME() test_stack_resume()
#else
// stubs if not measuring stack
#define TEST_STACK_PAUSE()
#define TEST_STACK_RESUME()
#endif #endif
#ifdef TEST_YES_HEAP #ifdef TEST_HEAP
// get the maximum/current heap usage for this run // get the maximum/current heap usage for this run
size_t test_heap(void); extern size_t test_heap_watermark;
size_t test_heap_current(void); extern size_t test_heap_current;
void test_heap_pause(void); void test_heap_pause(void);
void test_heap_resume(void); void test_heap_resume(void);
void test_heap_inc(size_t size); void test_heap_inc(size_t size);
void test_heap_dec(size_t size); void test_heap_dec(size_t size);
#define TEST_HEAP() test_heap() #define TEST_HEAP_WATERMARK() test_heap_watermark
#define TEST_HEAP_CURRENT() test_heap_current() #define TEST_HEAP_CURRENT() test_heap_current
#define TEST_HEAP_PAUSE() test_heap_pause() #define TEST_HEAP_PAUSE() test_heap_pause()
#define TEST_HEAP_RESUME() test_heap_resume() #define TEST_HEAP_RESUME() test_heap_resume()
#define TEST_HEAP_INC(size) test_heap_inc(size) #define TEST_HEAP_INC(size) test_heap_inc(size)
#define TEST_HEAP_DEC(size) test_heap_dec(size) #define TEST_HEAP_DEC(size) test_heap_dec(size)
#else
// stubs if not measuring heap
#define TEST_HEAP_PAUSE()
#define TEST_HEAP_RESUME()
#define TEST_HEAP_INC(size)
#define TEST_HEAP_DEC(size)
#endif #endif