loop: Add PF_LESS_THROTTLE to block/loop device thread.
Subsystems (2)
PATCH 1/1 loop: Add PF_LESS_THROTTLE to block/loop device thread.
When a filesystem is mounted from a loop device, writes are throttled by balance_dirty_pages() twice: once when writing to the filesystem and once when the loop_handle_cmd() writes to the backing file. This double-throttling can trigger positive feedback loops that create significant delays. The throttling at the lower level is seen by the upper level as a slow device, so it throttles extra hard.
The PF_LESS_THROTTLE flag was created to handle exactly this circumstance, though with an NFS filesystem mounted from a local NFS server. It reduces the throttling on the lower layer so that it can proceed largely unthrottled.
To demonstrate this, create a filesystem on a loop device and write (e.g. with dd) several large files which combine to consume significantly more than the limit set by /proc/sys/vm/dirty_ratio or dirty_bytes. Measure the total time taken.
When I do this directly on a device (no loop device) the total time for several runs (mkfs, mount, write 200 files, umount) is fairly stable: 28-35 seconds.
When I do this over a loop device the times are much worse and less stable. 52-460 seconds. Half below 100seconds, half above.
When I apply this patch, the times become stable again, though not as fast as the no-loop-back case: 53-72 seconds.
There may be room for further improvement as the total overhead still seems too high, but this is a big improvement.
--- drivers/block/loop.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/block/loop.c +3 -0
@@ -1694,8 +1694,11 @@ static void loop_queue_work(struct kthread_work *work) {struct loop_cmd *cmd = container_of(work, struct loop_cmd, work); +int oldflags = current->flags &PF_LESS_THROTTLE ; + current->flags |=PF_LESS_THROTTLE ;loop_handle_cmd (cmd); + current->flags = (current->flags & ~PF_LESS_THROTTLE ) | oldflags; } static int loop_init_request(void *data, struct request *rq,
Signature · 1 line
2.12.0
Looks fine,
But if you actually care about performance in any way I'd suggest to use the loop device in direct I/O mode..
Quoted 6 lines · Christoph Hellwig
Looks fine,
Reviewed-by Christoph Hellwig <[email protected]>But if you actually care about performance in any way I'd suggest to use the loop device in direct I/O mode..
The losetup on my test VM is too old to support that :-( I guess it might be time to upgraded.
It seems that there is not "mount -o direct_loop" or similar, so you have to do the losetup and the mount separately. Any thoughts on whether that should be changed ?
Thanks,
NeilBrown
Quoted 6 lines · NeilBrown
Quoted 4 lines · Christoph Hellwig
Looks fine,
Reviewed-by Christoph Hellwig <[email protected]>
Quoted 8 lines
Quoted 2 lines
But if you actually care about performance in any way I'd suggest to use the loop device in direct I/O mode..
The losetup on my test VM is too old to support that :-( I guess it might be time to upgraded.
It seems that there is not "mount -o
direct_loop" or similar, so you have to do the losetup and the mount separately. Any thoughts on
I guess the 'direct_loop' can be added into 'mount' directly? but not familiar with mount utility.
Quoted 1 line
whether that should be changed ?
There was sysfs interface for controling direct IO in the initial submission, but
looks it was reviewed out, :-)
Thanks,
Ming Lei
Quoted 29 lines · NeilBrown
When a filesystem is mounted from a loop device, writes are throttled by
balance_dirty_pages()twice: once when writing to the filesystem and once when theloop_handle_cmd()writes to the backing file. This double-throttling can trigger positive feedback loops that create significant delays. The throttling at the lower level is seen by the upper level as a slow device, so it throttles extra hard.The
PF_LESS_THROTTLEflag was created to handle exactly this circumstance, though with an NFS filesystem mounted from a local NFS server. It reduces the throttling on the lower layer so that it can proceed largely unthrottled.To demonstrate this, create a filesystem on a loop device and write (e.g. with dd) several large files which combine to consume significantly more than the limit set by
/proc/sys/vm/dirty_ratioordirty_bytes. Measure the total time taken.When I do this directly on a device (no loop device) the total time for several runs (mkfs, mount, write 200 files, umount) is fairly stable: 28-35 seconds.
When I do this over a loop device the times are much worse and less stable. 52-460 seconds. Half below 100seconds, half above.
When I apply this patch, the times become stable again, though not as fast as the no-loop-back case: 53-72 seconds.
Quoted 2 lines
There may be room for further improvement as the total overhead still seems too high, but this is a big improvement.
Yes this makes sense to me
Quoted 1 line
Signed-off-by NeilBrown <[email protected]>
one nit below
Quoted 9 lines
--- drivers/block/loop.c | 3 +++ 1 file changed, 3 insertions(+)drivers/block/loop.c +0
-0
drivers/block/loop.c static void loop_queue_work(struct kthread_work *work) · line 1701
Quoted 8 lines
drivers/block/loop.c +3
-0@@ -1694,8 +1694,11 @@ static void loop_queue_work(struct kthread_work *work) {struct loop_cmd *cmd = container_of(work, struct loop_cmd, work); +int oldflags = current->flags &PF_LESS_THROTTLE ; + current->flags |=PF_LESS_THROTTLE ;loop_handle_cmd (cmd); + current->flags = (current->flags & ~PF_LESS_THROTTLE ) | oldflags;
we have a helper for this tsk_restore_flags(). It is not used consistently and maybe we want a dedicated api like we have for the scope NOIO/NOFS but that is a separate thing. I would find tsk_restore_flags easier to read.
Signature · 2 lines
Michal Hocko SUSE Labs
Quoted 42 lines · NeilBrown
When a filesystem is mounted from a loop device, writes are throttled by
balance_dirty_pages()twice: once when writing to the filesystem and once when theloop_handle_cmd()writes to the backing file. This double-throttling can trigger positive feedback loops that create significant delays. The throttling at the lower level is seen by the upper level as a slow device, so it throttles extra hard.The
PF_LESS_THROTTLEflag was created to handle exactly this circumstance, though with an NFS filesystem mounted from a local NFS server. It reduces the throttling on the lower layer so that it can proceed largely unthrottled.To demonstrate this, create a filesystem on a loop device and write (e.g. with dd) several large files which combine to consume significantly more than the limit set by
/proc/sys/vm/dirty_ratioordirty_bytes. Measure the total time taken.When I do this directly on a device (no loop device) the total time for several runs (mkfs, mount, write 200 files, umount) is fairly stable: 28-35 seconds.
When I do this over a loop device the times are much worse and less stable. 52-460 seconds. Half below 100seconds, half above.
When I apply this patch, the times become stable again, though not as fast as the no-loop-back case: 53-72 seconds.There may be room for further improvement as the total overhead still seems too high, but this is a big improvement.
Signed-off-by NeilBrown <[email protected]>--- drivers/block/loop.c | 3 +++ 1 file changed, 3 insertions(+)drivers/block/loop.c +0
-0
drivers/block/loop.c static void loop_queue_work(struct kthread_work *work) · line 1702
Quoted 9 lines
drivers/block/loop.c +3
-0@@ -1694,8 +1694,11 @@ static void loop_queue_work(struct kthread_work *work) {struct loop_cmd *cmd = container_of(work, struct loop_cmd, work); +int oldflags = current->flags &PF_LESS_THROTTLE ; + current->flags |=PF_LESS_THROTTLE ;loop_handle_cmd (cmd); + current->flags = (current->flags & ~PF_LESS_THROTTLE ) | oldflags; }
You can do it against 'lo->worker_task' instead of doing it in each loop_queue_work(),
and this flag needn't to be restored because the kernel thread is loop specialized.
thanks,
Ming Lei
Quoted 48 lines · Ming Lei
Quoted 47 lines · NeilBrown
When a filesystem is mounted from a loop device, writes are throttled by
balance_dirty_pages()twice: once when writing to the filesystem and once when theloop_handle_cmd()writes to the backing file. This double-throttling can trigger positive feedback loops that create significant delays. The throttling at the lower level is seen by the upper level as a slow device, so it throttles extra hard.The
PF_LESS_THROTTLEflag was created to handle exactly this circumstance, though with an NFS filesystem mounted from a local NFS server. It reduces the throttling on the lower layer so that it can proceed largely unthrottled.To demonstrate this, create a filesystem on a loop device and write (e.g. with dd) several large files which combine to consume significantly more than the limit set by
/proc/sys/vm/dirty_ratioordirty_bytes. Measure the total time taken.When I do this directly on a device (no loop device) the total time for several runs (mkfs, mount, write 200 files, umount) is fairly stable: 28-35 seconds.
When I do this over a loop device the times are much worse and less stable. 52-460 seconds. Half below 100seconds, half above.
When I apply this patch, the times become stable again, though not as fast as the no-loop-back case: 53-72 seconds.There may be room for further improvement as the total overhead still seems too high, but this is a big improvement.
Signed-off-by NeilBrown <[email protected]>--- drivers/block/loop.c | 3 +++ 1 file changed, 3 insertions(+)drivers/block/loop.c +1
-0@@ -1694,8 +1694,11 @@ static void loop_queue_work(struct kthread_work *work) {struct loop_cmd *cmd = container_of(work, struct loop_cmd, work); +int oldflags = current->flags &PF_LESS_THROTTLE ;
Quoted 10 lines
drivers/block/loop.c static void loop_queue_work(struct kthread_work *work) · line 1702
Quoted 4 lines
drivers/block/loop.c +2
-0+ current->flags |=PF_LESS_THROTTLE ;loop_handle_cmd (cmd); + current->flags = (current->flags & ~PF_LESS_THROTTLE ) | oldflags; }You can do it against '
lo->worker_task' instead of doing it in eachloop_queue_work(),
and this flag needn't to be restored because the kernel thread is loop specialized.
good point. I'll do that. Thanks,
NeilBrown
PATCH v2 1/1 loop: Add PF_LESS_THROTTLE to block/loop device thread.
In reply to NeilBrownWhen a filesystem is mounted from a loop device, writes are throttled by balance_dirty_pages() twice: once when writing to the filesystem and once when the loop_handle_cmd() writes to the backing file. This double-throttling can trigger positive feedback loops that create significant delays. The throttling at the lower level is seen by the upper level as a slow device, so it throttles extra hard.
The PF_LESS_THROTTLE flag was created to handle exactly this circumstance, though with an NFS filesystem mounted from a local NFS server. It reduces the throttling on the lower layer so that it can proceed largely unthrottled.
To demonstrate this, create a filesystem on a loop device and write (e.g. with dd) several large files which combine to consume significantly more than the limit set by /proc/sys/vm/dirty_ratio or dirty_bytes. Measure the total time taken.
When I do this directly on a device (no loop device) the total time for several runs (mkfs, mount, write 200 files, umount) is fairly stable: 28-35 seconds.
When I do this over a loop device the times are much worse and less stable. 52-460 seconds. Half below 100seconds, half above.
When I apply this patch, the times become stable again, though not as fast as the no-loop-back case: 53-72 seconds.
There may be room for further improvement as the total overhead still seems too high, but this is a big improvement.
---
I moved where the flag is set, thanks to suggestion from Ming Lei.
I've preserved the *-by: tags I was offered despite the code being different, as the concept is identical.
Thanks,
NeilBrown
drivers/block/loop.c | 1 + 1 file changed, 1 insertion(+)
drivers/block/loop.c +1 -0
@@ -852,6 +852,7 @@ static int loop_prepare_queue(struct loop_device *lo)if (IS_ERR (lo->worker_task))return -ENOMEM ;set_user_nice (lo->worker_task,MIN_NICE ); + lo->worker_task->flags |=PF_LESS_THROTTLE ;return 0 ; }
Signature · 1 line
2.12.2
Quoted 29 lines · NeilBrown
When a filesystem is mounted from a loop device, writes are throttled by
balance_dirty_pages()twice: once when writing to the filesystem and once when theloop_handle_cmd()writes to the backing file. This double-throttling can trigger positive feedback loops that create significant delays. The throttling at the lower level is seen by the upper level as a slow device, so it throttles extra hard.The
PF_LESS_THROTTLEflag was created to handle exactly this circumstance, though with an NFS filesystem mounted from a local NFS server. It reduces the throttling on the lower layer so that it can proceed largely unthrottled.To demonstrate this, create a filesystem on a loop device and write (e.g. with dd) several large files which combine to consume significantly more than the limit set by
/proc/sys/vm/dirty_ratioordirty_bytes. Measure the total time taken.When I do this directly on a device (no loop device) the total time for several runs (mkfs, mount, write 200 files, umount) is fairly stable: 28-35 seconds.
When I do this over a loop device the times are much worse and less stable. 52-460 seconds. Half below 100seconds, half above.
When I apply this patch, the times become stable again, though not as fast as the no-loop-back case: 53-72 seconds.
Quoted 6 lines
There may be room for further improvement as the total overhead still seems too high, but this is a big improvement.
Reviewed-by Christoph Hellwig <[email protected]>Acked-by Michal Hocko <[email protected]>Signed-off-by NeilBrown <[email protected]>
Quoted 29 lines
---
I moved where the flag is set, thanks to suggestion from Ming Lei.
I've preserved the *-by: tags I was offered despite the code being different, as the concept is identical.Thanks,
NeilBrowndrivers/block/loop.c | 1 + 1 file changed, 1 insertion(+)drivers/block/loop.c +1
-1@@ -852,6 +852,7 @@ static int loop_prepare_queue(struct loop_device *lo)if (IS_ERR (lo->worker_task))return -ENOMEM ;set_user_nice (lo->worker_task,MIN_NICE ); + lo->worker_task->flags |=PF_LESS_THROTTLE ;return 0 ; } --2.12.2
Quoted 54 lines · NeilBrown
When a filesystem is mounted from a loop device, writes are throttled by
balance_dirty_pages()twice: once when writing to the filesystem and once when theloop_handle_cmd()writes to the backing file. This double-throttling can trigger positive feedback loops that create significant delays. The throttling at the lower level is seen by the upper level as a slow device, so it throttles extra hard.The
PF_LESS_THROTTLEflag was created to handle exactly this circumstance, though with an NFS filesystem mounted from a local NFS server. It reduces the throttling on the lower layer so that it can proceed largely unthrottled.To demonstrate this, create a filesystem on a loop device and write (e.g. with dd) several large files which combine to consume significantly more than the limit set by
/proc/sys/vm/dirty_ratioordirty_bytes. Measure the total time taken.When I do this directly on a device (no loop device) the total time for several runs (mkfs, mount, write 200 files, umount) is fairly stable: 28-35 seconds.
When I do this over a loop device the times are much worse and less stable. 52-460 seconds. Half below 100seconds, half above.
When I apply this patch, the times become stable again, though not as fast as the no-loop-back case: 53-72 seconds.There may be room for further improvement as the total overhead still seems too high, but this is a big improvement.
Reviewed-by Christoph Hellwig <[email protected]>Acked-by Michal Hocko <[email protected]>Signed-off-by NeilBrown <[email protected]>---
I moved where the flag is set, thanks to suggestion from Ming Lei.
I've preserved the *-by: tags I was offered despite the code being different, as the concept is identical.Thanks,
NeilBrowndrivers/block/loop.c | 1 + 1 file changed, 1 insertion(+)drivers/block/loop.c +0
-0
drivers/block/loop.c static int loop_prepare_queue(struct loop_device *lo) · line 856
Quoted 5 lines
drivers/block/loop.c +1
-0@@ -852,6 +852,7 @@ static int loop_prepare_queue(struct loop_device *lo)if (IS_ERR (lo->worker_task))return -ENOMEM ;set_user_nice (lo->worker_task,MIN_NICE ); + lo->worker_task->flags |=PF_LESS_THROTTLE ;return 0 ;
As mentioned elsewhere, PF flags should be updated only on the current task otherwise there is potential rmw race. Is this safe? The code runs concurrently with the worker thread.
Signature · 2 lines
Michal Hocko SUSE Labs
Quoted 1 line · Michal Hocko
On Wed 05-04-17 14:33:50, NeilBrown wrote:
[...]
Quoted 6 lines
Quoted 6 lines
drivers/block/loop.c +0
-0@@ -852,6 +852,7 @@ static int loop_prepare_queue(struct loop_device *lo)if (IS_ERR (lo->worker_task))
Quoted 8 lines
drivers/block/loop.c static int loop_prepare_queue(struct loop_device *lo) · line 856
Quoted 4 lines
drivers/block/loop.c +1
-0return -ENOMEM ;set_user_nice (lo->worker_task,MIN_NICE ); + lo->worker_task->flags |=PF_LESS_THROTTLE ;return 0 ;As mentioned elsewhere, PF flags should be updated only on the current task otherwise there is potential rmw race. Is this safe? The code runs concurrently with the worker thread.
I believe you need something like this instead
---
drivers/block/loop.c +7 -1
@@ -844,10 +844,16 @@ static void loop_unprepare_queue(struct loop_device *lo)kthread_stop (lo->worker_task); } +int loop_kthread_worker_fn (void *worker_ptr) +{ + current->flags |=PF_LESS_THROTTLE ; +return kthread_worker_fn (worker_ptr); +} +static int loop_prepare_queue (struct loop_device *lo) {kthread_init_worker (&lo->worker); - lo->worker_task =kthread_run (kthread_worker_fn, + lo->worker_task =kthread_run (loop_kthread_worker_fn, &lo->worker,"loop%d" , lo->lo_number);if (IS_ERR (lo->worker_task))return -ENOMEM ;
Signature · 2 lines
Michal Hocko SUSE Labs
Quoted 32 lines · Michal Hocko
Quoted 1 line · Michal Hocko
On Wed 05-04-17 14:33:50, NeilBrown wrote:
[...]
Quoted 6 lines
Quoted 6 lines
drivers/block/loop.c +0
-0@@ -852,6 +852,7 @@ static int loop_prepare_queue(struct loop_device *lo)if (IS_ERR (lo->worker_task))Quoted 8 lines
drivers/block/loop.c static int loop_prepare_queue(struct loop_device *lo) · line 856
Quoted 4 lines
drivers/block/loop.c +1
-0return -ENOMEM ;set_user_nice (lo->worker_task,MIN_NICE ); + lo->worker_task->flags |=PF_LESS_THROTTLE ;return 0 ;As mentioned elsewhere, PF flags should be updated only on the current task otherwise there is potential rmw race. Is this safe? The code runs concurrently with the worker thread.
I believe you need something like this instead
---drivers/block/loop.c +4
-0@@ -844,10 +844,16 @@ static void loop_unprepare_queue(struct loop_device *lo)kthread_stop (lo->worker_task); } +int loop_kthread_worker_fn (void *worker_ptr) +{ + current->flags |=PF_LESS_THROTTLE ; +return kthread_worker_fn (worker_ptr);
drivers/block/loop.c static void loop_unprepare_queue(struct loop_device *lo) · line 859
Quoted 10 lines
drivers/block/loop.c +3
-1+} +static int loop_prepare_queue (struct loop_device *lo) {kthread_init_worker (&lo->worker); - lo->worker_task =kthread_run (kthread_worker_fn, + lo->worker_task =kthread_run (loop_kthread_worker_fn, &lo->worker,"loop%d" , lo->lo_number);if (IS_ERR (lo->worker_task))return -ENOMEM ;
Arg - of course.
How about we just split the kthread_create from the wake_up?
Thanks,
NeilBrown
From: NeilBrown <[email protected]>
Subject: [PATCH] loop: Add PF_LESS_THROTTLE to block/loop device thread.
When a filesystem is mounted from a loop device, writes are throttled by balance_dirty_pages() twice: once when writing to the filesystem and once when the loop_handle_cmd() writes to the backing file. This double-throttling can trigger positive feedback loops that create significant delays. The throttling at the lower level is seen by the upper level as a slow device, so it throttles extra hard.
The PF_LESS_THROTTLE flag was created to handle exactly this circumstance, though with an NFS filesystem mounted from a local NFS server. It reduces the throttling on the lower layer so that it can proceed largely unthrottled.
To demonstrate this, create a filesystem on a loop device and write (e.g. with dd) several large files which combine to consume significantly more than the limit set by /proc/sys/vm/dirty_ratio or dirty_bytes. Measure the total time taken.
When I do this directly on a device (no loop device) the total time for several runs (mkfs, mount, write 200 files, umount) is fairly stable: 28-35 seconds.
When I do this over a loop device the times are much worse and less stable. 52-460 seconds. Half below 100seconds, half above.
When I apply this patch, the times become stable again, though not as fast as the no-loop-back case: 53-72 seconds.
There may be room for further improvement as the total overhead still seems too high, but this is a big improvement.
--- drivers/block/loop.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/block/loop.c +3 -1
@@ -847,10 +847,12 @@ static void loop_unprepare_queue(struct loop_device *lo)static int loop_prepare_queue (struct loop_device *lo) {kthread_init_worker (&lo->worker); - lo->worker_task =kthread_run (kthread_worker_fn, + lo->worker_task =kthread_create (kthread_worker_fn, &lo->worker,"loop%d" , lo->lo_number);if (IS_ERR (lo->worker_task))return -ENOMEM ; + lo->worker_task->flags |=PF_LESS_THROTTLE ; +wake_up_process (lo->worker_task);set_user_nice (lo->worker_task,MIN_NICE );return 0 ; }
Signature · 1 line
2.12.2
On Thu 06-04-17 12:23:51, NeilBrown wrote:
[...]
Quoted 7 lines
drivers/block/loop.c +0
-0@@ -847,10 +847,12 @@ static void loop_unprepare_queue(struct loop_device *lo)static int loop_prepare_queue (struct loop_device *lo) {
drivers/block/loop.c static void loop_unprepare_queue(struct loop_device *lo) · line 857
Quoted 10 lines
drivers/block/loop.c +3
-1kthread_init_worker (&lo->worker); - lo->worker_task =kthread_run (kthread_worker_fn, + lo->worker_task =kthread_create (kthread_worker_fn, &lo->worker,"loop%d" , lo->lo_number);if (IS_ERR (lo->worker_task))return -ENOMEM ; + lo->worker_task->flags |=PF_LESS_THROTTLE ; +wake_up_process (lo->worker_task);set_user_nice (lo->worker_task,MIN_NICE );return 0 ;
This should work for the current implementation because kthread_create will return only after the full initialization has been done. No idea whether we can rely on that in future. I also think it would be cleaner to set the flag on current and keep the current semantic that only current changes its flags.
So while I do not have a strong opinion on this I think defining loop specific thread function which set PF_LESS_THROTTLE as the first thing is more elegant and less error prone longerm. A short comment explaining why we use the flag there would be also preferred.
I will leave the decision to you.
Thanks.
Signature · 2 lines
Michal Hocko SUSE Labs
PATCH v3 1/1 loop: Add PF_LESS_THROTTLE to block/loop device thread.
When a filesystem is mounted from a loop device, writes are throttled by balance_dirty_pages() twice: once when writing to the filesystem and once when the loop_handle_cmd() writes to the backing file. This double-throttling can trigger positive feedback loops that create significant delays. The throttling at the lower level is seen by the upper level as a slow device, so it throttles extra hard.
The PF_LESS_THROTTLE flag was created to handle exactly this circumstance, though with an NFS filesystem mounted from a local NFS server. It reduces the throttling on the lower layer so that it can proceed largely unthrottled.
To demonstrate this, create a filesystem on a loop device and write (e.g. with dd) several large files which combine to consume significantly more than the limit set by /proc/sys/vm/dirty_ratio or dirty_bytes. Measure the total time taken.
When I do this directly on a device (no loop device) the total time for several runs (mkfs, mount, write 200 files, umount) is fairly stable: 28-35 seconds.
When I do this over a loop device the times are much worse and less stable. 52-460 seconds. Half below 100seconds, half above.
When I apply this patch, the times become stable again, though not as fast as the no-loop-back case: 53-72 seconds.
There may be room for further improvement as the total overhead still seems too high, but this is a big improvement.
---
Hi Jens,
I think this version meets with everyone's approval.
Thanks,
NeilBrown
drivers/block/loop.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
drivers/block/loop.c +7 -1
@@ -844,10 +844,16 @@ static void loop_unprepare_queue(struct loop_device *lo)kthread_stop (lo->worker_task); } +static int loop_kthread_worker_fn (void *worker_ptr) +{ + current->flags |=PF_LESS_THROTTLE ; +return kthread_worker_fn (worker_ptr); +} +static int loop_prepare_queue (struct loop_device *lo) {kthread_init_worker (&lo->worker); - lo->worker_task =kthread_run (kthread_worker_fn, + lo->worker_task =kthread_run (loop_kthread_worker_fn, &lo->worker,"loop%d" , lo->lo_number);if (IS_ERR (lo->worker_task))return -ENOMEM ;
Signature · 1 line
2.12.2