Github/littlefs
1
Fork 0
Code Actions Activity

Updated benches based on changes, commented out outdated benchmarks

Browse Source
This commit is contained in:
Christopher Haster
2023-06-30 03:00:07 -05:00
parent eee0e6cfa1
commit 938cee1640
6 changed files with 461 additions and 467 deletions
Download Patch File Download Diff File Expand all files Collapse all files
benches/bench_btree.toml
+8 -8
View File
@@ -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;
benches/bench_dir.toml
+270 -270
View File
@@ -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;
#'''
#
#
benches/bench_file.toml
+95 -95
View File
@@ -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;
#'''
benches/bench_mtree.toml
+7 -4
View File
@@ -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
benches/bench_rbyd.toml
+25 -34
View File
@@ -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();
'''
benches/bench_superblock.toml
+56 -56
View File
@@ -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();
#'''
#