Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1303656 > unrolled thread

[PATCH 5/5] cfq-iosched: Allow parent cgroup to preempt its child

Back to article view | Back to linux.kernel

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.

Contents

  [PATCH 5/5] cfq-iosched: Allow parent cgroup to preempt its child Jan Kara <jack@suse.cz> - 2016-01-07 16:30 +0100
    Re: [PATCH 5/5] cfq-iosched: Allow parent cgroup to preempt its child Tejun Heo <tj@kernel.org> - 2016-01-08 19:20 +0100

#1303656 — [PATCH 5/5] cfq-iosched: Allow parent cgroup to preempt its child

From: Jan Kara <jack@suse.com>

Currently we don't allow sync workload of one cgroup to preempt sync
workload of any other cgroup. This is because we want to achieve service
separation between cgroups. However in cases where cgroup preempting is
ancestor of the current cgroup, there is no need of separation and
idling introduces unnecessary overhead. This is hurts for example the
case when workload is isolated within a cgroup but journalling threads
are in root cgroup. Simple way to demostrate the issue is using:

dbench4 -c /usr/share/dbench4/client.txt -t 10 -D /mnt 1

on ext4 filesystem on plain SATA driver (mounted with barrier=0 to make
difference more visible). When all processes are in the root cgroup,
reported throughput is 153.132 MB/sec. When dbench process gets its own
blkio cgroup, reported throughput drops to 26.1006 MB/sec.

Fix the problem by making check in cfq_should_preempt() more benevolent
and allow preemption by ancestor cgroup. This improves the throughput
reported by dbench4 to 48.9106 MB/sec.

Signed-off-by: Jan Kara <jack@suse.com>
---
 block/cfq-iosched.c | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
index 6c8bd1025c62..0961b84a9107 100644
--- a/block/cfq-iosched.c
+++ b/block/cfq-iosched.c
@@ -632,6 +632,13 @@ static inline struct cfq_group *cfqg_parent(struct cfq_group *cfqg)
 	return pblkg ? blkg_to_cfqg(pblkg) : NULL;
 }
 
+static inline bool cfqg_is_descendant(struct cfq_group *cfqg,
+				      struct cfq_group *ancestor)
+{
+	return cgroup_is_descendant(cfqg_to_blkg(cfqg)->blkcg->css.cgroup,
+				    cfqg_to_blkg(ancestor)->blkcg->css.cgroup);
+}
+
 static inline void cfqg_get(struct cfq_group *cfqg)
 {
 	return blkg_get(cfqg_to_blkg(cfqg));
@@ -758,6 +765,11 @@ static void cfqg_stats_xfer_dead(struct cfq_group *cfqg)
 #else	/* CONFIG_CFQ_GROUP_IOSCHED */
 
 static inline struct cfq_group *cfqg_parent(struct cfq_group *cfqg) { return NULL; }
+static inline bool cfqg_is_descendant(struct cfq_group *cfqg,
+				      struct cfq_group *ancestor)
+{
+	return true;
+}
 static inline void cfqg_get(struct cfq_group *cfqg) { }
 static inline void cfqg_put(struct cfq_group *cfqg) { }
 
@@ -3953,7 +3965,12 @@ cfq_should_preempt(struct cfq_data *cfqd, struct cfq_queue *new_cfqq,
 	if (rq_is_sync(rq) && !cfq_cfqq_sync(cfqq))
 		return true;
 
-	if (new_cfqq->cfqg != cfqq->cfqg)
+	/*
+	 * Treat ancestors of current cgroup the same way as current cgroup.
+	 * For anybody else we disallow preemption to guarantee service
+	 * fairness among cgroups.
+	 */
+	if (!cfqg_is_descendant(cfqq->cfqg, new_cfqq->cfqg))
 		return false;
 
 	if (cfq_slice_used(cfqq))
-- 
2.6.2

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [next] | [standalone]

#1304830

Hello,

On Thu, Jan 07, 2016 at 04:28:16PM +0100, Jan Kara wrote:
> From: Jan Kara <jack@suse.com>
> 
> Currently we don't allow sync workload of one cgroup to preempt sync
> workload of any other cgroup. This is because we want to achieve service
> separation between cgroups. However in cases where cgroup preempting is
> ancestor of the current cgroup, there is no need of separation and
> idling introduces unnecessary overhead. This is hurts for example the
                                               ^^^
> case when workload is isolated within a cgroup but journalling threads
> are in root cgroup. Simple way to demostrate the issue is using:
> 
> dbench4 -c /usr/share/dbench4/client.txt -t 10 -D /mnt 1
> 
> on ext4 filesystem on plain SATA driver (mounted with barrier=0 to make
> difference more visible). When all processes are in the root cgroup,
> reported throughput is 153.132 MB/sec. When dbench process gets its own
> blkio cgroup, reported throughput drops to 26.1006 MB/sec.
> 
> Fix the problem by making check in cfq_should_preempt() more benevolent
> and allow preemption by ancestor cgroup. This improves the throughput
> reported by dbench4 to 48.9106 MB/sec.
> 
> Signed-off-by: Jan Kara <jack@suse.com>

Acked-by: Tejun Heo <tj@kernel.org>

Thanks.

-- 
tejun

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web