Express data path based tag matching of packets
The XDP-based framework addresses the inefficiencies in RDMA tag matching by using a hashmap or ring buffer for packet tag matching, reducing latency and improving performance across diverse hardware, without needing specialized hardware or APIs.
Patent Information
- Application Number
- PCT/EP2023/062777
- Authority / Receiving Office
- WO · WO
- Patent Type
- Applications
- Current Assignee / Owner
- Filing Date
- 2023-05-12
- Publication Date
- 2024-11-21
AI Technical Summary
Current tag matching methods for RDMA require hardware vendor support, are complex to implement, and limited to specific hardware, leading to increased latency and inefficiencies in packet processing, especially for applications not using RDMA.
An XDP-based framework that uses a hashmap or ring buffer data structure to match packet tags, allowing for efficient tag-based buffer allocation and placement without requiring special hardware or APIs, supporting both user and kernel space operations.
This solution reduces latency and enhances application performance by enabling efficient tag matching across various hardware platforms, eliminating the need for RDMA-specific hardware and simplifying buffer management.
Smart Images

Figure EP2023062777_21112024_PF_FP_ABST
Abstract
Description
[0001] EXPRESS DATA PATH BASED TAG MATCHING OF PACKETS
[0002] TECHNICAL FIELD
[0003] The present disclosure relates to procedures of tag matching packets. The disclosure also relates to express data path (XDP) applications. In this disclosure an XDP application is used for performing tag matching of packets. To implement this tag matching, a method, an entity, and a computer program are proposed.
[0004] BACKGROUND
[0005] XDP provides a high performance, programmable network data path in the Linux kernel. XDP provides bare metal packet processing at the lowest point in the software stack, which makes it ideal for improving speed without compromising programmability. Furthermore, new functions can be implemented dynamically with the integrated fast path without kernel modifications. Other benefits of XDP are that it does not require any specialized hardware, that it does not require a kernel bypass, that it does not replace the TCP / IP stack, and that it works in concert with the TCP / IP stack along with all the benefits of Berkeley Packet Filter (BPF).
[0006] The XDP packet process includes an in-kemel component that processes received packet- pages directly out of driver via a functional interface without early allocation of skbuff s or software queues. Normally, one core of a central processing unit (CPU) is respectively assigned to each receive (RX) queue, but in this model there is no locking RX queue, and a CPU can be dedicated to a busy poll or interrupt model.
[0007] BPF programs perform processing such as packet parsing, table look ups, creating and / managing stateful filters, or encapsulating or decapsulating packets. The extensibility of BPF is kept intact with packet inspection and manipulation functions, flow and table lookups, and application processing leveraging BPF programs, which are portable to user space and other operating systems.
[0008] An XDP program can be connected to an interface using the following models:
[0009] • Generic XDP: The XDP program is loaded into the kernel as part of the ordinary network path. This may not provide full performance benefits, but is an easy way to test XDP programs or run them on generic hardware that does not provide specific support for XDP. • Native XDP: The XDP program is loaded by the network card driver as part of its initial receive path. This may also require support from the network card driver.
[0010] • Offloaded XDP: The XDP program loads directly on the network interface card (NIC), and executes without using the CPU.
[0011] A conventional XDP program can perform various operations with packets it receives, once it is connected to a network interface, for instance, dropping packets, forwarding packets, and redirecting packets.
[0012] Some modern high performance computing (HPC) applications use remote direct memory access (RDMA) tag matching, in order to decrease latency and increase performance and for better utilization. Networking libraries typically maintain several queues to keep track of a receive requests from an application. A receive request is equipped with a ‘tag’, while the header of every received packet also contains a tag field. There must be a match between these two tags, so that, the networking library can correctly copy a received message to an application buffer. This is how RDMA tag matching works.
[0013] RDMA tag matching enables a very efficient way to zero copy buffers from networking libraries that use RDMA tag matching. However, for an MPI library to support hardware tag matching, its entire communication stack needs to be reworked in accordance with hardware tag matching semantics. There are various design challenges of tag matching in hardware, for instance, how to handle expected messages, how to handle unexpected messages when a matching tag cannot be found, and how to preserve an order of consecutive messages with the same tag.
[0014] Modern efficient applications and user processes aim to decrease latency to provide world class user experience, and they aim to expose zero copy methods and application end buffer matching for placing data on its end location with specific description, also called tag matching. There are few common approaches in the industry for user space zero copy approaches, but not all can expose tag matching. RDMA tag matching requires special knowledge and commonly works for big messages only. SUMMARY
[0015] In summary of the above-described techniques, at least the following issues are identified by this disclosure:
[0016] • Enabling RDMA hardware tag matching requires the support of the hardware vendor.
[0017] • Applications need performance, but should not deal with networking configuration.
[0018] • Implementing a buffer list handler adds complexity to an application.
[0019] • There is no easy way to zero copy without special hardware or application programming interface.
[0020] • There is a need for more vendors to support generic hardware tag matching.
[0021] • Hardware implementation of tag matching can only support a limited number of outstanding receives due to limited resources.
[0022] • Hardware offload commonly requires the usage of large messages (>4K) and works for RDMA transport only.
[0023] • Applications that are not using RDMA are using copies on received buffers as the order is unknown.
[0024] • Most hardware vendors do not support RDMA tag matching.
[0025] In view of this, the present disclosure aims for a new method for tag matching messages. An objective is to accelerate applications by decreasing latency. To this end, a new framework is desired, which allows leveraging the tag matching of packets.
[0026] These and other objectives are achieved by the solutions of this disclosure as described in the independent claims. Advantageous implementations are described in the dependent claims.
[0027] A first aspect of this disclosure provides a method for tag matching packets, wherein the method executes an XDP application, wherein the XDP application performs the following steps: determining a tag included in a header of a received packet; determining whether the determined tag is included in a first data structure, wherein the first data structure includes one or more tags; if the determined tag is included in the first data structure, using the first data structure to determine a buffer that is associated with the determined tag; and placing the received packet into the determined buffer.
[0028] The use of the XDP application allows implementing tag matching, while providing the advantages of XDP described above. RDMA tag matching is not needed. The tag matching can accelerate applications, for example user processes, by decreasing their latency. The solution of the first aspect does not require a special hardware or application programming interface. Overall, the solution of the first aspect provides a new and improved method for tag matching packets.
[0029] In an implementation form of the first aspect, the first data structure is a hashmap storing one or more key-value pairs; the one or more tags are the one or more keys of the hashmap; and the one or more values in the hashmap are, per each key, a reference to a buffer or a reference to a second data structure.
[0030] In an implementation form of the first aspect, the XDP application further stores, in a second data structure, a reference to at least one buffer for each tag included in the first data structure.
[0031] In an implementation form of the first aspect, the XDP application determines the buffer that is associated with the determined tag from the second data structure.
[0032] In an implementation form of the first aspect, the second data structure is a ring buffer.
[0033] In an implementation form of the first aspect, the second data structure is a list in which references to the buffers are aligned, and each tag included in the first data structure is an index of a reference to at least one buffer in the list.
[0034] In an implementation form of the first aspect, the XDP application further performs the following steps, if the determined tag is not included in the first data structure: adding the determined tag into the first data structure; creating a buffer for the determined tag; and wherein the XDP application further performs one of the following steps: adding a reference to the created buffer in association with the added tag into the first data structure; or adding a reference to the second data structure in association with the added tag into the first data structure, and adding a reference to the created buffer for the added tag into the second data structure.
[0035] In an implementation form of the first aspect, the XDP application is executed in a NIC. Thus, native XDP and offloaded XDP are supported by the solution of the first aspect.
[0036] In an implementation form of the first aspect, the first data structure is stored in a kernel, and the XDP application loads the first data structure into a cache of the NIC.
[0037] In an implementation form of the first aspect, the XDP application is executed in a kernel, wherein the first data structure is stored in the kernel.
[0038] Thus, generic XDP is supported by the solution of the first aspect.
[0039] In an implementation form of the first aspect, each buffer and / or the second data structure is stored in the kernel.
[0040] In an implementation form of the first aspect, the XDP application further marks the determined buffer as completed, after placing the received packet into it.
[0041] In an implementation form of the first aspect, each buffer or each tag corresponds to a user process, and different user processes respectively process packets including different tags.
[0042] In an implementation form of the first aspect, the XDP application further performs the following steps: determining location information included in the header of the received packet, the location information indicating a location of the received packet within a queue of packets; and placing the received packet into the determined buffer according to the determined location information.
[0043] In this way, an order of the packets in the queue can be maintained.
[0044] A second aspect of this disclosure provides an entity for tag matching packets, wherein the entity is configured to execute an XDP application, and wherein the XDP application is configured to: determine a tag included in a header of a packet received by the entity; determine whether the determined tag is included in a first data structure, wherein the first data structure includes one or more tags; if the determined tag is included in the first data structure, use the first data structure to determine a buffer that is associated with the determined tag; and place the received packet into the determined buffer.
[0045] The entity of the second aspect may perform the method of the first aspect and its implementation forms. In particular, the XDP application of the entity may be configured to perform all functions of the XDP application described in the method of the first aspect and its implementation forms.
[0046] A third aspect of this disclosure provides computer program comprising instructions which, when the program is executed by a computer, cause the computer to perform the method according to the first aspect or any of its implementation forms.
[0047] A fourth aspect of this disclosure provides a non-transitory storage medium storing executable program code which, when executed by a processor, causes the method according to the second aspect or any of its implementation forms to be performed.
[0048] In summary of the above aspects and implementation forms, this disclosure proposes an advanced tag matching framework by leveraging purely XDP and its underlying enhanced BPF infrastructure. The solution of this disclosure may allow any user process that uses the framework to leverage tag matching of packets, for instance, with network cards that support XDP, and to enhance even more when using hardware enabled cards. Further, the solution of this disclosure may also allow any user to extend an XDP supporting network driver or device, in order to support tag matching of packets.
[0049] It has to be noted that all devices, elements, units and means described in the present application could be implemented in the software or hardware elements or any kind of combination thereof. All steps which are performed by the various entities described in the present application as well as the functionalities described to be performed by the various entities are intended to mean that the respective entity is adapted to or configured to perform the respective steps and functionalities. Even if, in the following description of specific embodiments, a specific functionality or step to be performed by external entities is not reflected in the description of a specific detailed element of that entity which performs that specific step or functionality, it should be clear for a skilled person that these methods and functionalities can be implemented in respective software or hardware elements, or any kind of combination thereof.
[0050] BRIEF DESCRIPTION OF DRAWINGS
[0051] The above described aspects and implementation forms will be explained in the following description of specific embodiments in relation to the enclosed drawings, in which
[0052] FIG. 1 shows an entity for tag matching packets according to this disclosure. FIG. 2 shows a method of tag matching packets according to this disclosure.
[0053] FIG. 3 shows schematically a framework proposed by this disclosure.
[0054] FIG. 4 shows an example of the method of this disclosure with hardware offload.
[0055] FIG. 5 shows further the example of FIG. 4.
[0056] FIG. 6 shows further the example of FIGs. 4 and 5.
[0057] FIG. 7 shows an example of the method of this disclosure with software offload
[0058] FIG. 8 shows further the example of FIG. 7.
[0059] FIG. 9 shows further the example of FIGs. 7 and 8.
[0060] FIG. 10 shows an exemplary flow chart for a method according to this disclosure.
[0061] FIG. 11 shows exemplary extensions for a method of this disclosure.
[0062] DETAILED DESCRIPTION OF EMBODIMENTS
[0063] FIG. 1 shows an entity 100 according to this disclosure. The entity 100 is configured for tag matching of packets 102. The entity 100 is, to this end, configured to perform a method 200 according to this disclosure, which is shown as a flow-diagram in FIG. 2. The entity 100 is configured to execute an XDP application 101, and specifically the XDP application 101 may perform the method 200 of FIG. 2 upon being executed by the entity 100. The entity 100 may be any device, and / or hardware, and / or software, which is able to support XDP and thus to execute the XDP application 101.
[0064] FIGs. and 2 illustrate how the XDP application 101 may perform tag matching based on a received packet 102, for instance, received by the entity 100 or by the XDP application 101.
[0065] At first, after obtaining the packet 102, the XDP application 101 determines a tag 103, which is included in a header of the received packet 102. OF course, if there is no tag 103 in the received packet 102, then the XDP application may determine this as well. However, it is assumed that in this case the received packet 102 includes a tag 103. The tag 103 may be included or indicated in a tag field of the header of the packet 102. The XDP application 101 may determine the tag 103 by extracting and / or reading it from the header of the packet 102, or any other suitable method.
[0066] Then, the XDP application 101 determines, whether the determined tag 103 of the packet 102 is included in a first data structure 104. The first data structure 104 includes one or more tags 103. The XDP application 103 may determine whether the tag 103 is included in the first data structure 104 by querying the first data structure 104, for instance, using the tag 103 in the query. The first data structure 104 could be a hashmap, which uses the included tags 103 as keys, or the first data structure may be a list, which uses the included tags 103 as indices of the listed elements. Each tag 103 included in the first data structure 104 may be associated with further information or references.
[0067] If the determined tag 103 of the packet 102 is included in the first data structure 104, i.e., if the XDP application 101 determines that the tag 103 of the received packet 102 is included, the XDP application 101 uses the first data structure 104 to determine a buffer 105 that is associated with the determined tag 103. For instance, the XDP application 101 may obtain information about the buffer 105 directly from the first data structure 104, for instance, it may obtain a reference to the buffer 105. The reference to the buffer 105 may be associated with the tag 103 of the packet 102 in the first data structure 104. The XDP application 101 may also obtain a reference to a further data structure from the first data structure 104, and may further obtain a reference to the buffer 105 from that further data structure. Such reference to the second data structure may be associated with the tag 103 of the packet 102 in the first data structure 104.
[0068] Then, the XDP application 101 places the received packet 102 into the determined buffer 105.
[0069] The XDP application 101 may perform the above-described steps of the method 200 for each of multiple packets 102 it obtains / receives. For instance, for two or more packets 102 including the same tag 103, which may be arranged and received as a queue of packets 102, and / or for two or more packets 102 including different tags 103, which may be received one after the other or in any interleaved manner. The XDP application 101 may thereby be able to maintain the receiving order of the multiple packets 102, when placing them into the determine buffer(s) 105.
[0070] The XDP application 101 may accordingly be part of a tag matching framework, and may allow implementing the tag matching of packets 102 on any XDP-compatible entity or device. The XDP application 101 may also create new buffers 105 with a specific associated tag 103. For instance, if the tag 103 determined from the received packet 102 is not included in the first data structure 104, the XDP application 101 may add the determined tag 103 into the first data structure 104, and may further create a buffer 105 for the determined tag 103. If a further packet 102 is then received, and the same tag 103 is determined from that further packet 102, the XDP application 102 may place that further packet 102 into the created buffer 105. When creating the new buffer 105, the XDP application 101 may further add reference to the newly created buffer 105, in association with the added tag 103, into the first data structure 104. Alternatively, it may add a reference to the second data structure 302 (see FIG. 3), in association with the added tag 103, into the first data structure 104, and add a reference to the newly created buffer 105 into the second data structure 302.
[0071] The entity 100 may comprise a processor or processing circuitry (not shown) configured to perform, conduct or initiate the various operations of the entity 100 described herein. The processing circuitry may comprise hardware and / or the processing circuitry may be controlled by software. The hardware may comprise analog circuitry or digital circuitry, or both analog and digital circuitry. The digital circuitry may comprise components such as applicationspecific integrated circuits (ASICs), field-programmable arrays (FPGAs), digital signal processors (DSPs), or multi-purpose processors. The entity 100 may further comprise memory circuitry, which stores one or more instruction(s) that can be executed by the processor or by the processing circuitry, in particular under control of the software. For instance, the memory circuitry may comprise a non-transitory storage medium storing executable software code which, when executed by the processor or the processing circuitry, causes the various operations of the entity 100 to be performed. In one embodiment, the processing circuitry comprises one or more processors and a non-transitory memory connected to the one or more processors. The non-transitory memory may carry executable program code which, when executed by the one or more processors, causes the entity 100 to perform, conduct or initiate the operations or methods described herein.
[0072] FIG. 3 illustrates an exemplary framework of this disclosure as a block diagram. As can be seen, the framework of this disclosure is based on the use of the XDP application 101, which may be executed by any suitable entity 100 and is able to receive and tag-match packets 102. Thus, the XDP application 101 is also referred to as XDP tag matching program.
[0073] The XDP application 101 is further able to access the first data structure 104, which as shown in FIG. 3 may be a hashmap. The hashmap can store one or more key-value pairs, wherein one or more tags 103 (that are included in the first data structure 104) are one or more keys of the hashmap, and one or more values in the hashmap are, for each key / tag, either a direct reference to a buffer 105, or a reference to a second data structure 302 that again references to buffer(s) 105. The second data structure 302, as shown in FIG. 3, may be implemented as at least one ring buffer. The XDP application 101 may also access the second data structure 302, and may determine the buffer 105, which is associated with the determined tag 103, from the second data structure 302.
[0074] FIG. 3 shows also the side of a user 300, and multiple user processes 301, which may use the tag matching feature provided by the framework of this disclosure. Each buffer 105 or each tag 103 may correspond to one of the user processes 301. Different user processes 301, respectively, may process packets 102 including different tags 103. Each user process 301 may use the framework, for instance, may install and run an XDP application 101, or may interact with an XDP application 101 installed elsewhere. For each unique tag 103, the second data structure 302 may comprise a corresponding extended BPF (eBPF) map, which may holds one or more empty receive buffers 105 that were given by the corresponding user process 301 in association with the tag 103 used by this user process 301.
[0075] FIG. 4, FIG. 5 and FIG. 6 show an example of the method 200 of this disclosure with hardware offload. In this example, the XDP application 101 may be executed by a hardware 401, e.g., a part of the entity 100. In particular, the XDP application 101 may be executed by a NIC being the hardware 401. The first data structure 104 may be stored in a kernel 402. The second data structure 302 and / or the buffer(s) 105 may also be stored in the kernel 402.
[0076] At first, a packet 102 with a tag 103 arrives and is received by the XDP application 101, wherein the tag=2 in this example (see FIG. 4). The XDP application 101 can now load 101 the first data structure 104 into a cache of the NIC 401. For instance, this hardware fetch of the first data structure 104 may be performed by the XDP application, if the first data structure 104 does not (yet) exist in the cache of the hardware 401. The XDP application 101 determines the tag 103 of the packet 102 (FIG. 5), and can then check for this tag 103, e.g. for the tag=2, in the first data structure 104. Then, the XDP application 101 may place the packet 102 in a preallocated buffer 105 for this tag 103, if it finds the tag 103 in the first data structure 104. The XDP application 101 may further mark completion for this buffer 105, and the packet 102 may further arrive directly at the user process 301 on its expected buffer 105 (see FIG. 6). FIG. 7, FIG. 8 and FIG. 9 show an example of the method 200 of this disclosure with software execution. The XDP application 101 is executed in a kernel 402 in this example, wherein the first data structure 104 is also stored in the kernel 402. The second data structure 302 and / or the buffer(s) 105 may also be stored in the kernel 402.
[0077] At first, a packet 102 with a tag 103 arrives and is received by the hardware 401, wherein the tag=2 in this example (see FIG. 7). The packet 102 is then provided from the hardware 401 to the kernel 402, and the XDP application 101 obtains the packet 102 and determines the tag 103 of the packet 102 (FIG. 8), Then, the XDP application 101 may place the packet 102 in a preallocated buffer 105 for this tag 103, if it finds the tag 103 in the first data structure 104. The XDP application 101 may further mark completion for this buffer 105, and the packet 102 then may arrive directly at the user process 301 on its expected buffer 105 (see FIG. 9).
[0078] FIG. 10 shows an exemplary flow chart for a method 1000 according to this disclosure, which may build on the method 200, or may be performed during the method 200 of FIG. 2. The method 1000 may be performed by the XDP application 101 and / or by the entity 100 of this disclosure.
[0079] At first, at step 1001 shown in FIG. 10, a packet 102 is received. At step 1002, the XDP application 101 determines whether there is a tag 103 in the header of the packet 102. If there is a tag 103, then the XDP application 101 checks whether this tag 102 is included in the first data structure 104 (which may be implemented as a “tags map”), and if it is included, the tag 103 is referred to as an “expected” tag 103. If there is no tag 103 in the received packet 102, or if there is a tag 103 in the received packet 102 that is not included in the first data structure 104, the packet 102 is marked as “unexpected” in step 1006. Such an unexpected packet 102 may then be moved up the stack to be handled by the software, e.g., of the user process 301, which is shown in step 1007. The XDP application 101 is in this case finished with the handling the packet 102, as shown in 1005.
[0080] If the tag 103 is an “expected” tag 103, the XDP application 101 determines a corresponding buffer 105, e.g., from the second data structure 302 (may be implemented as an “eBPF buffer map”), and fills the packet 102 into the buffer 105, as shown in 1004. The XDP application 101 is then finished with handling the packet 102, as shown in 1005.
[0081] FIG. 11 shows some exemplary variations of the solution of this disclosure. The XDP application 101 may be performed by a NIC 401 as the hardware. The XDP application 101 may receive one or more packets 102 from a cloud 1101. Multiple packets 102 may be received and may form a queue of packets 102. In this case, the packets 102 can include the tag 103 and additionally location information regarding the queue. The XDP application 101 may determine the location information included in the header of the respectively received packets 102 of the queue. The location information indicates a location of the respective received packet 102 within the queue. This may allow the XDP application 101 to place the packets 102 in the determined buffers 105 according to the right order of the tags 103 (out of order placement in the queue). In particular, the XDP application 101 may place each respective received packet 102 into the determined buffer 105 according to the determined location information for that packet 102.
[0082] Moreover, FIG. 11 also shows that the buffers 105, or references to the buffers 105, could be aligned in a list as the second data structure 302. Each tag 103 included in the first data structure 104 may be a buffer index in the list. In other words, in the second data structure 302 being the list, references to the buffers 105 may be aligned, and each tag 103 included in the first data structure 104 may be an index of a reference to at least one buffer 105 in the list. The XDP application 101 or entity 100 may also switch between descriptors to preserve CI / PI (head / tail) notation of packets 102.
[0083] In summary, the solution of this disclosure is based purely on eBPF and / or XDP, which makes it highly portable for any environment and infrastructure agnostic. The solution may introduce tag matching to any application or process, without requiring a dedicated hardware. The solution of this disclosure allows for faster IO operations of applications, and reduces the requirements for CPU processing in the system, since the packets 102 may bypass the network stack.
[0084] The present disclosure has been described in conjunction with various embodiments as examples as well as implementations. However, other variations can be understood and effected by those persons skilled in the art and practicing the claimed matter, from the studies of the drawings, this disclosure and the independent claims. In the claims as well as in the description the word “comprising” does not exclude other elements or steps and the indefinite article “a” or “an” does not exclude a plurality. A single element or other unit may fulfill the functions of several entities or items recited in the claims. The mere fact that certain measures are recited in the mutual different dependent claims does not indicate that a combination of these measures cannot be used in an advantageous implementation.
Claims
CLAIMS1. A method (200) for tag matching packets (102), wherein the method (200) executes an express data path, XDP, application (101), wherein the XDP application (101) performs the following steps: determining (201) a tag (103) included in a header of a received packet (102); determining (202) whether the determined tag (103) is included in a first data structure (104), wherein the first data structure (104) includes one or more tags (103); if the determined tag (103) is included in the first data structure (104), using (203) the first data structure (104) to determine a buffer (105) that is associated with the determined tag (103); and placing (204) the received packet (102) into the determined buffer (105).
2. The method (200) according to claim 1, wherein: the first data structure (104) is a hashmap storing one or more key- value pairs; the one or more tags (103) are the one or more keys of the hashmap; and the one or more values in the hashmap are, per each key, a reference to a buffer (105) or a reference to a second data structure (302).
3. The method (200) according to claim 1 or 2, wherein the XDP application (101) further stores, in a second data structure (302), a reference to at least one buffer (105) for each tag (103) included in the first data structure (104).
4. The method (200) according to claim 3, wherein the XDP application (101) determines the buffer (105) that is associated with the determined tag (103) from the second data structure (302).
5. The method (200) according to claim 3 or 4, wherein the second data structure (302) is a ring buffer.
6. The method (200) according to claim 3 or 4, wherein the second data structure (302) is a list in which references to the buffers (105) are aligned, and each tag (103) included in the first data structure (104) is an index of a reference to at least one buffer (105) in the list.
7. The method (200) according to one of the claims 3 to 6, wherein the XDP application (101) further performs the following steps, if the determined tag (103) is not included in the first data structure (104): adding the determined tag (103) into the first data structure (104); creating a buffer (105) for the determined tag (103); and wherein the XDP application (101) further performs one of the following steps: adding a reference to the created buffer (105) in association with the added tag (103) into the first data structure (104); or adding a reference to the second data structure (302) in association with the added tag (103) into the first data structure (104), and adding a reference to the created buffer (105) for the added tag (103) into the second data structure (302).
8. The method (200) according to one of the claims 1 to 7, wherein the XDP application (101) is executed in a network interface card, NIC (401).
9. The method (200) according to claim 8, wherein the first data structure (104) is stored in a kernel (402), and the XDP application loads (101) the first data structure (104) into a cache of the NIC (401).
10. The method (200) according to one of the claims 1 to 7, wherein the XDP application (101) is executed in a kernel (402), wherein the first data structure (104) is stored in the kernel (402).
11. The method (200) according to claim 9 or 10, wherein each buffer (105) and / or the second data structure (302) is stored in the kernel (402).
12. The method (200) according to one of the claims 1 to 11, wherein the XDP application(101) further marks the determined buffer (105) as completed, after placing the received packet(102) into it.
13. The method (200) according to one of the claims 1 to 12, wherein each buffer (105) or each tag (103) corresponds to a user process (301), and different user processes (301) respectively process packets (102) including different tags (103).
14. The method (200) according to one of the claims 1 to 13, wherein the XDP application (101) further performs the following steps: determining location information included in the header of the received packet (102), the location information indicating a location of the received packet (102) within a queue of packets (102); and placing the received packet (102) into the determined buffer (105) according to the determined location information.
15. An entity (100) for tag matching packets (102), wherein the entity (100) is configured to execute an express data path, XDP, application (101), and wherein the XDP application (101) is configured to: determine a tag (103) included in a header of a packet (102) received by the entity (101); determine whether the determined tag (103) is included in a first data structure (104), wherein the first data structure (104) includes one or more tags (103); if the determined tag (103) is included in the first data structure (104), use the first data structure (104) to determine a buffer (105) that is associated with the determined tag (103); and place the received packet (102) into the determined buffer (105).
16. A computer program comprising instructions which, when the program is executed by a computer, cause the computer to perform the method (200) according to one of the claims 1
Citation Information
Patent Citations
Dual user space-kernel space datapaths for packet processing operations
EP4141666A1
Reliable transport offloaded to network devices
US20220247696A1
Packet processing configurations
US20230043461A1
