[PATCH 01/35] writeback: enabling gate limit for light dirtied bdi

Wu Fengguang
2010-12-13T15:08:48Z

[-- Attachment #1: writeback-min-bdi-dirty-limit.patch --]
[-- Type: text/plain, Size: 4291 bytes --]

I noticed that my NFSROOT test system goes slow responding when there
is heavy dd to a local disk. Traces show that the NFSROOT's bdi limit
is near 0 and many tasks in the system are repeatedly stuck in
balance_dirty_pages().

There are two generic problems:

- light dirtiers at one device (more often than not the rootfs) get
heavily impacted by heavy dirtiers on another independent device

- the light dirtied device does heavy throttling because bdi limit=0,
and the heavy throttling may in turn withhold its bdi limit in 0 as
it cannot dirty fast enough to grow up the bdi's proportional weight.

Fix it by introducing some "low pass" gate, which is a small (<=32MB)
value reserved by others and can be safely "stole" from the current
global dirty margin. It does not need to be big to help the bdi gain
its initial weight.

Acked-by: Rik van Riel <riel@redhat.com>
CC: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Wu Fengguang <fengguang.wu@intel.com>
---
include/linux/writeback.h | 3 ++-
mm/backing-dev.c | 2 +-
mm/page-writeback.c | 29 ++++++++++++++++++++++++++---
3 files changed, 29 insertions(+), 5 deletions(-)

--- linux-next.orig/mm/page-writeback.c 2010-12-13 21:45:58.000000000 +0800
+++ linux-next/mm/page-writeback.c 2010-12-13 21:46:10.000000000 +0800
@@ -443,13 +443,26 @@ void global_dirty_limits(unsigned long *
*
* The bdi's share of dirty limit will be adapting to its throughput and
* bounded by the bdi->min_ratio and/or bdi->max_ratio parameters, if set.
- */
-unsigned long bdi_dirty_limit(struct backing_dev_info *bdi, unsigned long dirty)
+ *
+ * There is a chicken and egg problem: when bdi A (eg. /pub) is heavy dirtied
+ * and bdi B (eg. /) is light dirtied hence has 0 dirty limit, tasks writing to
+ * B always get heavily throttled and bdi B's dirty limit might never be able
+ * to grow up from 0. So we do tricks to reserve some global margin and honour
+ * it to the bdi's that run low.
+ */
+unsigned long bdi_dirty_limit(struct backing_dev_info *bdi,
+ unsigned long dirty,
+ unsigned long dirty_pages)
{
u64 bdi_dirty;
long numerator, denominator;

/*
+ * Provide a global safety margin of ~1%, or up to 32MB for a 20GB box.
+ */
+ dirty -= min(dirty / 128, 32768UL >> (PAGE_SHIFT-10));
+
+ /*
* Calculate this BDI's share of the dirty ratio.
*/
bdi_writeout_fraction(bdi, &numerator, &denominator);
@@ -459,6 +472,15 @@ unsigned long bdi_dirty_limit(struct bac
do_div(bdi_dirty, denominator);

bdi_dirty += (dirty * bdi->min_ratio) / 100;
+
+ /*
+ * If we can dirty N more pages globally, honour N/2 to the bdi that
+ * runs low, so as to help it ramp up.
+ */
+ if (unlikely(bdi_dirty < (dirty - dirty_pages) / 2 &&
+ dirty > dirty_pages))
+ bdi_dirty = (dirty - dirty_pages) / 2;
+
if (bdi_dirty > (dirty * bdi->max_ratio) / 100)
bdi_dirty = dirty * bdi->max_ratio / 100;

@@ -508,7 +530,8 @@ static void balance_dirty_pages(struct a
(background_thresh + dirty_thresh) / 2)
break;

- bdi_thresh = bdi_dirty_limit(bdi, dirty_thresh);
+ bdi_thresh = bdi_dirty_limit(bdi, dirty_thresh,
+ nr_reclaimable + nr_writeback);
bdi_thresh = task_dirty_limit(current, bdi_thresh);

/*
--- linux-next.orig/mm/backing-dev.c 2010-12-13 21:45:58.000000000 +0800
+++ linux-next/mm/backing-dev.c 2010-12-13 21:46:10.000000000 +0800
@@ -83,7 +83,7 @@ static int bdi_debug_stats_show(struct s
spin_unlock(&inode_lock);

global_dirty_limits(&background_thresh, &dirty_thresh);
- bdi_thresh = bdi_dirty_limit(bdi, dirty_thresh);
+ bdi_thresh = bdi_dirty_limit(bdi, dirty_thresh, dirty_thresh);

#define K(x) ((x) << (PAGE_SHIFT - 10))
seq_printf(m,
--- linux-next.orig/include/linux/writeback.h 2010-12-13 21:45:58.000000000 +0800
+++ linux-next/include/linux/writeback.h 2010-12-13 21:46:10.000000000 +0800
@@ -126,7 +126,8 @@ int dirty_writeback_centisecs_handler(st

void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty);
unsigned long bdi_dirty_limit(struct backing_dev_info *bdi,
- unsigned long dirty);
+ unsigned long dirty,
+ unsigned long dirty_pages);

void page_writeback_init(void);
void balance_dirty_pages_ratelimited_nr(struct address_space *mapping,