€•      Œsphinx.addnodes”Œdocument”“”)”}”(Œ	rawsource”Œ ”Œchildren”]”(Œtranslations”ŒLanguagesNode”“”)”}”(hhh]”(h Œpending_xref”“”)”}”(hhh]”Œdocutils.nodes”ŒText”“”ŒChinese (Simplified)”…””}”Œparent”hsbaŒ
attributes”}”(Œids”]”Œclasses”]”Œnames”]”Œdupnames”]”Œbackrefs”]”Œ	refdomain”Œstd”Œreftype”Œdoc”Œ	reftarget”Œ&/translations/zh_CN/networking/scaling”Œmodname”NŒ	classname”NŒrefexplicit”ˆuŒtagname”hhhubh)”}”(hhh]”hŒChinese (Traditional)”…””}”hh2sbah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ&/translations/zh_TW/networking/scaling”Œmodname”NŒ	classname”NŒrefexplicit”ˆuh1hhhubh)”}”(hhh]”hŒItalian”…””}”hhFsbah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ&/translations/it_IT/networking/scaling”Œmodname”NŒ	classname”NŒrefexplicit”ˆuh1hhhubh)”}”(hhh]”hŒJapanese”…””}”hhZsbah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ&/translations/ja_JP/networking/scaling”Œmodname”NŒ	classname”NŒrefexplicit”ˆuh1hhhubh)”}”(hhh]”hŒKorean”…””}”hhnsbah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ&/translations/ko_KR/networking/scaling”Œmodname”NŒ	classname”NŒrefexplicit”ˆuh1hhhubh)”}”(hhh]”hŒSpanish”…””}”hh‚sbah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ&/translations/sp_SP/networking/scaling”Œmodname”NŒ	classname”NŒrefexplicit”ˆuh1hhhubeh}”(h]”h ]”h"]”h$]”h&]”Œcurrent_language”ŒEnglish”uh1h
hhŒ	_document”hŒsource”NŒline”NubhŒcomment”“”)”}”(hŒ SPDX-License-Identifier: GPL-2.0”h]”hŒ SPDX-License-Identifier: GPL-2.0”…””}”hh£sbah}”(h]”h ]”h"]”h$]”h&]”Œ	xml:space”Œpreserve”uh1h¡hhhžhhŸŒ@/var/lib/git/docbuild/linux/Documentation/networking/scaling.rst”h KubhŒsection”“”)”}”(hhh]”(hŒtitle”“”)”}”(hŒ%Scaling in the Linux Networking Stack”h]”hŒ%Scaling in the Linux Networking Stack”…””}”(hh»hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hh¶hžhhŸh³h Kubhµ)”}”(hhh]”(hº)”}”(hŒIntroduction”h]”hŒIntroduction”…””}”(hhÌhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hhÉhžhhŸh³h K	ubhŒ	paragraph”“”)”}”(hŒ¤This document describes a set of complementary techniques in the Linux
networking stack to increase parallelism and improve performance for
multi-processor systems.”h]”hŒ¤This document describes a set of complementary techniques in the Linux
networking stack to increase parallelism and improve performance for
multi-processor systems.”…””}”(hhÜhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h KhhÉhžhubhÛ)”}”(hŒ)The following technologies are described:”h]”hŒ)The following technologies are described:”…””}”(hhêhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h KhhÉhžhubhŒbullet_list”“”)”}”(hhh]”(hŒ	list_item”“”)”}”(hŒRSS: Receive Side Scaling”h]”hÛ)”}”(hj  h]”hŒRSS: Receive Side Scaling”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Khhÿubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhhúhžhhŸh³h Nubhþ)”}”(hŒRPS: Receive Packet Steering”h]”hÛ)”}”(hj  h]”hŒRPS: Receive Packet Steering”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Khj  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhhúhžhhŸh³h Nubhþ)”}”(hŒRFS: Receive Flow Steering”h]”hÛ)”}”(hj/  h]”hŒRFS: Receive Flow Steering”…””}”(hj1  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Khj-  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhhúhžhhŸh³h Nubhþ)”}”(hŒ!Accelerated Receive Flow Steering”h]”hÛ)”}”(hjF  h]”hŒ!Accelerated Receive Flow Steering”…””}”(hjH  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h KhjD  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhhúhžhhŸh³h Nubhþ)”}”(hŒXPS: Transmit Packet Steering

”h]”hÛ)”}”(hŒXPS: Transmit Packet Steering”h]”hŒXPS: Transmit Packet Steering”…””}”(hj_  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Khj[  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhhúhžhhŸh³h Nubeh}”(h]”h ]”h"]”h$]”h&]”Œbullet”Œ-”uh1høhŸh³h KhhÉhžhubeh}”(h]”Œintroduction”ah ]”h"]”Œintroduction”ah$]”h&]”uh1h´hh¶hžhhŸh³h K	ubhµ)”}”(hhh]”(hº)”}”(hŒRSS: Receive Side Scaling”h]”hŒRSS: Receive Side Scaling”…””}”(hj†  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hjƒ  hžhhŸh³h KubhÛ)”}”(hX¾  Contemporary NICs support multiple receive and transmit descriptor queues
(multi-queue). On reception, a NIC can send different packets to different
queues to distribute processing among CPUs. The NIC distributes packets by
applying a filter to each packet that assigns it to one of a small number
of logical flows. Packets for each flow are steered to a separate receive
queue, which in turn can be processed by separate CPUs. This mechanism is
generally known as â€œReceive-side Scalingâ€ (RSS). The goal of RSS and
the other scaling techniques is to increase performance uniformly.
Multi-queue distribution can also be used for traffic prioritization, but
that is not the focus of these techniques.”h]”hX¾  Contemporary NICs support multiple receive and transmit descriptor queues
(multi-queue). On reception, a NIC can send different packets to different
queues to distribute processing among CPUs. The NIC distributes packets by
applying a filter to each packet that assigns it to one of a small number
of logical flows. Packets for each flow are steered to a separate receive
queue, which in turn can be processed by separate CPUs. This mechanism is
generally known as â€œReceive-side Scalingâ€ (RSS). The goal of RSS and
the other scaling techniques is to increase performance uniformly.
Multi-queue distribution can also be used for traffic prioritization, but
that is not the focus of these techniques.”…””}”(hj”  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Khjƒ  hžhubhÛ)”}”(hX  The filter used in RSS is typically a hash function over the network
and/or transport layer headers-- for example, a 4-tuple hash over
IP addresses and TCP ports of a packet. The most common hardware
implementation of RSS uses a 128-entry indirection table where each entry
stores a queue number. The receive queue for a packet is determined
by masking out the low order seven bits of the computed hash for the
packet (usually a Toeplitz hash), taking this number as a key into the
indirection table and reading the corresponding value.”h]”hX  The filter used in RSS is typically a hash function over the network
and/or transport layer headers-- for example, a 4-tuple hash over
IP addresses and TCP ports of a packet. The most common hardware
implementation of RSS uses a 128-entry indirection table where each entry
stores a queue number. The receive queue for a packet is determined
by masking out the low order seven bits of the computed hash for the
packet (usually a Toeplitz hash), taking this number as a key into the
indirection table and reading the corresponding value.”…””}”(hj¢  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h K&hjƒ  hžhubhÛ)”}”(hXt  Some NICs support symmetric RSS hashing where, if the IP (source address,
destination address) and TCP/UDP (source port, destination port) tuples
are swapped, the computed hash is the same. This is beneficial in some
applications that monitor TCP/IP flows (IDS, firewalls, ...etc) and need
both directions of the flow to land on the same Rx queue (and CPU). The
"Symmetric-XOR" and "Symmetric-OR-XOR" are types of RSS algorithms that
achieve this hash symmetry by XOR/ORing the input source and destination
fields of the IP and/or L4 protocols. This, however, results in reduced
input entropy and could potentially be exploited.”h]”hX|  Some NICs support symmetric RSS hashing where, if the IP (source address,
destination address) and TCP/UDP (source port, destination port) tuples
are swapped, the computed hash is the same. This is beneficial in some
applications that monitor TCP/IP flows (IDS, firewalls, ...etc) and need
both directions of the flow to land on the same Rx queue (and CPU). The
â€œSymmetric-XORâ€ and â€œSymmetric-OR-XORâ€ are types of RSS algorithms that
achieve this hash symmetry by XOR/ORing the input source and destination
fields of the IP and/or L4 protocols. This, however, results in reduced
input entropy and could potentially be exploited.”…””}”(hj°  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h K/hjƒ  hžhubhÛ)”}”(hŒGSpecifically, the "Symmetric-XOR" algorithm XORs the input
as follows::”h]”hŒJSpecifically, the â€œSymmetric-XORâ€ algorithm XORs the input
as follows:”…””}”(hj¾  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h K9hjƒ  hžhubhŒliteral_block”“”)”}”(hŒN# (SRC_IP ^ DST_IP, SRC_IP ^ DST_IP, SRC_PORT ^ DST_PORT, SRC_PORT ^ DST_PORT)”h]”hŒN# (SRC_IP ^ DST_IP, SRC_IP ^ DST_IP, SRC_PORT ^ DST_PORT, SRC_PORT ^ DST_PORT)”…””}”hjÎ  sbah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jÌ  hŸh³h K<hjƒ  hžhubhÛ)”}”(hŒVThe "Symmetric-OR-XOR" algorithm, on the other hand, transforms the input as
follows::”h]”hŒYThe â€œSymmetric-OR-XORâ€ algorithm, on the other hand, transforms the input as
follows:”…””}”(hjÜ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h K>hjƒ  hžhubjÍ  )”}”(hŒN# (SRC_IP | DST_IP, SRC_IP ^ DST_IP, SRC_PORT | DST_PORT, SRC_PORT ^ DST_PORT)”h]”hŒN# (SRC_IP | DST_IP, SRC_IP ^ DST_IP, SRC_PORT | DST_PORT, SRC_PORT ^ DST_PORT)”…””}”hjê  sbah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jÌ  hŸh³h KAhjƒ  hžhubhÛ)”}”(hŒ7The result is then fed to the underlying RSS algorithm.”h]”hŒ7The result is then fed to the underlying RSS algorithm.”…””}”(hjø  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h KChjƒ  hžhubhÛ)”}”(hŒüSome advanced NICs allow steering packets to queues based on
programmable filters. For example, webserver bound TCP port 80 packets
can be directed to their own receive queue. Such â€œn-tupleâ€ filters can
be configured from ethtool (--config-ntuple).”h]”hŒüSome advanced NICs allow steering packets to queues based on
programmable filters. For example, webserver bound TCP port 80 packets
can be directed to their own receive queue. Such â€œn-tupleâ€ filters can
be configured from ethtool (--config-ntuple).”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h KEhjƒ  hžhubhµ)”}”(hhh]”(hº)”}”(hŒRSS Configuration”h]”hŒRSS Configuration”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hj  hžhhŸh³h KLubhÛ)”}”(hXã  The driver for a multi-queue capable NIC typically provides a kernel
module parameter for specifying the number of hardware queues to
configure. In the bnx2x driver, for instance, this parameter is called
num_queues. A typical RSS configuration would be to have one receive queue
for each CPU if the device supports enough queues, or otherwise at least
one for each memory domain, where a memory domain is a set of CPUs that
share a particular memory level (L1, L2, NUMA node, etc.).”h]”hXã  The driver for a multi-queue capable NIC typically provides a kernel
module parameter for specifying the number of hardware queues to
configure. In the bnx2x driver, for instance, this parameter is called
num_queues. A typical RSS configuration would be to have one receive queue
for each CPU if the device supports enough queues, or otherwise at least
one for each memory domain, where a memory domain is a set of CPUs that
share a particular memory level (L1, L2, NUMA node, etc.).”…””}”(hj%  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h KNhj  hžhubhÛ)”}”(hX±  The indirection table of an RSS device, which resolves a queue by masked
hash, is usually programmed by the driver at initialization. The
default mapping is to distribute the queues evenly in the table, but the
indirection table can be retrieved and modified at runtime using ethtool
commands (--show-rxfh-indir and --set-rxfh-indir). Modifying the
indirection table could be done to give different queues different
relative weights.”h]”hX±  The indirection table of an RSS device, which resolves a queue by masked
hash, is usually programmed by the driver at initialization. The
default mapping is to distribute the queues evenly in the table, but the
indirection table can be retrieved and modified at runtime using ethtool
commands (--show-rxfh-indir and --set-rxfh-indir). Modifying the
indirection table could be done to give different queues different
relative weights.”…””}”(hj3  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h KVhj  hžhubhµ)”}”(hhh]”(hº)”}”(hŒRSS IRQ Configuration”h]”hŒRSS IRQ Configuration”…””}”(hjD  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hjA  hžhhŸh³h K`ubhÛ)”}”(hX  Each receive queue has a separate IRQ associated with it. The NIC triggers
this to notify a CPU when new packets arrive on the given queue. The
signaling path for PCIe devices uses message signaled interrupts (MSI-X),
that can route each interrupt to a particular CPU. The active mapping
of queues to IRQs can be determined from /proc/interrupts. By default,
an IRQ may be handled on any CPU. Because a non-negligible part of packet
processing takes place in receive interrupt handling, it is advantageous
to spread receive interrupts between CPUs. To manually adjust the IRQ
affinity of each interrupt see Documentation/core-api/irq/irq-affinity.rst. Some systems
will be running irqbalance, a daemon that dynamically optimizes IRQ
assignments and as a result may override any manual settings.”h]”hX  Each receive queue has a separate IRQ associated with it. The NIC triggers
this to notify a CPU when new packets arrive on the given queue. The
signaling path for PCIe devices uses message signaled interrupts (MSI-X),
that can route each interrupt to a particular CPU. The active mapping
of queues to IRQs can be determined from /proc/interrupts. By default,
an IRQ may be handled on any CPU. Because a non-negligible part of packet
processing takes place in receive interrupt handling, it is advantageous
to spread receive interrupts between CPUs. To manually adjust the IRQ
affinity of each interrupt see Documentation/core-api/irq/irq-affinity.rst. Some systems
will be running irqbalance, a daemon that dynamically optimizes IRQ
assignments and as a result may override any manual settings.”…””}”(hjR  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h KbhjA  hžhubeh}”(h]”Œrss-irq-configuration”ah ]”h"]”Œrss irq configuration”ah$]”h&]”uh1h´hj  hžhhŸh³h K`ubhµ)”}”(hhh]”(hº)”}”(hŒSuggested Configuration”h]”hŒSuggested Configuration”…””}”(hjk  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hjh  hžhhŸh³h KpubhÛ)”}”(hX_  RSS should be enabled when latency is a concern or whenever receive
interrupt processing forms a bottleneck. Spreading load between CPUs
decreases queue length. For low latency networking, the optimal setting
is to allocate as many queues as there are CPUs in the system (or the
NIC maximum, if lower). The most efficient high-rate configuration
is likely the one with the smallest number of receive queues where no
receive queue overflows due to a saturated CPU, because in default
mode with interrupt coalescing enabled, the aggregate number of
interrupts (and thus work) grows with each additional queue.”h]”hX_  RSS should be enabled when latency is a concern or whenever receive
interrupt processing forms a bottleneck. Spreading load between CPUs
decreases queue length. For low latency networking, the optimal setting
is to allocate as many queues as there are CPUs in the system (or the
NIC maximum, if lower). The most efficient high-rate configuration
is likely the one with the smallest number of receive queues where no
receive queue overflows due to a saturated CPU, because in default
mode with interrupt coalescing enabled, the aggregate number of
interrupts (and thus work) grows with each additional queue.”…””}”(hjy  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Krhjh  hžhubhÛ)”}”(hX)  Per-cpu load can be observed using the mpstat utility, but note that on
processors with hyperthreading (HT), each hyperthread is represented as
a separate CPU. For interrupt handling, HT has shown no benefit in
initial tests, so limit the number of queues to the number of CPU cores
in the system.”h]”hX)  Per-cpu load can be observed using the mpstat utility, but note that on
processors with hyperthreading (HT), each hyperthread is represented as
a separate CPU. For interrupt handling, HT has shown no benefit in
initial tests, so limit the number of queues to the number of CPU cores
in the system.”…””}”(hj‡  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h K|hjh  hžhubeh}”(h]”Œsuggested-configuration”ah ]”h"]”h$]”Œsuggested configuration”ah&]”uh1h´hj  hžhhŸh³h KpŒ
referenced”Kubhµ)”}”(hhh]”(hº)”}”(hŒDedicated RSS contexts”h]”hŒDedicated RSS contexts”…””}”(hj¡  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hjž  hžhhŸh³h KƒubhÛ)”}”(hXc  Modern NICs support creating multiple co-existing RSS configurations
which are selected based on explicit matching rules. This can be very
useful when application wants to constrain the set of queues receiving
traffic for e.g. a particular destination port or IP address.
The example below shows how to direct all traffic to TCP port 22
to queues 0 and 1.”h]”hXc  Modern NICs support creating multiple co-existing RSS configurations
which are selected based on explicit matching rules. This can be very
useful when application wants to constrain the set of queues receiving
traffic for e.g. a particular destination port or IP address.
The example below shows how to direct all traffic to TCP port 22
to queues 0 and 1.”…””}”(hj¯  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h K…hjž  hžhubhÛ)”}”(hŒ)To create an additional RSS context use::”h]”hŒ(To create an additional RSS context use:”…””}”(hj½  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h KŒhjž  hžhubjÍ  )”}”(hŒA# ethtool -X eth0 hfunc toeplitz context new
New RSS context is 1”h]”hŒA# ethtool -X eth0 hfunc toeplitz context new
New RSS context is 1”…””}”hjË  sbah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jÌ  hŸh³h KŽhjž  hžhubhÛ)”}”(hŒÃKernel reports back the ID of the allocated context (the default, always
present RSS context has ID of 0). The new context can be queried and
modified using the same APIs as the default context::”h]”hŒÂKernel reports back the ID of the allocated context (the default, always
present RSS context has ID of 0). The new context can be queried and
modified using the same APIs as the default context:”…””}”(hjÙ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h K‘hjž  hžhubjÍ  )”}”(hX·  # ethtool -x eth0 context 1
RX flow hash indirection table for eth0 with 13 RX ring(s):
  0:      0     1     2     3     4     5     6     7
  8:      8     9    10    11    12     0     1     2
[...]
# ethtool -X eth0 equal 2 context 1
# ethtool -x eth0 context 1
RX flow hash indirection table for eth0 with 13 RX ring(s):
  0:      0     1     0     1     0     1     0     1
  8:      0     1     0     1     0     1     0     1
[...]”h]”hX·  # ethtool -x eth0 context 1
RX flow hash indirection table for eth0 with 13 RX ring(s):
  0:      0     1     2     3     4     5     6     7
  8:      8     9    10    11    12     0     1     2
