* [PATCH v2 0/3] Preventing job distribution to isolated CPUs
@ 2020-06-22 23:45 Nitesh Narayan Lal
2020-06-22 23:45 ` [Patch v2 1/3] lib: Restrict cpumask_local_spread to houskeeping CPUs Nitesh Narayan Lal
` (3 more replies)
0 siblings, 4 replies; 9+ messages in thread
From: Nitesh Narayan Lal @ 2020-06-22 23:45 UTC (permalink / raw)
To: linux-kernel, linux-api, frederic, mtosatti, juri.lelli, abelits,
bhelgaas, linux-pci, rostedt, mingo, peterz, tglx, davem, akpm,
sfr, stephen, rppt
Testing
=======
* Patch 1:
Fix for cpumask_local_spread() is tested by creating VFs, loading
iavf module and by adding a tracepoint to confirm that only housekeeping
CPUs are picked when an appropriate profile is set up and all remaining
CPUs when no CPU isolation is configured.
* Patch 2:
To test the PCI fix, I hotplugged a virtio-net-pci from qemu console
and forced its addition to a specific node to trigger the code path that
includes the proposed fix and verified that only housekeeping CPUs
are included via tracepoint.
* Patch 3:
To test the fix in store_rps_map(), I tried configuring an isolated
CPU by writing to /sys/class/net/en*/queues/rx*/rps_cpus which
resulted in 'write error: Invalid argument' error. For the case
where a non-isolated CPU is writing in rps_cpus the above operation
succeeded without any error.
Changes from v1:
===============
- Included the suggestions made by Bjorn Helgaas in the commit messages.
- Included the 'Reviewed-by' and 'Acked-by' received for Patch-2.
[1] https://patchwork.ozlabs.org/project/netdev/patch/51102eebe62336c6a4e584c7a503553b9f90e01c.camel@marvell.com/
Alex Belits (3):
lib: Restrict cpumask_local_spread to houskeeping CPUs
PCI: Restrict probe functions to housekeeping CPUs
net: Restrict receive packets queuing to housekeeping CPUs
drivers/pci/pci-driver.c | 5 ++++-
lib/cpumask.c | 43 +++++++++++++++++++++++-----------------
net/core/net-sysfs.c | 10 +++++++++-
3 files changed, 38 insertions(+), 20 deletions(-)
--
^ permalink raw reply [flat|nested] 9+ messages in thread
* [Patch v2 1/3] lib: Restrict cpumask_local_spread to houskeeping CPUs
2020-06-22 23:45 [PATCH v2 0/3] Preventing job distribution to isolated CPUs Nitesh Narayan Lal
@ 2020-06-22 23:45 ` Nitesh Narayan Lal
2020-06-23 9:21 ` Peter Zijlstra
2020-06-22 23:45 ` [Patch v2 2/3] PCI: Restrict probe functions to housekeeping CPUs Nitesh Narayan Lal
` (2 subsequent siblings)
3 siblings, 1 reply; 9+ messages in thread
From: Nitesh Narayan Lal @ 2020-06-22 23:45 UTC (permalink / raw)
To: linux-kernel, linux-api, frederic, mtosatti, juri.lelli, abelits,
bhelgaas, linux-pci, rostedt, mingo, peterz, tglx, davem, akpm,
sfr, stephen, rppt
From: Alex Belits <abelits@marvell.com>
The current implementation of cpumask_local_spread() does not respect the
isolated CPUs, i.e., even if a CPU has been isolated for Real-Time task,
it will return it to the caller for pinning of its IRQ threads. Having
these unwanted IRQ threads on an isolated CPU adds up to a latency
overhead.
Restrict the CPUs that are returned for spreading IRQs only to the
available housekeeping CPUs.
Signed-off-by: Alex Belits <abelits@marvell.com>
Signed-off-by: Nitesh Narayan Lal <nitesh@redhat.com>
---
lib/cpumask.c | 43 +++++++++++++++++++++++++------------------
1 file changed, 25 insertions(+), 18 deletions(-)
diff --git a/lib/cpumask.c b/lib/cpumask.c
index fb22fb266f93..cc4311a8c079 100644
--- a/lib/cpumask.c
+++ b/lib/cpumask.c
@@ -6,6 +6,7 @@
#include <linux/export.h>
#include <linux/memblock.h>
#include <linux/numa.h>
+#include <linux/sched/isolation.h>
/**
* cpumask_next - get the next cpu in a cpumask
@@ -205,28 +206,34 @@ void __init free_bootmem_cpumask_var(cpumask_var_t mask)
*/
unsigned int cpumask_local_spread(unsigned int i, int node)
{
- int cpu;
+ int cpu, m, n, hk_flags;
+ const struct cpumask *mask;
+ hk_flags = HK_FLAG_DOMAIN | HK_FLAG_WQ;
+ mask = housekeeping_cpumask(hk_flags);
+ m = cpumask_weight(mask);
/* Wrap: we always want a cpu. */
- i %= num_online_cpus();
+ n = i % m;
+ while (m-- > 0) {
+ if (node == NUMA_NO_NODE) {
+ for_each_cpu(cpu, mask)
+ if (n-- == 0)
+ return cpu;
+ } else {
+ /* NUMA first. */
+ for_each_cpu_and(cpu, cpumask_of_node(node), mask)
+ if (n-- == 0)
+ return cpu;
- if (node == NUMA_NO_NODE) {
- for_each_cpu(cpu, cpu_online_mask)
- if (i-- == 0)
- return cpu;
- } else {
- /* NUMA first. */
- for_each_cpu_and(cpu, cpumask_of_node(node), cpu_online_mask)
- if (i-- == 0)
- return cpu;
+ for_each_cpu(cpu, mask) {
+ /* Skip NUMA nodes, done above. */
+ if (cpumask_test_cpu(cpu,
+ cpumask_of_node(node)))
+ continue;
- for_each_cpu(cpu, cpu_online_mask) {
- /* Skip NUMA nodes, done above. */
- if (cpumask_test_cpu(cpu, cpumask_of_node(node)))
- continue;
-
- if (i-- == 0)
- return cpu;
+ if (n-- == 0)
+ return cpu;
+ }
}
}
BUG();
--
2.18.4
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [Patch v2 2/3] PCI: Restrict probe functions to housekeeping CPUs
2020-06-22 23:45 [PATCH v2 0/3] Preventing job distribution to isolated CPUs Nitesh Narayan Lal
2020-06-22 23:45 ` [Patch v2 1/3] lib: Restrict cpumask_local_spread to houskeeping CPUs Nitesh Narayan Lal
@ 2020-06-22 23:45 ` Nitesh Narayan Lal
2020-06-22 23:45 ` [Patch v2 3/3] net: Restrict receive packets queuing " Nitesh Narayan Lal
2020-06-23 1:03 ` [PATCH v2 0/3] Preventing job distribution to isolated CPUs Nitesh Narayan Lal
3 siblings, 0 replies; 9+ messages in thread
From: Nitesh Narayan Lal @ 2020-06-22 23:45 UTC (permalink / raw)
To: linux-kernel, linux-api, frederic, mtosatti, juri.lelli, abelits,
bhelgaas, linux-pci, rostedt, mingo, peterz, tglx, davem, akpm,
sfr, stephen, rppt
From: Alex Belits <abelits@marvell.com>
pci_call_probe() prevents the nesting of work_on_cpu() for a scenario
where a VF device is probed from work_on_cpu() of the PF.
Replace the cpumask used in pci_call_probe() from all online CPUs to only
housekeeping CPUs. This is to ensure that there are no additional latency
overheads caused due to the pinning of jobs on isolated CPUs.
Signed-off-by: Alex Belits <abelits@marvell.com>
Signed-off-by: Nitesh Narayan Lal <nitesh@redhat.com>
Acked-by: Bjorn Helgaas <bhelgaas@google.com>
Reviewed-by: Frederic Weisbecker <frederic@kernel.org>
---
drivers/pci/pci-driver.c | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index da6510af1221..449466f71040 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -12,6 +12,7 @@
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/sched.h>
+#include <linux/sched/isolation.h>
#include <linux/cpu.h>
#include <linux/pm_runtime.h>
#include <linux/suspend.h>
@@ -333,6 +334,7 @@ static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
const struct pci_device_id *id)
{
int error, node, cpu;
+ int hk_flags = HK_FLAG_DOMAIN | HK_FLAG_WQ;
struct drv_dev_and_id ddi = { drv, dev, id };
/*
@@ -353,7 +355,8 @@ static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
pci_physfn_is_probed(dev))
cpu = nr_cpu_ids;
else
- cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
+ cpu = cpumask_any_and(cpumask_of_node(node),
+ housekeeping_cpumask(hk_flags));
if (cpu < nr_cpu_ids)
error = work_on_cpu(cpu, local_pci_probe, &ddi);
--
2.18.4
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [Patch v2 3/3] net: Restrict receive packets queuing to housekeeping CPUs
2020-06-22 23:45 [PATCH v2 0/3] Preventing job distribution to isolated CPUs Nitesh Narayan Lal
2020-06-22 23:45 ` [Patch v2 1/3] lib: Restrict cpumask_local_spread to houskeeping CPUs Nitesh Narayan Lal
2020-06-22 23:45 ` [Patch v2 2/3] PCI: Restrict probe functions to housekeeping CPUs Nitesh Narayan Lal
@ 2020-06-22 23:45 ` Nitesh Narayan Lal
2020-06-23 9:23 ` Peter Zijlstra
2020-06-23 1:03 ` [PATCH v2 0/3] Preventing job distribution to isolated CPUs Nitesh Narayan Lal
3 siblings, 1 reply; 9+ messages in thread
From: Nitesh Narayan Lal @ 2020-06-22 23:45 UTC (permalink / raw)
To: linux-kernel, linux-api, frederic, mtosatti, juri.lelli, abelits,
bhelgaas, linux-pci, rostedt, mingo, peterz, tglx, davem, akpm,
sfr, stephen, rppt
From: Alex Belits <abelits@marvell.com>
With the existing implementation of store_rps_map(), packets are queued
in the receive path on the backlog queues of other CPUs irrespective of
whether they are isolated or not. This could add a latency overhead to
any RT workload that is running on the same CPU.
Ensure that store_rps_map() only uses available housekeeping CPUs for
storing the rps_map.
Signed-off-by: Alex Belits <abelits@marvell.com>
Signed-off-by: Nitesh Narayan Lal <nitesh@redhat.com>
---
net/core/net-sysfs.c | 10 +++++++++-
1 file changed, 9 insertions(+), 1 deletion(-)
diff --git a/net/core/net-sysfs.c b/net/core/net-sysfs.c
index e353b822bb15..16e433287191 100644
--- a/net/core/net-sysfs.c
+++ b/net/core/net-sysfs.c
@@ -11,6 +11,7 @@
#include <linux/if_arp.h>
#include <linux/slab.h>
#include <linux/sched/signal.h>
+#include <linux/sched/isolation.h>
#include <linux/nsproxy.h>
#include <net/sock.h>
#include <net/net_namespace.h>
@@ -741,7 +742,7 @@ static ssize_t store_rps_map(struct netdev_rx_queue *queue,
{
struct rps_map *old_map, *map;
cpumask_var_t mask;
- int err, cpu, i;
+ int err, cpu, i, hk_flags;
static DEFINE_MUTEX(rps_map_mutex);
if (!capable(CAP_NET_ADMIN))
@@ -756,6 +757,13 @@ static ssize_t store_rps_map(struct netdev_rx_queue *queue,
return err;
}
+ hk_flags = HK_FLAG_DOMAIN | HK_FLAG_WQ;
+ cpumask_and(mask, mask, housekeeping_cpumask(hk_flags));
+ if (cpumask_weight(mask) == 0) {
+ free_cpumask_var(mask);
+ return -EINVAL;
+ }
+
map = kzalloc(max_t(unsigned int,
RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES),
GFP_KERNEL);
--
2.18.4
^ permalink raw reply related [flat|nested] 9+ messages in thread
* Re: [PATCH v2 0/3] Preventing job distribution to isolated CPUs
2020-06-22 23:45 [PATCH v2 0/3] Preventing job distribution to isolated CPUs Nitesh Narayan Lal
` (2 preceding siblings ...)
2020-06-22 23:45 ` [Patch v2 3/3] net: Restrict receive packets queuing " Nitesh Narayan Lal
@ 2020-06-23 1:03 ` Nitesh Narayan Lal
3 siblings, 0 replies; 9+ messages in thread
From: Nitesh Narayan Lal @ 2020-06-23 1:03 UTC (permalink / raw)
To: linux-kernel, linux-api, frederic, mtosatti, juri.lelli, abelits,
bhelgaas, linux-pci, rostedt, mingo, peterz, tglx, davem, akpm,
sfr, stephen, rppt
[-- Attachment #1.1: Type: text/plain, Size: 7037 bytes --]
On 6/22/20 7:45 PM, Nitesh Narayan Lal wrote:
>
> Testing
> =======
> * Patch 1:
> Fix for cpumask_local_spread() is tested by creating VFs, loading
> iavf module and by adding a tracepoint to confirm that only housekeeping
> CPUs are picked when an appropriate profile is set up and all remaining
> CPUs when no CPU isolation is configured.
>
> * Patch 2:
> To test the PCI fix, I hotplugged a virtio-net-pci from qemu console
> and forced its addition to a specific node to trigger the code path that
> includes the proposed fix and verified that only housekeeping CPUs
> are included via tracepoint.
>
> * Patch 3:
> To test the fix in store_rps_map(), I tried configuring an isolated
> CPU by writing to /sys/class/net/en*/queues/rx*/rps_cpus which
> resulted in 'write error: Invalid argument' error. For the case
> where a non-isolated CPU is writing in rps_cpus the above operation
> succeeded without any error.
>
>
> Changes from v1:
> ===============
> - Included the suggestions made by Bjorn Helgaas in the commit messages.
> - Included the 'Reviewed-by' and 'Acked-by' received for Patch-2.
>
> [1] https://patchwork.ozlabs.org/project/netdev/patch/51102eebe62336c6a4e584c7a503553b9f90e01c.camel@marvell.com/
>
> Alex Belits (3):
> lib: Restrict cpumask_local_spread to houskeeping CPUs
> PCI: Restrict probe functions to housekeeping CPUs
> net: Restrict receive packets queuing to housekeeping CPUs
>
> drivers/pci/pci-driver.c | 5 ++++-
> lib/cpumask.c | 43 +++++++++++++++++++++++-----------------
> net/core/net-sysfs.c | 10 +++++++++-
> 3 files changed, 38 insertions(+), 20 deletions(-)
>
> --
>
Hi,
It seems that the cover email got messed up while I was sending the patches.
I am putting my intended cover-email below for now. I can send a v3 with proper
cover-email if needed. The reason, I am not sending it right now, is that if I
get some comments in my patches I will prefer including them as well in my
v3 posting.
"
This patch-set is originated from one of the patches that have been
posted earlier as a part of "Task_isolation" mode [1] patch series
by Alex Belits <abelits@marvell.com>. There are only a couple of
changes that I am proposing in this patch-set compared to what Alex
has posted earlier.
Context
=======
On a broad level, all three patches that are included in this patch
set are meant to improve the driver/library to respect isolated
CPUs by not pinning any job on it. Not doing so could impact
the latency values in RT use-cases.
Patches
=======
* Patch1:
The first patch is meant to make cpumask_local_spread()
aware of the isolated CPUs. It ensures that the CPUs that
are returned by this API only includes housekeeping CPUs.
* Patch2:
This patch ensures that a probe function that is called
using work_on_cpu() doesn't run any task on an isolated CPU.
* Patch3:
This patch makes store_rps_map() aware of the isolated
CPUs so that rps don't queue any jobs on an isolated CPU.
Proposed Changes
================
To fix the above-mentioned issues Alex has used housekeeping_cpumask().
The only changes that I am proposing here are:
- Removing the dependency on CONFIG_TASK_ISOLATION that was proposed by
Alex. As it should be safe to rely on housekeeping_cpumask()
even when we don't have any isolated CPUs and we want
to fall back to using all available CPUs in any of the above scenarios.
- Using both HK_FLAG_DOMAIN and HK_FLAG_WQ in all three patches, this is
because we would want the above fixes not only when we have isolcpus but
also with something like systemd's CPU affinity.
Testing
=======
* Patch 1:
Fix for cpumask_local_spread() is tested by creating VFs, loading
iavf module and by adding a tracepoint to confirm that only housekeeping
CPUs are picked when an appropriate profile is set up and all remaining
CPUs when no CPU isolation is configured.
* Patch 2:
To test the PCI fix, I hotplugged a virtio-net-pci from qemu console
and forced its addition to a specific node to trigger the code path that
includes the proposed fix and verified that only housekeeping CPUs
are included via tracepoint.
* Patch 3:
To test the fix in store_rps_map(), I tried configuring an isolated
CPU by writing to /sys/class/net/en*/queues/rx*/rps_cpus which
resulted in 'write error: Invalid argument' error. For the case
where a non-isolated CPU is writing in rps_cpus the above operation
succeeded without any error.
Changes from v1: [2]
===============
- Included the suggestions made by Bjorn Helgaas in the commit message.
- Included the 'Reviewed-by' and 'Acked-by' received for Patch-2.
[1]
https://patchwork.ozlabs.org/project/netdev/patch/51102eebe62336c6a4e584c7a503553b9f90e01c.camel@marvell.com/
[2]
https://patchwork.ozlabs.org/project/linux-pci/cover/20200610161226.424337-1-nitesh@redhat.com/
Alex Belits (3):
lib: Restrict cpumask_local_spread to houskeeping CPUs
PCI: Restrict probe functions to housekeeping CPUs
net: Restrict receive packets queuing to housekeeping CPUs
drivers/pci/pci-driver.c | 5 ++++-
lib/cpumask.c | 43 +++++++++++++++++++++++-----------------
net/core/net-sysfs.c | 10 +++++++++-
3 files changed, 38 insertions(+), 20 deletions(-)
--
"
--
Thanks
Nitesh
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [Patch v2 1/3] lib: Restrict cpumask_local_spread to houskeeping CPUs
2020-06-22 23:45 ` [Patch v2 1/3] lib: Restrict cpumask_local_spread to houskeeping CPUs Nitesh Narayan Lal
@ 2020-06-23 9:21 ` Peter Zijlstra
2020-06-23 13:18 ` Nitesh Narayan Lal
0 siblings, 1 reply; 9+ messages in thread
From: Peter Zijlstra @ 2020-06-23 9:21 UTC (permalink / raw)
To: Nitesh Narayan Lal
Cc: linux-kernel, linux-api, frederic, mtosatti, juri.lelli, abelits,
bhelgaas, linux-pci, rostedt, mingo, tglx, davem, akpm, sfr,
stephen, rppt
On Mon, Jun 22, 2020 at 07:45:08PM -0400, Nitesh Narayan Lal wrote:
> From: Alex Belits <abelits@marvell.com>
>
> The current implementation of cpumask_local_spread() does not respect the
> isolated CPUs, i.e., even if a CPU has been isolated for Real-Time task,
> it will return it to the caller for pinning of its IRQ threads. Having
> these unwanted IRQ threads on an isolated CPU adds up to a latency
> overhead.
>
> Restrict the CPUs that are returned for spreading IRQs only to the
> available housekeeping CPUs.
>
> Signed-off-by: Alex Belits <abelits@marvell.com>
> Signed-off-by: Nitesh Narayan Lal <nitesh@redhat.com>
> ---
> lib/cpumask.c | 43 +++++++++++++++++++++++++------------------
> 1 file changed, 25 insertions(+), 18 deletions(-)
>
> diff --git a/lib/cpumask.c b/lib/cpumask.c
> index fb22fb266f93..cc4311a8c079 100644
> --- a/lib/cpumask.c
> +++ b/lib/cpumask.c
> @@ -6,6 +6,7 @@
> #include <linux/export.h>
> #include <linux/memblock.h>
> #include <linux/numa.h>
> +#include <linux/sched/isolation.h>
>
> /**
> * cpumask_next - get the next cpu in a cpumask
> @@ -205,28 +206,34 @@ void __init free_bootmem_cpumask_var(cpumask_var_t mask)
> */
> unsigned int cpumask_local_spread(unsigned int i, int node)
> {
> - int cpu;
> + int cpu, m, n, hk_flags;
> + const struct cpumask *mask;
>
> + hk_flags = HK_FLAG_DOMAIN | HK_FLAG_WQ;
> + mask = housekeeping_cpumask(hk_flags);
> + m = cpumask_weight(mask);
> /* Wrap: we always want a cpu. */
> - i %= num_online_cpus();
> + n = i % m;
> + while (m-- > 0) {
I are confuzled. What do we need this outer loop for?
Why isn't something like:
i %= cpumask_weight(mask);
good enough? That voids having to touch the test.
Still when you're there, at the very least you can fix the horrible
style:
> + if (node == NUMA_NO_NODE) {
> + for_each_cpu(cpu, mask)
> + if (n-- == 0)
> + return cpu;
{ }
> + } else {
> + /* NUMA first. */
> + for_each_cpu_and(cpu, cpumask_of_node(node), mask)
> + if (n-- == 0)
> + return cpu;
{ }
>
> + for_each_cpu(cpu, mask) {
> + /* Skip NUMA nodes, done above. */
> + if (cpumask_test_cpu(cpu,
> + cpumask_of_node(node)))
> + continue;
No linebreak please.
>
> + if (n-- == 0)
> + return cpu;
> + }
> }
> }
> BUG();
> --
> 2.18.4
>
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [Patch v2 3/3] net: Restrict receive packets queuing to housekeeping CPUs
2020-06-22 23:45 ` [Patch v2 3/3] net: Restrict receive packets queuing " Nitesh Narayan Lal
@ 2020-06-23 9:23 ` Peter Zijlstra
2020-06-23 11:42 ` Nitesh Narayan Lal
0 siblings, 1 reply; 9+ messages in thread
From: Peter Zijlstra @ 2020-06-23 9:23 UTC (permalink / raw)
To: Nitesh Narayan Lal
Cc: linux-kernel, linux-api, frederic, mtosatti, juri.lelli, abelits,
bhelgaas, linux-pci, rostedt, mingo, tglx, davem, akpm, sfr,
stephen, rppt
On Mon, Jun 22, 2020 at 07:45:10PM -0400, Nitesh Narayan Lal wrote:
> @@ -756,6 +757,13 @@ static ssize_t store_rps_map(struct netdev_rx_queue *queue,
> return err;
> }
>
> + hk_flags = HK_FLAG_DOMAIN | HK_FLAG_WQ;
> + cpumask_and(mask, mask, housekeeping_cpumask(hk_flags));
> + if (cpumask_weight(mask) == 0) {
We have cpumask_empty() for that, which is a much more efficient way of
testing the same.
> + free_cpumask_var(mask);
> + return -EINVAL;
> + }
> +
> map = kzalloc(max_t(unsigned int,
> RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES),
> GFP_KERNEL);
> --
> 2.18.4
>
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [Patch v2 3/3] net: Restrict receive packets queuing to housekeeping CPUs
2020-06-23 9:23 ` Peter Zijlstra
@ 2020-06-23 11:42 ` Nitesh Narayan Lal
0 siblings, 0 replies; 9+ messages in thread
From: Nitesh Narayan Lal @ 2020-06-23 11:42 UTC (permalink / raw)
To: Peter Zijlstra
Cc: linux-kernel, linux-api, frederic, mtosatti, juri.lelli, abelits,
bhelgaas, linux-pci, rostedt, mingo, tglx, davem, akpm, sfr,
stephen, rppt
[-- Attachment #1.1: Type: text/plain, Size: 769 bytes --]
On 6/23/20 5:23 AM, Peter Zijlstra wrote:
> On Mon, Jun 22, 2020 at 07:45:10PM -0400, Nitesh Narayan Lal wrote:
>> @@ -756,6 +757,13 @@ static ssize_t store_rps_map(struct netdev_rx_queue *queue,
>> return err;
>> }
>>
>> + hk_flags = HK_FLAG_DOMAIN | HK_FLAG_WQ;
>> + cpumask_and(mask, mask, housekeeping_cpumask(hk_flags));
>> + if (cpumask_weight(mask) == 0) {
> We have cpumask_empty() for that, which is a much more efficient way of
> testing the same.
Yes, right.
I will make this change.
>
>> + free_cpumask_var(mask);
>> + return -EINVAL;
>> + }
>> +
>> map = kzalloc(max_t(unsigned int,
>> RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES),
>> GFP_KERNEL);
>> --
>> 2.18.4
>>
--
Thanks
Nitesh
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [Patch v2 1/3] lib: Restrict cpumask_local_spread to houskeeping CPUs
2020-06-23 9:21 ` Peter Zijlstra
@ 2020-06-23 13:18 ` Nitesh Narayan Lal
0 siblings, 0 replies; 9+ messages in thread
From: Nitesh Narayan Lal @ 2020-06-23 13:18 UTC (permalink / raw)
To: Peter Zijlstra
Cc: linux-kernel, linux-api, frederic, mtosatti, juri.lelli, abelits,
bhelgaas, linux-pci, rostedt, mingo, tglx, davem, akpm, sfr,
stephen, rppt
[-- Attachment #1.1: Type: text/plain, Size: 2597 bytes --]
On 6/23/20 5:21 AM, Peter Zijlstra wrote:
> On Mon, Jun 22, 2020 at 07:45:08PM -0400, Nitesh Narayan Lal wrote:
>> From: Alex Belits <abelits@marvell.com>
>>
>> The current implementation of cpumask_local_spread() does not respect the
>> isolated CPUs, i.e., even if a CPU has been isolated for Real-Time task,
>> it will return it to the caller for pinning of its IRQ threads. Having
>> these unwanted IRQ threads on an isolated CPU adds up to a latency
>> overhead.
>>
>> Restrict the CPUs that are returned for spreading IRQs only to the
>> available housekeeping CPUs.
>>
>> Signed-off-by: Alex Belits <abelits@marvell.com>
>> Signed-off-by: Nitesh Narayan Lal <nitesh@redhat.com>
>> ---
>> lib/cpumask.c | 43 +++++++++++++++++++++++++------------------
>> 1 file changed, 25 insertions(+), 18 deletions(-)
>>
>> diff --git a/lib/cpumask.c b/lib/cpumask.c
>> index fb22fb266f93..cc4311a8c079 100644
>> --- a/lib/cpumask.c
>> +++ b/lib/cpumask.c
>> @@ -6,6 +6,7 @@
>> #include <linux/export.h>
>> #include <linux/memblock.h>
>> #include <linux/numa.h>
>> +#include <linux/sched/isolation.h>
>>
>> /**
>> * cpumask_next - get the next cpu in a cpumask
>> @@ -205,28 +206,34 @@ void __init free_bootmem_cpumask_var(cpumask_var_t mask)
>> */
>> unsigned int cpumask_local_spread(unsigned int i, int node)
>> {
>> - int cpu;
>> + int cpu, m, n, hk_flags;
>> + const struct cpumask *mask;
>>
>> + hk_flags = HK_FLAG_DOMAIN | HK_FLAG_WQ;
>> + mask = housekeeping_cpumask(hk_flags);
>> + m = cpumask_weight(mask);
>> /* Wrap: we always want a cpu. */
>> - i %= num_online_cpus();
>> + n = i % m;
>> + while (m-- > 0) {
> I are confuzled. What do we need this outer loop for?
>
> Why isn't something like:
>
> i %= cpumask_weight(mask);
>
> good enough? That voids having to touch the test.
Makes sense.
Thanks
> Still when you're there, at the very least you can fix the horrible
> style:
Sure.
>
>
>> + if (node == NUMA_NO_NODE) {
>> + for_each_cpu(cpu, mask)
>> + if (n-- == 0)
>> + return cpu;
> { }
>
>> + } else {
>> + /* NUMA first. */
>> + for_each_cpu_and(cpu, cpumask_of_node(node), mask)
>> + if (n-- == 0)
>> + return cpu;
> { }
>
>>
>> + for_each_cpu(cpu, mask) {
>> + /* Skip NUMA nodes, done above. */
>> + if (cpumask_test_cpu(cpu,
>> + cpumask_of_node(node)))
>> + continue;
> No linebreak please.
>
>>
>> + if (n-- == 0)
>> + return cpu;
>> + }
>> }
>> }
>> BUG();
>> --
>> 2.18.4
>>
--
Nitesh
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2020-06-23 13:19 UTC | newest]
Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-06-22 23:45 [PATCH v2 0/3] Preventing job distribution to isolated CPUs Nitesh Narayan Lal
2020-06-22 23:45 ` [Patch v2 1/3] lib: Restrict cpumask_local_spread to houskeeping CPUs Nitesh Narayan Lal
2020-06-23 9:21 ` Peter Zijlstra
2020-06-23 13:18 ` Nitesh Narayan Lal
2020-06-22 23:45 ` [Patch v2 2/3] PCI: Restrict probe functions to housekeeping CPUs Nitesh Narayan Lal
2020-06-22 23:45 ` [Patch v2 3/3] net: Restrict receive packets queuing " Nitesh Narayan Lal
2020-06-23 9:23 ` Peter Zijlstra
2020-06-23 11:42 ` Nitesh Narayan Lal
2020-06-23 1:03 ` [PATCH v2 0/3] Preventing job distribution to isolated CPUs Nitesh Narayan Lal
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).