From 938cee16409d843bf4aa3014e0c05d61f77cd246 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Fri, 30 Jun 2023 03:00:07 -0500 Subject: [PATCH] Updated benches based on changes, commented out outdated benchmarks --- benches/bench_btree.toml | 16 +- benches/bench_dir.toml | 540 +++++++++++++++++----------------- benches/bench_file.toml | 190 ++++++------ benches/bench_mtree.toml | 11 +- benches/bench_rbyd.toml | 59 ++-- benches/bench_superblock.toml | 112 +++---- 6 files changed, 461 insertions(+), 467 deletions(-) diff --git a/benches/bench_btree.toml b/benches/bench_btree.toml index a3ee3ada..004e1ed7 100644 --- a/benches/bench_btree.toml +++ b/benches/bench_btree.toml @@ -15,11 +15,11 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; // create free lookahead - memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size); - lfs.free.off = 0; - lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size, + memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size); + lfs.lookahead.start = 0; + lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size, lfs.cfg->block_count); - lfs.free.i = 0; + lfs.lookahead.next = 0; lfs_alloc_ack(&lfs); uint32_t prng = SEED; @@ -66,11 +66,11 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; // create free lookahead - memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size); - lfs.free.off = 0; - lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size, + memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size); + lfs.lookahead.start = 0; + lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size, lfs.cfg->block_count); - lfs.free.i = 0; + lfs.lookahead.next = 0; lfs_alloc_ack(&lfs); uint32_t prng = SEED; diff --git a/benches/bench_dir.toml b/benches/bench_dir.toml index 5f8cb490..bcc3de0e 100644 --- a/benches/bench_dir.toml +++ b/benches/bench_dir.toml @@ -1,270 +1,270 @@ -[cases.bench_dir_open] -# 0 = in-order -# 1 = reversed-order -# 2 = random-order -defines.ORDER = [0, 1, 2] -defines.N = 1024 -defines.FILE_SIZE = 8 -defines.CHUNK_SIZE = 8 -code = ''' - lfs_t lfs; - lfs_format(&lfs, cfg) => 0; - lfs_mount(&lfs, cfg) => 0; - - // first create the files - char name[256]; - uint8_t buffer[CHUNK_SIZE]; - for (lfs_size_t i = 0; i < N; i++) { - sprintf(name, "file%08x", i); - lfs_file_t file; - lfs_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - - uint32_t file_prng = i; - for (lfs_size_t j = 0; j < FILE_SIZE; j += CHUNK_SIZE) { - for (lfs_size_t k = 0; k < CHUNK_SIZE; k++) { - buffer[k] = BENCH_PRNG(&file_prng); - } - lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; - } - - lfs_file_close(&lfs, &file) => 0; - } - - // then read the files - BENCH_START(); - uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { - lfs_off_t i_ - = (ORDER == 0) ? i - : (ORDER == 1) ? (N-1-i) - : BENCH_PRNG(&prng) % N; - sprintf(name, "file%08x", i_); - lfs_file_t file; - lfs_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - - uint32_t file_prng = i_; - for (lfs_size_t j = 0; j < FILE_SIZE; j += CHUNK_SIZE) { - lfs_file_read(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; - for (lfs_size_t k = 0; k < CHUNK_SIZE; k++) { - assert(buffer[k] == BENCH_PRNG(&file_prng)); - } - } - - lfs_file_close(&lfs, &file) => 0; - } - BENCH_STOP(); - - lfs_unmount(&lfs) => 0; -''' - -[cases.bench_dir_creat] -# 0 = in-order -# 1 = reversed-order -# 2 = random-order -defines.ORDER = [0, 1, 2] -defines.N = 1024 -defines.FILE_SIZE = 8 -defines.CHUNK_SIZE = 8 -code = ''' - lfs_t lfs; - lfs_format(&lfs, cfg) => 0; - lfs_mount(&lfs, cfg) => 0; - - BENCH_START(); - uint32_t prng = 42; - char name[256]; - uint8_t buffer[CHUNK_SIZE]; - for (lfs_size_t i = 0; i < N; i++) { - lfs_off_t i_ - = (ORDER == 0) ? i - : (ORDER == 1) ? (N-1-i) - : BENCH_PRNG(&prng) % N; - sprintf(name, "file%08x", i_); - lfs_file_t file; - lfs_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - - uint32_t file_prng = i_; - for (lfs_size_t j = 0; j < FILE_SIZE; j += CHUNK_SIZE) { - for (lfs_size_t k = 0; k < CHUNK_SIZE; k++) { - buffer[k] = BENCH_PRNG(&file_prng); - } - lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; - } - - lfs_file_close(&lfs, &file) => 0; - } - BENCH_STOP(); - - lfs_unmount(&lfs) => 0; -''' - -[cases.bench_dir_remove] -# 0 = in-order -# 1 = reversed-order -# 2 = random-order -defines.ORDER = [0, 1, 2] -defines.N = 1024 -defines.FILE_SIZE = 8 -defines.CHUNK_SIZE = 8 -code = ''' - lfs_t lfs; - lfs_format(&lfs, cfg) => 0; - lfs_mount(&lfs, cfg) => 0; - - // first create the files - char name[256]; - uint8_t buffer[CHUNK_SIZE]; - for (lfs_size_t i = 0; i < N; i++) { - sprintf(name, "file%08x", i); - lfs_file_t file; - lfs_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - - uint32_t file_prng = i; - for (lfs_size_t j = 0; j < FILE_SIZE; j += CHUNK_SIZE) { - for (lfs_size_t k = 0; k < CHUNK_SIZE; k++) { - buffer[k] = BENCH_PRNG(&file_prng); - } - lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; - } - - lfs_file_close(&lfs, &file) => 0; - } - - // then remove the files - BENCH_START(); - uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { - lfs_off_t i_ - = (ORDER == 0) ? i - : (ORDER == 1) ? (N-1-i) - : BENCH_PRNG(&prng) % N; - sprintf(name, "file%08x", i_); - int err = lfs_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOENT); - } - BENCH_STOP(); - - lfs_unmount(&lfs) => 0; -''' - -[cases.bench_dir_read] -defines.N = 1024 -defines.FILE_SIZE = 8 -defines.CHUNK_SIZE = 8 -code = ''' - lfs_t lfs; - lfs_format(&lfs, cfg) => 0; - lfs_mount(&lfs, cfg) => 0; - - // first create the files - char name[256]; - uint8_t buffer[CHUNK_SIZE]; - for (lfs_size_t i = 0; i < N; i++) { - sprintf(name, "file%08x", i); - lfs_file_t file; - lfs_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - - uint32_t file_prng = i; - for (lfs_size_t j = 0; j < FILE_SIZE; j += CHUNK_SIZE) { - for (lfs_size_t k = 0; k < CHUNK_SIZE; k++) { - buffer[k] = BENCH_PRNG(&file_prng); - } - lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; - } - - lfs_file_close(&lfs, &file) => 0; - } - - // then read the directory - BENCH_START(); - lfs_dir_t dir; - lfs_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfs_dir_read(&lfs, &dir, &info) => 1; - assert(info.type == LFS_TYPE_DIR); - assert(strcmp(info.name, ".") == 0); - lfs_dir_read(&lfs, &dir, &info) => 1; - assert(info.type == LFS_TYPE_DIR); - assert(strcmp(info.name, "..") == 0); - for (int i = 0; i < N; i++) { - sprintf(name, "file%08x", i); - lfs_dir_read(&lfs, &dir, &info) => 1; - assert(info.type == LFS_TYPE_REG); - assert(strcmp(info.name, name) == 0); - } - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - BENCH_STOP(); - - lfs_unmount(&lfs) => 0; -''' - -[cases.bench_dir_mkdir] -# 0 = in-order -# 1 = reversed-order -# 2 = random-order -defines.ORDER = [0, 1, 2] -defines.N = 8 -code = ''' - lfs_t lfs; - lfs_format(&lfs, cfg) => 0; - lfs_mount(&lfs, cfg) => 0; - - BENCH_START(); - uint32_t prng = 42; - char name[256]; - for (lfs_size_t i = 0; i < N; i++) { - lfs_off_t i_ - = (ORDER == 0) ? i - : (ORDER == 1) ? (N-1-i) - : BENCH_PRNG(&prng) % N; - printf("hm %d\n", i); - sprintf(name, "dir%08x", i_); - int err = lfs_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST); - } - BENCH_STOP(); - - lfs_unmount(&lfs) => 0; -''' - -[cases.bench_dir_rmdir] -# 0 = in-order -# 1 = reversed-order -# 2 = random-order -defines.ORDER = [0, 1, 2] -defines.N = 8 -code = ''' - lfs_t lfs; - lfs_format(&lfs, cfg) => 0; - lfs_mount(&lfs, cfg) => 0; - - // first create the dirs - char name[256]; - for (lfs_size_t i = 0; i < N; i++) { - sprintf(name, "dir%08x", i); - lfs_mkdir(&lfs, name) => 0; - } - - // then remove the dirs - BENCH_START(); - uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { - lfs_off_t i_ - = (ORDER == 0) ? i - : (ORDER == 1) ? (N-1-i) - : BENCH_PRNG(&prng) % N; - sprintf(name, "dir%08x", i_); - int err = lfs_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOENT); - } - BENCH_STOP(); - - lfs_unmount(&lfs) => 0; -''' - - +#[cases.bench_dir_open] +## 0 = in-order +## 1 = reversed-order +## 2 = random-order +#defines.ORDER = [0, 1, 2] +#defines.N = 1024 +#defines.FILE_SIZE = 8 +#defines.CHUNK_SIZE = 8 +#code = ''' +# lfs_t lfs; +# lfs_format(&lfs, cfg) => 0; +# lfs_mount(&lfs, cfg) => 0; +# +# // first create the files +# char name[256]; +# uint8_t buffer[CHUNK_SIZE]; +# for (lfs_size_t i = 0; i < N; i++) { +# sprintf(name, "file%08x", i); +# lfs_file_t file; +# lfs_file_open(&lfs, &file, name, +# LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; +# +# uint32_t file_prng = i; +# for (lfs_size_t j = 0; j < FILE_SIZE; j += CHUNK_SIZE) { +# for (lfs_size_t k = 0; k < CHUNK_SIZE; k++) { +# buffer[k] = BENCH_PRNG(&file_prng); +# } +# lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; +# } +# +# lfs_file_close(&lfs, &file) => 0; +# } +# +# // then read the files +# BENCH_START(); +# uint32_t prng = 42; +# for (lfs_size_t i = 0; i < N; i++) { +# lfs_off_t i_ +# = (ORDER == 0) ? i +# : (ORDER == 1) ? (N-1-i) +# : BENCH_PRNG(&prng) % N; +# sprintf(name, "file%08x", i_); +# lfs_file_t file; +# lfs_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; +# +# uint32_t file_prng = i_; +# for (lfs_size_t j = 0; j < FILE_SIZE; j += CHUNK_SIZE) { +# lfs_file_read(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; +# for (lfs_size_t k = 0; k < CHUNK_SIZE; k++) { +# assert(buffer[k] == BENCH_PRNG(&file_prng)); +# } +# } +# +# lfs_file_close(&lfs, &file) => 0; +# } +# BENCH_STOP(); +# +# lfs_unmount(&lfs) => 0; +#''' +# +#[cases.bench_dir_creat] +## 0 = in-order +## 1 = reversed-order +## 2 = random-order +#defines.ORDER = [0, 1, 2] +#defines.N = 1024 +#defines.FILE_SIZE = 8 +#defines.CHUNK_SIZE = 8 +#code = ''' +# lfs_t lfs; +# lfs_format(&lfs, cfg) => 0; +# lfs_mount(&lfs, cfg) => 0; +# +# BENCH_START(); +# uint32_t prng = 42; +# char name[256]; +# uint8_t buffer[CHUNK_SIZE]; +# for (lfs_size_t i = 0; i < N; i++) { +# lfs_off_t i_ +# = (ORDER == 0) ? i +# : (ORDER == 1) ? (N-1-i) +# : BENCH_PRNG(&prng) % N; +# sprintf(name, "file%08x", i_); +# lfs_file_t file; +# lfs_file_open(&lfs, &file, name, +# LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; +# +# uint32_t file_prng = i_; +# for (lfs_size_t j = 0; j < FILE_SIZE; j += CHUNK_SIZE) { +# for (lfs_size_t k = 0; k < CHUNK_SIZE; k++) { +# buffer[k] = BENCH_PRNG(&file_prng); +# } +# lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; +# } +# +# lfs_file_close(&lfs, &file) => 0; +# } +# BENCH_STOP(); +# +# lfs_unmount(&lfs) => 0; +#''' +# +#[cases.bench_dir_remove] +## 0 = in-order +## 1 = reversed-order +## 2 = random-order +#defines.ORDER = [0, 1, 2] +#defines.N = 1024 +#defines.FILE_SIZE = 8 +#defines.CHUNK_SIZE = 8 +#code = ''' +# lfs_t lfs; +# lfs_format(&lfs, cfg) => 0; +# lfs_mount(&lfs, cfg) => 0; +# +# // first create the files +# char name[256]; +# uint8_t buffer[CHUNK_SIZE]; +# for (lfs_size_t i = 0; i < N; i++) { +# sprintf(name, "file%08x", i); +# lfs_file_t file; +# lfs_file_open(&lfs, &file, name, +# LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; +# +# uint32_t file_prng = i; +# for (lfs_size_t j = 0; j < FILE_SIZE; j += CHUNK_SIZE) { +# for (lfs_size_t k = 0; k < CHUNK_SIZE; k++) { +# buffer[k] = BENCH_PRNG(&file_prng); +# } +# lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; +# } +# +# lfs_file_close(&lfs, &file) => 0; +# } +# +# // then remove the files +# BENCH_START(); +# uint32_t prng = 42; +# for (lfs_size_t i = 0; i < N; i++) { +# lfs_off_t i_ +# = (ORDER == 0) ? i +# : (ORDER == 1) ? (N-1-i) +# : BENCH_PRNG(&prng) % N; +# sprintf(name, "file%08x", i_); +# int err = lfs_remove(&lfs, name); +# assert(!err || err == LFS_ERR_NOENT); +# } +# BENCH_STOP(); +# +# lfs_unmount(&lfs) => 0; +#''' +# +#[cases.bench_dir_read] +#defines.N = 1024 +#defines.FILE_SIZE = 8 +#defines.CHUNK_SIZE = 8 +#code = ''' +# lfs_t lfs; +# lfs_format(&lfs, cfg) => 0; +# lfs_mount(&lfs, cfg) => 0; +# +# // first create the files +# char name[256]; +# uint8_t buffer[CHUNK_SIZE]; +# for (lfs_size_t i = 0; i < N; i++) { +# sprintf(name, "file%08x", i); +# lfs_file_t file; +# lfs_file_open(&lfs, &file, name, +# LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; +# +# uint32_t file_prng = i; +# for (lfs_size_t j = 0; j < FILE_SIZE; j += CHUNK_SIZE) { +# for (lfs_size_t k = 0; k < CHUNK_SIZE; k++) { +# buffer[k] = BENCH_PRNG(&file_prng); +# } +# lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; +# } +# +# lfs_file_close(&lfs, &file) => 0; +# } +# +# // then read the directory +# BENCH_START(); +# lfs_dir_t dir; +# lfs_dir_open(&lfs, &dir, "/") => 0; +# struct lfs_info info; +# lfs_dir_read(&lfs, &dir, &info) => 1; +# assert(info.type == LFS_TYPE_DIR); +# assert(strcmp(info.name, ".") == 0); +# lfs_dir_read(&lfs, &dir, &info) => 1; +# assert(info.type == LFS_TYPE_DIR); +# assert(strcmp(info.name, "..") == 0); +# for (int i = 0; i < N; i++) { +# sprintf(name, "file%08x", i); +# lfs_dir_read(&lfs, &dir, &info) => 1; +# assert(info.type == LFS_TYPE_REG); +# assert(strcmp(info.name, name) == 0); +# } +# lfs_dir_read(&lfs, &dir, &info) => 0; +# lfs_dir_close(&lfs, &dir) => 0; +# BENCH_STOP(); +# +# lfs_unmount(&lfs) => 0; +#''' +# +#[cases.bench_dir_mkdir] +## 0 = in-order +## 1 = reversed-order +## 2 = random-order +#defines.ORDER = [0, 1, 2] +#defines.N = 8 +#code = ''' +# lfs_t lfs; +# lfs_format(&lfs, cfg) => 0; +# lfs_mount(&lfs, cfg) => 0; +# +# BENCH_START(); +# uint32_t prng = 42; +# char name[256]; +# for (lfs_size_t i = 0; i < N; i++) { +# lfs_off_t i_ +# = (ORDER == 0) ? i +# : (ORDER == 1) ? (N-1-i) +# : BENCH_PRNG(&prng) % N; +# printf("hm %d\n", i); +# sprintf(name, "dir%08x", i_); +# int err = lfs_mkdir(&lfs, name); +# assert(!err || err == LFS_ERR_EXIST); +# } +# BENCH_STOP(); +# +# lfs_unmount(&lfs) => 0; +#''' +# +#[cases.bench_dir_rmdir] +## 0 = in-order +## 1 = reversed-order +## 2 = random-order +#defines.ORDER = [0, 1, 2] +#defines.N = 8 +#code = ''' +# lfs_t lfs; +# lfs_format(&lfs, cfg) => 0; +# lfs_mount(&lfs, cfg) => 0; +# +# // first create the dirs +# char name[256]; +# for (lfs_size_t i = 0; i < N; i++) { +# sprintf(name, "dir%08x", i); +# lfs_mkdir(&lfs, name) => 0; +# } +# +# // then remove the dirs +# BENCH_START(); +# uint32_t prng = 42; +# for (lfs_size_t i = 0; i < N; i++) { +# lfs_off_t i_ +# = (ORDER == 0) ? i +# : (ORDER == 1) ? (N-1-i) +# : BENCH_PRNG(&prng) % N; +# sprintf(name, "dir%08x", i_); +# int err = lfs_remove(&lfs, name); +# assert(!err || err == LFS_ERR_NOENT); +# } +# BENCH_STOP(); +# +# lfs_unmount(&lfs) => 0; +#''' +# +# diff --git a/benches/bench_file.toml b/benches/bench_file.toml index 168eaad8..2979c10a 100644 --- a/benches/bench_file.toml +++ b/benches/bench_file.toml @@ -1,95 +1,95 @@ -[cases.bench_file_read] -# 0 = in-order -# 1 = reversed-order -# 2 = random-order -defines.ORDER = [0, 1, 2] -defines.SIZE = '128*1024' -defines.CHUNK_SIZE = 64 -code = ''' - lfs_t lfs; - lfs_format(&lfs, cfg) => 0; - lfs_mount(&lfs, cfg) => 0; - lfs_size_t chunks = (SIZE+CHUNK_SIZE-1)/CHUNK_SIZE; - - // first write the file - lfs_file_t file; - uint8_t buffer[CHUNK_SIZE]; - lfs_file_open(&lfs, &file, "file", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - for (lfs_size_t i = 0; i < chunks; i++) { - uint32_t chunk_prng = i; - for (lfs_size_t j = 0; j < CHUNK_SIZE; j++) { - buffer[j] = BENCH_PRNG(&chunk_prng); - } - - lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; - } - lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; - lfs_file_close(&lfs, &file) => 0; - - // then read the file - BENCH_START(); - lfs_file_open(&lfs, &file, "file", LFS_O_RDONLY) => 0; - - uint32_t prng = 42; - for (lfs_size_t i = 0; i < chunks; i++) { - lfs_off_t i_ - = (ORDER == 0) ? i - : (ORDER == 1) ? (chunks-1-i) - : BENCH_PRNG(&prng) % chunks; - lfs_file_seek(&lfs, &file, i_*CHUNK_SIZE, LFS_SEEK_SET) - => i_*CHUNK_SIZE; - lfs_file_read(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; - - uint32_t chunk_prng = i_; - for (lfs_size_t j = 0; j < CHUNK_SIZE; j++) { - assert(buffer[j] == BENCH_PRNG(&chunk_prng)); - } - } - - lfs_file_close(&lfs, &file) => 0; - BENCH_STOP(); - - lfs_unmount(&lfs) => 0; -''' - -[cases.bench_file_write] -# 0 = in-order -# 1 = reversed-order -# 2 = random-order -defines.ORDER = [0, 1, 2] -defines.SIZE = '128*1024' -defines.CHUNK_SIZE = 64 -code = ''' - lfs_t lfs; - lfs_format(&lfs, cfg) => 0; - lfs_mount(&lfs, cfg) => 0; - lfs_size_t chunks = (SIZE+CHUNK_SIZE-1)/CHUNK_SIZE; - - BENCH_START(); - lfs_file_t file; - lfs_file_open(&lfs, &file, "file", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - - uint8_t buffer[CHUNK_SIZE]; - uint32_t prng = 42; - for (lfs_size_t i = 0; i < chunks; i++) { - lfs_off_t i_ - = (ORDER == 0) ? i - : (ORDER == 1) ? (chunks-1-i) - : BENCH_PRNG(&prng) % chunks; - uint32_t chunk_prng = i_; - for (lfs_size_t j = 0; j < CHUNK_SIZE; j++) { - buffer[j] = BENCH_PRNG(&chunk_prng); - } - - lfs_file_seek(&lfs, &file, i_*CHUNK_SIZE, LFS_SEEK_SET) - => i_*CHUNK_SIZE; - lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; - } - - lfs_file_close(&lfs, &file) => 0; - BENCH_STOP(); - - lfs_unmount(&lfs) => 0; -''' +#[cases.bench_file_read] +## 0 = in-order +## 1 = reversed-order +## 2 = random-order +#defines.ORDER = [0, 1, 2] +#defines.SIZE = '128*1024' +#defines.CHUNK_SIZE = 64 +#code = ''' +# lfs_t lfs; +# lfs_format(&lfs, cfg) => 0; +# lfs_mount(&lfs, cfg) => 0; +# lfs_size_t chunks = (SIZE+CHUNK_SIZE-1)/CHUNK_SIZE; +# +# // first write the file +# lfs_file_t file; +# uint8_t buffer[CHUNK_SIZE]; +# lfs_file_open(&lfs, &file, "file", +# LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; +# for (lfs_size_t i = 0; i < chunks; i++) { +# uint32_t chunk_prng = i; +# for (lfs_size_t j = 0; j < CHUNK_SIZE; j++) { +# buffer[j] = BENCH_PRNG(&chunk_prng); +# } +# +# lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; +# } +# lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; +# lfs_file_close(&lfs, &file) => 0; +# +# // then read the file +# BENCH_START(); +# lfs_file_open(&lfs, &file, "file", LFS_O_RDONLY) => 0; +# +# uint32_t prng = 42; +# for (lfs_size_t i = 0; i < chunks; i++) { +# lfs_off_t i_ +# = (ORDER == 0) ? i +# : (ORDER == 1) ? (chunks-1-i) +# : BENCH_PRNG(&prng) % chunks; +# lfs_file_seek(&lfs, &file, i_*CHUNK_SIZE, LFS_SEEK_SET) +# => i_*CHUNK_SIZE; +# lfs_file_read(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; +# +# uint32_t chunk_prng = i_; +# for (lfs_size_t j = 0; j < CHUNK_SIZE; j++) { +# assert(buffer[j] == BENCH_PRNG(&chunk_prng)); +# } +# } +# +# lfs_file_close(&lfs, &file) => 0; +# BENCH_STOP(); +# +# lfs_unmount(&lfs) => 0; +#''' +# +#[cases.bench_file_write] +## 0 = in-order +## 1 = reversed-order +## 2 = random-order +#defines.ORDER = [0, 1, 2] +#defines.SIZE = '128*1024' +#defines.CHUNK_SIZE = 64 +#code = ''' +# lfs_t lfs; +# lfs_format(&lfs, cfg) => 0; +# lfs_mount(&lfs, cfg) => 0; +# lfs_size_t chunks = (SIZE+CHUNK_SIZE-1)/CHUNK_SIZE; +# +# BENCH_START(); +# lfs_file_t file; +# lfs_file_open(&lfs, &file, "file", +# LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; +# +# uint8_t buffer[CHUNK_SIZE]; +# uint32_t prng = 42; +# for (lfs_size_t i = 0; i < chunks; i++) { +# lfs_off_t i_ +# = (ORDER == 0) ? i +# : (ORDER == 1) ? (chunks-1-i) +# : BENCH_PRNG(&prng) % chunks; +# uint32_t chunk_prng = i_; +# for (lfs_size_t j = 0; j < CHUNK_SIZE; j++) { +# buffer[j] = BENCH_PRNG(&chunk_prng); +# } +# +# lfs_file_seek(&lfs, &file, i_*CHUNK_SIZE, LFS_SEEK_SET) +# => i_*CHUNK_SIZE; +# lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; +# } +# +# lfs_file_close(&lfs, &file) => 0; +# BENCH_STOP(); +# +# lfs_unmount(&lfs) => 0; +#''' diff --git a/benches/bench_mtree.toml b/benches/bench_mtree.toml index 2dd81b71..76bdf7b9 100644 --- a/benches/bench_mtree.toml +++ b/benches/bench_mtree.toml @@ -18,6 +18,7 @@ code = ''' lfs_t lfs; lfsr_format(&lfs, cfg) => 0; lfsr_mount(&lfs, cfg) => 0; + lfs_alloc_ack(&lfs); // create an mtree with N entries for (lfs_size_t i = 0; i < N; i++) { @@ -39,7 +40,7 @@ code = ''' // create an entry lfsr_mdir_commit(&lfs, &mdir, &rid, LFSR_ATTRS( - LFSR_ATTR(rid, MKINLINED, +1, &alphas[i % 26], 1))) => 0; + LFSR_ATTR(rid, INLINED, +1, &alphas[i % 26], 1))) => 0; } // bench lookup @@ -79,6 +80,7 @@ code = ''' lfs_t lfs; lfsr_format(&lfs, cfg) => 0; lfsr_mount(&lfs, cfg) => 0; + lfs_alloc_ack(&lfs); // create an mtree with N entries if (AMORTIZED) { @@ -103,7 +105,7 @@ code = ''' // create an entry lfsr_mdir_commit(&lfs, &mdir, &rid, LFSR_ATTRS( - LFSR_ATTR(rid, MKINLINED, +1, &alphas[i % 26], 1))) => 0; + LFSR_ATTR(rid, INLINED, +1, &alphas[i % 26], 1))) => 0; } // bench commit @@ -128,7 +130,7 @@ code = ''' // create an entry lfsr_mdir_commit(&lfs, &mdir, &rid, LFSR_ATTRS( - LFSR_ATTR(rid, MKINLINED, +1, "C", 1))) => 0; + LFSR_ATTR(rid, INLINED, +1, "C", 1))) => 0; BENCH_STOP(); lfsr_unmount(&lfs) => 0; @@ -150,6 +152,7 @@ code = ''' lfs_t lfs; lfsr_format(&lfs, cfg) => 0; lfsr_mount(&lfs, cfg) => 0; + lfs_alloc_ack(&lfs); // create an mtree with N entries for (lfs_size_t i = 0; i < N; i++) { @@ -171,7 +174,7 @@ code = ''' // create an entry lfsr_mdir_commit(&lfs, &mdir, &rid, LFSR_ATTRS( - LFSR_ATTR(rid, MKINLINED, +1, &alphas[i % 26], 1))) => 0; + LFSR_ATTR(rid, INLINED, +1, &alphas[i % 26], 1))) => 0; } // traverse the mtree diff --git a/benches/bench_rbyd.toml b/benches/bench_rbyd.toml index 83af381c..6e4c6981 100644 --- a/benches/bench_rbyd.toml +++ b/benches/bench_rbyd.toml @@ -22,7 +22,6 @@ code = ''' lfsr_rbyd_t rbyd = { .block = 0, - .rev = 1, .off = 0, .crc = 0, .trunk = 0, @@ -60,7 +59,7 @@ code = ''' } BENCH_STOP(); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0; ''' [cases.bench_rbyd_attr_fetch] @@ -80,7 +79,6 @@ code = ''' lfsr_rbyd_t rbyd = { .block = 0, - .rev = 1, .off = 0, .crc = 0, .trunk = 0, @@ -117,7 +115,7 @@ code = ''' } BENCH_START(); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0; BENCH_STOP(); ''' @@ -138,7 +136,6 @@ code = ''' lfsr_rbyd_t rbyd = { .block = 0, - .rev = 1, .off = 0, .crc = 0, .trunk = 0, @@ -174,13 +171,13 @@ code = ''' } } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0; BENCH_START(); lfs_off_t i_ = BENCH_PRNG(&prng) % N; lfsr_data_t data_; int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(i_ & 0xff), - &data_); + NULL, &data_); // note that random order may have some collisions assert(!err || err == LFS_ERR_NOENT); BENCH_STOP(); @@ -203,7 +200,6 @@ code = ''' lfsr_rbyd_t rbyd = { .block = 0, - .rev = 1, .off = 0, .crc = 0, .trunk = 0, @@ -239,7 +235,7 @@ code = ''' } } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0; BENCH_START(); lfs_off_t i_ = BENCH_PRNG(&prng) % N; @@ -270,7 +266,6 @@ code = ''' lfsr_rbyd_t rbyd = { .block = 0, - .rev = 1, .off = 0, .crc = 0, .trunk = 0, @@ -306,7 +301,7 @@ code = ''' } } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0; BENCH_START(); lfs_off_t i_ = BENCH_PRNG(&prng) % N; @@ -336,7 +331,6 @@ code = ''' lfsr_rbyd_t rbyd = { .block = 0, - .rev = 1, .off = 0, .crc = 0, .trunk = 0, @@ -355,7 +349,7 @@ code = ''' = (ORDER == 0) ? i : (ORDER == 1) ? 0 : BENCH_PRNG(&prng) % (rbyd.weight+1); - attrs[i] = LFSR_ATTR(i_, MKREG, +1, "\xaa\xaa\xaa\xaa", 4); + attrs[i] = LFSR_ATTR(i_, REG, +1, "\xaa\xaa\xaa\xaa", 4); } lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0; } else { @@ -365,12 +359,12 @@ code = ''' : (ORDER == 1) ? 0 : BENCH_PRNG(&prng) % (rbyd.weight+1); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(i_, MKREG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; + LFSR_ATTR(i_, REG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; } } BENCH_STOP(); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0; ''' [cases.bench_rbyd_id_fetch] @@ -390,7 +384,6 @@ code = ''' lfsr_rbyd_t rbyd = { .block = 0, - .rev = 1, .off = 0, .crc = 0, .trunk = 0, @@ -408,7 +401,7 @@ code = ''' = (ORDER == 0) ? i : (ORDER == 1) ? 0 : BENCH_PRNG(&prng) % (rbyd.weight+1); - attrs[i] = LFSR_ATTR(i_, MKREG, +1, "\xaa\xaa\xaa\xaa", 4); + attrs[i] = LFSR_ATTR(i_, REG, +1, "\xaa\xaa\xaa\xaa", 4); } lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0; } else { @@ -418,12 +411,12 @@ code = ''' : (ORDER == 1) ? 0 : BENCH_PRNG(&prng) % (rbyd.weight+1); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(i_, MKREG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; + LFSR_ATTR(i_, REG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; } } BENCH_START(); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0; BENCH_STOP(); ''' @@ -444,7 +437,6 @@ code = ''' lfsr_rbyd_t rbyd = { .block = 0, - .rev = 1, .off = 0, .crc = 0, .trunk = 0, @@ -462,7 +454,7 @@ code = ''' = (ORDER == 0) ? i : (ORDER == 1) ? 0 : BENCH_PRNG(&prng) % (rbyd.weight+1); - attrs[i] = LFSR_ATTR(i_, MKREG, +1, "\xaa\xaa\xaa\xaa", 4); + attrs[i] = LFSR_ATTR(i_, REG, +1, "\xaa\xaa\xaa\xaa", 4); } lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0; } else { @@ -472,16 +464,17 @@ code = ''' : (ORDER == 1) ? 0 : BENCH_PRNG(&prng) % (rbyd.weight+1); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(i_, MKREG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; + LFSR_ATTR(i_, REG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; } } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0; BENCH_START(); lfs_off_t i_ = BENCH_PRNG(&prng) % N; lfsr_data_t data_; - lfsr_rbyd_lookup(&lfs, &rbyd, i_, LFSR_TAG_REG, &data_) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, i_, LFSR_TAG_REG, + NULL, &data_) => 0; BENCH_STOP(); ''' @@ -502,7 +495,6 @@ code = ''' lfsr_rbyd_t rbyd = { .block = 0, - .rev = 1, .off = 0, .crc = 0, .trunk = 0, @@ -520,7 +512,7 @@ code = ''' = (ORDER == 0) ? i : (ORDER == 1) ? 0 : BENCH_PRNG(&prng) % (rbyd.weight+1); - attrs[i] = LFSR_ATTR(i_, MKREG, +1, "\xaa\xaa\xaa\xaa", 4); + attrs[i] = LFSR_ATTR(i_, REG, +1, "\xaa\xaa\xaa\xaa", 4); } lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0; } else { @@ -530,16 +522,16 @@ code = ''' : (ORDER == 1) ? 0 : BENCH_PRNG(&prng) % (rbyd.weight+1); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(i_, MKREG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; + LFSR_ATTR(i_, REG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; } } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0; BENCH_START(); lfs_off_t i_ = BENCH_PRNG(&prng) % (N+1); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(i_, MKREG, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; + LFSR_ATTR(i_, REG, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; BENCH_STOP(); uint8_t buffer[4]; @@ -564,7 +556,6 @@ code = ''' lfsr_rbyd_t rbyd = { .block = 0, - .rev = 1, .off = 0, .crc = 0, .trunk = 0, @@ -582,7 +573,7 @@ code = ''' = (ORDER == 0) ? i : (ORDER == 1) ? 0 : BENCH_PRNG(&prng) % (rbyd.weight+1); - attrs[i] = LFSR_ATTR(i_, MKREG, +1, "\xaa\xaa\xaa\xaa", 4); + attrs[i] = LFSR_ATTR(i_, REG, +1, "\xaa\xaa\xaa\xaa", 4); } lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0; } else { @@ -592,15 +583,15 @@ code = ''' : (ORDER == 1) ? 0 : BENCH_PRNG(&prng) % (rbyd.weight+1); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(i_, MKREG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; + LFSR_ATTR(i_, REG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; } } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0; BENCH_START(); lfs_off_t i_ = BENCH_PRNG(&prng) % N; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(i_, MKUNR, -1, NULL, 0))) => 0; + LFSR_ATTR(i_, UNR, -1, NULL, 0))) => 0; BENCH_STOP(); ''' diff --git a/benches/bench_superblock.toml b/benches/bench_superblock.toml index 37659d47..d91eb8f6 100644 --- a/benches/bench_superblock.toml +++ b/benches/bench_superblock.toml @@ -1,56 +1,56 @@ -[cases.bench_superblocks_found] -# support benchmarking with files -defines.N = [0, 1024] -defines.FILE_SIZE = 8 -defines.CHUNK_SIZE = 8 -code = ''' - lfs_t lfs; - lfs_format(&lfs, cfg) => 0; - - // create files? - lfs_mount(&lfs, cfg) => 0; - char name[256]; - uint8_t buffer[CHUNK_SIZE]; - for (lfs_size_t i = 0; i < N; i++) { - sprintf(name, "file%08x", i); - lfs_file_t file; - lfs_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - - for (lfs_size_t j = 0; j < FILE_SIZE; j += CHUNK_SIZE) { - for (lfs_size_t k = 0; k < CHUNK_SIZE; k++) { - buffer[k] = i+j+k; - } - lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; - } - - lfs_file_close(&lfs, &file) => 0; - } - lfs_unmount(&lfs) => 0; - - BENCH_START(); - lfs_mount(&lfs, cfg) => 0; - BENCH_STOP(); - - lfs_unmount(&lfs) => 0; -''' - -[cases.bench_superblocks_missing] -code = ''' - lfs_t lfs; - - BENCH_START(); - int err = lfs_mount(&lfs, cfg); - assert(err != 0); - BENCH_STOP(); -''' - -[cases.bench_superblocks_format] -code = ''' - lfs_t lfs; - - BENCH_START(); - lfs_format(&lfs, cfg) => 0; - BENCH_STOP(); -''' - +#[cases.bench_superblocks_found] +## support benchmarking with files +#defines.N = [0, 1024] +#defines.FILE_SIZE = 8 +#defines.CHUNK_SIZE = 8 +#code = ''' +# lfs_t lfs; +# lfs_format(&lfs, cfg) => 0; +# +# // create files? +# lfs_mount(&lfs, cfg) => 0; +# char name[256]; +# uint8_t buffer[CHUNK_SIZE]; +# for (lfs_size_t i = 0; i < N; i++) { +# sprintf(name, "file%08x", i); +# lfs_file_t file; +# lfs_file_open(&lfs, &file, name, +# LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; +# +# for (lfs_size_t j = 0; j < FILE_SIZE; j += CHUNK_SIZE) { +# for (lfs_size_t k = 0; k < CHUNK_SIZE; k++) { +# buffer[k] = i+j+k; +# } +# lfs_file_write(&lfs, &file, buffer, CHUNK_SIZE) => CHUNK_SIZE; +# } +# +# lfs_file_close(&lfs, &file) => 0; +# } +# lfs_unmount(&lfs) => 0; +# +# BENCH_START(); +# lfs_mount(&lfs, cfg) => 0; +# BENCH_STOP(); +# +# lfs_unmount(&lfs) => 0; +#''' +# +#[cases.bench_superblocks_missing] +#code = ''' +# lfs_t lfs; +# +# BENCH_START(); +# int err = lfs_mount(&lfs, cfg); +# assert(err != 0); +# BENCH_STOP(); +#''' +# +#[cases.bench_superblocks_format] +#code = ''' +# lfs_t lfs; +# +# BENCH_START(); +# lfs_format(&lfs, cfg) => 0; +# BENCH_STOP(); +#''' +#