Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:6 as permitted sender) client-ip=2620:137:e000::3:6;
Date:   Mon, 9 Oct 2023 13:14:34 +0800
From:   Chen Yu <yu.c.chen@intel.com>
To:     Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
CC:     Peter Zijlstra <peterz@infradead.org>,
        <linux-kernel@vger.kernel.org>, Ingo Molnar <mingo@redhat.com>,
        Valentin Schneider <vschneid@redhat.com>,
        Steven Rostedt <rostedt@goodmis.org>,
        Ben Segall <bsegall@google.com>,
        "Mel Gorman" <mgorman@suse.de>,
        Daniel Bristot de Oliveira <bristot@redhat.com>,
        Vincent Guittot <vincent.guittot@linaro.org>,
        Juri Lelli <juri.lelli@redhat.com>,
        Swapnil Sapkal <Swapnil.Sapkal@amd.com>,
        Aaron Lu <aaron.lu@intel.com>, Tim Chen <tim.c.chen@intel.com>,
        K Prateek Nayak <kprateek.nayak@amd.com>,
        "Gautham R . Shenoy" <gautham.shenoy@amd.com>, <x86@kernel.org>
Subject: Re: [RFC PATCH] sched/fair: Bias runqueue selection towards almost
 idle prev CPU
Message-ID: <ZSOMOhhkPIFmvz97@chenyu5-mobl2.ccr.corp.intel.com>
References: <20230929183350.239721-1-mathieu.desnoyers@efficios.com>
 <ZRfKKxBzfu+kf0tM@chenyu5-mobl2.ccr.corp.intel.com>
 <0f3cfff3-0df4-3cb7-95cb-ea378517e13b@efficios.com>
Content-Type: text/plain; charset="us-ascii"
Content-Disposition: inline
In-Reply-To: <0f3cfff3-0df4-3cb7-95cb-ea378517e13b@efficios.com>
MIME-Version: 1.0
X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1
X-MS-Exchange-AntiSpam-MessageData-0: =?us-ascii?Q?9xB/TJoIL4NP54SHBXsOr3u6WUKlPXmhV9ryHUZVpznzP9/bFhRBMaInfgjj?=
 =?us-ascii?Q?1AuvUYRFsA0kcdAPLAbBp3HjNeYxsWYDkogkY3Qx23VZ58gUPZR+vyvZQGRl?=
 =?us-ascii?Q?qd/JfsgT+bn0fyMsakNejBhW0/4Thy0Zr+x4OHyYAGITb46zJtuuiy3aMWTq?=
 =?us-ascii?Q?p5gkFgvyO6eWTbuCAUlWCSOmzZy8MPh/3UzIltXUNcoIHxyjQGwx3c4ocWWz?=
 =?us-ascii?Q?LsLQATF0i/zDCuBWxGMRNQxeQ19i8SjFhJFxbsgUudW5bcaDaiAsUtxGqXVR?=
 =?us-ascii?Q?xAJ5mAxE4ZqZhT5VuYfQxrQgvqMJ/LhbKFyNrsRddiHCgKkf/R+BZXz5pm45?=
 =?us-ascii?Q?GyvqnijpGHrEgHnHHMlcvY3uiQ08xGFVQUnueXRT8yYyIinlfG6ec65naLbO?=
 =?us-ascii?Q?liVciLnH73d+uT0fggOiGseb+YY+GtDrIv9wj0zs8dui68+zgpzE9Qd4jZU4?=
 =?us-ascii?Q?DEpg67WntoMMDGYnnW6PLigZ1hik1wvC+iiBmA9g52q0Nfw0bdMVMHy21peD?=
 =?us-ascii?Q?8vE6/pAISEvwE6at8r1V6HaFRwm1gGhBr/+P2//0+4TLeS+8bOJmxNohzGMf?=
 =?us-ascii?Q?61C6h1T/M6cRe/PB0iEZFwidoe84NC/SdID6ABx5lVQSt3Pw3uHe5AkiAZKT?=
 =?us-ascii?Q?nHSS9LUQ8uJphPCtSARG6P0FmMrcJDJsDUHyiEdga8Z2/BtQzWVmijOreGYx?=
 =?us-ascii?Q?dnmQWsuuSFl6MLcowkq6O8Wd8cddTDGtqc08oJapGWUi6cy0fJWQceFy+H6T?=
 =?us-ascii?Q?JZtqN9dcD90J2CzJQ85COp/egQz3lXbr9vINtKJzFK64sW3k3gm9oCl9pIol?=
 =?us-ascii?Q?NDW4d2goDwb1YV0Ln5FAPF2SFZxHlwjJmPXwqSdALshnCRe5fNPIOJP3vuDW?=
 =?us-ascii?Q?q8OW3kNc4o682U+sNab4RsPoJxCEswkietdxf2K4/YO0hspCkCmJ/keOiGiq?=
 =?us-ascii?Q?QCYLoLdRotUO7aAd5N26BhwEiVNRJ9hzJT7pP5kUIesge3uqYxhnRAitzT1t?=
 =?us-ascii?Q?PeMqISdUJP5mAQWW4bbswG/DqlhvINdyddPO/BleoPmAFaYmDcV2MupeXInW?=
 =?us-ascii?Q?kKNNL1MZpxPfi53oDe/xyBA7ImAVcE5QrW0NMgDIGPrLktP24TIRHYYqOWUC?=
 =?us-ascii?Q?GEu18tLBR35zSXxJsQquiJ/EhHe5Z5wzBSjhXi47tGOlYtW6A0O42i9i2jDH?=
 =?us-ascii?Q?kfhQDF3kmbsS9bnW0eZSl9Jdm7YEdRdOlaUhiFfFoQDTo53YmGvthL6rBRyr?=
 =?us-ascii?Q?ccDnKhxEmLkM+9ORbMIQbocxptl0U+gCwNLwM8KolAJkI/IC+FMH3arnamke?=
 =?us-ascii?Q?B7ncII4dBCm7sqQt18KcIUB/JzecQLo9bKQdeJ1fV2KMWoVUGFf2sKmnMC8g?=
 =?us-ascii?Q?ettPoDFuINWubxaPprgoxbnYU6bdqwEzhWPLC3f/wxoADvXKXP2uTlDozdf9?=
 =?us-ascii?Q?Q5pX1O2KEjDMgmb9aDIEwQWyjwo1JdZxqtJwVKPGBlwEyvDHUs0twg6LOfgw?=
 =?us-ascii?Q?vkjKU6ebSdx+XUl+D1jcqLFofH+tOhGOcjW4eHajxx4J40mU7WpMsuFU++T9?=
 =?us-ascii?Q?sRQ15ZvsI8x/cUhcgMZBsVoKnEcLlVm0Deq/TbQX?=
