Github/littlefs
1
Fork 0
Code Actions Activity

runners: emubd/kiwibd: Adopted emulated simtime API

Browse Source 
This is based on some work in external benchmarks. What's worked well
there is emulating a global simtime based on per-byte estimates.

This moves the emulated simtime into emubd/kiwibd, and extends the idea
with both per-byte and per-op timing estimates for hopefully more
realistic results.

---

The problem is how NAND flash reads work.

Per-byte timing estimates are surprisingly accurate for NOR flash. There
is some overhead for sending the address, but it's mostly dominated by
bus cost (~20ns/B [1]).

NAND flash, on the otherhand, technically does support byte-level reads,
but first needs to read into 2KiB buffer. Surprisingly, these are pretty
close in cost (~19ns/B bus [2] vs ~12ns/B buffer [2]).

This close-ness makes modeling NAND flash difficult. If we set
read_size=1, we risk hiding the cost of small reads, which littlefs3 is
full of (rbyd lookups). If we set read_size=2048, we unfairly penalize
littlefs3 for the same reason.

---

The solution here is to expose both per-byte and per-op timing
estimates. This lets you model NAND reads using two data points:

  ^
  |                                realtime --> ...............o
  |                                             :    .....'''' :
  |                              ...............:''''  ^       :
  |                              :....'''''            |       :
  |               ..........::::::                  simtime    :
  |          .....:''''                                        :
  |o....:::::.....:                                            :
  |:                                                           :
  |:                                                           :
  +:-----------------------------------------------------------:>
   min read                                              max read

Where:

  bus_timing = 19ns
  buffer_timing = 25us
  buffer_size = 2KiB
  erase_size = 128KiB

  min_read = buffer_timing
  max_read = (erase_size/buffer_size)*buffer_timing - buffer_timing
  read_timing = min_read
  readed_timing = ((max_read - min_read)/erase_size) + bus_timing

  simtime = reads*read_timing + readed*readed_timing
            (per-op)            (per-byte)

This should correctly penalize small reads without complicating
emubd/kiwibd too much.

That's the idea anyways! It will take some use to understand if this is
a reasonable approach.

As a plus, this is a superset of the per-byte model, so both can be used
for realistic vs idealistic simulations (and to test the bus+buffer
model itself).

