[v2,0/8] btrfs: Refactor delayed ref parameter list
mbox series

Message ID 20181212073102.7736-1-wqu@suse.com
Headers show
Series
  • btrfs: Refactor delayed ref parameter list
Related show

Message

Qu Wenruo Dec. 12, 2018, 7:30 a.m. UTC
This patchset can be fetched from github:
https://github.com/adam900710/linux/tree/refactor_delayed_ref_parameter

Which is based on previous delayed subtree scan patchset.
(https://github.com/adam900710/linux/tree/qgroup_delayed_subtree)


Current delayed ref interface has several problems:
- Longer and longer parameter lists
  bytenr
  num_bytes
  parent
  ---- So far so good
  ref_root
  owner
  offset
  ---- I don't feel well now
  for_reloc
  ^^^^ This parameter only makes sense for qgroup code, but we need
       to pass the parameter a long way.

  This makes later expand on parameter list more and more tricky.

- Different interpretation for the same parameter
  Above @owner for data ref is ino who owns this extent,
  while for tree ref, it's level. They are even in different size range.

  For level we only need 0~8, while for ino it's
  BTRFS_FIRST_FREE_OBJECTID~BTRFS_LAST_FREE_OBJECTID, so it's still
  possible to distinguish them, but it's never a straight-forward thing
  to grasp.

  And @offset doesn't even makes sense for tree ref.

  Such parameter reuse may look clever as an hidden union, but it
  destroys code readability.

This patchset will change the way how we pass parameters for delayed
ref.
Instead of calling delayed ref interface like:
  ret = btrfs_inc_extent_ref(trans, root, bytenr, num_bytes, parent,
			     ref_root, owner, offset);
Or
  ret = btrfs_inc_extent_ref(trans, root, bytenr, nodesize, parent,
			     level, ref_root, 0);

We now call like:
  btrfs_init_generic_ref(&ref, bytenr, num_bytes,
			 root->root_key.objectid, parent);
  btrfs_init_data_ref(&ref, ref_root, owner, offset);
  ret = btrfs_inc_extent_ref(trans, &ref);
Or
  btrfs_init_generic_ref(&ref, bytenr, num_bytes,
			 root->root_key.objectid, parent);
  btrfs_init_tree_ref(&ref, level, ref_root);
  ret = btrfs_inc_extent_ref(trans, &ref);

To determine if a ref is tree or data, instead of calling like:
  if (owner < BTRFS_FIRST_FREE_OBJECTID) {
  } else {
  }
We do it straight-forward:
  if (ref->type == BTRFS_REF_METADATA) {
  } else {
  }

And for newer and minor new members, we don't need to add a new
parameter to btrfs_add_delayed_tree|data_ref() or
btrfs_inc_extent_ref(), just assign them after generic/data/tree init:
  btrfs_init_generic_ref(&ref, bytenr, num_bytes,
			 root->root_key.objectid, parent);
  ref->real_root = root->root_key.objectid;
  ref->skip_qgroup = true;
  btrfs_init_data_ref(&ref, ref_root, owner, offset);

  ret = btrfs_inc_extent_ref(trans, &ref);

This should improve the code readability and make later code easier to
write.


Furthermore, with the help of btrfs_ref::real_root parameter, qgroup
can skip quit a lot of delayed tree/data ref for reloc tree, which
result an obvious time save for balance:
Test VM:
- vRAM		8G
- vCPU		8
- block dev	vitrio-blk, 'unsafe' cache mode
- host block	850evo

Test workload
- Copy 4G data from /usr/ to one subvolume
- Create 16 snapshots of that subvolume, and modify 3 files in each
  snapshot
- Enable quota, rescan
- Time "btrfs balance start -m"

              |  base (*) |  w/ patchset |    diff
-------------------------------------------------------------
relocated     |     22653 |        22673 |   0.0 %
qgroup dirty  |    122792 |        48360 | -60.6 %
time          |    24.494 |       11.606 | -52.6 %

Changelog:
v2:
- Better documentation for btrfs_ref declaration
- Rebase to newer delayed subtree rescan patchset
- Add reviewed-by tags
- Remove unnecessary ASSERT() for NULL pointer.

Qu Wenruo (8):
  btrfs: delayed-ref: Introduce better documented delayed ref structures
  btrfs: extent-tree: Open-code process_func in __btrfs_mod_ref
  btrfs: delayed-ref: Use btrfs_ref to refactor
    btrfs_add_delayed_tree_ref()
  btrfs: delayed-ref: Use btrfs_ref to refactor
    btrfs_add_delayed_data_ref()
  btrfs: ref-verify: Use btrfs_ref to refactor btrfs_ref_tree_mod()
  btrfs: extent-tree: Use btrfs_ref to refactor add_pinned_bytes()
  btrfs: extent-tree: Use btrfs_ref to refactor btrfs_inc_extent_ref()
  btrfs: extent-tree: Use btrfs_ref to refactor btrfs_free_extent()

 fs/btrfs/ctree.h       |  10 +--
 fs/btrfs/delayed-ref.c |  40 ++++++---
 fs/btrfs/delayed-ref.h | 126 +++++++++++++++++++++++++--
 fs/btrfs/extent-tree.c | 189 ++++++++++++++++++++---------------------
 fs/btrfs/file.c        |  39 +++++----
 fs/btrfs/inode.c       |  23 +++--
 fs/btrfs/ioctl.c       |  15 ++--
 fs/btrfs/ref-verify.c  |  53 +++++++-----
 fs/btrfs/ref-verify.h  |  10 +--
 fs/btrfs/relocation.c  |  67 +++++++++------
 fs/btrfs/tree-log.c    |  11 ++-
 11 files changed, 374 insertions(+), 209 deletions(-)

Comments

David Sterba Dec. 12, 2018, 12:42 p.m. UTC | #1
On Wed, Dec 12, 2018 at 03:30:54PM +0800, Qu Wenruo wrote:
> This patchset can be fetched from github:
> https://github.com/adam900710/linux/tree/refactor_delayed_ref_parameter
> 
> Which is based on previous delayed subtree scan patchset.
> (https://github.com/adam900710/linux/tree/qgroup_delayed_subtree)

I like the cleanups however due to the dependency it would need to be
reworked on top of misc-next without it. At this point the pull request
branch is being finalized, I'm not sure I'd squeeze that one in. So same
as with the delayed subtree, postponed to the next cycle.
Qu Wenruo Dec. 12, 2018, 1:21 p.m. UTC | #2
On 2018/12/12 下午8:42, David Sterba wrote:
> On Wed, Dec 12, 2018 at 03:30:54PM +0800, Qu Wenruo wrote:
>> This patchset can be fetched from github:
>> https://github.com/adam900710/linux/tree/refactor_delayed_ref_parameter
>>
>> Which is based on previous delayed subtree scan patchset.
>> (https://github.com/adam900710/linux/tree/qgroup_delayed_subtree)
> 
> I like the cleanups however due to the dependency it would need to be
> reworked on top of misc-next without it. At this point the pull request
> branch is being finalized, I'm not sure I'd squeeze that one in.

Feel free to postpone this cleanup.

This cleanup is not that emergency.

Thanks,
Qu

> So same
> as with the delayed subtree, postponed to the next cycle.