btrfs: some speedup with fiemap when leaves are shared
cover btrfs: some speedup with fiemap when leaves are shared
From: Filipe Manana <[email protected]>
Add a couple assertions for the fiemap code that checks if extents are shared and speedup the extent sharedness check when we already know the current leaf is shared. More details on the changelogs.
Filipe Manana (2):
btrfs: assert commit root semaphore is held when accessing backref cache
btrfs: skip backref walking during fiemap if we know the leaf is shared
fs/btrfs/backref.c | 33 ++++++++++++++++++++++++++++++--- 1 file changed, 30 insertions(+), 3 deletions(-)
Signature · 1 line
2.35.1
PATCH 1/2 btrfs: assert commit root semaphore is held when accessing backref cache
From: Filipe Manana <[email protected]>
During fiemap, when accessing the cache that stores the sharedness of an extent, we need to either be holding a transaction handle or the commit root semaphore. I left comments about this in the comment that precedes store_backref_shared_cache() and lookup_backref_shared_cache(), but have actually not enforced it through assertions. So assert that the commit root semaphore is held if we are not holding a transaction handle.
--- fs/btrfs/backref.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-)
fs/btrfs/backref.c +10 -2
@@ -1252,8 +1252,12 @@ static bool lookup_backref_shared_cache(struct btrfs_backref_share_check_ctx *ctstruct btrfs_root *root, u64 bytenr, int level, bool *is_shared) { + const struct btrfs_fs_info *fs_info = root->fs_info;struct btrfs_backref_shared_cache_entry *entry; +if (!current->journal_info) +lockdep_assert_held (&fs_info->commit_root_sem); +if (!ctx->use_path_cache)return false;
@@ -1288,7 +1292,7 @@ static bool lookup_backref_shared_cache(struct btrfs_backref_share_check_ctx *ct* could be a snapshot sharing this extent buffer. */ if (entry->is_shared && - entry->gen !=btrfs_get_last_root_drop_gen (root->fs_info)) + entry->gen !=btrfs_get_last_root_drop_gen (fs_info))return false; *is_shared = entry->is_shared;
@@ -1318,9 +1322,13 @@ static void store_backref_shared_cache(struct btrfs_backref_share_check_ctx *ctxstruct btrfs_root *root, u64 bytenr, int level, bool is_shared) { + const struct btrfs_fs_info *fs_info = root->fs_info;struct btrfs_backref_shared_cache_entry *entry;u64 gen; +if (!current->journal_info) +lockdep_assert_held (&fs_info->commit_root_sem); +if (!ctx->use_path_cache)return ;
@@ -1336,7 +1344,7 @@ static void store_backref_shared_cache(struct btrfs_backref_share_check_ctx *ctxASSERT (level >=0 );if (is_shared) - gen =btrfs_get_last_root_drop_gen (root->fs_info); + gen =btrfs_get_last_root_drop_gen (fs_info);else gen =btrfs_root_last_snapshot (&root->root_item);
Signature · 1 line
2.35.1
PATCH 2/2 btrfs: skip backref walking during fiemap if we know the leaf is shared
In reply to [email protected]From: Filipe Manana <[email protected]>
During fiemap, when checking if a data extent is shared we are doing the backref walking even if we already know the leaf is shared, which is a waste of time since if the leaf shared then the data extent is also shared. So skip the backref walking when we know we are in a shared leaf.
The following test was measures the gains for a case where all leaves are shared due to a snapshot:
$ cat test.sh #!/bin/bash
DEV=/dev/sdj
MNT=/mnt/sdj
umount $DEV &> /dev/null
mkfs.btrfs -f $DEV
# Use compression to quickly create files with a lot of extents # (each with a size of 128K).
mount -o compress=lzo $DEV $MNT
# 40G gives 327680 extents, each with a size of 128K. xfs_io -f -c "pwrite -S 0xab -b 1M 0 40G" $MNT/foobar
# Add some more files to increase the size of the fs and extent
# trees (in the real world there's a lot of files and extents # from other files). xfs_io -f -c "pwrite -S 0xcd -b 1M 0 20G" $MNT/file1 xfs_io -f -c "pwrite -S 0xef -b 1M 0 20G" $MNT/file2 xfs_io -f -c "pwrite -S 0x73 -b 1M 0 20G" $MNT/file3
# Create a snapshot so all the extents become indirectly shared
# through subtrees, with a generation less than or equals to the # generation used to create the snapshot. btrfs subvolume snapshot -r $MNT $MNT/snap1
# Unmount and mount again to clear cached metadata. umount $MNT
mount -o compress=lzo $DEV $MNT
start=$(date +%s%N) # The filefrag tool uses the fiemap ioctl. filefrag $MNT/foobar end=$(date +%s%N) dur=$(( (end - start) / 1000000 )) echo "fiemap took $dur milliseconds (metadata not cached)" echo start=$(date +%s%N) filefrag $MNT/foobar end=$(date +%s%N) dur=$(( (end - start) / 1000000 )) echo "fiemap took $dur milliseconds (metadata cached)"
umount $MNT
The results were the following on a non-debug kernel (Debian's default kernel config).
Before this patch:
(...)
/mnt/sdi/foobar: 327680 extents found fiemap took 1821 milliseconds (metadata not cached)
/mnt/sdi/foobar: 327680 extents found
fiemap took 399 milliseconds (metadata cached)
After this patch:
(...)
/mnt/sdi/foobar: 327680 extents found fiemap took 591 milliseconds (metadata not cached)
/mnt/sdi/foobar: 327680 extents found
fiemap took 123 milliseconds (metadata cached)
That's a speedup of 3.1x and 3.2x.
--- fs/btrfs/backref.c | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-)
fs/btrfs/backref.c +20 -1
@@ -1872,6 +1872,8 @@ int btrfs_is_data_extent_shared(struct btrfs_inode *inode, u64 bytenr, .have_delayed_delete_refs = false, };int level; +bool leaf_cached; +bool leaf_is_shared;for (int i =0 ; i <BTRFS_BACKREF_CTX_PREV_EXTENTS_SIZE ; i++) {if (ctx->prev_extents_cache[i].bytenr == bytenr)
@@ -1893,6 +1895,23 @@ int btrfs_is_data_extent_shared(struct btrfs_inode *inode, u64 bytenr, walk_ctx.time_seq = elem.seq; } + ctx->use_path_cache = true; + +/* +* We may have previously determined that the current leaf is shared. +* If it is, then we have a data extent that is shared due to a shared +* subtree (caused by snapshotting) and we don't need to check for data +* backrefs. If the leaf is not shared, then we must do backref walking +* to determine if the data extent is shared through reflinks. +*/ + leaf_cached =lookup_backref_shared_cache (ctx, root, + ctx->curr_leaf_bytenr,0 , + &leaf_is_shared); +if (leaf_cached && leaf_is_shared) { + ret =1 ; + goto out_trans; + } + walk_ctx.ignore_extent_item_pos = true; walk_ctx.trans = trans; walk_ctx.fs_info = fs_info;
@@ -1901,7 +1920,6 @@ int btrfs_is_data_extent_shared(struct btrfs_inode *inode, u64 bytenr,/* -1 means we are in the bytenr of the data extent. */ level =-1 ;ULIST_ITER_INIT (&uiter); - ctx->use_path_cache = true;while (1 ) {bool is_shared;bool cached;
@@ -1972,6 +1990,7 @@ int btrfs_is_data_extent_shared(struct btrfs_inode *inode, u64 bytenr, ctx->prev_extents_cache_slot = slot; } +out_trans:if (trans) {btrfs_put_tree_mod_seq (fs_info, &elem);btrfs_end_transaction (trans);
Signature · 1 line
2.35.1
Re: [PATCH 1/2] btrfs: assert commit root semaphore is held when accessing backref cache
In reply to [email protected]Looks good,
Quoted 9 lines · On Tue, Jan 17, 2023 at 11:21:37AM +0000, [email protected] wrote:
From: Filipe Manana <[email protected]>
Add a couple assertions for the fiemap code that checks if extents are shared and speedup the extent sharedness check when we already know the current leaf is shared. More details on the changelogs.
Filipe Manana (2):
btrfs: assert commit root semaphore is held when accessing backref cache
btrfs: skip backref walking during fiemap if we know the leaf is shared
Added to misc-next, thanks.