[...]
# ethtool -X eth0 equal 2 context 1
# ethtool -x eth0 context 1
RX flow hash indirection table for eth0 with 13 RX ring(s):
  0:      0     1     0     1     0     1     0     1
  8:      0     1     0     1     0     1     0     1
[...]”…””}”hjç  sbah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jÌ  hŸh³h K•hjž  hžhubhÛ)”}”(hŒMTo make use of the new context direct traffic to it using an n-tuple
filter::”h]”hŒLTo make use of the new context direct traffic to it using an n-tuple
filter:”…””}”(hjõ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h K¡hjž  hžhubjÍ  )”}”(hŒN# ethtool -N eth0 flow-type tcp6 dst-port 22 context 1
Added rule with ID 1023”h]”hŒN# ethtool -N eth0 flow-type tcp6 dst-port 22 context 1
Added rule with ID 1023”…””}”hj  sbah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jÌ  hŸh³h K¤hjž  hžhubhÛ)”}”(hŒ,When done, remove the context and the rule::”h]”hŒ+When done, remove the context and the rule:”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h K§hjž  hžhubjÍ  )”}”(hŒ@# ethtool -N eth0 delete 1023
# ethtool -X eth0 context 1 delete”h]”hŒ@# ethtool -N eth0 delete 1023
# ethtool -X eth0 context 1 delete”…””}”hj  sbah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jÌ  hŸh³h K©hjž  hžhubeh}”(h]”Œdedicated-rss-contexts”ah ]”h"]”Œdedicated rss contexts”ah$]”h&]”uh1h´hj  hžhhŸh³h Kƒubeh}”(h]”Œrss-configuration”ah ]”h"]”Œrss configuration”ah$]”h&]”uh1h´hjƒ  hžhhŸh³h KLubeh}”(h]”Œrss-receive-side-scaling”ah ]”h"]”Œrss: receive side scaling”ah$]”h&]”uh1h´hh¶hžhhŸh³h Kubhµ)”}”(hhh]”(hº)”}”(hŒRPS: Receive Packet Steering”h]”hŒRPS: Receive Packet Steering”…””}”(hjH  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hjE  hžhhŸh³h K®ubhÛ)”}”(hXÑ  Receive Packet Steering (RPS) is logically a software implementation of
RSS. Being in software, it is necessarily called later in the datapath.
Whereas RSS selects the queue and hence CPU that will run the hardware
interrupt handler, RPS selects the CPU to perform protocol processing
above the interrupt handler. This is accomplished by placing the packet
on the desired CPUâ€™s backlog queue and waking up the CPU for processing.
RPS has some advantages over RSS:”h]”hXÑ  Receive Packet Steering (RPS) is logically a software implementation of
RSS. Being in software, it is necessarily called later in the datapath.
Whereas RSS selects the queue and hence CPU that will run the hardware
interrupt handler, RPS selects the CPU to perform protocol processing
above the interrupt handler. This is accomplished by placing the packet
on the desired CPUâ€™s backlog queue and waking up the CPU for processing.
RPS has some advantages over RSS:”…””}”(hjV  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h K°hjE  hžhubhŒenumerated_list”“”)”}”(hhh]”(hþ)”}”(hŒit can be used with any NIC”h]”hÛ)”}”(hjk  h]”hŒit can be used with any NIC”…””}”(hjm  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h K¸hji  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhjf  hžhhŸh³h Nubhþ)”}”(hŒ?software filters can easily be added to hash over new protocols”h]”hÛ)”}”(hj‚  h]”hŒ?software filters can easily be added to hash over new protocols”…””}”(hj„  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h K¹hj€  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhjf  hžhhŸh³h Nubhþ)”}”(hŒsit does not increase hardware device interrupt rate (although it does
introduce inter-processor interrupts (IPIs))
”h]”hÛ)”}”(hŒrit does not increase hardware device interrupt rate (although it does
introduce inter-processor interrupts (IPIs))”h]”hŒrit does not increase hardware device interrupt rate (although it does
introduce inter-processor interrupts (IPIs))”…””}”(hj›  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Kºhj—  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhjf  hžhhŸh³h Nubeh}”(h]”h ]”h"]”h$]”h&]”Œenumtype”Œarabic”Œprefix”hŒsuffix”Œ)”uh1jd  hjE  hžhhŸh³h K¸ubhÛ)”}”(hŒùRPS is called during bottom half of the receive interrupt handler, when
a driver sends a packet up the network stack with netif_rx() or
netif_receive_skb(). These call the get_rps_cpu() function, which
selects the queue that should process a packet.”h]”hŒùRPS is called during bottom half of the receive interrupt handler, when
a driver sends a packet up the network stack with netif_rx() or
netif_receive_skb(). These call the get_rps_cpu() function, which
selects the queue that should process a packet.”…””}”(hjº  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h K½hjE  hžhubhÛ)”}”(hXB  The first step in determining the target CPU for RPS is to calculate a
flow hash over the packetâ€™s addresses or ports (2-tuple or 4-tuple hash
depending on the protocol). This serves as a consistent hash of the
associated flow of the packet. The hash is either provided by hardware
or will be computed in the stack. Capable hardware can pass the hash in
the receive descriptor for the packet; this would usually be the same
hash used for RSS (e.g. computed Toeplitz hash). The hash is saved in
skb->hash and can be used elsewhere in the stack as a hash of the
packetâ€™s flow.”h]”hXB  The first step in determining the target CPU for RPS is to calculate a
flow hash over the packetâ€™s addresses or ports (2-tuple or 4-tuple hash
depending on the protocol). This serves as a consistent hash of the
associated flow of the packet. The hash is either provided by hardware
or will be computed in the stack. Capable hardware can pass the hash in
the receive descriptor for the packet; this would usually be the same
hash used for RSS (e.g. computed Toeplitz hash). The hash is saved in
skb->hash and can be used elsewhere in the stack as a hash of the
packetâ€™s flow.”…””}”(hjÈ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h KÂhjE  hžhubhÛ)”}”(hXH  Each receive hardware queue has an associated list of CPUs to which
RPS may enqueue packets for processing. For each received packet,
an index into the list is computed from the flow hash modulo the size
of the list. The indexed CPU is the target for processing the packet,
and the packet is queued to the tail of that CPUâ€™s backlog queue. At
the end of the bottom half routine, IPIs are sent to any CPUs for which
packets have been queued to their backlog queue. The IPI wakes backlog
processing on the remote CPU, and any queued packets are then processed
up the networking stack.”h]”hXH  Each receive hardware queue has an associated list of CPUs to which
RPS may enqueue packets for processing. For each received packet,
an index into the list is computed from the flow hash modulo the size
of the list. The indexed CPU is the target for processing the packet,
and the packet is queued to the tail of that CPUâ€™s backlog queue. At
the end of the bottom half routine, IPIs are sent to any CPUs for which
packets have been queued to their backlog queue. The IPI wakes backlog
processing on the remote CPU, and any queued packets are then processed
up the networking stack.”…””}”(hjÖ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h KÌhjE  hžhubhµ)”}”(hhh]”(hº)”}”(hŒRPS Configuration”h]”hŒRPS Configuration”…””}”(hjç  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hjä  hžhhŸh³h KØubhÛ)”}”(hX  RPS requires a kernel compiled with the CONFIG_RPS kconfig symbol (on
by default for SMP). Even when compiled in, RPS remains disabled until
explicitly configured. The list of CPUs to which RPS may forward traffic
can be configured for each receive queue using a sysfs file entry::”h]”hX  RPS requires a kernel compiled with the CONFIG_RPS kconfig symbol (on
by default for SMP). Even when compiled in, RPS remains disabled until
explicitly configured. The list of CPUs to which RPS may forward traffic
can be configured for each receive queue using a sysfs file entry:”…””}”(hjõ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h KÚhjä  hžhubjÍ  )”}”(hŒ+/sys/class/net/<dev>/queues/rx-<n>/rps_cpus”h]”hŒ+/sys/class/net/<dev>/queues/rx-<n>/rps_cpus”…””}”hj  sbah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jÌ  hŸh³h Kßhjä  hžhubhÛ)”}”(hŒìThis file implements a bitmap of CPUs. RPS is disabled when it is zero
(the default), in which case packets are processed on the interrupting
CPU. Documentation/core-api/irq/irq-affinity.rst explains how CPUs are assigned to
the bitmap.”h]”hŒìThis file implements a bitmap of CPUs. RPS is disabled when it is zero
(the default), in which case packets are processed on the interrupting
CPU. Documentation/core-api/irq/irq-affinity.rst explains how CPUs are assigned to
the bitmap.”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Káhjä  hžhubhµ)”}”(hhh]”(hº)”}”(hŒSuggested Configuration”h]”hŒSuggested Configuration”…””}”(hj"  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hj  hžhhŸh³h KèubhÛ)”}”(hX\  For a single queue device, a typical RPS configuration would be to set
the rps_cpus to the CPUs in the same memory domain of the interrupting
CPU. If NUMA locality is not an issue, this could also be all CPUs in
the system. At high interrupt rate, it might be wise to exclude the
interrupting CPU from the map since that already performs much work.”h]”hX\  For a single queue device, a typical RPS configuration would be to set
the rps_cpus to the CPUs in the same memory domain of the interrupting
CPU. If NUMA locality is not an issue, this could also be all CPUs in
the system. At high interrupt rate, it might be wise to exclude the
interrupting CPU from the map since that already performs much work.”…””}”(hj0  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Kêhj  hžhubhÛ)”}”(hXW  For a multi-queue system, if RSS is configured so that a hardware
receive queue is mapped to each CPU, then RPS is probably redundant
and unnecessary. If there are fewer hardware queues than CPUs, then
RPS might be beneficial if the rps_cpus for each queue are the ones that
share the same memory domain as the interrupting CPU for that queue.”h]”hXW  For a multi-queue system, if RSS is configured so that a hardware
receive queue is mapped to each CPU, then RPS is probably redundant
and unnecessary. If there are fewer hardware queues than CPUs, then
RPS might be beneficial if the rps_cpus for each queue are the ones that
share the same memory domain as the interrupting CPU for that queue.”…””}”(hj>  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Kðhj  hžhubeh}”(h]”Œid1”ah ]”h"]”h$]”j›  ah&]”uh1h´hjä  hžhhŸh³h Kèj  Kubeh}”(h]”Œrps-configuration”ah ]”h"]”Œrps configuration”ah$]”h&]”uh1h´hjE  hžhhŸh³h KØubhµ)”}”(hhh]”(hº)”}”(hŒRPS Flow Limit”h]”hŒRPS Flow Limit”…””}”(hj^  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hj[  hžhhŸh³h KøubhÛ)”}”(hX²  RPS scales kernel receive processing across CPUs without introducing
reordering. The trade-off to sending all packets from the same flow
to the same CPU is CPU load imbalance if flows vary in packet rate.
In the extreme case a single flow dominates traffic. Especially on
common server workloads with many concurrent connections, such
behavior indicates a problem such as a misconfiguration or spoofed
source Denial of Service attack.”h]”hX²  RPS scales kernel receive processing across CPUs without introducing
reordering. The trade-off to sending all packets from the same flow
to the same CPU is CPU load imbalance if flows vary in packet rate.
In the extreme case a single flow dominates traffic. Especially on
common server workloads with many concurrent connections, such
behavior indicates a problem such as a misconfiguration or spoofed
source Denial of Service attack.”…””}”(hjl  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Kúhj[  hžhubhÛ)”}”(hXA  Flow Limit is an optional RPS feature that prioritizes small flows
during CPU contention by dropping packets from large flows slightly
ahead of those from small flows. It is active only when an RPS or RFS
destination CPU approaches saturation.  Once a CPU's input packet
queue exceeds half the maximum queue length (as set by sysctl
net.core.netdev_max_backlog), the kernel starts a per-flow packet
count over the last 256 packets. If a flow exceeds a set ratio (by
default, half) of these packets when a new packet arrives, then the
new packet is dropped. Packets from other flows are still only
dropped once the input packet queue reaches netdev_max_backlog.
No packets are dropped when the input packet queue length is below
the threshold, so flow limit does not sever connections outright:
even large flows maintain connectivity.”h]”hXC  Flow Limit is an optional RPS feature that prioritizes small flows
during CPU contention by dropping packets from large flows slightly
ahead of those from small flows. It is active only when an RPS or RFS
destination CPU approaches saturation.  Once a CPUâ€™s input packet
queue exceeds half the maximum queue length (as set by sysctl
net.core.netdev_max_backlog), the kernel starts a per-flow packet
count over the last 256 packets. If a flow exceeds a set ratio (by
default, half) of these packets when a new packet arrives, then the
new packet is dropped. Packets from other flows are still only
dropped once the input packet queue reaches netdev_max_backlog.
No packets are dropped when the input packet queue length is below
the threshold, so flow limit does not sever connections outright:
even large flows maintain connectivity.”…””}”(hjz  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Mhj[  hžhubhµ)”}”(hhh]”(hº)”}”(hŒ	Interface”h]”hŒ	Interface”…””}”(hj‹  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hjˆ  hžhhŸh³h MubhÛ)”}”(hXW  Flow limit is compiled in by default (CONFIG_NET_FLOW_LIMIT), but not
turned on. It is implemented for each CPU independently (to avoid lock
and cache contention) and toggled per CPU by setting the relevant bit
in sysctl net.core.flow_limit_cpu_bitmap. It exposes the same CPU
bitmap interface as rps_cpus (see above) when called from procfs::”h]”hXV  Flow limit is compiled in by default (CONFIG_NET_FLOW_LIMIT), but not
turned on. It is implemented for each CPU independently (to avoid lock
and cache contention) and toggled per CPU by setting the relevant bit
in sysctl net.core.flow_limit_cpu_bitmap. It exposes the same CPU
bitmap interface as rps_cpus (see above) when called from procfs:”…””}”(hj™  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Mhjˆ  hžhubjÍ  )”}”(hŒ(/proc/sys/net/core/flow_limit_cpu_bitmap”h]”hŒ(/proc/sys/net/core/flow_limit_cpu_bitmap”…””}”hj§  sbah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jÌ  hŸh³h Mhjˆ  hžhubhÛ)”}”(hX™  Per-flow rate is calculated by hashing each packet into a hashtable
bucket and incrementing a per-bucket counter. The hash function is
the same that selects a CPU in RPS, but as the number of buckets can
be much larger than the number of CPUs, flow limit has finer-grained
identification of large flows and fewer false positives. The default
table has 4096 buckets. This value can be modified through sysctl::”h]”hX˜  Per-flow rate is calculated by hashing each packet into a hashtable
bucket and incrementing a per-bucket counter. The hash function is
the same that selects a CPU in RPS, but as the number of buckets can
be much larger than the number of CPUs, flow limit has finer-grained
identification of large flows and fewer false positives. The default
table has 4096 buckets. This value can be modified through sysctl:”…””}”(hjµ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Mhjˆ  hžhubjÍ  )”}”(hŒnet.core.flow_limit_table_len”h]”hŒnet.core.flow_limit_table_len”…””}”hjÃ  sbah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jÌ  hŸh³h M#hjˆ  hžhubhÛ)”}”(hŒfThe value is only consulted when a new table is allocated. Modifying
it does not update active tables.”h]”hŒfThe value is only consulted when a new table is allocated. Modifying
it does not update active tables.”…””}”(hjÑ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M%hjˆ  hžhubeh}”(h]”Œ	interface”ah ]”h"]”Œ	interface”ah$]”h&]”uh1h´hj[  hžhhŸh³h Mubhµ)”}”(hhh]”(hº)”}”(hŒSuggested Configuration”h]”hŒSuggested Configuration”…””}”(hjê  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hjç  hžhhŸh³h M*ubhÛ)”}”(hX  Flow limit is useful on systems with many concurrent connections,
where a single connection taking up 50% of a CPU indicates a problem.
In such environments, enable the feature on all CPUs that handle
network rx interrupts (as set in /proc/irq/N/smp_affinity).”h]”hX  Flow limit is useful on systems with many concurrent connections,
where a single connection taking up 50% of a CPU indicates a problem.
In such environments, enable the feature on all CPUs that handle
network rx interrupts (as set in /proc/irq/N/smp_affinity).”…””}”(hjø  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M,hjç  hžhubhÛ)”}”(hŒÙThe feature depends on the input packet queue length to exceed
the flow limit threshold (50%) + the flow history length (256).
Setting net.core.netdev_max_backlog to either 1000 or 10000
performed well in experiments.”h]”hŒÙThe feature depends on the input packet queue length to exceed
the flow limit threshold (50%) + the flow history length (256).
Setting net.core.netdev_max_backlog to either 1000 or 10000
performed well in experiments.”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M1hjç  hžhubeh}”(h]”Œid2”ah ]”h"]”h$]”Œsuggested configuration”ah&]”uh1h´hj[  hžhhŸh³h M*j  Kubeh}”(h]”Œrps-flow-limit”ah ]”h"]”Œrps flow limit”ah$]”h&]”uh1h´hjE  hžhhŸh³h Køubeh}”(h]”Œrps-receive-packet-steering”ah ]”h"]”Œrps: receive packet steering”ah$]”h&]”uh1h´hh¶hžhhŸh³h K®ubhµ)”}”(hhh]”(hº)”}”(hŒRFS: Receive Flow Steering”h]”hŒRFS: Receive Flow Steering”…””}”(hj/  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hj,  hžhhŸh³h M8ubhÛ)”}”(hXà  While RPS steers packets solely based on hash, and thus generally
provides good load distribution, it does not take into account
application locality. This is accomplished by Receive Flow Steering
(RFS). The goal of RFS is to increase datacache hitrate by steering
kernel processing of packets to the CPU where the application thread
consuming the packet is running. RFS relies on the same RPS mechanisms
to enqueue packets onto the backlog of another CPU and to wake up that
CPU.”h]”hXà  While RPS steers packets solely based on hash, and thus generally
provides good load distribution, it does not take into account
application locality. This is accomplished by Receive Flow Steering
(RFS). The goal of RFS is to increase datacache hitrate by steering
kernel processing of packets to the CPU where the application thread
consuming the packet is running. RFS relies on the same RPS mechanisms
to enqueue packets onto the backlog of another CPU and to wake up that
CPU.”…””}”(hj=  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M:hj,  hžhubhÛ)”}”(hX†  In RFS, packets are not forwarded directly by the value of their hash,
but the hash is used as index into a flow lookup table. This table maps
flows to the CPUs where those flows are being processed. The flow hash
(see RPS section above) is used to calculate the index into this table.
The CPU recorded in each entry is the one which last processed the flow.
If an entry does not hold a valid CPU, then packets mapped to that entry
are steered using plain RPS. Multiple table entries may point to the
same CPU. Indeed, with many flows and few CPUs, it is very likely that
a single application thread handles flows with many different flow hashes.”h]”hX†  In RFS, packets are not forwarded directly by the value of their hash,
but the hash is used as index into a flow lookup table. This table maps
flows to the CPUs where those flows are being processed. The flow hash
(see RPS section above) is used to calculate the index into this table.
The CPU recorded in each entry is the one which last processed the flow.
If an entry does not hold a valid CPU, then packets mapped to that entry
are steered using plain RPS. Multiple table entries may point to the
same CPU. Indeed, with many flows and few CPUs, it is very likely that
a single application thread handles flows with many different flow hashes.”…””}”(hjK  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MChj,  hžhubhÛ)”}”(hX+  rps_sock_flow_table is a global flow table that contains the *desired* CPU
for flows: the CPU that is currently processing the flow in userspace.
Each table value is a CPU index that is updated during calls to recvmsg
and sendmsg (specifically, inet_recvmsg(), inet_sendmsg() and
tcp_splice_read()).”h]”(hŒ=rps_sock_flow_table is a global flow table that contains the ”…””}”(hjY  hžhhŸNh NubhŒemphasis”“”)”}”(hŒ	*desired*”h]”hŒdesired”…””}”(hjc  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1ja  hjY  ubhŒå CPU
for flows: the CPU that is currently processing the flow in userspace.
Each table value is a CPU index that is updated during calls to recvmsg
and sendmsg (specifically, inet_recvmsg(), inet_sendmsg() and
tcp_splice_read()).”…””}”(hjY  hžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MMhj,  hžhubhÛ)”}”(hX÷  When the scheduler moves a thread to a new CPU while it has outstanding
receive packets on the old CPU, packets may arrive out of order. To
avoid this, RFS uses a second flow table to track outstanding packets
for each flow: rps_dev_flow_table is a table specific to each hardware
receive queue of each device. Each table value stores a CPU index and a
counter. The CPU index represents the *current* CPU onto which packets
for this flow are enqueued for further kernel processing. Ideally, kernel
and userspace processing occur on the same CPU, and hence the CPU index
in both tables is identical. This is likely false if the scheduler has
recently migrated a userspace thread while the kernel still has packets
enqueued for kernel processing on the old CPU.”h]”(hX‡  When the scheduler moves a thread to a new CPU while it has outstanding
receive packets on the old CPU, packets may arrive out of order. To
avoid this, RFS uses a second flow table to track outstanding packets
for each flow: rps_dev_flow_table is a table specific to each hardware
receive queue of each device. Each table value stores a CPU index and a
counter. The CPU index represents the ”…””}”(hj{  hžhhŸNh Nubjb  )”}”(hŒ	*current*”h]”hŒcurrent”…””}”(hjƒ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1ja  hj{  ubhXg   CPU onto which packets
for this flow are enqueued for further kernel processing. Ideally, kernel
and userspace processing occur on the same CPU, and hence the CPU index
in both tables is identical. This is likely false if the scheduler has
recently migrated a userspace thread while the kernel still has packets
enqueued for kernel processing on the old CPU.”…””}”(hj{  hžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MShj,  hžhubhÛ)”}”(hX   The counter in rps_dev_flow_table values records the length of the current
CPU's backlog when a packet in this flow was last enqueued. Each backlog
queue has a head counter that is incremented on dequeue. A tail counter
is computed as head counter + queue length. In other words, the counter
in rps_dev_flow[i] records the last element in flow i that has
been enqueued onto the currently designated CPU for flow i (of course,
entry i is actually selected by hash and multiple flows may hash to the
same entry i).”h]”hX  The counter in rps_dev_flow_table values records the length of the current
CPUâ€™s backlog when a packet in this flow was last enqueued. Each backlog
queue has a head counter that is incremented on dequeue. A tail counter
is computed as head counter + queue length. In other words, the counter
in rps_dev_flow[i] records the last element in flow i that has
been enqueued onto the currently designated CPU for flow i (of course,
entry i is actually selected by hash and multiple flows may hash to the
same entry i).”…””}”(hj›  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M_hj,  hžhubhÛ)”}”(hXù  And now the trick for avoiding out of order packets: when selecting the
CPU for packet processing (from get_rps_cpu()) the rps_sock_flow table
and the rps_dev_flow table of the queue that the packet was received on
are compared. If the desired CPU for the flow (found in the
rps_sock_flow table) matches the current CPU (found in the rps_dev_flow
table), the packet is enqueued onto that CPUâ€™s backlog. If they differ,
the current CPU is updated to match the desired CPU if one of the
following is true:”h]”hXù  And now the trick for avoiding out of order packets: when selecting the
CPU for packet processing (from get_rps_cpu()) the rps_sock_flow table
and the rps_dev_flow table of the queue that the packet was received on
are compared. If the desired CPU for the flow (found in the
rps_sock_flow table) matches the current CPU (found in the rps_dev_flow
table), the packet is enqueued onto that CPUâ€™s backlog. If they differ,
the current CPU is updated to match the desired CPU if one of the
following is true:”…””}”(hj©  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Mhhj,  hžhubhŒblock_quote”“”)”}”(hŒ§- The current CPU's queue head counter >= the recorded tail counter
  value in rps_dev_flow[i]
- The current CPU is unset (>= nr_cpu_ids)
- The current CPU is offline
”h]”hù)”}”(hhh]”(hþ)”}”(hŒZThe current CPU's queue head counter >= the recorded tail counter
value in rps_dev_flow[i]”h]”hÛ)”}”(hŒZThe current CPU's queue head counter >= the recorded tail counter
value in rps_dev_flow[i]”h]”hŒ\The current CPUâ€™s queue head counter >= the recorded tail counter
value in rps_dev_flow[i]”…””}”(hjÄ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MqhjÀ  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhj½  ubhþ)”}”(hŒ(The current CPU is unset (>= nr_cpu_ids)”h]”hÛ)”}”(hjÚ  h]”hŒ(The current CPU is unset (>= nr_cpu_ids)”…””}”(hjÜ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MshjØ  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhj½  ubhþ)”}”(hŒThe current CPU is offline
”h]”hÛ)”}”(hŒThe current CPU is offline”h]”hŒThe current CPU is offline”…””}”(hjó  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Mthjï  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhj½  ubeh}”(h]”h ]”h"]”h$]”h&]”jy  jz  uh1høhŸh³h Mqhj¹  ubah}”(h]”h ]”h"]”h$]”h&]”uh1j·  hŸh³h Mqhj,  hžhubhÛ)”}”(hX  After this check, the packet is sent to the (possibly updated) current
CPU. These rules aim to ensure that a flow only moves to a new CPU when
there are no packets outstanding on the old CPU, as the outstanding
packets could arrive later than those about to be processed on the new
CPU.”h]”hX  After this check, the packet is sent to the (possibly updated) current
CPU. These rules aim to ensure that a flow only moves to a new CPU when
there are no packets outstanding on the old CPU, as the outstanding
packets could arrive later than those about to be processed on the new
CPU.”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Mvhj,  hžhubhµ)”}”(hhh]”(hº)”}”(hŒRFS Configuration”h]”hŒRFS Configuration”…””}”(hj$  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hj!  hžhhŸh³h M~ubhÛ)”}”(hŒÚRFS is only available if the kconfig symbol CONFIG_RPS is enabled (on
by default for SMP). The functionality remains disabled until explicitly
configured. The number of entries in the global flow table is set through::”h]”hŒÙRFS is only available if the kconfig symbol CONFIG_RPS is enabled (on
by default for SMP). The functionality remains disabled until explicitly
configured. The number of entries in the global flow table is set through:”…””}”(hj2  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M€hj!  hžhubjÍ  )”}”(hŒ(/proc/sys/net/core/rps_sock_flow_entries”h]”hŒ(/proc/sys/net/core/rps_sock_flow_entries”…””}”hj@  sbah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jÌ  hŸh³h M„hj!  hžhubhÛ)”}”(hŒCThe number of entries in the per-queue flow table are set through::”h]”hŒBThe number of entries in the per-queue flow table are set through:”…””}”(hjN  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M†hj!  hžhubjÍ  )”}”(hŒ//sys/class/net/<dev>/queues/rx-<n>/rps_flow_cnt”h]”hŒ//sys/class/net/<dev>/queues/rx-<n>/rps_flow_cnt”…””}”hj\  sbah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jÌ  hŸh³h Mˆhj!  hžhubhµ)”}”(hhh]”(hº)”}”(hŒSuggested Configuration”h]”hŒSuggested Configuration”…””}”(hjm  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hjj  hžhhŸh³h MŒubhÛ)”}”(hX˜  Both of these need to be set before RFS is enabled for a receive queue.
Values for both are rounded up to the nearest power of two. The
suggested flow count depends on the expected number of active connections
at any given time, which may be significantly less than the number of open
connections. We have found that a value of 32768 for rps_sock_flow_entries
works fairly well on a moderately loaded server.”h]”hX˜  Both of these need to be set before RFS is enabled for a receive queue.
Values for both are rounded up to the nearest power of two. The
suggested flow count depends on the expected number of active connections
at any given time, which may be significantly less than the number of open
connections. We have found that a value of 32768 for rps_sock_flow_entries
works fairly well on a moderately loaded server.”…””}”(hj{  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MŽhjj  hžhubhÛ)”}”(hX»  For a single queue device, the rps_flow_cnt value for the single queue
would normally be configured to the same value as rps_sock_flow_entries.
For a multi-queue device, the rps_flow_cnt for each queue might be
configured as rps_sock_flow_entries / N, where N is the number of
queues. So for instance, if rps_sock_flow_entries is set to 32768 and there
are 16 configured receive queues, rps_flow_cnt for each queue might be
configured as 2048.”h]”hX»  For a single queue device, the rps_flow_cnt value for the single queue
would normally be configured to the same value as rps_sock_flow_entries.
For a multi-queue device, the rps_flow_cnt for each queue might be
configured as rps_sock_flow_entries / N, where N is the number of
queues. So for instance, if rps_sock_flow_entries is set to 32768 and there
are 16 configured receive queues, rps_flow_cnt for each queue might be
configured as 2048.”…””}”(hj‰  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M•hjj  hžhubeh}”(h]”Œid3”ah ]”h"]”h$]”Œsuggested configuration”ah&]”uh1h´hj!  hžhhŸh³h MŒj  Kubeh}”(h]”Œrfs-configuration”ah ]”h"]”Œrfs configuration”ah$]”h&]”uh1h´hj,  hžhhŸh³h M~ubeh}”(h]”Œrfs-receive-flow-steering”ah ]”h"]”Œrfs: receive flow steering”ah$]”h&]”uh1h´hh¶hžhhŸh³h M8ubhµ)”}”(hhh]”(hº)”}”(hŒAccelerated RFS”h]”hŒAccelerated RFS”…””}”(hj²  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hj¯  hžhhŸh³h MŸubhÛ)”}”(hXø  Accelerated RFS is to RFS what RSS is to RPS: a hardware-accelerated load
balancing mechanism that uses soft state to steer flows based on where
the application thread consuming the packets of each flow is running.
Accelerated RFS should perform better than RFS since packets are sent
directly to a CPU local to the thread consuming the data. The target CPU
will either be the same CPU where the application runs, or at least a CPU
which is local to the application threadâ€™s CPU in the cache hierarchy.”h]”hXø  Accelerated RFS is to RFS what RSS is to RPS: a hardware-accelerated load
balancing mechanism that uses soft state to steer flows based on where
the application thread consuming the packets of each flow is running.
Accelerated RFS should perform better than RFS since packets are sent
directly to a CPU local to the thread consuming the data. The target CPU
will either be the same CPU where the application runs, or at least a CPU
which is local to the application threadâ€™s CPU in the cache hierarchy.”…””}”(hjÀ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M¡hj¯  hžhubhÛ)”}”(hXu  To enable accelerated RFS, the networking stack calls the
ndo_rx_flow_steer driver function to communicate the desired hardware
queue for packets matching a particular flow. The network stack
automatically calls this function every time a flow entry in
rps_dev_flow_table is updated. The driver in turn uses a device specific
method to program the NIC to steer the packets.”h]”hXu  To enable accelerated RFS, the networking stack calls the
ndo_rx_flow_steer driver function to communicate the desired hardware
queue for packets matching a particular flow. The network stack
automatically calls this function every time a flow entry in
rps_dev_flow_table is updated. The driver in turn uses a device specific
method to program the NIC to steer the packets.”…””}”(hjÎ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M©hj¯  hžhubhÛ)”}”(hXX  The hardware queue for a flow is derived from the CPU recorded in
rps_dev_flow_table. The stack consults a CPU to hardware queue map which
is maintained by the NIC driver. This is an auto-generated reverse map of
the IRQ affinity table shown by /proc/interrupts. Drivers can use
functions in the cpu_rmap (â€œCPU affinity reverse mapâ€) kernel library
to populate the map. Alternatively, drivers can delegate the cpu_rmap
management to the Kernel by calling netif_enable_cpu_rmap(). For each CPU,
the corresponding queue in the map is set to be one whose processing CPU is
closest in cache locality.”h]”hXX  The hardware queue for a flow is derived from the CPU recorded in
rps_dev_flow_table. The stack consults a CPU to hardware queue map which
is maintained by the NIC driver. This is an auto-generated reverse map of
the IRQ affinity table shown by /proc/interrupts. Drivers can use
functions in the cpu_rmap (â€œCPU affinity reverse mapâ€) kernel library
to populate the map. Alternatively, drivers can delegate the cpu_rmap
management to the Kernel by calling netif_enable_cpu_rmap(). For each CPU,
the corresponding queue in the map is set to be one whose processing CPU is
closest in cache locality.”…””}”(hjÜ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M°hj¯  hžhubhµ)”}”(hhh]”(hº)”}”(hŒAccelerated RFS Configuration”h]”hŒAccelerated RFS Configuration”…””}”(hjí  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hjê  hžhhŸh³h M¼ubhÛ)”}”(hXu  Accelerated RFS is only available if the kernel is compiled with
CONFIG_RFS_ACCEL and support is provided by the NIC device and driver.
It also requires that ntuple filtering is enabled via ethtool. The map
of CPU to queues is automatically deduced from the IRQ affinities
configured for each receive queue by the driver, so no additional
configuration should be necessary.”h]”hXu  Accelerated RFS is only available if the kernel is compiled with
CONFIG_RFS_ACCEL and support is provided by the NIC device and driver.
It also requires that ntuple filtering is enabled via ethtool. The map
of CPU to queues is automatically deduced from the IRQ affinities
configured for each receive queue by the driver, so no additional
configuration should be necessary.”…””}”(hjû  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M¾hjê  hžhubhµ)”}”(hhh]”(hº)”}”(hŒSuggested Configuration”h]”hŒSuggested Configuration”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hj	  hžhhŸh³h MÇubhÛ)”}”(hŒjThis technique should be enabled whenever one wants to use RFS and the
NIC supports hardware acceleration.”h]”hŒjThis technique should be enabled whenever one wants to use RFS and the
NIC supports hardware acceleration.”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MÉhj	  hžhubeh}”(h]”Œid4”ah ]”h"]”h$]”Œsuggested configuration”ah&]”uh1h´hjê  hžhhŸh³h MÇj  Kubeh}”(h]”Œaccelerated-rfs-configuration”ah ]”h"]”Œaccelerated rfs configuration”ah$]”h&]”uh1h´hj¯  hžhhŸh³h M¼ubeh}”(h]”Œaccelerated-rfs”ah ]”h"]”Œaccelerated rfs”ah$]”h&]”uh1h´hh¶hžhhŸh³h MŸubhµ)”}”(hhh]”(hº)”}”(hŒXPS: Transmit Packet Steering”h]”hŒXPS: Transmit Packet Steering”…””}”(hjC  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hj@  hžhhŸh³h MÎubhÛ)”}”(hX9  Transmit Packet Steering is a mechanism for intelligently selecting
which transmit queue to use when transmitting a packet on a multi-queue
device. This can be accomplished by recording two kinds of maps, either
a mapping of CPU to hardware queue(s) or a mapping of receive queue(s)
to hardware transmit queue(s).”h]”hX9  Transmit Packet Steering is a mechanism for intelligently selecting
which transmit queue to use when transmitting a packet on a multi-queue
device. This can be accomplished by recording two kinds of maps, either
a mapping of CPU to hardware queue(s) or a mapping of receive queue(s)
to hardware transmit queue(s).”…””}”(hjQ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MÐhj@  hžhubje  )”}”(hhh]”hþ)”}”(hŒXPS using CPUs map
”h]”hÛ)”}”(hŒXPS using CPUs map”h]”hŒXPS using CPUs map”…””}”(hjf  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MÖhjb  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhj_  hžhhŸh³h Nubah}”(h]”h ]”h"]”h$]”h&]”jµ  j¶  j·  hj¸  Œ.”uh1jd  hj@  hžhhŸh³h MÖubhÛ)”}”(hX  The goal of this mapping is usually to assign queues
exclusively to a subset of CPUs, where the transmit completions for
these queues are processed on a CPU within this set. This choice
provides two benefits. First, contention on the device queue lock is
significantly reduced since fewer CPUs contend for the same queue
(contention can be eliminated completely if each CPU has its own
transmit queue). Secondly, cache miss rate on transmit completion is
reduced, in particular for data cache lines that hold the sk_buff
structures.”h]”hX  The goal of this mapping is usually to assign queues
exclusively to a subset of CPUs, where the transmit completions for
these queues are processed on a CPU within this set. This choice
provides two benefits. First, contention on the device queue lock is
significantly reduced since fewer CPUs contend for the same queue
(contention can be eliminated completely if each CPU has its own
transmit queue). Secondly, cache miss rate on transmit completion is
reduced, in particular for data cache lines that hold the sk_buff
structures.”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MØhj@  hžhubje  )”}”(hhh]”hþ)”}”(hŒXPS using receive queues map
”h]”hÛ)”}”(hŒXPS using receive queues map”h]”hŒXPS using receive queues map”…””}”(hj–  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Mâhj’  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhj  hžhhŸh³h Nubah}”(h]”h ]”h"]”h$]”h&]”jµ  j¶  j·  hj¸  j€  Œstart”Kuh1jd  hj@  hžhhŸh³h MâubhÛ)”}”(hX…  This mapping is used to pick transmit queue based on the receive
queue(s) map configuration set by the administrator. A set of receive
queues can be mapped to a set of transmit queues (many:many), although
the common use case is a 1:1 mapping. This will enable sending packets
on the same queue associations for transmit and receive. This is useful for
busy polling multi-threaded workloads where there are challenges in
associating a given CPU to a given application thread. The application
threads are not pinned to CPUs and each thread handles packets
received on a single queue. The receive queue number is cached in the
socket for the connection. In this model, sending the packets on the same
transmit queue corresponding to the associated receive queue has benefits
in keeping the CPU overhead low. Transmit completion work is locked into
the same queue-association that a given application is polling on. This
avoids the overhead of triggering an interrupt on another CPU. When the
application cleans up the packets during the busy poll, transmit completion
may be processed along with it in the same thread context and so result in
reduced latency.”h]”hX…  This mapping is used to pick transmit queue based on the receive
queue(s) map configuration set by the administrator. A set of receive
queues can be mapped to a set of transmit queues (many:many), although
the common use case is a 1:1 mapping. This will enable sending packets
on the same queue associations for transmit and receive. This is useful for
busy polling multi-threaded workloads where there are challenges in
associating a given CPU to a given application thread. The application
threads are not pinned to CPUs and each thread handles packets
received on a single queue. The receive queue number is cached in the
socket for the connection. In this model, sending the packets on the same
transmit queue corresponding to the associated receive queue has benefits
in keeping the CPU overhead low. Transmit completion work is locked into
the same queue-association that a given application is polling on. This
avoids the overhead of triggering an interrupt on another CPU. When the
application cleans up the packets during the busy poll, transmit completion
may be processed along with it in the same thread context and so result in
reduced latency.”…””}”(hj±  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Mähj@  hžhubhÛ)”}”(hXÈ  XPS is configured per transmit queue by setting a bitmap of
CPUs/receive-queues that may use that queue to transmit. The reverse
mapping, from CPUs to transmit queues or from receive-queues to transmit
queues, is computed and maintained for each network device. When
transmitting the first packet in a flow, the function get_xps_queue() is
called to select a queue. This function uses the ID of the receive queue
for the socket connection for a match in the receive queue-to-transmit queue
lookup table. Alternatively, this function can also use the ID of the
running CPU as a key into the CPU-to-queue lookup table. If the
ID matches a single queue, that is used for transmission. If multiple
queues match, one is selected by using the flow hash to compute an index
into the set. When selecting the transmit queue based on receive queue(s)
map, the transmit device is not validated against the receive device as it
requires expensive lookup operation in the datapath.”h]”hXÈ  XPS is configured per transmit queue by setting a bitmap of
CPUs/receive-queues that may use that queue to transmit. The reverse
mapping, from CPUs to transmit queues or from receive-queues to transmit
queues, is computed and maintained for each network device. When
transmitting the first packet in a flow, the function get_xps_queue() is
called to select a queue. This function uses the ID of the receive queue
for the socket connection for a match in the receive queue-to-transmit queue
lookup table. Alternatively, this function can also use the ID of the
running CPU as a key into the CPU-to-queue lookup table. If the
ID matches a single queue, that is used for transmission. If multiple
queues match, one is selected by using the flow hash to compute an index
into the set. When selecting the transmit queue based on receive queue(s)
map, the transmit device is not validated against the receive device as it
requires expensive lookup operation in the datapath.”…””}”(hj¿  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Möhj@  hžhubhÛ)”}”(hX	  The queue chosen for transmitting a particular flow is saved in the
corresponding socket structure for the flow (e.g. a TCP connection).
This transmit queue is used for subsequent packets sent on the flow to
prevent out of order (ooo) packets. The choice also amortizes the cost
of calling get_xps_queues() over all packets in the flow. To avoid
ooo packets, the queue for a flow can subsequently only be changed if
skb->ooo_okay is set for a packet in the flow. This flag indicates that
there are no outstanding packets in the flow, so the transmit queue can
change without the risk of generating out of order packets. The
transport layer is responsible for setting ooo_okay appropriately. TCP,
for instance, sets the flag when all data for a connection has been
acknowledged.”h]”hX	  The queue chosen for transmitting a particular flow is saved in the
corresponding socket structure for the flow (e.g. a TCP connection).
This transmit queue is used for subsequent packets sent on the flow to
prevent out of order (ooo) packets. The choice also amortizes the cost
of calling get_xps_queues() over all packets in the flow. To avoid
ooo packets, the queue for a flow can subsequently only be changed if
skb->ooo_okay is set for a packet in the flow. This flag indicates that
there are no outstanding packets in the flow, so the transmit queue can
change without the risk of generating out of order packets. The
transport layer is responsible for setting ooo_okay appropriately. TCP,
for instance, sets the flag when all data for a connection has been
acknowledged.”…””}”(hjÍ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h Mhj@  hžhubhµ)”}”(hhh]”(hº)”}”(hŒXPS Configuration”h]”hŒXPS Configuration”…””}”(hjÞ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hjÛ  hžhhŸh³h MubhÛ)”}”(hX  XPS is only available if the kconfig symbol CONFIG_XPS is enabled (on by
default for SMP). If compiled in, it is driver dependent whether, and
how, XPS is configured at device init. The mapping of CPUs/receive-queues
to transmit queue can be inspected and configured using sysfs:”h]”hX  XPS is only available if the kconfig symbol CONFIG_XPS is enabled (on by
default for SMP). If compiled in, it is driver dependent whether, and
how, XPS is configured at device init. The mapping of CPUs/receive-queues
to transmit queue can be inspected and configured using sysfs:”…””}”(hjì  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MhjÛ  hžhubhÛ)”}”(hŒ!For selection based on CPUs map::”h]”hŒ For selection based on CPUs map:”…””}”(hjú  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MhjÛ  hžhubjÍ  )”}”(hŒ+/sys/class/net/<dev>/queues/tx-<n>/xps_cpus”h]”hŒ+/sys/class/net/<dev>/queues/tx-<n>/xps_cpus”…””}”hj  sbah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jÌ  hŸh³h MhjÛ  hžhubhÛ)”}”(hŒ+For selection based on receive-queues map::”h]”hŒ*For selection based on receive-queues map:”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MhjÛ  hžhubjÍ  )”}”(hŒ+/sys/class/net/<dev>/queues/tx-<n>/xps_rxqs”h]”hŒ+/sys/class/net/<dev>/queues/tx-<n>/xps_rxqs”…””}”hj$  sbah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jÌ  hŸh³h M hjÛ  hžhubhµ)”}”(hhh]”(hº)”}”(hŒSuggested Configuration”h]”hŒSuggested Configuration”…””•„(      }”(hj5  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hj2  hžhhŸh³h M$ubhÛ)”}”(hXO  For a network device with a single transmission queue, XPS configuration
has no effect, since there is no choice in this case. In a multi-queue
system, XPS is preferably configured so that each CPU maps onto one queue.
If there are as many queues as there are CPUs in the system, then each
queue can also map onto one CPU, resulting in exclusive pairings that
experience no contention. If there are fewer queues than CPUs, then the
best CPUs to share a given queue are probably those that share the cache
with the CPU that processes transmit completions for that queue
(transmit interrupts).”h]”hXO  For a network device with a single transmission queue, XPS configuration
has no effect, since there is no choice in this case. In a multi-queue
system, XPS is preferably configured so that each CPU maps onto one queue.
If there are as many queues as there are CPUs in the system, then each
queue can also map onto one CPU, resulting in exclusive pairings that
experience no contention. If there are fewer queues than CPUs, then the
best CPUs to share a given queue are probably those that share the cache
with the CPU that processes transmit completions for that queue
(transmit interrupts).”…””}”(hjC  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M&hj2  hžhubhÛ)”}”(hX  For transmit queue selection based on receive queue(s), XPS has to be
explicitly configured mapping receive-queue(s) to transmit queue(s). If the
user configuration for receive-queue map does not apply, then the transmit
queue is selected based on the CPUs map.”h]”hX  For transmit queue selection based on receive queue(s), XPS has to be
explicitly configured mapping receive-queue(s) to transmit queue(s). If the
user configuration for receive-queue map does not apply, then the transmit
queue is selected based on the CPUs map.”…””}”(hjQ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M0hj2  hžhubeh}”(h]”Œid5”ah ]”h"]”h$]”Œsuggested configuration”ah&]”uh1h´hjÛ  hžhhŸh³h M$j  Kubeh}”(h]”Œxps-configuration”ah ]”h"]”Œxps configuration”ah$]”h&]”uh1h´hj@  hžhhŸh³h Mubeh}”(h]”Œxps-transmit-packet-steering”ah ]”h"]”Œxps: transmit packet steering”ah$]”h&]”uh1h´hh¶hžhhŸh³h MÎubhµ)”}”(hhh]”(hº)”}”(hŒPer TX Queue rate limitation”h]”hŒPer TX Queue rate limitation”…””}”(hjz  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hjw  hžhhŸh³h M7ubhÛ)”}”(hŒ‡These are rate-limitation mechanisms implemented by HW, where currently
a max-rate attribute is supported, by setting a Mbps value to::”h]”hŒ†These are rate-limitation mechanisms implemented by HW, where currently
a max-rate attribute is supported, by setting a Mbps value to:”…””}”(hjˆ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M9hjw  hžhubjÍ  )”}”(hŒ-/sys/class/net/<dev>/queues/tx-<n>/tx_maxrate”h]”hŒ-/sys/class/net/<dev>/queues/tx-<n>/tx_maxrate”…””}”hj–  sbah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jÌ  hŸh³h M<hjw  hžhubhÛ)”}”(hŒ8A value of zero means disabled, and this is the default.”h]”hŒ8A value of zero means disabled, and this is the default.”…””}”(hj¤  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h M>hjw  hžhubeh}”(h]”Œper-tx-queue-rate-limitation”ah ]”h"]”Œper tx queue rate limitation”ah$]”h&]”uh1h´hh¶hžhhŸh³h M7ubhµ)”}”(hhh]”(hº)”}”(hŒFurther Information”h]”hŒFurther Information”…””}”(hj½  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hjº  hžhhŸh³h MBubhÛ)”}”(hŒ”RPS and RFS were introduced in kernel 2.6.35. XPS was incorporated into
2.6.38. Original patches were submitted by Tom Herbert
(therbert@google.com)”h]”(hŒ€RPS and RFS were introduced in kernel 2.6.35. XPS was incorporated into
2.6.38. Original patches were submitted by Tom Herbert
(”…””}”(hjË  hžhhŸNh NubhŒ	reference”“”)”}”(hŒtherbert@google.com”h]”hŒtherbert@google.com”…””}”(hjÕ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”Œrefuri”Œmailto:therbert@google.com”uh1jÓ  hjË  ubhŒ)”…””}”(hjË  hžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MChjº  hžhubhÛ)”}”(hŒkAccelerated RFS was introduced in 2.6.35. Original patches were
submitted by Ben Hutchings (bwh@kernel.org)”h]”(hŒ\Accelerated RFS was introduced in 2.6.35. Original patches were
submitted by Ben Hutchings (”…””}”(hjï  hžhhŸNh NubjÔ  )”}”(hŒbwh@kernel.org”h]”hŒbwh@kernel.org”…””}”(hj÷  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”Œrefuri”Œmailto:bwh@kernel.org”uh1jÓ  hjï  ubhŒ)”…””}”(hjï  hžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MGhjº  hžhubhÛ)”}”(hŒAuthors:”h]”hŒAuthors:”…””}”(hj	  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MJhjº  hžhubhù)”}”(hhh]”(hþ)”}”(hŒ!Tom Herbert (therbert@google.com)”h]”hÛ)”}”(hj$	  h]”(hŒTom Herbert (”…””}”(hj&	  hžhhŸNh NubjÔ  )”}”(hŒtherbert@google.com”h]”hŒtherbert@google.com”…””}”(hj-	  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”Œrefuri”Œmailto:therbert@google.com”uh1jÓ  hj&	  ubhŒ)”…””}”(hj&	  hžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MLhj"	  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhj	  hžhhŸh³h Nubhþ)”}”(hŒ%Willem de Bruijn (willemb@google.com)”h]”hÛ)”}”(hjO	  h]”(hŒWillem de Bruijn (”…””}”(hjQ	  hžhhŸNh NubjÔ  )”}”(hŒwillemb@google.com”h]”hŒwillemb@google.com”…””}”(hjX	  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”Œrefuri”Œmailto:willemb@google.com”uh1jÓ  hjQ	  ubhŒ)”…””}”(hjQ	  hžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÚhŸh³h MMhjM	  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hýhj	  hžhhŸh³h Nubeh}”(h]”h ]”h"]”h$]”h&]”jy  jz  uh1høhŸh³h MLhjº  hžhubeh}”(h]”Œfurther-information”ah ]”h"]”Œfurther information”ah$]”h&]”uh1h´hh¶hžhhŸh³h MBubeh}”(h]”Œ%scaling-in-the-linux-networking-stack”ah ]”h"]”Œ%scaling in the linux networking stack”ah$]”h&]”uh1h´hhhžhhŸh³h Kubeh}”(h]”h ]”h"]”h$]”h&]”Œsource”h³uh1hŒcurrent_source”NŒcurrent_line”NŒsettings”Œdocutils.frontend”ŒValues”“”)”}”(h¹NŒ	generator”NŒ	datestamp”NŒsource_link”NŒ
source_url”NŒtoc_backlinks”Œentry”Œfootnote_backlinks”KŒsectnum_xform”KŒstrip_comments”NŒstrip_elements_with_classes”NŒstrip_classes”NŒreport_level”KŒ
halt_level”KŒexit_status_level”KŒdebug”NŒwarning_stream”NŒ	traceback”ˆŒinput_encoding”Œ	utf-8-sig”Œinput_encoding_error_handler”Œstrict”Œoutput_encoding”Œutf-8”Œoutput_encoding_error_handler”j±	  Œerror_encoding”Œutf-8”Œerror_encoding_error_handler”Œbackslashreplace”Œlanguage_code”Œen”Œrecord_dependencies”NŒconfig”NŒ	id_prefix”hŒauto_id_prefix”Œid”Œdump_settings”NŒdump_internals”NŒdump_transforms”NŒdump_pseudo_xml”NŒexpose_internals”NŒstrict_visitor”NŒ_disable_config”NŒ_source”h³Œ_destination”NŒ_config_files”]”Œ7/var/lib/git/docbuild/linux/Documentation/docutils.conf”aŒfile_insertion_enabled”ˆŒraw_enabled”KŒline_length_limit”M'Œpep_references”NŒpep_base_url”Œhttps://peps.python.org/”Œpep_file_url_template”Œpep-%04d”Œrfc_references”NŒrfc_base_url”Œ&https://datatracker.ietf.org/doc/html/”Œ	tab_width”KŒtrim_footnote_reference_space”‰Œsyntax_highlight”Œlong”Œsmart_quotes”ˆŒsmartquotes_locales”]”Œcharacter_level_inline_markup”‰Œdoctitle_xform”‰Œdocinfo_xform”KŒsectsubtitle_xform”‰Œimage_loading”Œlink”Œembed_stylesheet”‰Œcloak_email_addresses”ˆŒsection_self_link”‰Œenv”NubŒreporter”NŒindirect_targets”]”Œsubstitution_defs”}”Œsubstitution_names”}”Œrefnames”}”Œrefids”}”Œnameids”}”(j‹	  jˆ	  j€  j}  jB  j?  j:  j7  je  jb  Œsuggested configuration”Nj2  j/  j)  j&  jX  jU  j!  j  jä  já  j¬  j©  j¤  j¡  j=  j:  j5  j2  jt  jq  jl  ji  j·  j´  jƒ	  j€	  uŒ	nametypes”}”(j‹	  ‰j€  ‰jB  ‰j:  ‰je  ‰jõ	  ‰j2  ‰j)  ‰jX  ‰j!  ‰jä  ‰j¬  ‰j¤  ‰j=  ‰j5  ‰jt  ‰jl  ‰j·  ‰jƒ	  ‰uh}”(jˆ	  h¶j}  hÉj?  jƒ  j7  j  jb  jA  j—  jh  j/  jž  j&  jE  jU  jä  jN  j  j  j[  já  jˆ  j  jç  j©  j,  j¡  j!  j™  jj  j:  j¯  j2  jê  j*  j	  jq  j@  ji  jÛ  ja  j2  j´  jw  j€	  jº  uŒfootnote_refs”}”Œcitation_refs”}”Œautofootnotes”]”Œautofootnote_refs”]”Œsymbol_footnotes”]”Œsymbol_footnote_refs”]”Œ	footnotes”]”Œ	citations”]”Œautofootnote_start”KŒsymbol_footnote_start”K Œ
id_counter”Œcollections”ŒCounter”“”}”j¿	  Ks…”R”Œparse_messages”]”(hŒsystem_message”“”)”}”(hhh]”hÛ)”}”(hŒ:Duplicate implicit target name: "suggested configuration".”h]”hŒ>Duplicate implicit target name: â€œsuggested configurationâ€.”…””}”(hj
  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhj
  ubah}”(h]”h ]”h"]”h$]”h&]”jN  aŒlevel”KŒtype”ŒINFO”Œsource”h³Œline”Kèuh1j
  hj  hžhhŸh³h Kèubj
  )”}”(hhh]”hÛ)”}”(hŒ:Duplicate implicit target name: "suggested configuration".”h]”hŒ>Duplicate implicit target name: â€œsuggested configurationâ€.”…””}”(hj5
  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhj2
  ubah}”(h]”h ]”h"]”h$]”h&]”j  aŒlevel”KŒtype”j/
  Œsource”h³Œline”M*uh1j
  hjç  hžhhŸh³h M*ubj
  )”}”(hhh]”hÛ)”}”(hŒ:Duplicate implicit target name: "suggested configuration".”h]”hŒ>Duplicate implicit target name: â€œsuggested configurationâ€.”…””}”(hjP
  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhjM
  ubah}”(h]”h ]”h"]”h$]”h&]”j™  aŒlevel”KŒtype”j/
  Œsource”h³Œline”MŒuh1j
  hjj  hžhhŸh³h MŒubj
  )”}”(hhh]”hÛ)”}”(hŒ:Duplicate implicit target name: "suggested configuration".”h]”hŒ>Duplicate implicit target name: â€œsuggested configurationâ€.”…””}”(hjk
  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhjh
  ubah}”(h]”h ]”h"]”h$]”h&]”j*  aŒlevel”KŒtype”j/
  Œsource”h³Œline”MÇuh1j
  hj	  hžhhŸh³h MÇubj
  )”}”(hhh]”hÛ)”}”(hŒ:Enumerated list start value not ordinal-1: "2" (ordinal 2)”h]”hŒ>Enumerated list start value not ordinal-1: â€œ2â€ (ordinal 2)”…””}”(hj†
  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhjƒ
  ubah}”(h]”h ]”h"]”h$]”h&]”Œlevel”KŒtype”j/
  Œsource”h³Œline”Kuh1j
  hj@  hžhhŸh³h Mâubj
  )”}”(hhh]”hÛ)”}”(hŒ:Duplicate implicit target name: "suggested configuration".”h]”hŒ>Duplicate implicit target name: â€œsuggested configurationâ€.”…””}”(hj¡
  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÚhjž
  ubah}”(h]”h ]”h"]”h$]”h&]”ja  aŒlevel”KŒtype”j/
  Œsource”h³Œline”M$uh1j
  hj2  hžhhŸh³h M$ubeŒtransform_messages”]”Œtransformer”NŒinclude_log”]”Œ
decoration”Nhžhub.