1: https://www.winbond.com/resource-files/W25Q256JV%20SPI%20RevQ%2002072025%20Plus.pdf
2: https://www.winbond.com/resource-files/W25N01GV%20Rev%20R%20070323.pdf
This commit is contained in:
Christopher Haster
2026-01-18 23:57:23 -06:00
parent 1b70c1f199
commit d3dd927de3
10 changed files with 548 additions and 278 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bd/lfs3_emubd.h
+67 -35
View File
@@ -63,8 +63,8 @@ typedef uint32_t lfs3_emubd_powercycles_t;
typedef int32_t lfs3_emubd_spowercycles_t;
// Type for delays in nanoseconds
typedef uint64_t lfs3_emubd_sleep_t;
typedef int64_t lfs3_emubd_ssleep_t;
typedef uint64_t lfs3_emubd_ns_t;
typedef int64_t lfs3_emubd_sns_t;
// emubd config, this is required for testing
struct lfs3_emubd_cfg {
@@ -74,6 +74,42 @@ struct lfs3_emubd_cfg {
// does _not_ rely on this!).
int32_t erase_value;
// Simulated read transaction timing in nanoseconds, this is added
// to simtime each read call, ignoring the requested size
lfs3_emubd_ns_t reads_timing;
// Simulated prog transaction timing in nanoseconds, this is added
// to simtime each prog call, ignoring the requested size
lfs3_emubd_ns_t progs_timing;
// Simulated erase transaction timing in nanoseconds, this is added
// to simtime each erase call, ignoring the requested size
lfs3_emubd_ns_t erases_timing;
// Simulated read byte timing in nanoseconds, this is scaled by the
// requested size and added to simtime each read call.
lfs3_emubd_ns_t readed_timing;
// Simulated prog byte timing in nanoseconds, this is scaled by the
// requested size and added to simtime each prog call.
lfs3_emubd_ns_t progged_timing;
// Simulated erase byte timing in nanoseconds, this is scaled by the
// requested size and added to simtime each erase call.
lfs3_emubd_ns_t erased_timing;
// Artificial read transaction delay in nanoseconds, there is no
// purpose for this other than slowing down the simulation.
lfs3_emubd_ns_t read_sleep;
// Artificial prog transaction delay in nanoseconds, there is no
// purpose for this other than slowing down the simulation.
lfs3_emubd_ns_t prog_sleep;
// Artificial erase transaction delay in nanoseconds, there is no
// purpose for this other than slowing down the simulation.
lfs3_emubd_ns_t erase_sleep;
// Number of erase cycles before a block becomes "bad". The exact behavior
// of bad blocks is controlled by badblock_behavior.
uint32_t erase_cycles;
@@ -99,18 +135,6 @@ struct lfs3_emubd_cfg {
// Seed for prng, which may be used for emulating failed progs. This does
// not affect normal operation.
uint32_t seed;
// Artificial delay in nanoseconds, there is no purpose for this other
// than slowing down the simulation.
lfs3_emubd_sleep_t read_sleep;
// Artificial delay in nanoseconds, there is no purpose for this other
// than slowing down the simulation.
lfs3_emubd_sleep_t prog_sleep;
// Artificial delay in nanoseconds, there is no purpose for this other
// than slowing down the simulation.
lfs3_emubd_sleep_t erase_sleep;
};
// A reference counted block
@@ -138,8 +162,11 @@ typedef struct lfs3_emubd {
lfs3_emubd_block_t **blocks;
// some other test state
lfs3_emubd_io_t reads;
lfs3_emubd_io_t progs;
lfs3_emubd_io_t erases;
lfs3_emubd_io_t readed;
lfs3_emubd_io_t proged;
lfs3_emubd_io_t progged;
lfs3_emubd_io_t erased;
uint32_t prng;
lfs3_emubd_powercycles_t power_cycles;
@@ -188,33 +215,32 @@ int lfs3_emubd_sync(const struct lfs3_cfg *cfg);
/// Additional emubd features for testing ///
// Set the current prng state
void lfs3_emubd_seed(const struct lfs3_cfg *cfg, uint32_t seed);
// Get total simulated runtime
lfs3_emubd_sns_t lfs3_emubd_simtime(const struct lfs3_cfg *cfg);
// Get a pseudo-random number from emubd's internal prng
uint32_t lfs3_emubd_prng(const struct lfs3_cfg *cfg);
// Reset simulation counters
//
// You probably shouldn't call this, instead diff before/after simtimes
int lfs3_emubd_simreset(const struct lfs3_cfg *cfg);
// Get total number of read transactions
lfs3_emubd_sio_t lfs3_emubd_reads(const struct lfs3_cfg *cfg);
// Get total number of prog transactions
lfs3_emubd_sio_t lfs3_emubd_progs(const struct lfs3_cfg *cfg);
// Get total number of erase transactions
lfs3_emubd_sio_t lfs3_emubd_erases(const struct lfs3_cfg *cfg);
// Get total amount of bytes read
lfs3_emubd_sio_t lfs3_emubd_readed(const struct lfs3_cfg *cfg);
// Get total amount of bytes programmed
lfs3_emubd_sio_t lfs3_emubd_proged(const struct lfs3_cfg *cfg);
lfs3_emubd_sio_t lfs3_emubd_progged(const struct lfs3_cfg *cfg);
// Get total amount of bytes erased
lfs3_emubd_sio_t lfs3_emubd_erased(const struct lfs3_cfg *cfg);
// Manually set amount of bytes read
int lfs3_emubd_setreaded(const struct lfs3_cfg *cfg,
lfs3_emubd_io_t readed);
// Manually set amount of bytes programmed
int lfs3_emubd_setproged(const struct lfs3_cfg *cfg,
lfs3_emubd_io_t proged);
// Manually set amount of bytes erased
int lfs3_emubd_seterased(const struct lfs3_cfg *cfg,
lfs3_emubd_io_t erased);
// Get simulated wear on a given block
lfs3_emubd_swear_t lfs3_emubd_wear(const struct lfs3_cfg *cfg,
lfs3_block_t block);
@@ -224,10 +250,10 @@ int lfs3_emubd_setwear(const struct lfs3_cfg *cfg,
lfs3_block_t block, lfs3_emubd_wear_t wear);
// Mark a block as bad, this is equivalent to setting wear to maximum
int lfs3_emubd_markbad(const struct lfs3_cfg *cfg, lfs3_block_t block);
int lfs3_emubd_mkbad(const struct lfs3_cfg *cfg, lfs3_block_t block);
// Clear any simulated wear on a given block
int lfs3_emubd_markgood(const struct lfs3_cfg *cfg, lfs3_block_t block);
int lfs3_emubd_mkgood(const struct lfs3_cfg *cfg, lfs3_block_t block);
// Get which bit failed, this changes on erase/power-loss unless manually set
lfs3_ssize_t lfs3_emubd_badbit(const struct lfs3_cfg *cfg,
@@ -242,7 +268,7 @@ int lfs3_emubd_randomizebadbit(const struct lfs3_cfg *cfg,
lfs3_block_t block);
// Mark a block as bad and which bit should fail
int lfs3_emubd_markbadbit(const struct lfs3_cfg *cfg,
int lfs3_emubd_mkbadbit(const struct lfs3_cfg *cfg,
lfs3_block_t block, lfs3_size_t bit);
// Flip a bit in a given block, intended for emulating bit errors
@@ -260,6 +286,12 @@ lfs3_emubd_spowercycles_t lfs3_emubd_powercycles(
int lfs3_emubd_setpowercycles(const struct lfs3_cfg *cfg,
lfs3_emubd_powercycles_t power_cycles);
// Get a pseudo-random number from emubd's internal prng
uint32_t lfs3_emubd_prng(const struct lfs3_cfg *cfg);
// Set the current prng state
void lfs3_emubd_seed(const struct lfs3_cfg *cfg, uint32_t seed);
// Create a copy-on-write copy of the state of this block device
int lfs3_emubd_cpy(const struct lfs3_cfg *cfg, lfs3_emubd_t *copy);