From patchwork Mon Sep 26 12:19:48 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Vincent Guittot X-Patchwork-Id: 77029 Delivered-To: patch@linaro.org Received: by 10.140.106.72 with SMTP id d66csp1146591qgf; Mon, 26 Sep 2016 05:22:04 -0700 (PDT) X-Received: by 10.98.85.198 with SMTP id j189mr37678424pfb.123.1474892524485; Mon, 26 Sep 2016 05:22:04 -0700 (PDT) Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id yn6si7098914pab.271.2016.09.26.05.22.04; Mon, 26 Sep 2016 05:22:04 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S941248AbcIZMWB (ORCPT + 27 others); Mon, 26 Sep 2016 08:22:01 -0400 Received: from mail-pf0-f178.google.com ([209.85.192.178]:35140 "EHLO mail-pf0-f178.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S941347AbcIZMUW (ORCPT ); Mon, 26 Sep 2016 08:20:22 -0400 Received: by mail-pf0-f178.google.com with SMTP id s13so31045640pfd.2 for ; Mon, 26 Sep 2016 05:20:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=on5cItCAfQSZNroSX+M0TS8aK12xmoUX49Tcq5C2Kzk=; b=RIu1LjyONCdQNjCFZ1/KOfA1v/4t3I/Yy+LAPSnoCLoGvNLj6y4L2MJAJG1uH/k7fx XMMxVjgD98nnvy2surtytFaaxv4SR5qRGuWzvF5tZIodB8+1XSfg/aL7DEuwiBmXVZ46 Ek6q01dR+rlv2Tqy1GHKLDQwHFOMscBpe2QSw= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=on5cItCAfQSZNroSX+M0TS8aK12xmoUX49Tcq5C2Kzk=; b=G0DzJrh4+Xwrup9zu64BGjAw8ytQBfgL1ivnPnJLLzOJkCCKL3E38mb6DvHJLiWSPh OLh5DDXV5rKtnJJFb0kWXvRK4OXfLCbk63HzqAIELLlSmtGnIhOVTqRW+S3l2F24hY5o A8YBagg+6S/KjelANiV2ZANRIUU9+FfNkhfnfw1AlaCeF5zd+hjfCxt1gBHhJz37wMuV D1l5ziGBmg/es9YFLxctKrsQnB8cxBsen6Wx9WahOX0bhkqLLevpa5ewsgG2COHWbscA UJHrHoNYW6+8osW8I0eRi9QjBwO450Hmla5aCRXTQ6bi3FBQT5wg0KLHVzitP0mYS1eA VhrQ== X-Gm-Message-State: AE9vXwO6nZ3ue65yqFFGoUY+Wcj7C1fQgyWRY7jcMkeoRVaYN5o+HGQFnLkXwv/ekHLf4j3P X-Received: by 10.98.198.70 with SMTP id m67mr38093658pfg.34.1474892422123; Mon, 26 Sep 2016 05:20:22 -0700 (PDT) Received: from localhost.localdomain ([67.238.99.186]) by smtp.gmail.com with ESMTPSA id i62sm30773860pfg.89.2016.09.26.05.20.20 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 26 Sep 2016 05:20:21 -0700 (PDT) From: Vincent Guittot To: peterz@infradead.org, mingo@kernel.org, linux-kernel@vger.kernel.org, dietmar.eggemann@arm.com, kernellwp@gmail.com Cc: yuyang.du@intel.com, Morten.Rasmussen@arm.com, linaro-kernel@lists.linaro.org, pjt@google.com, bsegall@google.com, Vincent Guittot Subject: [PATCH 2/7 v4] sched: fix hierarchical order in rq->leaf_cfs_rq_list Date: Mon, 26 Sep 2016 14:19:48 +0200 Message-Id: <1474892393-5095-3-git-send-email-vincent.guittot@linaro.org> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1474892393-5095-1-git-send-email-vincent.guittot@linaro.org> References: <1474892393-5095-1-git-send-email-vincent.guittot@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Fix the insertion of cfs_rq in rq->leaf_cfs_rq_list to ensure that a child will always be called before its parent. The hierarchical order in shares update list has been introduced by commit 67e86250f8ea ("sched: Introduce hierarchal order on shares update list") With the current implementation a child can be still put after its parent. Lets take the example of root \ b /\ c d* | e* with root -> b -> c already enqueued but not d -> e so the leaf_cfs_rq_list looks like: head -> c -> b -> root -> tail The branch d -> e will be added the first time that they are enqueued, starting with e then d. When e is added, its parents is not already on the list so e is put at the tail : head -> c -> b -> root -> e -> tail Then, d is added at the head because its parent is already on the list: head -> d -> c -> b -> root -> e -> tail e is not placed at the right position and will be called the last whereas it should be called at the beginning. Because it follows the bottom-up enqueue sequence, we are sure that we will finished to add either a cfs_rq without parent or a cfs_rq with a parent that is already on the list. We can use this event to detect when we have finished to add a new branch. For the others, whose parents are not already added, we have to ensure that they will be added after their children that have just been inserted the steps before, and after any potential parents that are already in the list. The easiest way is to put the cfs_rq just after the last inserted one and to keep track of it untl the branch is fully added. Signed-off-by: Vincent Guittot --- kernel/sched/core.c | 1 + kernel/sched/fair.c | 54 +++++++++++++++++++++++++++++++++++++++++++++------- kernel/sched/sched.h | 1 + 3 files changed, 49 insertions(+), 7 deletions(-) -- 1.9.1 diff --git a/kernel/sched/core.c b/kernel/sched/core.c :confirm b3 index 860070f..3e52d08 100644 --- a/kernel/sched/core.c +++ b/kernel/sched/core.c @@ -7489,6 +7489,7 @@ void __init sched_init(void) #ifdef CONFIG_FAIR_GROUP_SCHED root_task_group.shares = ROOT_TASK_GROUP_LOAD; INIT_LIST_HEAD(&rq->leaf_cfs_rq_list); + rq->tmp_alone_branch = &rq->leaf_cfs_rq_list; /* * How much cpu bandwidth does root_task_group get? * diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index e8ed8d1..3d29492 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -292,19 +292,59 @@ static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp) static inline void list_add_leaf_cfs_rq(struct cfs_rq *cfs_rq) { if (!cfs_rq->on_list) { + struct rq *rq = rq_of(cfs_rq); + int cpu = cpu_of(rq); /* * Ensure we either appear before our parent (if already * enqueued) or force our parent to appear after us when it is - * enqueued. The fact that we always enqueue bottom-up - * reduces this to two cases. + * enqueued. The fact that we always enqueue bottom-up + * reduces this to two cases and a special case for the root + * cfs_rq. Furthermore, it also means that we will always reset + * tmp_alone_branch either when the branch is connected + * to a tree or when we reach the beg of the tree */ if (cfs_rq->tg->parent && - cfs_rq->tg->parent->cfs_rq[cpu_of(rq_of(cfs_rq))]->on_list) { - list_add_rcu(&cfs_rq->leaf_cfs_rq_list, - &rq_of(cfs_rq)->leaf_cfs_rq_list); - } else { + cfs_rq->tg->parent->cfs_rq[cpu]->on_list) { + /* + * If parent is already on the list, we add the child + * just before. Thanks to circular linked property of + * the list, this means to put the child at the tail + * of the list that starts by parent. + */ + list_add_tail_rcu(&cfs_rq->leaf_cfs_rq_list, + &(cfs_rq->tg->parent->cfs_rq[cpu]->leaf_cfs_rq_list)); + /* + * The branch is now connected to its tree so we can + * reset tmp_alone_branch to the beginning of the + * list. + */ + rq->tmp_alone_branch = &rq->leaf_cfs_rq_list; + } else if (!cfs_rq->tg->parent) { + /* + * cfs rq without parent should be put + * at the tail of the list. + */ list_add_tail_rcu(&cfs_rq->leaf_cfs_rq_list, - &rq_of(cfs_rq)->leaf_cfs_rq_list); + &rq->leaf_cfs_rq_list); + /* + * We have reach the beg of a tree so we can reset + * tmp_alone_branch to the beginning of the list. + */ + rq->tmp_alone_branch = &rq->leaf_cfs_rq_list; + } else { + /* + * The parent has not already been added so we want to + * make sure that it will be put after us. + * tmp_alone_branch points to the beg of the branch + * where we will add parent. + */ + list_add_rcu(&cfs_rq->leaf_cfs_rq_list, + rq->tmp_alone_branch); + /* + * update tmp_alone_branch to points to the new beg + * of the branch + */ + rq->tmp_alone_branch = &cfs_rq->leaf_cfs_rq_list; } cfs_rq->on_list = 1; diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h index 420c05d..483616a 100644 --- a/kernel/sched/sched.h +++ b/kernel/sched/sched.h @@ -616,6 +616,7 @@ struct rq { #ifdef CONFIG_FAIR_GROUP_SCHED /* list of leaf cfs_rq on this cpu: */ struct list_head leaf_cfs_rq_list; + struct list_head *tmp_alone_branch; #endif /* CONFIG_FAIR_GROUP_SCHED */ /*