X-MS-Exchange-CrossTenant-Network-Message-Id: 07502bf9-8f1b-4b8d-d0aa-08dbc886aa3f
X-MS-Exchange-CrossTenant-AuthSource: CY5PR11MB6211.namprd11.prod.outlook.com
X-MS-Exchange-CrossTenant-AuthAs: Internal
X-MS-Exchange-CrossTenant-OriginalArrivalTime: 09 Oct 2023 05:14:51.4933
 (UTC)
X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted
X-MS-Exchange-CrossTenant-Id: 46c98d88-e344-4ed4-8496-4ed7712e255d
X-MS-Exchange-CrossTenant-MailboxType: HOSTED
X-MS-Exchange-CrossTenant-UserPrincipalName: AS+onfQ5CnUydFBmraM70xM4o17+CmLf/vLhpRACx5Y4dFCPjlfBdKsJvLTTEMrcsGwZvJFCkWMz4YjlrhrBFA==
X-MS-Exchange-Transport-CrossTenantHeadersStamped: SA3PR11MB7609
X-OriginatorOrg: intel.com
X-Spam-Status: No, score=2.7 required=5.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED,
	DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,
	MAILING_LIST_MULTI,RCVD_IN_SBL_CSS,SPF_HELO_NONE,SPF_PASS autolearn=no
	autolearn_force=no version=3.4.6
X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on pete.vger.email
Precedence: bulk
List-ID: <linux-kernel.vger.kernel.org>
X-Mailing-List: linux-kernel@vger.kernel.org
X-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (pete.vger.email [0.0.0.0]); Sun, 08 Oct 2023 22:15:10 -0700 (PDT)
X-Spam-Level: **

