| Message ID | 20230217100606.1234-1-nbd@nbd.name (mailing list archive) |
|---|---|
| State | RFC |
| Delegated to: | Netdev Maintainers |
| Headers | show |
| Series | [RFC,v2] net/core: add optional threading for rps backlog processing | expand |
On Fri, Feb 17, 2023 at 11:06 AM Felix Fietkau <nbd@nbd.name> wrote: > > When dealing with few flows or an imbalance on CPU utilization, static RPS > CPU assignment can be too inflexible. Add support for enabling threaded NAPI > for RPS backlog processing in order to allow the scheduler to better balance > processing. This helps better spread the load across idle CPUs. > > Signed-off-by: Felix Fietkau <nbd@nbd.name> > --- > > RFC v2: > - fix rebase error in rps locking Why only deal with RPS ? It seems you propose the sofnet_data backlog be processed by a thread, instead than from softirq ?
On 17.02.23 13:23, Eric Dumazet wrote: > On Fri, Feb 17, 2023 at 11:06 AM Felix Fietkau <nbd@nbd.name> wrote: >> >> When dealing with few flows or an imbalance on CPU utilization, static RPS >> CPU assignment can be too inflexible. Add support for enabling threaded NAPI >> for RPS backlog processing in order to allow the scheduler to better balance >> processing. This helps better spread the load across idle CPUs. >> >> Signed-off-by: Felix Fietkau <nbd@nbd.name> >> --- >> >> RFC v2: >> - fix rebase error in rps locking > > Why only deal with RPS ? > > It seems you propose the sofnet_data backlog be processed by a thread, > instead than from softirq ? Right. I originally wanted to mainly improve RPS, but my patch does cover backlog in general. I will update the description in the next version. Does the approach in general make sense to you? Thanks, - Felix
On Fri, Feb 17, 2023 at 1:35 PM Felix Fietkau <nbd@nbd.name> wrote: > > On 17.02.23 13:23, Eric Dumazet wrote: > > On Fri, Feb 17, 2023 at 11:06 AM Felix Fietkau <nbd@nbd.name> wrote: > >> > >> When dealing with few flows or an imbalance on CPU utilization, static RPS > >> CPU assignment can be too inflexible. Add support for enabling threaded NAPI > >> for RPS backlog processing in order to allow the scheduler to better balance > >> processing. This helps better spread the load across idle CPUs. > >> > >> Signed-off-by: Felix Fietkau <nbd@nbd.name> > >> --- > >> > >> RFC v2: > >> - fix rebase error in rps locking > > > > Why only deal with RPS ? > > > > It seems you propose the sofnet_data backlog be processed by a thread, > > instead than from softirq ? > Right. I originally wanted to mainly improve RPS, but my patch does > cover backlog in general. I will update the description in the next > version. Does the approach in general make sense to you? > I do not know, this seems to lack some (perf) numbers, and descriptions of added max latencies and stuff like that :)
On 17.02.23 13:57, Eric Dumazet wrote: > On Fri, Feb 17, 2023 at 1:35 PM Felix Fietkau <nbd@nbd.name> wrote: >> >> On 17.02.23 13:23, Eric Dumazet wrote: >> > On Fri, Feb 17, 2023 at 11:06 AM Felix Fietkau <nbd@nbd.name> wrote: >> >> >> >> When dealing with few flows or an imbalance on CPU utilization, static RPS >> >> CPU assignment can be too inflexible. Add support for enabling threaded NAPI >> >> for RPS backlog processing in order to allow the scheduler to better balance >> >> processing. This helps better spread the load across idle CPUs. >> >> >> >> Signed-off-by: Felix Fietkau <nbd@nbd.name> >> >> --- >> >> >> >> RFC v2: >> >> - fix rebase error in rps locking >> > >> > Why only deal with RPS ? >> > >> > It seems you propose the sofnet_data backlog be processed by a thread, >> > instead than from softirq ? >> Right. I originally wanted to mainly improve RPS, but my patch does >> cover backlog in general. I will update the description in the next >> version. Does the approach in general make sense to you? >> > > I do not know, this seems to lack some (perf) numbers, and > descriptions of added max latencies and stuff like that :) I just ran some test where I used a MT7621 device (dual-core 800 MHz MIPS, 4 threads) as a router doing NAT without flow offloading. Using the flent RRUL test between 2 PCs connected through the router, I get these results: rps_threaded=0: (combined CPU idle time around 27%) avg median 99th % # data pts Ping (ms) ICMP : 26.08 28.70 54.74 ms 199 Ping (ms) UDP BE : 1.96 24.12 37.28 ms 200 Ping (ms) UDP BK : 1.88 15.86 27.30 ms 200 Ping (ms) UDP EF : 1.98 31.77 54.10 ms 200 Ping (ms) avg : 1.94 N/A N/A ms 200 TCP download BE : 69.25 70.20 139.55 Mbits/s 200 TCP download BK : 95.15 92.51 163.93 Mbits/s 200 TCP download CS5 : 133.64 129.10 292.46 Mbits/s 200 TCP download EF : 129.86 127.70 254.47 Mbits/s 200 TCP download avg : 106.97 N/A N/A Mbits/s 200 TCP download sum : 427.90 N/A N/A Mbits/s 200 TCP totals : 864.43 N/A N/A Mbits/s 200 TCP upload BE : 97.54 96.67 163.99 Mbits/s 200 TCP upload BK : 139.76 143.88 190.37 Mbits/s 200 TCP upload CS5 : 97.52 94.70 206.60 Mbits/s 200 TCP upload EF : 101.71 106.72 147.88 Mbits/s 200 TCP upload avg : 109.13 N/A N/A Mbits/s 200 TCP upload sum : 436.53 N/A N/A Mbits/s 200 rps_threaded=1: (combined CPU idle time around 16%) avg median 99th % # data pts Ping (ms) ICMP : 13.70 16.10 27.60 ms 199 Ping (ms) UDP BE : 2.03 18.35 24.16 ms 200 Ping (ms) UDP BK : 2.03 18.36 29.13 ms 200 Ping (ms) UDP EF : 2.36 25.20 41.50 ms 200 Ping (ms) avg : 2.14 N/A N/A ms 200 TCP download BE : 118.69 120.94 160.12 Mbits/s 200 TCP download BK : 134.67 137.81 177.14 Mbits/s 200 TCP download CS5 : 126.15 127.81 174.84 Mbits/s 200 TCP download EF : 78.36 79.41 143.31 Mbits/s 200 TCP download avg : 114.47 N/A N/A Mbits/s 200 TCP download sum : 457.87 N/A N/A Mbits/s 200 TCP totals : 918.19 N/A N/A Mbits/s 200 TCP upload BE : 112.20 111.55 164.38 Mbits/s 200 TCP upload BK : 144.99 139.24 205.12 Mbits/s 200 TCP upload CS5 : 93.09 95.50 132.39 Mbits/s 200 TCP upload EF : 110.04 108.21 207.00 Mbits/s 200 TCP upload avg : 115.08 N/A N/A Mbits/s 200 TCP upload sum : 460.32 N/A N/A Mbits/s 200 As you can see, both throughput and latency improve because load can be better distributed across CPU cores. - Felix
On Fri, Feb 17, 2023 at 2:40 PM Felix Fietkau <nbd@nbd.name> wrote: > > On 17.02.23 13:57, Eric Dumazet wrote: > > On Fri, Feb 17, 2023 at 1:35 PM Felix Fietkau <nbd@nbd.name> wrote: > >> > >> On 17.02.23 13:23, Eric Dumazet wrote: > >> > On Fri, Feb 17, 2023 at 11:06 AM Felix Fietkau <nbd@nbd.name> wrote: > >> >> > >> >> When dealing with few flows or an imbalance on CPU utilization, static RPS > >> >> CPU assignment can be too inflexible. Add support for enabling threaded NAPI > >> >> for RPS backlog processing in order to allow the scheduler to better balance > >> >> processing. This helps better spread the load across idle CPUs. > >> >> > >> >> Signed-off-by: Felix Fietkau <nbd@nbd.name> > >> >> --- > >> >> > >> >> RFC v2: > >> >> - fix rebase error in rps locking > >> > > >> > Why only deal with RPS ? > >> > > >> > It seems you propose the sofnet_data backlog be processed by a thread, > >> > instead than from softirq ? > >> Right. I originally wanted to mainly improve RPS, but my patch does > >> cover backlog in general. I will update the description in the next > >> version. Does the approach in general make sense to you? > >> > > > > I do not know, this seems to lack some (perf) numbers, and > > descriptions of added max latencies and stuff like that :) > I just ran some test where I used a MT7621 device (dual-core 800 MHz > MIPS, 4 threads) as a router doing NAT without flow offloading. > > Using the flent RRUL test between 2 PCs connected through the router, > I get these results: > > rps_threaded=0: (combined CPU idle time around 27%) > avg median 99th % # data pts > Ping (ms) ICMP : 26.08 28.70 54.74 ms 199 > Ping (ms) UDP BE : 1.96 24.12 37.28 ms 200 > Ping (ms) UDP BK : 1.88 15.86 27.30 ms 200 > Ping (ms) UDP EF : 1.98 31.77 54.10 ms 200 > Ping (ms) avg : 1.94 N/A N/A ms 200 > TCP download BE : 69.25 70.20 139.55 Mbits/s 200 > TCP download BK : 95.15 92.51 163.93 Mbits/s 200 > TCP download CS5 : 133.64 129.10 292.46 Mbits/s 200 > TCP download EF : 129.86 127.70 254.47 Mbits/s 200 > TCP download avg : 106.97 N/A N/A Mbits/s 200 > TCP download sum : 427.90 N/A N/A Mbits/s 200 > TCP totals : 864.43 N/A N/A Mbits/s 200 > TCP upload BE : 97.54 96.67 163.99 Mbits/s 200 > TCP upload BK : 139.76 143.88 190.37 Mbits/s 200 > TCP upload CS5 : 97.52 94.70 206.60 Mbits/s 200 > TCP upload EF : 101.71 106.72 147.88 Mbits/s 200 > TCP upload avg : 109.13 N/A N/A Mbits/s 200 > TCP upload sum : 436.53 N/A N/A Mbits/s 200 > > rps_threaded=1: (combined CPU idle time around 16%) > avg median 99th % # data pts > Ping (ms) ICMP : 13.70 16.10 27.60 ms 199 > Ping (ms) UDP BE : 2.03 18.35 24.16 ms 200 > Ping (ms) UDP BK : 2.03 18.36 29.13 ms 200 > Ping (ms) UDP EF : 2.36 25.20 41.50 ms 200 > Ping (ms) avg : 2.14 N/A N/A ms 200 > TCP download BE : 118.69 120.94 160.12 Mbits/s 200 > TCP download BK : 134.67 137.81 177.14 Mbits/s 200 > TCP download CS5 : 126.15 127.81 174.84 Mbits/s 200 > TCP download EF : 78.36 79.41 143.31 Mbits/s 200 > TCP download avg : 114.47 N/A N/A Mbits/s 200 > TCP download sum : 457.87 N/A N/A Mbits/s 200 > TCP totals : 918.19 N/A N/A Mbits/s 200 > TCP upload BE : 112.20 111.55 164.38 Mbits/s 200 > TCP upload BK : 144.99 139.24 205.12 Mbits/s 200 > TCP upload CS5 : 93.09 95.50 132.39 Mbits/s 200 > TCP upload EF : 110.04 108.21 207.00 Mbits/s 200 > TCP upload avg : 115.08 N/A N/A Mbits/s 200 > TCP upload sum : 460.32 N/A N/A Mbits/s 200 > > As you can see, both throughput and latency improve because load can be > better distributed across CPU cores. > What happens if user threads are competing with your kthreads ? It seems you are adding another variant of ksoftirqd. More threads might look better in some cases, if we accept to be at the mercy of process scheduling decisions. NUMA affinities matter, I do not see how you are dealing with this. Your patch assumes all cpus can participate in network processing, but rps is fine grained: Boxes with 128 or 256 cpus usually have different rps_mask per receive queue, with 2 or 4 bits set in the per-rx-queue rps_mask. Then, process_backlog() has been designed to run only from the cpu tied to the per-cpu data (softnet_data) There are multiple comments about this assumption, and various things that would need to be changed (eg sd_has_rps_ipi_waiting() would be wrong in its current implementation)
On 17.02.23 15:38, Eric Dumazet wrote: > On Fri, Feb 17, 2023 at 2:40 PM Felix Fietkau <nbd@nbd.name> wrote: >> >> On 17.02.23 13:57, Eric Dumazet wrote: >> > On Fri, Feb 17, 2023 at 1:35 PM Felix Fietkau <nbd@nbd.name> wrote: >> >> >> >> On 17.02.23 13:23, Eric Dumazet wrote: >> >> > On Fri, Feb 17, 2023 at 11:06 AM Felix Fietkau <nbd@nbd.name> wrote: >> >> >> >> >> >> When dealing with few flows or an imbalance on CPU utilization, static RPS >> >> >> CPU assignment can be too inflexible. Add support for enabling threaded NAPI >> >> >> for RPS backlog processing in order to allow the scheduler to better balance >> >> >> processing. This helps better spread the load across idle CPUs. >> >> >> >> >> >> Signed-off-by: Felix Fietkau <nbd@nbd.name> >> >> >> --- >> >> >> >> >> >> RFC v2: >> >> >> - fix rebase error in rps locking >> >> > >> >> > Why only deal with RPS ? >> >> > >> >> > It seems you propose the sofnet_data backlog be processed by a thread, >> >> > instead than from softirq ? >> >> Right. I originally wanted to mainly improve RPS, but my patch does >> >> cover backlog in general. I will update the description in the next >> >> version. Does the approach in general make sense to you? >> >> >> > >> > I do not know, this seems to lack some (perf) numbers, and >> > descriptions of added max latencies and stuff like that :) >> I just ran some test where I used a MT7621 device (dual-core 800 MHz >> MIPS, 4 threads) as a router doing NAT without flow offloading. >> >> Using the flent RRUL test between 2 PCs connected through the router, >> I get these results: >> >> rps_threaded=0: (combined CPU idle time around 27%) >> avg median 99th % # data pts >> Ping (ms) ICMP : 26.08 28.70 54.74 ms 199 >> Ping (ms) UDP BE : 1.96 24.12 37.28 ms 200 >> Ping (ms) UDP BK : 1.88 15.86 27.30 ms 200 >> Ping (ms) UDP EF : 1.98 31.77 54.10 ms 200 >> Ping (ms) avg : 1.94 N/A N/A ms 200 >> TCP download BE : 69.25 70.20 139.55 Mbits/s 200 >> TCP download BK : 95.15 92.51 163.93 Mbits/s 200 >> TCP download CS5 : 133.64 129.10 292.46 Mbits/s 200 >> TCP download EF : 129.86 127.70 254.47 Mbits/s 200 >> TCP download avg : 106.97 N/A N/A Mbits/s 200 >> TCP download sum : 427.90 N/A N/A Mbits/s 200 >> TCP totals : 864.43 N/A N/A Mbits/s 200 >> TCP upload BE : 97.54 96.67 163.99 Mbits/s 200 >> TCP upload BK : 139.76 143.88 190.37 Mbits/s 200 >> TCP upload CS5 : 97.52 94.70 206.60 Mbits/s 200 >> TCP upload EF : 101.71 106.72 147.88 Mbits/s 200 >> TCP upload avg : 109.13 N/A N/A Mbits/s 200 >> TCP upload sum : 436.53 N/A N/A Mbits/s 200 >> >> rps_threaded=1: (combined CPU idle time around 16%) >> avg median 99th % # data pts >> Ping (ms) ICMP : 13.70 16.10 27.60 ms 199 >> Ping (ms) UDP BE : 2.03 18.35 24.16 ms 200 >> Ping (ms) UDP BK : 2.03 18.36 29.13 ms 200 >> Ping (ms) UDP EF : 2.36 25.20 41.50 ms 200 >> Ping (ms) avg : 2.14 N/A N/A ms 200 >> TCP download BE : 118.69 120.94 160.12 Mbits/s 200 >> TCP download BK : 134.67 137.81 177.14 Mbits/s 200 >> TCP download CS5 : 126.15 127.81 174.84 Mbits/s 200 >> TCP download EF : 78.36 79.41 143.31 Mbits/s 200 >> TCP download avg : 114.47 N/A N/A Mbits/s 200 >> TCP download sum : 457.87 N/A N/A Mbits/s 200 >> TCP totals : 918.19 N/A N/A Mbits/s 200 >> TCP upload BE : 112.20 111.55 164.38 Mbits/s 200 >> TCP upload BK : 144.99 139.24 205.12 Mbits/s 200 >> TCP upload CS5 : 93.09 95.50 132.39 Mbits/s 200 >> TCP upload EF : 110.04 108.21 207.00 Mbits/s 200 >> TCP upload avg : 115.08 N/A N/A Mbits/s 200 >> TCP upload sum : 460.32 N/A N/A Mbits/s 200 >> >> As you can see, both throughput and latency improve because load can be >> better distributed across CPU cores. >> > > What happens if user threads are competing with your kthreads ? > > It seems you are adding another variant of ksoftirqd. > > More threads might look better in some cases, if we accept to be at > the mercy of process scheduling decisions. > > NUMA affinities matter, I do not see how you are dealing with this. > > Your patch assumes all cpus can participate in network processing, > but rps is fine grained: > Boxes with 128 or 256 cpus usually have different rps_mask per receive > queue, with 2 or 4 bits set in the per-rx-queue rps_mask. I'm assuming that in cases where this matters, user space can set the affinities and priority of the rps threads. The number in the rps-%d process name matches the bit number for rps_mask, so it can control things in a more fine grained way. Would you prefer having support for selectively enabling threading on individual backlogs with a mask? > Then, process_backlog() has been designed to run only from the cpu > tied to the per-cpu data (softnet_data) > There are multiple comments about this assumption, and various things > that would need to be changed > (eg sd_has_rps_ipi_waiting() would be wrong in its current implementation) That's why I added the NAPI_STATE_THREADED check in napi_schedule_rps, so that sd_has_rps_ipi_waiting would always return false. Or are you worried about a race when enabling threading? - Felix
On Fri, Feb 17, 2023 at 4:26 PM Felix Fietkau <nbd@nbd.name> wrote: > > > Then, process_backlog() has been designed to run only from the cpu > > tied to the per-cpu data (softnet_data) > > There are multiple comments about this assumption, and various things > > that would need to be changed > > (eg sd_has_rps_ipi_waiting() would be wrong in its current implementation) > That's why I added the NAPI_STATE_THREADED check in napi_schedule_rps, > so that sd_has_rps_ipi_waiting would always return false. > Or are you worried about a race when enabling threading? > Please look at all uses of sd->process_queue, without locking. They do not care about NAPI_STATE_THREADED flush_backlog() is one instance, but process_backlog() is also using __skb_dequeue(&sd->process_queue) I suspect the following patch would work today, and would show process_queue lock is not used. diff --git a/net/core/dev.c b/net/core/dev.c index 5687b528d4c18ef2960edb6bf3161bbad666aece..bed540b417a1b4cd3e384611a4681b8e2a43fd30 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -11396,7 +11396,7 @@ static int __init net_dev_init(void) INIT_WORK(flush, flush_backlog); skb_queue_head_init(&sd->input_pkt_queue); - skb_queue_head_init(&sd->process_queue); + __skb_queue_head_init(&sd->process_queue); #ifdef CONFIG_XFRM_OFFLOAD skb_queue_head_init(&sd->xfrm_backlog); #endif
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h index d9cdbc047b49..9ee2162c907e 100644 --- a/include/linux/netdevice.h +++ b/include/linux/netdevice.h @@ -522,6 +522,7 @@ static inline bool napi_complete(struct napi_struct *n) } int dev_set_threaded(struct net_device *dev, bool threaded); +int rps_set_threaded(bool threaded); /** * napi_disable - prevent NAPI from scheduling diff --git a/net/core/dev.c b/net/core/dev.c index 357081b0113c..c138e40536e4 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -4597,7 +4597,7 @@ static int napi_schedule_rps(struct softnet_data *sd) struct softnet_data *mysd = this_cpu_ptr(&softnet_data); #ifdef CONFIG_RPS - if (sd != mysd) { + if (sd != mysd && !test_bit(NAPI_STATE_THREADED, &sd->backlog.state)) { sd->rps_ipi_next = mysd->rps_ipi_list; mysd->rps_ipi_list = sd; @@ -5936,13 +5936,12 @@ static int process_backlog(struct napi_struct *napi, int quota) if (skb_queue_empty(&sd->input_pkt_queue)) { /* * Inline a custom version of __napi_complete(). - * only current cpu owns and manipulates this napi, - * and NAPI_STATE_SCHED is the only possible flag set - * on backlog. + * only current cpu owns and manipulates this napi. * We can use a plain write instead of clear_bit(), * and we dont need an smp_mb() memory barrier. */ - napi->state = 0; + napi->state &= ~(NAPIF_STATE_SCHED | + NAPIF_STATE_SCHED_THREADED); again = false; } else { skb_queue_splice_tail_init(&sd->input_pkt_queue, @@ -6356,6 +6355,55 @@ int dev_set_threaded(struct net_device *dev, bool threaded) } EXPORT_SYMBOL(dev_set_threaded); +#ifdef CONFIG_RPS +int rps_set_threaded(bool threaded) +{ + static bool rps_threaded; + int err = 0; + int i; + + if (rps_threaded == threaded) + return 0; + + for_each_possible_cpu(i) { + struct softnet_data *sd = &per_cpu(softnet_data, i); + struct napi_struct *n = &sd->backlog; + + n->thread = kthread_run(napi_threaded_poll, n, "napi/rps-%d", i); + if (IS_ERR(n->thread)) { + err = PTR_ERR(n->thread); + pr_err("kthread_run failed with err %d\n", err); + n->thread = NULL; + threaded = false; + break; + } + + } + + rps_threaded = threaded; + + /* Make sure kthread is created before THREADED bit + * is set. + */ + smp_mb__before_atomic(); + + for_each_possible_cpu(i) { + struct softnet_data *sd = &per_cpu(softnet_data, i); + struct napi_struct *n = &sd->backlog; + unsigned long flags; + + rps_lock_irqsave(sd, &flags); + if (threaded) + n->state |= NAPIF_STATE_THREADED; + else + n->state &= ~NAPIF_STATE_THREADED; + rps_lock_irq_restore(sd, &flags); + } + + return err; +} +#endif + void netif_napi_add_weight(struct net_device *dev, struct napi_struct *napi, int (*poll)(struct napi_struct *, int), int weight) { @@ -11114,6 +11162,9 @@ static int dev_cpu_dead(unsigned int oldcpu) raise_softirq_irqoff(NET_TX_SOFTIRQ); local_irq_enable(); + if (test_bit(NAPI_STATE_THREADED, &oldsd->backlog.state)) + return 0; + #ifdef CONFIG_RPS remsd = oldsd->rps_ipi_list; oldsd->rps_ipi_list = NULL; diff --git a/net/core/sysctl_net_core.c b/net/core/sysctl_net_core.c index 7130e6d9e263..438957535e74 100644 --- a/net/core/sysctl_net_core.c +++ b/net/core/sysctl_net_core.c @@ -30,6 +30,7 @@ static int int_3600 = 3600; static int min_sndbuf = SOCK_MIN_SNDBUF; static int min_rcvbuf = SOCK_MIN_RCVBUF; static int max_skb_frags = MAX_SKB_FRAGS; +static int rps_threaded; static int net_msg_warn; /* Unused, but still a sysctl */ @@ -163,6 +164,23 @@ static int rps_sock_flow_sysctl(struct ctl_table *table, int write, return ret; } + +static int rps_threaded_sysctl(struct ctl_table *table, int write, + void *buffer, size_t *lenp, loff_t *ppos) +{ + static DEFINE_MUTEX(rps_threaded_mutex); + int ret; + + mutex_lock(&rps_threaded_mutex); + + ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); + if (write && !ret) + ret = rps_set_threaded(rps_threaded); + + mutex_unlock(&rps_threaded_mutex); + + return ret; +} #endif /* CONFIG_RPS */ #ifdef CONFIG_NET_FLOW_LIMIT @@ -513,6 +531,15 @@ static struct ctl_table net_core_table[] = { .mode = 0644, .proc_handler = rps_default_mask_sysctl }, + { + .procname = "rps_threaded", + .data = &rps_threaded, + .maxlen = sizeof(unsigned int), + .mode = 0644, + .proc_handler = rps_threaded_sysctl, + .extra1 = SYSCTL_ZERO, + .extra2 = SYSCTL_ONE + }, #endif #ifdef CONFIG_NET_FLOW_LIMIT {
When dealing with few flows or an imbalance on CPU utilization, static RPS CPU assignment can be too inflexible. Add support for enabling threaded NAPI for RPS backlog processing in order to allow the scheduler to better balance processing. This helps better spread the load across idle CPUs. Signed-off-by: Felix Fietkau <nbd@nbd.name> --- RFC v2: - fix rebase error in rps locking include/linux/netdevice.h | 1 + net/core/dev.c | 61 ++++++++++++++++++++++++++++++++++---- net/core/sysctl_net_core.c | 27 +++++++++++++++++ 3 files changed, 84 insertions(+), 5 deletions(-)