btrfs: only ignore delalloc if delalloc is much smaller than ordered

While testing heavy delalloc workloads I noticed that sometimes we'd
just stop preemptively flushing when we had loads of delalloc available
to flush.  This is because we skip preemptive flushing if delalloc <=
ordered.  However if we start with say 4gib of delalloc, and we flush
2gib of that, we'll stop flushing there, when we still have 2gib of
delalloc to flush.

Instead adjust the ordered bytes down by half, this way if 2/3 of our
outstanding delalloc reservations are tied up by ordered extents we
don't bother preemptive flushing, as we're getting close to the state
where we need to wait on ordered extents.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/space-info.c b/fs/btrfs/space-info.c
index 0e88a1482624e4f42e9ea00020de012716566568..639787beb57aadecbc2e9e031cb2cbe2bed8c2e9 100644 (file)
--- a/fs/btrfs/space-info.c
+++ b/fs/btrfs/space-info.c
@@ -864,8 +864,14 @@ static bool need_preemptive_reclaim(struct btrfs_fs_info *fs_info,
         * clearly be heavy enough to warrant preemptive flushing.  In the case
         * of heavy DIO or ordered reservations, preemptive flushing will just
         * waste time and cause us to slow down.
+        *
+        * We want to make sure we truly are maxed out on ordered however, so
+        * cut ordered in half, and if it's still higher than delalloc then we
+        * can keep flushing.  This is to avoid the case where we start
+        * flushing, and now delalloc == ordered and we stop preemptively
+        * flushing when we could still have several gigs of delalloc to flush.
         */
-       ordered = percpu_counter_read_positive(&fs_info->ordered_bytes);
+       ordered = percpu_counter_read_positive(&fs_info->ordered_bytes) >> 1;
        delalloc = percpu_counter_read_positive(&fs_info->delalloc_bytes);
        if (ordered >= delalloc)
                used += fs_info->delayed_refs_rsv.reserved +