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
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
#ifdef TEST_YES_STACK
uint8_t *test_stack_watermark_enter;
uint8_t *test_stack_watermark_depth;
#ifdef TEST_STACK
uint8_t *test_stack_entrance = NULL;
size_t test_stack_watermark = 0;
#endif
// call me when entering/exiting a test!
#ifdef TEST_YES_STACK
#ifdef TEST_STACK
__attribute__((noinline))
void test_stack_enter(void) {
test_stack_watermark_enter = __builtin_frame_address(0);
test_stack_watermark_depth = test_stack_watermark_enter;
test_stack_entrance = __builtin_frame_address(0);
test_stack_watermark = 0;
}
#endif
#ifdef TEST_YES_STACK
#ifdef TEST_STACK
void test_stack_exit(void) {
// do nothing
}
#endif
// call me when entering/exiting a bd op!
#ifdef TEST_YES_STACK
#ifdef TEST_STACK
__attribute__((noinline))
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
ssize_t depth = test_stack_watermark_depth - test_stack_watermark_enter;
ssize_t depth = current - test_stack_entrance;
if (depth < 0) {
depth = -depth;
}
ssize_t depth_ = watermark - test_stack_watermark_enter;
if (depth_ < 0) {
depth_ = -depth_;
}
if (depth_ > depth) {
test_stack_watermark_depth = watermark;
if ((size_t)depth > test_stack_watermark) {
test_stack_watermark = depth;
}
}
#endif
#ifdef TEST_YES_STACK
#ifdef TEST_STACK
void test_stack_resume(void) {
// do nothing
}
#endif
// get the worst-case 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
// get the current stack usage
//
// note note the noinline here is important for forcing a new stack frame
#ifdef TEST_YES_STACK
// note the noinline here is important for forcing a new stack frame
#ifdef TEST_STACK
__attribute__((noinline))
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) {
depth = -depth;
}
return depth;
}
#endif
// heap hooks
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
uint32_t test_heap_entered = 0;
size_t test_heap_current = 0;
size_t test_heap_watermark = 0;
size_t test_heap_watermark_depth = 0;
#endif
// call me when entering/exiting a test!
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
void test_heap_enter(void) {
test_heap_entered = 1;
test_heap_current = 0;
test_heap_watermark = 0;
test_heap_watermark_depth = 0;
}
#endif
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
void test_heap_exit(void) {
test_heap_entered = 0;
if (test_heap_watermark != 0) {
@@ -735,56 +722,42 @@ void test_heap_exit(void) {
#endif
// call me when entering/exiting a bd op!
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
void test_heap_pause(void) {
// haha, a little 32-bit stack
test_heap_entered <<= 1;
}
#endif
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
void test_heap_resume(void) {
test_heap_entered >>= 1;
}
#endif
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
void test_heap_inc(size_t size) {
if (test_heap_entered & 1) {
test_heap_watermark += size;
test_heap_current += size;
// keep track of the deepest heap
if (test_heap_watermark > test_heap_watermark_depth) {
test_heap_watermark_depth = test_heap_watermark;
if (test_heap_current > test_heap_watermark) {
test_heap_watermark = test_heap_current;
}
}
}
#endif
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
void test_heap_dec(size_t size) {
if (test_heap_entered & 1) {
assert(test_heap_watermark >= size);
test_heap_watermark -= size;
assert(test_heap_current >= size);
test_heap_current -= size;
}
}
#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
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
extern void *__real_malloc(size_t size);
extern void __real_free(void *p);
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
//
// these only work if wrapped via gcc's --wrap
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
void *__wrap_malloc(size_t size) {
// prefix with allocation size, note we use uintptr_t to hopefully
// keep things aligned
@@ -802,13 +775,13 @@ void *__wrap_malloc(size_t size) {
return NULL;
}
test_heap_inc(size);
TEST_HEAP_INC(size);
*p_ = size;
return p_ + 1;
}
#endif
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
void __wrap_free(void *p) {
if (!p) {
return;
@@ -816,13 +789,13 @@ void __wrap_free(void *p) {
uintptr_t *p_ = ((uintptr_t*)p) - 1;
size_t size = *p_;
test_heap_dec(size);
TEST_HEAP_DEC(size);
__real_free(p_);
}
#endif
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
void *__wrap_realloc(void *p, size_t size) {
uintptr_t *p_;
size_t old;
@@ -840,8 +813,8 @@ void *__wrap_realloc(void *p, size_t size) {
return NULL;
}
test_heap_dec(old);
test_heap_inc(size);
TEST_HEAP_DEC(old);
TEST_HEAP_INC(size);
*p_ = size;
return p_ + 1;
}
@@ -1551,12 +1524,8 @@ static void list_implicit_defines(void) {
// test bd wrappers for heap/stack tracking
int test_bd_read(const struct lfs3_cfg *cfg, lfs3_block_t block,
lfs3_off_t off, void *buffer, lfs3_size_t size) {
#ifdef TEST_YES_STACK
TEST_STACK_PAUSE();
#endif
#ifdef TEST_YES_HEAP
TEST_HEAP_PAUSE();
#endif
#ifdef TEST_KIWIBD
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);
#endif
#ifdef TEST_YES_HEAP
TEST_HEAP_RESUME();
#endif
#ifdef TEST_YES_STACK
TEST_STACK_RESUME();
#endif
return err;
}
int test_bd_prog(const struct lfs3_cfg *cfg, lfs3_block_t block,
lfs3_off_t off, const void *buffer, lfs3_size_t size) {
#ifdef TEST_YES_STACK
TEST_STACK_PAUSE();
#endif
#ifdef TEST_YES_HEAP
TEST_HEAP_PAUSE();
#endif
#ifdef TEST_KIWIBD
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);
#endif
#ifdef TEST_YES_HEAP
TEST_HEAP_RESUME();
#endif
#ifdef TEST_YES_STACK
TEST_STACK_RESUME();
#endif
return err;
}
int test_bd_erase(const struct lfs3_cfg *cfg, lfs3_block_t block) {
#ifdef TEST_YES_STACK
TEST_STACK_PAUSE();
#endif
#ifdef TEST_YES_HEAP
TEST_HEAP_PAUSE();
#endif
#ifdef TEST_KIWIBD
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);
#endif
#ifdef TEST_YES_HEAP
TEST_HEAP_RESUME();
#endif
#ifdef TEST_YES_STACK
TEST_STACK_RESUME();
#endif
return err;
}
int test_bd_sync(const struct lfs3_cfg *cfg) {
#ifdef TEST_YES_STACK
TEST_STACK_PAUSE();
#endif
#ifdef TEST_YES_HEAP
TEST_HEAP_PAUSE();
#endif
#ifdef TEST_KIWIBD
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);
#endif
#ifdef TEST_YES_HEAP
TEST_HEAP_RESUME();
#endif
#ifdef TEST_YES_STACK
TEST_STACK_RESUME();
#endif
return err;
}
@@ -1703,19 +1644,19 @@ static void run_powerloss_none(
printf("running ");
perm_printid(suite, case_, NULL, 0);
printf("\n");
#ifdef TEST_YES_STACK
#ifdef TEST_STACK
test_stack_enter();
#endif
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
test_heap_enter();
#endif
case_->run(CFG);
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
test_heap_exit();
#endif
#ifdef TEST_YES_STACK
#ifdef TEST_STACK
test_stack_exit();
#endif
printf("finished ");
@@ -1795,20 +1736,20 @@ static void run_powerloss_linear(
while (true) {
if (!setjmp(powerloss_jmp)) {
#ifdef TEST_YES_STACK
#ifdef TEST_STACK
test_stack_enter();
#endif
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
test_heap_enter();
#endif
// run the test
case_->run(CFG);
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
test_heap_exit();
#endif
#ifdef TEST_YES_STACK
#ifdef TEST_STACK
test_stack_exit();
#endif
break;
@@ -1891,20 +1832,20 @@ static void run_powerloss_log(
while (true) {
if (!setjmp(powerloss_jmp)) {
#ifdef TEST_YES_STACK
#ifdef TEST_STACK
test_stack_enter();
#endif
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
test_heap_enter();
#endif
// run the test
case_->run(CFG);
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
test_heap_exit();
#endif
#ifdef TEST_YES_STACK
#ifdef TEST_STACK
test_stack_exit();
#endif
break;
@@ -1987,20 +1928,20 @@ static void run_powerloss_cycles(
while (true) {
if (!setjmp(powerloss_jmp)) {
#ifdef TEST_YES_STACK
#ifdef TEST_STACK
test_stack_enter();
#endif
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
test_heap_enter();
#endif
// run the test
case_->run(CFG);
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
test_heap_exit();
#endif
#ifdef TEST_YES_STACK
#ifdef TEST_STACK
test_stack_exit();
#endif
break;
@@ -2100,20 +2041,20 @@ static void run_powerloss_exhaustive_layer(
lfs3_emubd_setpowercycles(state.cfg, (depth > 0) ? 1 : 0);
bdcfg->powerloss_data = &state;
#ifdef TEST_YES_STACK
#ifdef TEST_STACK
test_stack_enter();
#endif
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
test_heap_enter();
#endif
// run the tests
case_->run(cfg);
#ifdef TEST_YES_HEAP
#ifdef TEST_HEAP
test_heap_exit();
#endif
#ifdef TEST_YES_STACK
#ifdef TEST_STACK
test_stack_exit();
#endif