Github/littlefs
1
Fork 0
Code Actions Activity

benches: Reworked bench_rt to fail gracefully

Browse Source 
This reworks bench_rt to write the target file gradually, mixing reads
and writes. This makes it so if the benchmark times out, the results are
still interesting, if less rigorous.

This is useful if you want to compare a change quickly, with more
SIM_TIME leading to a more accurate result.

---

The problem for bench_rt is that we first need to write a file. This can
take _quite_ a while for large SIM_TIME, completely failing in some
cases (bench_rt_many + BENCH_NAND).

The nice thing about bench_wt is that when it fails you still get
interesting numbers out of it. You don't find the relevant throughput
for the given SIZE, but you do find throughput for files _approaching_
SIZE. Unfortunately this didn't carry over to bench_rt.

The good news is the new bench probe system makes it easy to selectively
ignore parts of each bench, so we can rework bench_rt to start with a
CHUNK sized file and gradually increase it until it hits our target
size. This allows bench_rt to also fail gracefully.

Consider a 1 minute run:

  $ make bench-runner -j \
      && BENCHFLAGS='bench_rt -DSIM_TIME=60000000000' make bench -j \
      && make bench-marks
  bench+probe                            n       t  throughput
  bench_rt_seq+read                 302848     0.0  30690155.6
  bench_rt_random+read              302592     0.0  59646605.2
  bench_rt_logging+read              52992     5.9      8915.0
  bench_rt_many+read                112896     0.2    482831.6
  TOTAL                             771328     6.2  22707126.8

Vs the default 1 hour run:

  $ make bench-runner -j \
      && BENCHFLAGS='bench_rt' make bench -j \
      && make bench-marks
  bench+probe                            n       t  throughput
  bench_rt_seq+read            79600038272  3325.1  23939212.7
  bench_rt_random+read         21482635264  3325.0   6461004.1
  bench_rt_logging+read            3085056   740.9      4163.9
  bench_rt_many+read             706571904  1800.7    392380.4
  TOTAL                       101792330496  9191.7   7699190.3

The main risk of doing this is cross-contaminating read results with
write operations. Fortunately the current benches appear to be isolated
well enough:

  $ make bench-ops
  bench+probe                       readed     progged      erased
  bench_rt_logging+read           86886137    18936138    19767296
  bench_rt_seq+read            83127251476           0           0
  bench_rt_many+read           45018292401           0           0
  bench_rt_random+read         83124213669           0           0
  TOTAL                       211356643683    18936138    19767296

---

Oh! This also lets us add bench_rt_logging, which needs a mixed writer
to make any sense.