On 2023-09-30 at 07:45:38 -0400, Mathieu Desnoyers wrote:
> On 9/30/23 03:11, Chen Yu wrote:
> > Hi Mathieu,
> > 
> > On 2023-09-29 at 14:33:50 -0400, Mathieu Desnoyers wrote:
> > > Introduce the WAKEUP_BIAS_PREV_IDLE scheduler feature. It biases
> > > select_task_rq towards the previous CPU if it was almost idle
> > > (avg_load <= 0.1%).
> > 
> > Yes, this is a promising direction IMO. One question is that,
> > can cfs_rq->avg.load_avg be used for percentage comparison?
> > If I understand correctly, load_avg reflects that more than
> > 1 tasks could have been running this runqueue, and the
> > load_avg is the direct proportion to the load_weight of that
> > cfs_rq. Besides, LOAD_AVG_MAX seems to not be the max value
> > that load_avg can reach, it is the sum of
> > 1024 * (y + y^1 + y^2 ... )
> > 
> > For example,
> > taskset -c 1 nice -n -20 stress -c 1
> > cat /sys/kernel/debug/sched/debug | grep 'cfs_rq\[1\]' -A 12 | grep "\.load_avg"
> >    .load_avg                      : 88763
> >    .load_avg                      : 1024
> > 
> > 88763 is higher than LOAD_AVG_MAX=47742
> 
> I would have expected the load_avg to be limited to LOAD_AVG_MAX somehow,
> but it appears that it does not happen in practice.
> 
> That being said, if the cutoff is really at 0.1% or 0.2% of the real max,
> does it really matter ?
> 
> > Maybe the util_avg can be used for precentage comparison I suppose?
> [...]
> > Or
> > return cpu_util_without(cpu_rq(cpu), p) * 1000 <= capacity_orig_of(cpu) ?
> 
> Unfortunately using util_avg does not seem to work based on my testing.
> Even at utilization thresholds at 0.1%, 1% and 10%.
> 
> Based on comments in fair.c:
> 
>  * CPU utilization is the sum of running time of runnable tasks plus the
>  * recent utilization of currently non-runnable tasks on that CPU.
> 
> I think we don't want to include currently non-runnable tasks in the
> statistics we use, because we are trying to figure out if the cpu is a
> idle-enough target based on the tasks which are currently running, for the
> purpose of runqueue selection when waking up a task which is considered at
> that point in time a non-runnable task on that cpu, and which is about to
> become runnable again.
>

Although LOAD_AVG_MAX is not the max possible load_avg, we still want to find
a proper threshold to decide if the CPU is almost idle. The LOAD_AVG_MAX
based threshold is modified a little bit:

The theory is, if there is only 1 task on the CPU, and that task has a nice
of 0, the task runs 50 us every 1000 us, then this CPU is regarded as almost
idle.

The load_sum of the task is:
50 * (1 + y + y^2 + ... + y^n)
The corresponding avg_load of the task is approximately
NICE_0_WEIGHT * load_sum / LOAD_AVG_MAX = 50.
So:

/* which is close to LOAD_AVG_MAX/1000 = 47 */
#define ALMOST_IDLE_CPU_LOAD   50

static bool
almost_idle_cpu(int cpu, struct task_struct *p)
{
       if (!sched_feat(WAKEUP_BIAS_PREV_IDLE))
               return false;
       return cpu_load_without(cpu_rq(cpu), p) <= ALMOST_IDLE_CPU_LOAD;
}

Tested this on Intel Xeon Platinum 8360Y, Ice Lake server, 36 core/package,
total 72 core/144 CPUs. Slight improvement is observed in hackbench socket mode:

socket mode:
hackbench -g 16 -f 20 -l 480000 -s 100

Before patch:
Running in process mode with 16 groups using 40 file descriptors each (== 640 tasks)
Each sender will pass 480000 messages of 100 bytes
Time: 81.084

After patch:
Running in process mode with 16 groups using 40 file descriptors each (== 640 tasks)
Each sender will pass 480000 messages of 100 bytes
Time: 78.083


pipe mode:
hackbench -g 16 -f 20 --pipe  -l 480000 -s 100

Before patch:
Running in process mode with 16 groups using 40 file descriptors each (== 640 tasks)
Each sender will pass 480000 messages of 100 bytes
Time: 38.219

After patch:
Running in process mode with 16 groups using 40 file descriptors each (== 640 tasks)
Each sender will pass 480000 messages of 100 bytes
Time: 38.348

It suggests that, if the workload has larger working-set/cache footprint, waking up
the task on its previous CPU could get more benefit.

thanks,
Chenyu