Github/littlefs
1
Fork 0
Code Actions Activity

Merged lfsr_ftree_bufferedreadnext/readnext

Browse Source 
Turns out we don't need lfsr_ftree_(unbuffered)readnext. Even if we did,
the unbuffered behavior can be obtained by passing a NULL buffer to
lfsr_ftree_readnext.

Code changes minimal:

            code          stack
  before:  31760           2776
  after:   31716 (-0.1%)   2776 (+0.0%)
This commit is contained in:
Christopher Haster
2023-12-06 20:51:35 -06:00
parent 2793ae2e03
commit 0026121bc3
1 changed files with 19 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+19 -46
View File
@@ -9553,45 +9553,8 @@ static int lfsr_ftree_lookupnext(lfs_t *lfs,
} }
} }
static int lfsr_ftree_readnext(lfs_t *lfs,
const lfsr_mdir_t *mdir, const lfsr_ftree_t *ftree,
lfs_off_t pos, lfs_off_t size,
lfsr_data_t *data_) {
lfsr_bid_t bid;
lfsr_tag_t tag;
lfsr_bid_t weight;
lfsr_data_t data;
int err = lfsr_ftree_lookupnext(lfs, mdir, ftree, pos,
&bid, &tag, &weight, &data);
if (err) {
return err;
}
if (pos < bid-(weight-1) + lfsr_data_size(&data)) {
// note one important side-effect here is any reads to this
// data get a strict read hint
lfs_off_t d = lfs_min32(
size,
lfsr_data_size(&data) - (pos - (bid-(weight-1))));
if (data_) {
*data_ = LFSR_DATA_DISK(
data.u.disk.block,
data.u.disk.off + (pos - (bid-(weight-1))),
d);
}
return 0;
}
// found a hole, just make sure next leaf takes priority
lfs_off_t d = lfs_min32(size, bid+1 - pos);
if (data_) {
*data_ = LFSR_DATA_HOLE(d);
}
return 0;
}
// read buffered // read buffered
static int lfsr_ftree_bufferedreadnext(lfs_t *lfs, static int lfsr_ftree_readnext(lfs_t *lfs,
const lfsr_mdir_t *mdir, const lfsr_ftree_t *ftree, const lfsr_mdir_t *mdir, const lfsr_ftree_t *ftree,
lfs_off_t buffer_pos, const uint8_t *buffer, lfs_size_t buffer_size, lfs_off_t buffer_pos, const uint8_t *buffer, lfs_size_t buffer_size,
lfs_off_t pos, lfs_off_t size, lfs_off_t pos, lfs_off_t size,
@@ -9624,24 +9587,34 @@ static int lfsr_ftree_bufferedreadnext(lfs_t *lfs,
// any data on disk? // any data on disk?
if (pos < lfsr_ftree_size(ftree)) { if (pos < lfsr_ftree_size(ftree)) {
lfsr_bid_t bid;
lfsr_tag_t tag;
lfsr_bid_t weight;
lfsr_data_t data; lfsr_data_t data;
int err = lfsr_ftree_readnext(lfs, mdir, ftree, pos, d, int err = lfsr_ftree_lookupnext(lfs, mdir, ftree, pos,
&data); &bid, &tag, &weight, &data);
if (err) { if (err) {
LFS_ASSERT(err != LFS_ERR_NOENT); LFS_ASSERT(err != LFS_ERR_NOENT);
return err; return err;
} }
// found data? if (pos < bid-(weight-1) + lfsr_data_size(&data)) {
if (!lfsr_data_ishole(&data)) { // note one important side-effect here is any reads to this
// data get a strict read hint
d = lfs_min32(
d,
lfsr_data_size(&data) - (pos - (bid-(weight-1))));
if (data_) { if (data_) {
*data_ = data; *data_ = LFSR_DATA_DISK(
data.u.disk.block,
data.u.disk.off + (pos - (bid-(weight-1))),
d);
} }
return 0; return 0;
} }
// found a hole, just make sure next leaf takes priority // found a hole, just make sure next leaf takes priority
d = lfs_min32(d, lfsr_data_size(&data)); d = lfs_min32(d, bid+1 - pos);
} }
// found a hole? // found a hole?
@@ -10097,7 +10070,7 @@ static int lfsr_ftree_flush(lfs_t *lfs,
lfs_off_t pos_ = block_start; lfs_off_t pos_ = block_start;
while (pos_ < block_end) { while (pos_ < block_end) {
lfsr_data_t data; lfsr_data_t data;
err = lfsr_ftree_bufferedreadnext(lfs, mdir, ftree, err = lfsr_ftree_readnext(lfs, mdir, ftree,
buffer_pos, buffer, buffer_size, buffer_pos, buffer, buffer_size,
pos_, block_end - pos_, pos_, block_end - pos_,
&data); &data);
@@ -10272,7 +10245,7 @@ lfs_ssize_t lfsr_file_read(lfs_t *lfs, lfsr_file_t *file,
while (size > 0) { while (size > 0) {
// find a data/hole // find a data/hole
lfsr_data_t data; lfsr_data_t data;
int err = lfsr_ftree_bufferedreadnext(lfs, int err = lfsr_ftree_readnext(lfs,
&file->mdir, &file->ftree, &file->mdir, &file->ftree,
file->buffer_pos, file->buffer, file->buffer_size, file->buffer_pos, file->buffer, file->buffer_size,
pos, size, pos, size,