btrfs: zoned: fix bandwidth degradaton
cover btrfs: zoned: fix bandwidth degradaton
Writing sequentially to a huge file on btrfs on a SMR HDD revealed a decline of the performance (220 MiB/s to 30 MiB/s after 500 minutes). As shown in the attached plot, current btrfs exponentially drops its performance.
The drop is because find_free_extent() need to traverse a lot of full block groups, trying to find a space.
This series fixes the performance drop by choosing a proper block group from the zone_active_bgs. Since the list does not contain full block groups, there is no need of traversing the full BGs.
Naohiro Aota (2):
btrfs: zoned: split out prepare_allocation_zoned()
btrfs: zoned: optimize hint byte for zoned allocator
fs/btrfs/extent-tree.c | 50 +++++++++++++++++++++++++++++++----------- 1 file changed, 37 insertions(+), 13 deletions(-)
Signature · 1 line
2.43.0
PATCH 1/2 btrfs: zoned: split out prepare_allocation_zoned()
Split out prepare_allocation_zoned() for further extension. While at it, optimize the if-branch a bit.
--- fs/btrfs/extent-tree.c | 32 +++++++++++++++++++------------- 1 file changed, 19 insertions(+), 13 deletions(-)
fs/btrfs/extent-tree.c +19 -13
@@ -4298,6 +4298,24 @@ static int prepare_allocation_clustered(struct btrfs_fs_info *fs_info,return 0 ; } +static int prepare_allocation_zoned (struct btrfs_fs_info *fs_info, +struct find_free_extent_ctl *ffe_ctl) +{ +if (ffe_ctl->for_treelog) { +spin_lock (&fs_info->treelog_bg_lock); +if (fs_info->treelog_bg) + ffe_ctl->hint_byte = fs_info->treelog_bg; +spin_unlock (&fs_info->treelog_bg_lock); + }else if (ffe_ctl->for_data_reloc) { +spin_lock (&fs_info->relocation_bg_lock); +if (fs_info->data_reloc_bg) + ffe_ctl->hint_byte = fs_info->data_reloc_bg; +spin_unlock (&fs_info->relocation_bg_lock); + } + +return 0 ; +} + static int prepare_allocation(struct btrfs_fs_info *fs_info, struct find_free_extent_ctl *ffe_ctl, struct btrfs_space_info *space_info,
@@ -4308,19 +4326,7 @@ static int prepare_allocation(struct btrfs_fs_info *fs_info,return prepare_allocation_clustered (fs_info, ffe_ctl, space_info, ins);case BTRFS_EXTENT_ALLOC_ZONED : -if (ffe_ctl->for_treelog) { -spin_lock (&fs_info->treelog_bg_lock); -if (fs_info->treelog_bg) - ffe_ctl->hint_byte = fs_info->treelog_bg; -spin_unlock (&fs_info->treelog_bg_lock); - } -if (ffe_ctl->for_data_reloc) { -spin_lock (&fs_info->relocation_bg_lock); -if (fs_info->data_reloc_bg) - ffe_ctl->hint_byte = fs_info->data_reloc_bg; -spin_unlock (&fs_info->relocation_bg_lock); - } -return 0 ; +return prepare_allocation_zoned (fs_info, ffe_ctl);default :BUG (); }
Signature · 1 line
2.43.0
PATCH 2/2 btrfs: zoned: optimize hint byte for zoned allocator
In reply to Naohiro AotaWriting sequentially to a huge file on btrfs on a SMR HDD revealed a decline of the performance (220 MiB/s to 30 MiB/s after 500 minutes).
The performance goes down because of increased latency of the extent allocation, which is induced by a traversing of a lot of full block groups.
So, this patch optimizes the ffe_ctl->hint_byte by choosing a block group with sufficient size from the active block group list, which does not contain full block groups.
After applying the patch, the performance is maintained well.
--- fs/btrfs/extent-tree.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+)
fs/btrfs/extent-tree.c +18 -0
@@ -4311,6 +4311,24 @@ static int prepare_allocation_zoned(struct btrfs_fs_info *fs_info,if (fs_info->data_reloc_bg) ffe_ctl->hint_byte = fs_info->data_reloc_bg;spin_unlock (&fs_info->relocation_bg_lock); + }else if (ffe_ctl->flags &BTRFS_BLOCK_GROUP_DATA ) { +struct btrfs_block_group *block_group; + +spin_lock (&fs_info->zone_active_bgs_lock); +list_for_each_entry (block_group, &fs_info->zone_active_bgs, active_bg_list) { +/* +* No lock is OK here because avail is monotinically +* decreasing, and this is just a hint. +*/ +u64 avail = block_group->zone_capacity - block_group->alloc_offset; + +if (block_group_bits (block_group, ffe_ctl->flags) && + avail >= ffe_ctl->num_bytes) { + ffe_ctl->hint_byte = block_group->start; +break ; + } + } +spin_unlock (&fs_info->zone_active_bgs_lock); }return 0 ;
Signature · 1 line
2.43.0
For the series,
Quoted 8 lines · Naohiro Aota
Writing sequentially to a huge file on btrfs on a SMR HDD revealed a decline of the performance (220 MiB/s to 30 MiB/s after 500 minutes). As shown in the attached plot, current btrfs exponentially drops its performance.
The drop is because
find_free_extent()need to traverse a lot of full block groups, trying to find a space.
Quoted 7 lines
This series fixes the performance drop by choosing a proper block group from the
zone_active_bgs. Since the list does not contain full block groups, there is no need of traversing the full BGs.Naohiro Aota (2):
btrfs: zoned: split outprepare_allocation_zoned()
btrfs: zoned: optimize hint byte for zoned allocator
Added to misc-next, thanks.