Note bench_rt_logging also includes popping from the log (fifo?), so is
not a strictly read-only bench.
This commit is contained in:
Christopher Haster
2026-02-10 13:20:57 -06:00
parent a8b5a17933
commit 1a98d8089b
2 changed files with 277 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files
benches/bench_rt.toml
+242 -87
View File
@@ -28,64 +28,87 @@ code = '''
[cases.bench_rt_seq]
code = '''
lfs3_t lfs3;
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0;
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
if (!SKIP_WARMUP) {
BENCH_PAUSE();
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
int err = bench_helpers_warmup(&lfs3);
if (err) {
LFS3_ERROR("Bench warmup failed: %d", err);
return;
}
BENCH_RESUME();
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
}
uint32_t prng = SEED;
// reset our timer
BENCH_SIMRESET();
// create a file to read
lfs3_file_t file;
lfs3_file_open(&lfs3, &file, "bench_linear",
// open a file for both writing and reading
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
lfs3_file_t wfile;
lfs3_file_open(&lfs3, &wfile, "bench_seq",
LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
for (lfs3_size_t i = 0; i < (SIZE+(CHUNK-1))/CHUNK; i++) {
uint8_t wbuf[CHUNK];
for (lfs3_size_t j = 0; j < CHUNK; j++) {
wbuf[j] = 'a' + (BENCH_PRNG(&prng) % 26);
}
lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK;
// taking too long?
if (SIM_TIME && BENCH_SIMTIME() >= SIM_TIME) {
return;
}
}
lfs3_file_close(&lfs3, &file) => 0;
// reset our timer
BENCH_SIMRESET();
// open the file
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
BENCH_START("read");
lfs3_file_open(&lfs3, &file, "bench_linear", LFS3_O_RDONLY) => 0;
lfs3_file_t rfile;
lfs3_file_open(&lfs3, &rfile, "bench_seq",
LFS3_O_RDONLY) => 0;
lfs3_off_t size = 0;
lfs3_off_t readed_ = 0;
uint64_t readed = 0;
BENCH_STOP("read", readed);
// ok, one of these needs to be non-zero
LFS3_ASSERT(SIM_TIME > 0 || SIM_SIZE > 0);
while (!(SIM_SIZE && readed >= (uint64_t)SIM_SIZE)
&& !(SIM_TIME && BENCH_SIMTIME() >= SIM_TIME)) {
// gradually increase the file size, so we at least have somewhat
// meaningful results if we timeout early
if (size < SIZE) {
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
uint8_t wbuf[CHUNK];
for (lfs3_size_t j = 0; j < CHUNK; j++) {
wbuf[j] = 'a' + (BENCH_PRNG(&prng) % 26);
}
lfs3_file_write(&lfs3, &wfile, wbuf, CHUNK) => CHUNK;
lfs3_file_sync(&lfs3, &wfile) => 0;
size += CHUNK;
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
}
BENCH_START("read");
// rewind if we reach the end
if (readed_ >= size) {
lfs3_file_rewind(&lfs3, &rfile) => 0;
readed_ = 0;
}
// read from the file
uint8_t rbuf[CHUNK];
lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK;
lfs3_file_read(&lfs3, &rfile, rbuf, CHUNK) => CHUNK;
size += CHUNK;
readed_ += CHUNK;
readed += CHUNK;
// rewind if we reach the end
if (size >= SIZE) {
lfs3_file_rewind(&lfs3, &file) => 0;
size = 0;
}
BENCH_STOP("read", readed);
}
lfs3_file_close(&lfs3, &file) => 0;
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
lfs3_file_close(&lfs3, &wfile) => 0;
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
BENCH_START("read");
lfs3_file_close(&lfs3, &rfile) => 0;
// report the amount we managed to read
BENCH_STOP("read", readed);
@@ -96,60 +119,176 @@ code = '''
[cases.bench_rt_random]
code = '''
lfs3_t lfs3;
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0;
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
if (!SKIP_WARMUP) {
BENCH_PAUSE();
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
int err = bench_helpers_warmup(&lfs3);
if (err) {
return;
}
BENCH_RESUME();
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
}
uint32_t prng = SEED;
// reset our timer
BENCH_SIMRESET();
// create a file to read
lfs3_file_t file;
lfs3_file_open(&lfs3, &file, "bench_random",
// open a file for both writing and reading
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
lfs3_file_t wfile;
lfs3_file_open(&lfs3, &wfile, "bench_random",
LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
for (lfs3_size_t i = 0; i < (SIZE+(CHUNK-1))/CHUNK; i++) {
uint8_t wbuf[CHUNK];
for (lfs3_size_t j = 0; j < CHUNK; j++) {
wbuf[j] = 'a' + (BENCH_PRNG(&prng) % 26);
}
lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK;
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
BENCH_START("read");
lfs3_file_t rfile;
lfs3_file_open(&lfs3, &rfile, "bench_random",
LFS3_O_RDONLY) => 0;
lfs3_off_t size = 0;
uint64_t readed = 0;
BENCH_STOP("read", readed);
// ok, one of these needs to be non-zero
LFS3_ASSERT(SIM_TIME > 0 || SIM_SIZE > 0);
while (!(SIM_SIZE && readed >= (uint64_t)SIM_SIZE)
&& !(SIM_TIME && BENCH_SIMTIME() >= SIM_TIME)) {
// gradually increase the file size, so we at least have somewhat
// meaningful results if we timeout early
if (size < SIZE) {
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
uint8_t wbuf[CHUNK];
for (lfs3_size_t j = 0; j < CHUNK; j++) {
wbuf[j] = 'a' + (BENCH_PRNG(&prng) % 26);
}
lfs3_file_write(&lfs3, &wfile, wbuf, CHUNK) => CHUNK;
lfs3_file_sync(&lfs3, &wfile) => 0;
// taking too long?
if (SIM_TIME && BENCH_SIMTIME() >= SIM_TIME) {
size += CHUNK;
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
}
BENCH_START("read");
// seek to a random location
lfs3_off_t pos = BENCH_PRNG(&prng) % SIZE;
lfs3_file_seek(&lfs3, &rfile, pos, LFS3_SEEK_SET) => pos;
// read from the file
uint8_t rbuf[CHUNK];
lfs3_ssize_t d = lfs3_file_read(&lfs3, &rfile, rbuf, CHUNK);
assert(d <= CHUNK);
readed += CHUNK;
BENCH_STOP("read", readed);
}
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
lfs3_file_close(&lfs3, &wfile) => 0;
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
BENCH_START("read");
lfs3_file_close(&lfs3, &rfile) => 0;
// report the amount we managed to read
BENCH_STOP("read", readed);
lfs3_unmount(&lfs3) => 0;
'''
# logging read throughput
#
# note this will write as we need to pop the most recent read off the file!
[cases.bench_rt_logging]
code = '''
lfs3_t lfs3;
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0;
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
if (!SKIP_WARMUP) {
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
int err = bench_helpers_warmup(&lfs3);
if (err) {
return;
}
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
}
lfs3_file_close(&lfs3, &file) => 0;
uint32_t prng = SEED;
// reset our timer
BENCH_SIMRESET();
// open the file
// open a file for both writing and reading
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
lfs3_file_t wfile;
lfs3_file_open(&lfs3, &wfile, "bench_random",
LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_APPEND) => 0;
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
BENCH_START("read");
lfs3_file_open(&lfs3, &file, "bench_random", LFS3_O_RDONLY) => 0;
lfs3_file_t rfile;
lfs3_file_open(&lfs3, &rfile, "bench_random",
LFS3_O_RDWR) => 0;
lfs3_off_t size = 0;
uint64_t readed = 0;
BENCH_STOP("read", readed);
// ok, one of these needs to be non-zero
LFS3_ASSERT(SIM_TIME > 0 || SIM_SIZE > 0);
while (!(SIM_SIZE && readed >= (uint64_t)SIM_SIZE)
&& !(SIM_TIME && BENCH_SIMTIME() >= SIM_TIME)) {
// seek to a random location
lfs3_off_t pos = BENCH_PRNG(&prng) % SIZE;
lfs3_file_seek(&lfs3, &file, pos, LFS3_SEEK_SET) => pos;
// gradually increase the file size, so we at least have somewhat
// meaningful results if we timeout early
//
// note we need to write ~2x to keep up with the reader!
if (size < SIZE) {
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
uint8_t wbuf[CHUNK];
for (lfs3_size_t j_ = 0; j_ < 2; j_++) {
for (lfs3_size_t j = 0; j < CHUNK; j++) {
wbuf[j] = 'a' + (BENCH_PRNG(&prng) % 26);
}
lfs3_file_write(&lfs3, &wfile, wbuf, CHUNK) => CHUNK;
}
lfs3_file_sync(&lfs3, &wfile) => 0;
size += 2*CHUNK;
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
}
BENCH_START("read");
// read from the file
uint8_t rbuf[CHUNK];
lfs3_ssize_t d = lfs3_file_read(&lfs3, &file, rbuf, CHUNK);
assert(d <= CHUNK);
lfs3_file_read(&lfs3, &rfile, rbuf, CHUNK) => CHUNK;
// fruncate front of file
lfs3_file_fruncate(&lfs3, &rfile, size-CHUNK) => 0;
// broadcast to writer
lfs3_file_sync(&lfs3, &rfile) => 0;
size -= CHUNK;
readed += CHUNK;
BENCH_STOP("read", readed);
}
lfs3_file_close(&lfs3, &file) => 0;
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
lfs3_file_close(&lfs3, &wfile) => 0;
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
BENCH_START("read");
lfs3_file_close(&lfs3, &rfile) => 0;
// report the amount we managed to read
BENCH_STOP("read", readed);
@@ -162,52 +301,66 @@ defines.FILE_SIZE = 'CHUNK'
defines.FILE_COUNT = '(SIZE+(FILE_SIZE-1)) / lfs3_max(FILE_SIZE, 1)'
code = '''
lfs3_t lfs3;
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0;
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
if (!SKIP_WARMUP) {
BENCH_PAUSE();
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
int err = bench_helpers_warmup(&lfs3);
if (err) {
return;
}
BENCH_RESUME();
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
}
uint32_t prng = SEED;
// reset our timer
BENCH_SIMRESET();
// create files to read
for (lfs3_size_t i = 0; i < (SIZE+(CHUNK-1))/CHUNK; i++) {
char name[256];
sprintf(name, "bench_%08x", i);
lfs3_file_t file;
lfs3_file_open(&lfs3, &file, name,
LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
for (lfs3_size_t i = 0; i < (FILE_SIZE+(CHUNK-1))/CHUNK; i++) {
lfs3_ssize_t d = lfs3_min(CHUNK, FILE_SIZE);
uint8_t wbuf[CHUNK];
memset(wbuf, 'a'+(BENCH_PRNG(&prng) % 26), d);
lfs3_file_write(&lfs3, &file, wbuf, d) => d;
// taking too long?
if (SIM_TIME && BENCH_SIMTIME() >= SIM_TIME) {
return;
}
}
lfs3_file_close(&lfs3, &file) => 0;
}
// reset our timer
BENCH_SIMRESET();
// open the files
BENCH_START("read");
lfs3_off_t size = 0;
uint64_t readed = 0;
BENCH_STOP("read", readed);
// ok, one of these needs to be non-zero
LFS3_ASSERT(SIM_TIME > 0 || SIM_SIZE > 0);
while (!(SIM_SIZE && readed >= (uint64_t)SIM_SIZE)
&& !(SIM_TIME && BENCH_SIMTIME() >= SIM_TIME)) {
// gradually increase the filesystem size, so we at least have
// somewhat meaningful results if we timeout early
if (size < SIZE) {
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
char name[256];
sprintf(name, "bench_%08x", (lfs3_off_t)(size/CHUNK));
lfs3_file_t wfile;
lfs3_file_open(&lfs3, &wfile, name,
LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
for (lfs3_size_t i = 0; i < (FILE_SIZE+(CHUNK-1))/CHUNK; i++) {
lfs3_ssize_t d = lfs3_min(CHUNK, FILE_SIZE);
uint8_t wbuf[CHUNK];
memset(wbuf, 'a'+(BENCH_PRNG(&prng) % 26), d);
lfs3_file_write(&lfs3, &wfile, wbuf, d) => d;
// taking too long?
if (SIM_TIME && BENCH_SIMTIME() >= SIM_TIME) {
break;
}
}
lfs3_file_close(&lfs3, &wfile) => 0;
size += CHUNK;
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
}
BENCH_START("read");
// choose a random filename
lfs3_off_t pos = BENCH_PRNG(&prng) % ((SIZE+(CHUNK-1))/CHUNK);
lfs3_off_t pos = BENCH_PRNG(&prng) % ((size+(CHUNK-1))/CHUNK);
char name[256];
sprintf(name, "bench_%08x", pos);
uint8_t rbuf[CHUNK];
@@ -216,11 +369,11 @@ code = '''
//
// note file == CHUNK here, the sum of all files should add up
// roughly to the benchmark SIZE
lfs3_file_t file;
lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0;
lfs3_file_t rfile;
lfs3_file_open(&lfs3, &rfile, name, LFS3_O_RDONLY) => 0;
for (lfs3_size_t i = 0; i < (FILE_SIZE+(CHUNK-1))/CHUNK; i++) {
lfs3_ssize_t d = lfs3_min(CHUNK, FILE_SIZE);
lfs3_file_read(&lfs3, &file, rbuf, d) => d;
lfs3_file_read(&lfs3, &rfile, rbuf, d) => d;
readed += d;
// taking too long?
@@ -228,8 +381,10 @@ code = '''
break;
}
}
lfs3_file_close(&lfs3, &file) => 0;
lfs3_file_close(&lfs3, &rfile) => 0;
BENCH_STOP("read", readed);
}
BENCH_START("read");
// report the amount we managed to read
BENCH_STOP("read", readed);
benches/bench_wt.toml
+35 -10
View File
@@ -31,13 +31,15 @@ code = '''
lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0;
lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
if (!SKIP_WARMUP) {
BENCH_PAUSE();
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
int err = bench_helpers_warmup(&lfs3);
if (err) {
LFS3_ERROR("Bench warmup failed: %d", err);
return;
}
BENCH_RESUME();
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
}
uint32_t prng = SEED;
@@ -47,14 +49,16 @@ code = '''
// open a file
BENCH_START("write");
lfs3_file_t file;
lfs3_file_open(&lfs3, &file, "bench_linear",
lfs3_file_open(&lfs3, &file, "bench_seq",
LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
lfs3_off_t size = 0;
uint64_t written = 0;
BENCH_STOP("write", written);
// ok, one of these needs to be non-zero
LFS3_ASSERT(SIM_TIME > 0 || SIM_SIZE > 0);
while (!(SIM_SIZE && written >= (uint64_t)SIM_SIZE)
&& !(SIM_TIME && BENCH_SIMTIME() >= SIM_TIME)) {
BENCH_START("write");
// arguably we should just rewind and continue writing to the
// front of the file when we hit the end, but this overly
// penalizes littlefs2, so instead we truncate
@@ -73,7 +77,9 @@ code = '''
size += CHUNK;
written += CHUNK;
BENCH_STOP("write", written);
}
BENCH_START("write");
lfs3_file_close(&lfs3, &file) => 0;
// report the amount we managed to write
BENCH_STOP("write", written);
@@ -102,12 +108,14 @@ code = '''
lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0;
lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
if (!SKIP_WARMUP) {
BENCH_PAUSE();
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
int err = bench_helpers_warmup(&lfs3);
if (err) {
return;
}
BENCH_RESUME();
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
}
uint32_t prng = SEED;
@@ -121,8 +129,12 @@ code = '''
LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
lfs3_off_t size = 0;
uint64_t written = 0;
BENCH_STOP("write", written);
// ok, one of these needs to be non-zero
LFS3_ASSERT(SIM_TIME > 0 || SIM_SIZE > 0);
while (!(SIM_SIZE && written >= (uint64_t)SIM_SIZE)
&& !(SIM_TIME && BENCH_SIMTIME() >= SIM_TIME)) {
BENCH_START("write");
// seek to a random location
lfs3_off_t pos = BENCH_PRNG(&prng) % SIZE;
lfs3_file_seek(&lfs3, &file, pos, LFS3_SEEK_SET) => pos;
@@ -136,7 +148,9 @@ code = '''
size = lfs3_max(size, pos + CHUNK);
written += CHUNK;
BENCH_STOP("write", written);
}
BENCH_START("write");
lfs3_file_close(&lfs3, &file) => 0;
// report the amount we managed to write
BENCH_STOP("write", written);
@@ -168,12 +182,14 @@ code = '''
lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0;
lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
if (!SKIP_WARMUP) {
BENCH_PAUSE();
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
int err = bench_helpers_warmup(&lfs3);
if (err) {
return;
}
BENCH_RESUME();
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
}
uint32_t prng = SEED;
@@ -186,10 +202,12 @@ code = '''
lfs3_file_open(&lfs3, &file, "bench_log",
LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_APPEND) => 0;
uint64_t written = 0;
BENCH_STOP("write", written);
// ok, one of these needs to be non-zero
LFS3_ASSERT(SIM_TIME > 0 || SIM_SIZE > 0);
while (!(SIM_SIZE && written >= (uint64_t)SIM_SIZE)
&& !(SIM_TIME && BENCH_SIMTIME() >= SIM_TIME)) {
BENCH_START("write");
// append to log
uint8_t wbuf[CHUNK];
for (lfs3_size_t j = 0; j < CHUNK; j++) {
@@ -218,7 +236,9 @@ code = '''
}
written += CHUNK;
BENCH_STOP("write", written);
}
BENCH_START("write");
lfs3_file_close(&lfs3, &file) => 0;
// report the amount we managed to write
BENCH_STOP("write", written);
@@ -247,25 +267,28 @@ code = '''
lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0;
lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
if (!SKIP_WARMUP) {
BENCH_PAUSE();
BENCH_STACK_PAUSE();
BENCH_HEAP_PAUSE();
int err = bench_helpers_warmup(&lfs3);
if (err) {
return;
}
BENCH_RESUME();
BENCH_HEAP_RESUME();
BENCH_STACK_RESUME();
}
uint32_t prng = SEED;
// reset our timer
BENCH_SIMRESET();
// open a file
BENCH_START("write");
uint64_t written = 0;
BENCH_STOP("write", written);
// ok, one of these needs to be non-zero
LFS3_ASSERT(SIM_TIME > 0 || SIM_SIZE > 0);
while (!(SIM_SIZE && written >= (uint64_t)SIM_SIZE)
&& !(SIM_TIME && BENCH_SIMTIME() >= SIM_TIME)) {
BENCH_START("write");
// choose a random filename
lfs3_off_t pos = BENCH_PRNG(&prng) % FILE_COUNT;
char name[256];
@@ -292,7 +315,9 @@ code = '''
}
}
lfs3_file_close(&lfs3, &file) => 0;
BENCH_STOP("write", written);
}
BENCH_START("write");
// report the amount we managed to write
BENCH_STOP("write", written);