Patent Grant
11775359
The disclosure relates generally to the field of electronic devices, as well as networks thereof, and including computerized networking stack infrastructures.
The consumer electronics industry has seen explosive growth in network connectivity. As an example, Internet connectivity is virtually ubiquitous across many different device types for a variety of different applications and functionalities. The successful implementation of network connectivity over a myriad of different usage cases has been enabled by the principles of modular design and abstraction. Specifically, the conventional network communication paradigm incorporates multiple modular software “layers” into a “communication stack.” Each layer of the communication stack separately manages its own implementation specific considerations and provides an “abstracted” communication interface to the next layer. In this manner, different applications can communicate freely across different devices without considering the underlying network transport.
Modern user applications consume a tremendous number of data packets, and the trend in consumer data usage will only continue to increase. Furthermore, processing and memory speeds appear to be asymptotically approaching the theoretical limitations of conventional semiconductor manufacturing. Thus, the confluence of these factors, such as increasing overhead, aggressive consumer expectations, and diminishing improvements in semiconductor manufacturing to provide some examples, present significant design challenges for consumer electronics.
Kernel space processing overhead is a function of packet and/or data volume within conventional communication stacks. Sharing information between different layers of a communication stack could, for example, reduce unnecessary packet processing, batch related packet processing, or otherwise coordinate packet handling across different layers. Unfortunately, such techniques would violate the aforementioned principles of modular design and abstraction in kernel space networking stacks.
The present disclosure satisfies the foregoing needs by providing methods and apparatuses for cross-layer processing within non-kernel space networking stacks.
Some embodiments of present disclosure disclose various methods and apparatuses for buffer cloning. In these embodiments, a physically contiguous memory allocation for a first non-kernel space entity can be allocated and divided into one or more non-kernel space spans. In these embodiments, the physically contiguous memory allocation can be divided based on non-kernel space parameters. In these embodiments, the physically contiguous memory allocation can be transferred to a second non-kernel space entity.
Some embodiments of present disclosure disclose various methods and apparatuses for packet aggregation. In these embodiments, a physically contiguous kernel space object and/or packets can be obtained. In these embodiments, the physically contiguous kernel space object can be divided into one or more spans. In these embodiments, for at least one packet of the packets, the at least one packet can be stored into a first span with the first span being linked to a second span. In these embodiments, the physically contiguous kernel space object can be routed to an endpoint application.
Some embodiments of present disclosure disclose various methods and apparatuses for “just in time” transformation. In these embodiments, intent information from user applications is obtained. In these embodiments, the intent information identifies packets that are ready for transfer. In these embodiments, a memory can be allocated based on the intent information and/or in response to a device driver call.
Some embodiments of present disclosure disclose an integrated circuit, IC device implementing one or more of the foregoing aspects. In these embodiments, the IC device can be embodied as a system on chip, SoC device which supports operations such as those described above. In these embodiments, the IC device can include an application specific IC, ASIC for some portions of the SoC device. In these embodiments, the IC device can include multiple ICs used in coordinated fashion, also referred to as a chip set, for some portions of the SoC device. In these embodiments, the IC device can include a multi-logic block FPGA device.
Some embodiments of present disclosure disclose a computer readable apparatus. In some embodiments, the computer readable apparatus can include a storage medium configured to store one or more computer programs. In these embodiments, the storage medium can include a program memory, a hard disk drive (HDD), and/or a solid-state drive (SSD).
This Summary is provided merely for purposes of illustrating some embodiments to provide an understanding of the subject matter described herein. Accordingly, the above-described features are merely examples and should not be construed to narrow the scope of the subject matter in this disclosure. Other features, aspects, and advantages of this disclosure will become apparent from the following Detailed Description, Figures, and Claims.
The accompanying drawings, which are incorporated herein and form part of the specification, illustrate the disclosure and, together with the description, further serve to explain the principles of the disclosure and enable a person of skill in the relevant art(s) to make and use the disclosure.
The disclosure is to be described with reference to the accompanying drawings. In the drawings, generally, like reference numbers indicate identical or functionally similar elements. Additionally, generally, the left-most digit(s) of a reference number identifies the drawing in which the reference number first appears.
Exemplary Network Socket Technologies
As shown in
As a brief aside, user space is a portion of system memory that a processor executes user processes from. User space is relatively freely and dynamically allocated for application software and a few device drivers. The kernel space is a portion of memory that a processor executes the kernel from. Kernel space is strictly reserved (usually during the processor boot sequence) for running privileged operating system (O/S) processes, extensions, and most device drivers. For example, each user space process normally runs in a specific memory space (its own “sandbox”) and cannot access the memory of other processes unless explicitly allowed. In contrast, the kernel is the core of a computer's operating system; the kernel can exert complete control over all other processes in the system.
The term “operating system” may refer to software that controls and manages access to hardware. An 0/S commonly supports processing functions such as e.g., task scheduling, application execution, input and output management, memory management, security, and peripheral access. As used herein, the term “application” refers to software that can interact with the hardware only via procedures and interfaces offered by the O/S.
The term “privilege” may refer to any access restriction or permission which restricts or permits processor execution. System privileges are commonly used within the computing arts to, inter alia, mitigate the potential damage of a computer security vulnerability. For instance, a properly privileged computer system can prevent malicious software applications from affecting data and task execution associated with other applications and the kernel.
As used herein, the term “in-kernel” and/or “kernel space” may refer to data and/or processes that are stored in, and/or have privilege to access the kernel space memory allocations. In contrast, the terms “non-kernel” and/or “user space” refers to data and/or processes that are not privileged to access the kernel space memory allocations. In particular, user space represents the address space specific to the user process, whereas non-kernel space represents address space which is not in-kernel, but which may or may not be specific to user processes.
As previously noted, the illustrated socket 102 provides access to Transmission Control Protocol (TCP) 104, User Datagram Protocol (UDP) 106, and Inter-Processor Communication (OPC) 108. TCP, UDP, and IPC are various suites of transmission protocols each offering different capabilities and/or functionalities. For example, UDP is a minimal message-oriented encapsulation protocol that provides no guarantees to the upper layer protocol for message delivery and the UDP layer retains no state of UDP messages once sent. UDP is commonly used for real-time, interactive applications (e.g., video chat, voice over IP (VoIP)) where loss of packets is acceptable. In contrast, TCP provides reliable, ordered, and error-checked delivery of data via a retransmission and acknowledgement scheme; TCP is generally used for file transfers where packet loss is unacceptable, and transmission latency is flexible.
As used herein, the term “encapsulation protocol” may refer without limitation to modular communication protocols in which logically separate functions in the network are abstracted, such as from their underlying structures by inclusion or information hiding within higher level objects. For example, UDP provides extra information (ports numbering).
As used herein, the term “transport protocol” may refer without limitation to communication protocols that transport data between logical endpoints. A transport protocol may include encapsulation protocol functionality.
Both TCP and UDP are commonly layered over an Internet Protocol (IP) 110 for transmission. IP is a connectionless protocol for use on packet-switched networks that provides a “best effort delivery”. Best effort delivery does not guarantee delivery, nor does it assure proper sequencing or avoidance of duplicate delivery. Generally these aspects are addressed by TCP or another transport protocol based on UDP.
As a brief aside, consider a web browser that opens a webpage; the web browser application would generally open a number of network sockets to download and/or interact with the various digital assets of the webpage (e.g., for a relatively common place webpage, this could entail instantiating ˜300 sockets). The web browser can write (or read) data to the socket; thereafter, the socket object executes system calls within kernel space to copy (or fetch) data to data structures in the kernel space.
As used herein, the term “domain” may refer without limitation to a self-contained memory allocation e.g., user space, driver space, kernel space, etc. A “domain crossing” may refer without limitation to a transaction, event, or process that “crosses” from one domain to another domain. For example, writing to a network socket from the user space to the kernel space constitutes a domain crossing access.
In the context of a Berkeley Software Distribution (BSD) based networking implementation, data that is transacted within the kernel space is stored in memory buffers that are also commonly referred to as “mbufs”. Each mbuf is a fixed size memory buffer that is used generically for transfers (mbufs are used regardless of the calling process e.g., TCP, UDP, etc.). Arbitrarily sized data can be split into multiple mbufs and retrieved one at a time or (depending on system support) retrieved using “scatter-gather” direct memory access (DMA) (“scatter-gather” refers to the process of gathering data from, or scattering data into, a given set of buffers). Each mbuf transfer is parameterized by a single identified mbuf.
Notably, each socket transfer can create multiple mbuf transfers, where each mbuf transfer copies (or fetches) data from a single mbuf at a time. As a further complication, because the socket spans both: (i) user space (limited privileges) and (ii) kernel space (privileged without limitation), the socket transfer verifies that each mbuf copy into/out of kernel space is valid. More directly, the verification process ensures that the data access is not malicious, corrupted, and/or malformed (i.e., that the transfer is appropriately sized and is to/from an appropriate area).
The processing overhead associated with domain crossing is a non-trivial processing cost. Processing cost affects user experience both directly and indirectly. A processor has a fixed amount of processing cycles every second; thus cycles that are used for transfer verification detract from more user perceptible tasks (e.g., rendering a video or audio stream). Additionally, processor activity consumes power; thus, increases in processing overhead increases power consumption.
Referring back to
Kernel extensions and public APIs enable, for example, 3rd party software developers to develop a wide variety of applications that can interact with a computer system at even the lowest layers of abstraction. For example, kernel extensions can enable socket level filtering, IP level filtering, and even device interface filtering. In the current consumer applications space, many emerging technologies now rely on closely coupled interfaces to the hardware and kernel functionality. For example, many security applications “sniff” network traffic to detect malicious traffic or filter undesirable content; this requires access to other application sandboxes (a level of privilege that is normally reserved for the kernel).
Unfortunately, 3rd party kernel extensions can be dangerous and/or undesirable. As previously noted, software applications are restricted for security and stability reasons; however the kernel is largely unrestricted. A 3rd party kernel extension can introduce instability issues because the 3rd party kernel extensions run in the same address space as the kernel itself (which is outside the purview of exemplary memory read/write protections based on memory allocations). Illegal memory accesses can result in segmentation faults and memory corruptions. Furthermore, unsecure kernel extension can create security vulnerabilities that can be exploited by malware. Additionally, even where correctly used, a kernel extension can expose a user's data to the 3rd party software developer. This heightened level of access may raise privacy concerns (e.g., the 3rd party developer may have access to browsing habits, etc.).
Exemplary Performance Optimization Technologies
The DLIL 206 provides a common interface layer to each of the various physical device drivers which can handle the subsequent data transfer (e.g., Ethernet, Wi-Fi, cellular, etc.). The DLIL performs a number of system-wide holistic network traffic management functions. In one such implementation, the DLIL is responsible for BSD Virtual Interfaces, IOKit Interfaces (e.g., DLIL is the entity by which IOKit based network drivers are connected to the networking stack), Active Queue Management (AQM), flow control and advisory action, etc. In most cases, the device driver 208 may be handled by an external device (e.g., a baseband co-processor), thus the DLIL 206 is usually (but not always) the lowest layer of the network communication stack.
During normal operation, the computer system can logically segment its tasks to optimize overall system operation. In particular, a processor can execute a task, and then “context switch” to another task, thereby ensuring that any single process thread does not monopolize processor resources from start to finish. More directly, a context switch is the process of storing the state of a process, or of a thread, so that it can be restored and execution resumed from the same point later. This allows multiple processes to share a single processor. However, excessive amounts of context switching can slow processor performance down. Notably, while the present discussion is primarily discussed within the context of a single processor for ease of understanding, multi-processor systems have analogous concepts (e.g., multiple processors also perform context switching, although contexts may not necessarily be resumed by the same processor).
For example, consider the following example of a packet reception. Packets arrive at the device driver 208A. The hardware managed by the device driver 208A may notify the processor via e.g., a doorbell signal (e.g., an interrupt). The device driver 208A work loop thread handles the hardware interrupt/doorbell, then signals the DLIL thread (Loop 1 210). The processor services the device driver 208A with high priority, thereby ensuring that the device driver 208A operation is not bottlenecked (e.g., that the data does not overflow the device driver's memory and/or that the device driver does not stall). Once the data has been moved out of the device driver, the processor can context switch to other tasks.
At a later point, the processor can pick up the DLIL 206 execution process again. The processor determines which socket the packets should be routed to (e.g., socket 204A) and routes the packet data appropriately (Loop 2 212). During this loop, the DLIL thread takes each packet, and moves each one sequentially into the socket memory space. Again, the processor can context switch to other tasks so as to ensure that the DLIL task does not block other concurrently executed processing.
Subsequently thereafter, when the socket has the complete packet data transfer the processor can wake the user space application and deliver the packet into user space memory (Loop 3 214). Generally, user space applications are treated at lower priority than kernel tasks; this can be reflected by larger time intervals between suspension and resumption. While the foregoing discussion is presented in the context of packet reception, artisans of ordinary skill in the related arts will readily appreciate, given the contents of the present disclosure, that the process is substantially reversed for packet transmission.
As demonstrated in the foregoing example, context switching ensures that tasks of different processing priority are allocated commensurate amounts of processing time. For example, a processor can spend significantly more time executing tasks of relatively high priority, and service lower priority tasks on an as-needed basis. As a brief aside, human perception is much more forgiving than hardware operation. Consequently, kernel tasks are generally performed at a much higher priority than user space applications. The difference in priority between kernel and user space allows the kernel to handle immediate system management (e.g., hardware interrupts, and queue overflow) in a timely manner, with minimal noticeable impact to the user experience.
Moreover,
Unfortunately, changing tastes in consumer expectations cannot be effectively addressed with the one-size-fits-all model and the conservative in-kernel exemplary networking stack. Artisans of ordinary skill in the related arts will readily appreciate, given the contents of the present disclosure, that different device platforms have different capabilities; for example, a desktop processor may have significantly more processing and memory capability than a mobile phone processor. More directly, the “one-size-fits-all” solution does not account for the underlying platform capabilities and/or application requirements, and thus is not optimized for performance. Fine-tuning the exemplary networking stack for performance based on various “tailored” special cases results in an inordinate amount of software complexity which is untenable to support across the entire ecosystem of devices.
Emerging Use Cases
As shown, an application executing from user space can open a Hypertext Transfer Protocol (HTTP) session 302 with a TLS security layer 304 in order to securely transfer data (Application Transport Security (ATS) services) over a network socket 306 that offers TCP/IP transport 308, 310.
As a brief aside, TLS can be considered a record-based protocol; in other words, TLS uses data records which are arbitrarily sized (e.g., up to 16 kilobytes). In contrast, TCP can be considered a byte stream protocol (i.e., a byte has a fixed length of eight (8) bits). Consequently, the TCP layer subdivides TLS records into a sequentially ordered set of bytes for delivery. The receiver of the TCP byte stream reconstructs TLS records from the TCP byte stream by receiving each TCP packet, re-ordering the packets according to sequential numbering to recreate the byte stream and extracting the TLS record from the aggregated byte stream. Notably, every TCP packet of the sequence should be present before the TLS record can be reconstructed. Even though TCP can provide reliable delivery under lossy network conditions, there are a number of situations where TLS record delivery could fail. For example, under ideal conditions TCP isolates packet loss from its client (TLS in this example), and a single TCP packet loss should not result in failed TLS record delivery. However, the TLS layer or the application above may incorporate a timeout strategy in a manner that is unaware of the underlying TCP conditions. Thus, if there's significant packet loss in the network, the TLS timeout may be hit (and thus result in a failure to the application) even though TCP would normally provide reliable delivery.
Referring back to
Ideally, the TLS layer should set TLS record sizes based on network condition information. In particular, large TLS records can efficiently use network bandwidth, but require many successful TCP packet deliveries. In contrast, small TLS records incur significantly more network overhead, but can survive poor bandwidth conditions. Unfortunately, networking condition information is lower layer information that is available to the kernel space (e.g., the DLIL and device drivers), but generally restricted from user space applications. Some 3rd party application developers and device manufacturers have incorporated kernel extensions (or similar operating system capabilities) to provide network condition information to the TLS user space applications; however, kernel extensions are undesirable due to the aforementioned security and privacy concerns. Alternately, some 3rd party applications infer the presence of lossy network conditions based on historic TLS record loss. Such inferences are an indirect measure and significantly less accurate and lag behind real-time information (i.e., previous packet loss often does not predict future packet loss).
As shown, an application executing from user space can open a Virtual Private Network (VPN) session 402 over a network socket 406 that offers TCP/IP transport 408, 410. The VPN session is secured with Encapsulating Security Protocol (ESP) 412. The encrypted packet is securely tunneled via TLS 404 (in user space) and recursively sent again over TCP/IP transport 408, 410.
As illustrated within
Artisans of ordinary skill in the related arts, given the contents of the present disclosure, will readily appreciate that the exemplary recursive cross-layer transaction of
As shown, three (3) different concurrently executed applications (e.g., a real time application 502, interactive application 504, and file transfer applications 506) in user space, each open a session over network sockets 508 (508A, 508B, 508C) that offer TCP/UDP/IP transport 510/512. Depending on the type of physical interface required, the sessions are switched to BSD network interfaces (ifnet) 514 (514A, 514B, 514C) which handle the appropriate technology. Three different illustrated technology drivers are shown: Wi-Fi 516, Bluetooth 518, and cellular 520.
It is well understood within the networking arts that different application types are associated with different capabilities and requirements. One such example is real time applications 502, commonly used for e.g., streaming audio/visual and/or other “live” data. Real time data has significant latency and/or throughput restrictions; moreover, certain real time applications may not require (and/or support) retransmission for reliable delivery of lost or corrupted data. Instead, real time applications may lower bandwidth requirements to compensate for poor transmission quality (resulting in lower quality, but timely, delivered data).
Another such example is interactive applications 504, commonly used for e.g., human input/output. Interactive data should be delivered at latencies that are below the human perceptible threshold (within several milliseconds) to ensure that the human experience is relatively seamless. This latency interval may be long enough for a retransmission, depending on the underlying physical technology. Additionally, human perception can be more or less tolerant of certain types of data corruptions; for example, audio delays below 20 ms are generally imperceptible, whereas audio corruptions (pops and clicks) are noticeable. Consequently, some interactive applications may allow for some level of error correction and/or adopt less aggressive bandwidth management mechanisms depending on the acceptable performance requirements for human perception.
In contrast to real time applications and interactive applications, file transfer applications 506 require perfect data fidelity without latency restrictions. To these ends, most file transfer technologies support retransmission of lost or corrupted data, and retransmission can have relatively long attempt intervals (e.g., on the order of multiple seconds to a minute).
Similarly, within the communication arts, different communication technologies are associated with different capabilities and requirements. For example, Wi-Fi 516 (wireless local area networking based on IEEE 802.11) is heavily based on contention-based access and is best suited for high bandwidth deliveries with reasonable latency. Wi-Fi is commonly used for file transfer type applications. Bluetooth 518 (personal area networking) is commonly used for low data rate and low latency applications. Bluetooth is commonly used for human interface devices (e.g., headphones, keyboards, and mice). Cellular network technologies 520 often provide non-contention-based access (e.g., dedicated user access) and can be used over varying geographic ranges. Cellular voice or video delivery is a good example of streaming data applications. Artisans of ordinary skill in the related arts will readily recognize that the foregoing examples are purely illustrative, and that different communication technologies are often used to support a variety of different types of application data. For example, Wi-Fi 516 can support file transfer, real time data transmission and/or interactive data with equivalent success.
Referring back to
Moreover, in the computing arts, a “locking” synchronization mechanism is used by the kernel to enforce access limits (e.g., mutual exclusion) on resources in multi-threaded execution. During operation, each thread acquires a lock before accessing the corresponding locked resources data. In other words, at any point in time, the processor is necessarily limited to only the resources available to its currently executing process thread.
Unfortunately, each of the applications has different latency, throughput and processing utilization requirements. Since, each of the network interfaces is sending and receiving data at different times, in different amounts, and with different levels of priority. From a purely logistical standpoint, the kernel is constantly juggling between high priority kernel threads (to ensure that the high priority hardware activities do not stall out) while still servicing each of its concurrently running applications to attempt to provide acceptable levels of service. In some cases, however, the kernel is bottlenecked by the processor's capabilities. Under such situations, some threads can be deprioritized; currently, the exemplary networking stack architecture is unable it clearly identify which threads can be deprioritized while still providing acceptable user service.
For example, consider an “expected use” device of
Unfortunately, the addition of an unexpected amount of additional secondary interactive applications 504 (e.g., remote control interface, headphones, and/or other interface devices) and/or background file transfer applications can easily overwhelm the processor. Specifically, the primary real time application does not get enough CPU cycles to run within its time budget, because the kernel threads handling networking are selected at a higher priority. In other words, the user space application is not able to depress the priority of kernel networking threads (which are servicing both the primary and secondary processes). This can result in significantly worse user experience when the video rendering stalls out (video frame misses or video frame drops); whereas simply slowing down a file transfer or degrading the interaction interface may have been preferable.
Prior art solutions have tailored software for specific device implementations (e.g., the Apple TV®). For example, the device can be specifically programmed for an expected use. However, tailored solutions are becoming increasingly common and by extension the exceptions have swallowed the more generic use case. Moreover, tailored solutions are undesirable from multiple software maintenance standpoints. Devices have limited productive lifetimes, and software upkeep is non-trivial.
Ideally, a per-application or per-profile workload optimization would enable a single processor (or multiple processors) to intelligently determine when and/or how too intelligently context switch and/or prioritize its application load (e.g., in the example of
Exemplary User Space Networking Architecture
A networking stack architecture and technology that caters to the needs of non-kernel-based networking use cases is disclosed herein. Unlike prior art monolithic networking stacks, the exemplary networking stack architecture described hereinafter includes various components that span multiple domains (both in-kernel, and non-kernel), with varying transport compositions, workload characteristics and parameters.
The user space networking stack architecture provides an efficient infrastructure to transfer data across domains (user space, non-kernel, and kernel). Unlike the exemplary networking paradigm that hides the underlying networking tasks within the kernel and substantially limits control thereof by any non-kernel applications, the various embodiments described herein enable faster and more efficient cross domain data transfers.
Various embodiments of the present disclosure provide a faster and more efficient packet input/output (I/O) infrastructure than prior art techniques. Specifically, unlike exemplary networking stacks that use a “socket” based communication, disclosed embodiments can transfer data directly between the kernel and user space domains. Direct transfer reduces the per-byte and per-packet costs relative to socket-based communication. Additionally, direct transfer can improve observability and accountability with traffic monitoring.
As shown, a user space application 602 can initiate a network connection by instancing user space protocol stacks 604. Each user space protocol stacks includes network extensions for e.g., TCP/UDP/QUIC/IP, cryptography, framing, multiplexing, tunneling, and/or any number of other networking stack functionalities. Each user space protocol stack 604 communicates with one or more nexuses 608 via a channel input/output (I/O) 606. Each nexus 608 manages access to the network drivers 610. Additionally, shown is legacy application 612 support via existing network socket technologies 614. While the illustrated embodiment shows nexus connections to both user space and in-kernel networking stacks, it is appreciated that the nexus may also enable e.g., non-kernel networking stacks (such as may be used by a daemon or other non-kernel, non-user process).
The following topical sections hereinafter describe the salient features of the various logical constructs in greater detail.
Exemplary User Space I/O Infrastructure
In one embodiment, the non-kernel networking stack provides a direct channel input output (I/O) 606. In one such implementation, the channel I/O 606 is included as part of the user space protocol stack 604. More directly, the channel I/O 606 enables the delivery of packets as a raw data I/O into kernel space with a single validation (e.g., only when the user stack provides the data to the one or more nexuses 608). The data can be directly accessed and/or manipulated in situ, the data need not be copied to an intermediary buffer.
In one exemplary implementation, a channel is an I/O scheme leveraging kernel-managed shared memory. During an access, the channel I/O is presented to the process (e.g., the user process or kernel process) as a file descriptor-based object, rather than as data. In order to access the data, the process de-references the file descriptor for direct access to the shared memory within kernel space. In one such implementation, the file descriptor-based object based I/O is compatible with exemplary operating system signaling and “eventing” (event notification/response) mechanisms. In one exemplary variant, the channel I/O is based on Inter Process Communication (IPC) packets.
As used herein, the term “descriptor” may refer without limitation to data structures that indicate how other data is stored. Descriptors generally include multiple parameters and can be used to identify more complex data structures; for example, a descriptor may include one or more of type, size, address, tag, flag, headers, footers, metadata, structural links to other data descriptors or locations, and/or any other number of format or construction information.
Within the context of the present disclosure, as used herein, the term “pointer” may refer without limitation to a specific reference data type that “points” or “references” a location of data in memory. Typically, a pointer stores a memory address that is interpreted by a compiler as an absolute location in system memory or a relative location in system memory based on e.g., a base address, reference address, memory window, or other memory subset. During operation, a pointer is “de-referenced” to recover the data that is stored in the location of memory.
As used herein, the term “metadata” refers without limitation to data that describes data. Metadata varies widely in application, but generally falls into one of the descriptive, structural, and/or administrative categories. Descriptive metadata describes data in a manner to enable e.g., discovery and/or identification. Common examples include without limitation e.g., type, size, index tags, and keywords. Structural metadata describes the structure of the data e.g., how compound objects are put together. Common examples include without limitation e.g., prefix, postfix, table of contents, order, and/or any other information that describes the relationships and other characteristics of digital materials. Administrative metadata provides information to help manage a resource; common examples include e.g., authorship and creation information, access privileges, and/or error checking and security-based information (e.g., cyclic redundancy checks (CRC), parity, etc.).
In one embodiment, the channel I/O can be further leveraged to provide direct monitoring of its corresponding associated memory. More directly, unlike exemplary data transfers which are based on mbuf based divide/copy/move, etc., the channel I/O can provide (with appropriate viewing privileges) a direct window into the memory accesses of the system. Such implementations further simplify software development as debugging and/or traffic monitoring can be performed directly on traffic. Direct traffic monitoring can reduce errors attributed to false positives/false negatives caused by e.g., different software versioning, task scheduling, compiler settings, and/or other software introduced inaccuracies.
In one embodiment, the in-kernel network device drivers (e.g. Wi-Fi, Cellular, Ethernet) use simplified data movement models based on the aforementioned channel I/O scheme. More directly, the user space networking stacks can directly interface to each of the various different technology-based network drivers via channel I/O; in this manner, the user space networking stacks do not incur the exemplary data mbuf based divide/copy/move penalties. Additionally, user space applications can directly access user space networking components for immediate traffic handling and processing.
Exemplary Nexus
In one embodiment, the networking stack connects to one or more nexus 608. In one such implementation, the nexus 608 is a kernel space process that arbitrates access to system resources including, without limitation e.g., shared memory within kernel space, network drivers, and/or other kernel or user processes. In one such variant, the nexus 608 aggregates one or more channels 606 together for access to the network drivers 610 and/or shared kernel space memory.
In one exemplary implementation, a nexus is a kernel process that determines the format and/or parameters of the data flowing through its connected channels. In some variants, the nexus may further perform ingress and/or egress filtering.
The nexus may use the determined format and/or parameter information to facilitate one-to-one and one-to-many topologies. For example, the nexus can create user-pipes for process-to-process channels; kernel-pipes for process-to-kernel channels; network interfaces for direct channel connection from a process to in-kernel network drivers, or legacy networking stack interfaces; and/or flow-switches for multiplexing flows across channels (e.g., switching a flow from one channel to one or more other channels).
Additionally, in some variants the nexus may provide the format, parameter, and/or ingress egress information to kernel processes and/or one or more appropriately privileged user space processes.
In one embodiment, the nexus 608 may additionally ensure that there is fairness and/or appropriately prioritize each of its connected stacks. For example, within the context of
In one such embodiment, in-kernel, non-kernel, and/or user space infrastructures ensure fairness and can reduce latency due to e.g., buffer bloat (across channels in a given nexus, as well as flows within a channel). In other words, the in-kernel and/or user space infrastructures can negotiate proper buffering sizes based on the expected amount of traffic and/or network capabilities for each flow. By buffering data according to traffic and/or network capability, buffers are not undersized or oversized.
As a brief aside, “buffer bloat” is commonly used to describe e.g., high latency caused by excessive buffering of packets. Specifically, buffer bloat may occur when excessively large buffers are used to support a real time streaming application. As a brief aside, TCP retransmission mechanism relies on measuring the occurrence of packet drops to determine the available bandwidth. Under certain congestion conditions, excessively large buffers can prevent the TCP feedback mechanism from correctly inferring the presence of a network congestion event in a timely manner (the buffered packets “hide” the congestion, since they are not dropped). Consequently, the buffers have to drain before TCP congestion control resets and the TCP connection can correct itself.
Referring back to
While the foregoing example is based on “fairness” standard, artisans of ordinary skill in the related arts will readily appreciate that other schemes may be substituted with equivalent success given the contents of the present disclosure. For example, some embodiments may dynamically or statically service the user application networking space with greater or less weight compared to the legacy socket-based access. For example, user application networking space may be more heavily weighted to improve overall performance or functionality, whereas legacy socket-based access may be preferred where legacy applications are preferentially supported.
Exemplary Network Extensions
In one embodiment of the present disclosure, a network extension is disclosed. A network extension is an agent-based extension that is tightly coupled to network control policies. The agent is executed by the kernel and exposes libraries of network control functionality to user space applications. During operation, user space software can access kernel space functionality through the context and privileges of the agent.
As used herein, the term “agent” may refer to a software agent that acts for a user space application or other program in a relationship of agency with appropriate privileges. The agency relationship between the agent and the user space application implies the authority to decide which, if any, action is appropriate given the user application and kernel privileges. A software agent is privileged to negotiate with the kernel and other software agents regarding without limitation e.g., scheduling, priority, collaboration, visibility, and/other sharing of user space and kernel space information. While the agent negotiates with the kernel on behalf of the application, the kernel ultimately decides on scheduling, priority, etc.
Various benefits and efficiencies can be gained through the use of network extensions. In particular, user space applications can control the protocol stack down to the resolution of exposed threads (i.e., the threads that are made available by the agent). In other words, software agents expose specific access to lower layer network functionality which was previously hidden or abstracted away from user space applications. For example, consider the previous examples of TLS record sizing (see e.g.,
Similarly, consider the previous examples of multi-threading within the context of expected use devices (see e.g.,
As a related benefit, since a software agent represents the application to the kernel; the agent can trust the kernel, but the kernel may or may not trust the agent. For example, a software agent can be used by the kernel to convey network congestion information in a trusted manner to the application; similarly, a software agent can be used by an application to request a higher network priority. Notably, since a software agent operates from user space, the agent's privilege is not promoted to kernel level permissions. In other words, the agent does not permit the user application to exceed its privileges (e.g., the agent cannot commandeer the network driver at the highest network priority or force a read/write to another application's memory space without the other kernel and/or other application's consent).
Networking extensions allow the user space application to execute networking communications functionality within the user space and interpose a network extension between the user space application and the kernel space. As a result, the number of cross domain accesses for complex layering of different protocol stacks can be greatly reduced. Limiting cross domain accesses prevents context switching and allows the user space to efficiently police its own priorities. For example, consider the previous example of a VPN session as was previously illustrated in
As used herein, the term “interposition” may refer without limitation to the insertion of an entity between two or more layers. For example, an agent is interposed between the application and the user space networking stack. Depending on the type of agent or network extension, the interposition can be explicit or implicit. Explicit interposition occurs where the application explicitly instances the agent or network extension. For example, the application may explicitly call a user space tunnel extension. In contrast, implicit interposition occurs where the application did not explicitly instance the agent or network extension. Common examples of implicit interposition occur where one user space application sniffs the traffic or filters the content of another user space application.
As used herein, an “instance” may refer without limitation to a single copy of a software program or other software object; “instancing” and “instantiations” refers to the creation of the instance. Multiple instances of a program can be created; e.g., copied into memory several times. Software object instances are instantiations of a class; for example, a first software agent and second software instance are each distinct instances of the software agent class.
Exemplary User Space Networking Stack
Referring now to
In one exemplary embodiment, the user space networking stack 700 is instantiated within an application user space 718. More directly, the user space networking stack 700 is treated identically to any one of multiple threads 710 within the application user space 718. Each of the coexisting threads 720 has access to the various functions and libraries offered by the user space networking stack via a direct function call.
As a brief aside, each of the threads 720 reside within the same address space. By virtue of their shared addressability, each of the threads may grant or deny access to their portions of shared address space via existing user space memory management schemes and/or virtual machine type protections. Additionally, threads can freely transfer data structures from one to the other, without e.g., incurring cross domain penalties. For example, TCP data 710 can be freely passed to TLS 706 as a data structure within a user space function call.
As previously noted, the user space networking stack 700 may grant or deny access to other coexistent user space threads; e.g., a user space thread is restricted to the specific function calls and privileges made available via the application interface 702. Furthermore, the user space networking stack 700 is further restricted to interfacing the operating system via the specific kernel function calls and privileges made available via the operating system interface 704. In this manner, both the threads and the user space networking stack have access and visibility into the kernel space, without compromising the kernel's security and stability.
One significant benefit of the user space networking stack 700 is that networking function calls can be made without acquiring various locks that are present in the in-kernel networking stack. As previously noted, the “locking” mechanism is used by the kernel to enforce access limits on multiple threads from multiple different user space applications; however in the user space, access to shared resources are handled within the context of only one user application space at a time, consequently access to shared resources are inherently handled by the single threading nature of user space execution. More directly, only one thread can access the user space networking stack 700 at a time; consequently, kernel locking is entirely obviated by the user space networking stack.
Another benefit of user space network stack operation is cross platform compatibility. For example, certain types of applications (e.g., iTunes®, Apple Music® developed by the Assignee hereof) are deployed over a variety of different operating systems. Similarly, some emerging transport protocols (e.g. QUIC) are ideally served by portable and common software between the client and server endpoints. Consistency in the user space software implementation allows for better and more consistent user experience, improves statistical data gathering and analysis, and provides a foundation for enhancing, experimenting and developing network technologies used across such services. In other words, a consistent user space networking stack can be deployed over any operating system platform without regard for the native operating system stack (e.g., which may vary widely).
Another important advantage of the exemplary user space networking stack is the flexibility to extend and improve the core protocol functionalities, and thus deliver specialized stacks based on the application's requirements. For example, a video conferencing application (e.g., FaceTime® developed by the Assignee hereof) may benefit from a networking stack catered to optimize performance for real-time voice and video-streaming traffics (e.g., by allocating more CPU cycles for video rendering, or conversely deprioritizing unimportant ancillary tasks). In one such variant, a specialized stack can be deployed entirely within the user space application, without specialized kernel extensions or changes to the kernel. In this manner, the specialized user space networking stack can be isolated from networking stacks. This is important both from a reliability standpoint (e.g., updated software doesn't affect other software), as well as to minimize debugging and reduce development and test cycle times.
Furthermore, having the network transport layer (e.g. TCP, QUIC) reside in user space can open up many possibilities for improving performance. For example, as previously alluded to, applications (such as TLS) can be modified depending on the underlying network connections. User space applications can be collapsed or tightly integrated into network transports. In some variants, data structure sizes can be adjusted based on immediate lower layer network condition information (e.g., to accommodate or compensate for poor network conditions). Similarly, overly conservative or under conservative transport mechanisms can be avoided (e.g., too much or not enough buffering previously present at the socket layer). Furthermore, unnecessary data copies and/or transforms can be eliminated and protocol signaling (congestion, error, etc.) can be delivered more efficiently.
In yet another embodiment, the exemplary user space networking stack further provides a framework for both networking clients and networking providers. In one such variant, the networking client framework allows the client to interoperate with any network provider (including the legacy BSD stack). In one such variant, the network provider framework provides consistent methods of discovery, connection, and data transfer to networking clients. By providing consistent frameworks for clients and providers which operate seamlessly over a range of different technologies (such as a VPN, Bluetooth, Wi-Fi, cellular, etc.), the client software can be greatly simplified while retaining compatibility with many different technologies.
Cross-Layer Optimizations
Cross-layer processing may be difficult to implement efficiently and/or securely within kernel space networking architectures. As a practical matter, kernel processes are executed at a higher privilege and priority than user space processes, thus cross-layer communication that spans both kernel and user space may introduce system vulnerabilities and/or consume limited resources in an undesirable manner. Furthermore, cross-layer communication often relies on special treatment by the kernel (e.g., the kernel may be required to inspect the packet to provide prioritized or otherwise custom handling). Such kernel overhead should be paid even when the cross-layer processing is inactive. As a further complication, cross-layer communication that requires community participation may be adversely affected by other parties. Diverse network ecosystems (e.g., legacy devices, embedded devices, and limited function devices) may affect cross-layer communication in unexpected ways.
As but one such example, Explicit Congestion Notification (ECN) is an extension to the Transmission Control Protocol (TCP) that is defined in RFC 3168 (e.g., The Addition of Explicit Congestion Notification (ECN) to IP, published September 2001, incorporated by reference herein in its entirety). Non-ECN aware TCP/IP networks implicitly signal congestion by dropping packets (the recipient can infer congestion based on the dropped packets); in contrast, an ECN-aware network explicitly signals impending congestion. Each node of the network relays the congestion indication back to the sender. Once the congestion notification is received, the sender can reduce its transmission rate. Unfortunately, ECN requires cross-layer communication between multiple nodes of the network; for example, intermediate ECN-aware routers operate at the Internet Protocol (IP) layer, while transmission rate is handled at the TCP layer by the endpoint devices. Additionally, nodes that do not support ECN can drop or mangle ECN packets. As a result, empirical evidence suggests that less than 1% of the public Internet supports ECN functionality.
Exemplary embodiments described herein circumvent the limitations of kernel space networking architectures. Unlike kernel space networking architectures that have to accommodate generic use cases, user space networking architectures are application specific, run in their own memory allocations, and can be terminated without affecting other user space applications and/or kernel space operation. More directly, each user space networking stack can be customized to support cross-layer optimizations. The targeted and flexible nature of user space networking architectures can be used to provide application specific (non-generic) functionality without kernel assistance. Isolating user space networking stacks from kernel space provides added benefits in security and resource utilization (e.g., user space networking stacks do not run with kernel space privilege or priority). Furthermore, user space applications that have visibility and access to their user space networking stack can intelligently negotiate with peer devices; such cross-layer transparency can be used to e.g., provide explicit checks and/or discovery to ensure that network conditions for successful operation exist.
As used herein, the term “cross-layer” refers without limitation to an application specific transaction, event, or process that crosses from a first domain to a second domain via an intermediary domain (such as a kernel space entity, etc.) While the following discussions are presented in the context of specific cross-layer optimizations, other variations and applications for the principles described herein may be readily appreciated by artisans of ordinary skill in the related arts, given the contents of the present disclosure
Buffer Cloning for Link Layer Aggregation
Device drivers refer to the software and firmware that control physical devices of a computer system. Historically, device drivers have executed from kernel space for a variety of reasons; for example, drivers may e.g., require access to physical system resources, have timing and/or other privilege requirements, manipulate hardware in proprietary or otherwise unusual ways, etc. As one such example, certain network interface card (NIC) drivers enable packet buffer “striding” to optimize transactional overhead; during striding operation, multiple packets are read/written to offsets (strides) within a contiguous memory buffer. Packet buffer striding allows the NIC to resolve addressing for only the first packet; subsequent packet addresses are calculated by adding the stride value. Stride-based addressing is simpler and faster, but less secure and flexible, than kernel space memory management; stride-based addressing is often used by device drivers (independent of kernel memory management) to optimize for implementation specific physical device considerations.
In order to maintain a robust and cost-effective vendor ecosystem, device drivers are usually provided by 3rd party device manufacturers. Unfortunately, 3rd party device drivers can introduce instability issues because the device drivers run in the same address space as the kernel itself but often disable kernel space memory protections and usage restrictions. Device driver instability can make accidental memory accesses that result in segmentation faults and memory corruptions. Furthermore, unstable/unsecure drivers can create security vulnerabilities that can be exploited by malware.
Within the context of user space networking architectures, device driver memory management may be handled in non-kernel space. As a practical matter, executing device drivers in non-kernel space is both more secure and may provide opportunities for more efficient resource utilization. However, non-kernel space operation is subject to reduced privileges, lower priority, usage restrictions and/or active memory protections; thus, various embodiments of the present disclosure expose a cross-layer application programming interface (API) that allows user space networking stacks to communicate and/or configure device driver operation consistent with non-kernel space restrictions and protections. Handling cross-layer optimizations between user space networking stacks and device drivers can greatly reduce (and/or altogether avoid) kernel space overhead for application specific network traffic.
As a brief aside, computer systems organize data structures to assist in storage, retrieval, processing, manipulation, etc. Different computer architectures optimize data structure characteristics (such as granularity, complexity, contents, and/or encoding) to achieve improved e.g., performance, power, size, redundancy, robustness, security, etc. As but one such example, exemplary object-based granularity can significantly affect fragmentation and/or defragmentation and resulting performance.
Referring back to the example of
While user space networking stacks already provide substantial improvements over kernel space networking stacks for generic networking, various embodiments of the present disclosure may further improve network performance for certain types of device drivers and/or applications. In one exemplary embodiment of the present disclosure, a device driver can “clone” multiple data packets within a common object; the common object can be efficiently routed by any intermediary kernel space entity (avoiding per-packet routing costs) but processed on a per-packet basis at the endpoint application. As used herein, the terms “clone”, “cloned”, “cloning” (and related linguistic variants) refer without limitation to a discrete memory allocation for processing in a first domain (e.g., kernel space) that contains multiple similar data structures that are configured for the same control and/or data path endpoint processing in a second domain (e.g., non-kernel). For example, a driver application may request (or be granted) one or more discrete 32 KB object that stores up to sixteen 2 KB packets; the kernel can process the 32 KB object in aggregate using the cloned packet metadata. However, once delivered to an endpoint (e.g., an endpoint user application or the device driver) the object can be parsed for its constituent packets. Cloned packets can be directly manipulated by the endpoint/driver (independent of kernel space memory management) and routed/transported in aggregate by the intermediary kernel space entities. The packet cloning optimizations described herein provide multiple benefits over non-cloned operation. For example, user space networking architectures can greatly improve performance by batching similar traffic together thereby reducing per-packet costs (e.g., ACK/NACK, retransmission, etc.) and/or per-byte costs (copy, fragmentation, defragmentation, checksum, etc.)
During exemplary cloned operation, a driver is allocated an arena, a buffers region, and one or more segments, etc. However, unlike non-cloned operation, the allocated segments 906 are treated as discrete objects 908 by the kernel. The device driver (or other endpoint application) can freely subdivide the object 908 in accordance with its own requirements. The endpoint specific subdivisions are stored in metadata 910 that identifies the “span” of the subdivision. For example, in the illustrated implementation, a device driver that is allocated a 32 KB object 908 may subdivide the buffer into three spans of 9 KB (also “Jumbo” ethernet frames) and an unused space (as shown) for a first usage, but re-divide the 32 KB object 908 into sixteen spans of 2 KB for default use. In other words, the device driver may freely modify spans independent of kernel space memory management.
Notably, since spans are only used for specific (non-generic) data transfers between the endpoint and/or the device driver, spans may widely vary based on user space negotiated parameters. In other words, the device driver can adjust its span selection according to user space networking stack considerations and/or other cross-layer considerations. For example, spans may be symmetric/uniform or asymmetric (e.g., vary in size, access (R/W), etc.) Spans may be statically set, dynamically adjusted, or some variant thereof. As but one such example, a device driver may allocate a fixed number of spans based on its own considerations; alternatively, the device driver may flexibly allocate spans based on an as-needed-basis, based on its served endpoint requirements. Still other variants may consider any number of driver, client, kernel, and/or network considerations.
In one exemplary embodiment, spans may be determined according to a device driver specific addressing scheme; for example, an exemplary network interface card (NIC) may set span addressing for packet buffer striding in PCIe transactions (the span is set to the stride value). More generally however, any scheme for defining spans may be substituted with equal success. In some cases, spans may be defined according to an offset from a base address (such as is used in PCIe); in other cases, spans may be defined according to an offset from a previous address (e.g., a linked list); still other examples include absolute or relative start/stop addresses, headers, footers, pointers, and/or any other referential data structure.
In some variants, the kernel may additionally provide supplemental information and/or kernel support via degenerate or redundant data structures. In one such implementation, the degenerate data structure may be a “packet” pointer that points to the object (instead of its packet). As but one such example, degenerate pointers may be used by the kernel space to reference the same object for multiple data packets. The kernel space entity can use the degenerate pointers to e.g., provide kernel space updates that correspond to the endpoint packets without de-referencing or otherwise manipulating the packets of the object. Kernel space updates may be stored in metadata for the object and handled by the endpoint non-kernel space application when necessary (thereby avoiding per-packet kernel processing). More generally, while the foregoing example is presented in the context of a degenerate pointer (a packet pointer that does not point to its packet), any data structure that lacks a key characteristic of its type may be substituted with equal success by artisans of ordinary skill in the related arts, given the contents of the present disclosure. Examples of such data structures include referential data structures that do not reference a data structure, value data structures that are nulled, etc.
Buffer cloning provides a plethora of advantages that improve the functioning of a computer process. Notably, the exemplary buffer cloning described herein provides unconventional technical solutions for efficiently accessing data by differently privileged and/or prioritized entities. In one specific example, the cross-layer optimizations described herein enable kernel space transport of objects (that contain multiple packets) without incurring per-packet overhead. As but another benefit, the cross-layer optimizations described herein enable non-kernel space entities to independently manage memory without running afoul of kernel space usage restrictions and memory protections. As but one such example, a device driver may flexibly adjust its spans to dynamically support a greater or fewer number of packets without e.g., context switching to kernel space to instantiate/destroy objects, etc. More generally, the various principles described herein address specific privilege, prioritization, and/or utilization issues that are specific to non-kernel space networking architectures; these are unique and distinct from well-understood, routine, and/or conventional solutions implemented within kernel space networking architectures.
Additionally, while the techniques described herein are discussed in the context of kernel space operation, artisans of ordinary skill in the related arts given the contents of the present disclosure will readily appreciate that the techniques described herein enable endpoint and/or device driver processing in a manner that does not require any intermediary node support. Any device that has the ability to clone packets may benefit from their local optimization regardless of whether other devices support packet cloning. In other words, the techniques described herein may be broadly implemented across a diverse community of different intermediary devices (e.g., legacy devices, embedded devices, intermediate routers, etc.) without being limited to the least capable device of the community.
More generally, even though device driver manufacturers have tried to expose driver optimizations to kernel space networking stacks, the peculiarities of device driver implementation often cannot be standardized for general use within monolithic kernel space networking stacks. The exemplary buffer cloning techniques described herein provide a modular, consistent, convenient, cross-layer application programming interface (API) that enables user space networking stacks to configure a discrete memory allocation (provided by kernel space memory management) for transacting multiple packets that have been optimized for a device driver.
Cross-Layer Packet Aggregation
As previously alluded to, networking overhead is generally subdivided into two distinct categories of costs. So-called “per-packet” costs refer to system resources that are consumed in the parsing and processing of a network packet according to a network communication protocol. For example, a system that acknowledges or not acknowledges (ACKs/NACKs) every packet must e.g., parse the packet, determine whether the packet was correctly received, and then transmit a corresponding ACK/NACK. In contrast, “per-bit”, “per-byte”, “per-word” costs refer to system resources that are consumed for any data manipulation (network or otherwise). Examples of per-costs include e.g., copy, move, checksum, etc. As a practical matter, per-byte costs are largely driven by underlying processor construction and/or hardware acceleration. Thus, within the context of networking technologies, reducing per-packet costs often yield the greatest performance gains.
Batch processing to amortize per-packet processing costs over multiple packets (rather than paying such overhead costs for processing each packet individually) could greatly improve networking stack operation. Receive Segment Coalescing (RSC) and Large Receive Offload (LRO) are examples of techniques that, when used in conjunction with the TCP protocol, batch packets into larger segments to reduce per-packet processing costs for appropriately enabled network communication stacks.
In theory, packet aggregation should greatly reduce per-packet processing costs; however, practical limitations greatly inhibit or even prevent such functionality. For instance, RSC/LRO functionality assumes that TCP packets with similar configurations, metadata, and/or other operational parameters, are received in sequence. For example, since some header information is lost during aggregation, TCP packets that have different header fields (or that are received out-of-order) either: (i) conservatively cannot be batched, or (ii) are aggressively batched without their header information. In many cases, communities of mixed devices use different heuristics to determine when aggregation should be performed. Mismatches in aggregation heuristics can result in undesirable performance (e.g., congestion, data loss, packet processing errors, etc.) Additionally, packet aggregation technologies were originally conceived of, and designed for, large centralized router hubs. Centralized hubs have access to the entire corpus of data traffic and can make intelligent decisions to optimize overall traffic. However, modern networks often use distributed topologies that do not have visibility into overall network traffic. As but one such example, a wireless hotspot for other devices (e.g., smart phone, laptop, personal media device, etc.) serves as a hub at the edge of the network; the wireless hotspot is unaware of the data traffic outside of its own hub. Moreover, packet aggregation functionality is often protocol specific; common packet protocols (e.g., multipath TCP, User Datagram Protocol (UDP), etc.) may each need their own aggregation technologies; this is undesirable for a number of reasons (complexity, unexpected behavior, etc.) In view of the foregoing, improved solutions for batch processing packets are needed.
Various embodiments of the present disclosure leverage the aforementioned buffer cloning concepts (see e.g., Buffer Cloning for Link Layer Aggregation described supra) to implement cross-layer packet aggregation.
In one exemplary embodiment, linkage and/or chaining information 1112 may be included to explicitly identify how an endpoint application may unpack the flows. In one such example, the linkage/chaining information 1112 may identify the first span for each respective flow (1110A, 1110B). Any permutation of different parameters may be included in the linkage/chaining information 1112. Examples may include e.g., location, size, stride value, number, length, options, and/or other handling considerations.
In one exemplary embodiment, the device driver can aggregate similar packets together by storing them within adjacent spans of the memory allocation. For example, in the illustrated example, Flow A comprises three (3) sequentially stored packets and Flow B comprises three (3) sequentially stored packets. In the illustrated embodiment, packets are stored without modification (headers and tails remain intact). Preserving packet contents in this manner is non-lossy and also computationally easier (e.g., CRC and length are not re-calculated). As previously alluded to, the kernel space can natively route and/or manipulate the kernel space object without regard to the underlying user space spans. The exemplary nexus described supra may route the kernel space object based on only the first packet for each chain; notably, the nexus need not route each packet individually (thus avoiding per-packet routing costs).
The principles described herein enable virtually any combination of packet packing, the depicted example being purely illustrative. Packing schemes may be sequential or non-sequential, symmetric or asymmetric. Any number, type, size, and/or combination of packets may be delivered via the packet aggregation techniques described herein. For example, a kernel space object could contain e.g., a combination of standard and jumbo frame ethernet packets, TCP and UDP packets, etc.
The exemplary embodiments of the cross-layer packet aggregation scheme described herein provide a plethora of advantages that improve the functioning of a computer process. Notably, the exemplary packet aggregation described herein provides unconventional technical solutions for preserving packet data and/or metadata within a network. In one specific example, the packet aggregation techniques described herein enable the transfer of aggregated packet payloads without incurring per-packet header parsing overhead. As another benefit, the cross-layer packet aggregation preserves header information that enables non-kernel space entities to leverage optional protocol behavior. For example, explicit congestion notification (ECN) options may be freely interspersed within a packet stream. The ECN notifications are preserved during the packet aggregation process, allowing upstream and downstream network entities to coordinate their congestion management activities.
More generally, the various principles described herein address specific packet processing issues that are specific to non-kernel space networking architectures; these are unique and distinct from well-understood, routine, and/or conventional solutions implemented within kernel space networking architectures.
“Just in Time” Transformation
As previously noted, communication stacks were originally designed based on principles of modular design and abstraction. Each layer of the networking stack operates as a “black box” to other layers; thus, only fully-formed (ready-to-use) data moves between layers. Additionally, each layer of the stack operates asynchronously (without regard to timing) from one another. Within the context of a monolithic kernel space networking stack, there is only one communication stack, and each layer of the communication stack executes within the kernel space (at the highest level of privilege and priority). In contrast, multiple user space networking stacks may concurrently operate in conjunction with a variety of other non-kernel entities (each of which may have different privileges and/or priorities).
In the illustrated example, the first user application 1210A (which includes a user space networking stack) and the second user application 1210B (which includes a user space networking stack) each request a memory allocation for their expected data usage needs. Similarly, the device driver requests a memory allocation based on its considerations (e.g., available network bandwidth, etc.) However, since the non-kernel space applications are unaware of one another, they reserve resources according only to their own considerations; in the illustrated example, the first user application 1210A reserves memory sufficient to transfer six (6) packets, the second user application 1210B reserves memory for three (3) packets, and the driver reserves memory to transfer five (5) packets. Due to the tightly coupled software/firmware/hardware nature of device driver operation, the driver packet pool 1204 may be configured in accordance with driver specific requirements. For example, a device driver may require that its memory allocation is physically contiguous.
During operation, the first user space application 1210A generates data packets for transmission. However, the user space network communication stack treats all external processes as black boxes, thus data packets are queued for delivery without regard to e.g., the device driver's 1202 timing and/or bandwidth capabilities. In the exemplary system, the kernel space nexus 1206 asynchronously prioritizes non-kernel space process execution based on holistic system considerations (e.g., a prioritized process list, current system resources, currently active/inactive processes, etc.) In this case, the nexus 1206 determines that the first user space application should be serviced, and responsively transfers (via copy, copy-checksum, zero-copy, etc.) the data packets from the user space application packet pool 1208A to the driver packet pool 1204. Notably, the kernel space usage restrictions and memory protections transfer only the fully-formed packets; data that is not yet ready for transfer is held.
Unfortunately, in this scenario, the first user space application 1210A only has packets pA,1 and pA,2 that are ready for transfer. As a further complication, even though the second user space application has fully-formed packets that are available for transfer (pB,1 and pB,2), the kernel space nexus 1206 may be unable to intelligently aggregate the packets due to usage restrictions and/or memory configuration. In the instant example, smart packet aggregation cannot be performed because the individual packet flows use the same packet sequencing (packet numbers 1 and 2 are present for both flow A and flow B). Additionally, since each packet flow is isolated to its own buffer, copying both packet flows would result in a physically discontinuous memory allocation. In other words, if the device driver memory allocation should be physically contiguous, then the nexus 1206 must either only transfer packets that are physically contiguous or unpack-and-re-pack the device driver pool such that it is physically contiguous (which incurs significant per-packet cost). Consequently, the illustrated implementation only transfers a subset of the packets that could be transmitted; as a result, a significant portion of the reserved memory allocations remains underutilized.
More generally, usage restrictions and memory access protections that are imposed on non-kernel space processes may interfere with modular systems of processes. Non-kernel space processes execute asynchronously, and at reduced privileges and priorities to kernel space processes. In many cases, such processes are “black boxes” and often cannot communicate their internal considerations to other processes, or may have limited ability to do so. Batch processing techniques that were originally designed for kernel space networking architectures rely on kernel space visibility to maximally utilize system resources; such techniques result in suboptimal resource utilization when implemented in non-kernel space architectures.
During operation, the first user space application 1310A and second user space application 1310B both generate data packets for transmission; additionally, each user space application updates the kernel space nexus 1312 with a running tally of their “intent”; the intent metadata identifies which packets are ready for transfer. In one exemplary embodiment, the packet intent metadata identifies each packet by its corresponding packet flow and packet sequence. Other information may also be included in the intent metadata (e.g., time-to-live, driver options, packet type, etc.); the nexus 1306 can consult the intent metadata (and any other system considerations) to determine when to call the device driver 1302.
When the nexus 1306 calls the device driver 1302, the device driver may request or (be allocated) a memory allocation based on both its own considerations as well as the queued intent metadata and other kernel space considerations. For example, when the network is uncongested, the device driver 1302 may only be allocated memory sufficient to transfer the intended packets. When the network is congested, the device driver 1302 may only be allocated memory sufficient to service the available bandwidth. Still other variants, combinations, and/or hybrids thereof may be substituted by artisans of ordinary skill in the related arts, given the contents of the present disclosure. As but one such example, the device driver 1302 may only be allocated memory sufficient to transfer complete packet flows, high priority packets, low latency packets, etc.
As shown in
More directly, the foregoing scheme stages packet data as it is generated (which may be partially-formed/not ready-to-use) prior to the device driver's packet pool and/or Active Queue Management (AQM) process. The kernel nexus queues packet intent (a token or other metadata that corresponds to the intended fully-formed packet). When the device driver requests a memory allocation (e.g., via a transmit doorbell signal), the kernel space nexus 1306 generates fully-formed packets from the queued intents and queued packet data; in one exemplary implementation, the fully-formed packets are aggregated into the driver's packet pool 1304 (a cloned buffer object) “just in time” for delivery.
The foregoing example enables user space applications and device drivers to independently queue packets and/or resources for transfer; an intermediary kernel nexus fulfills the data transfers “just in time” using the pre-queued packets and/or resources. Just in time transformation greatly improves memory utilization because resources are not reserved while idle. More directly, the principles described herein enable non-kernel space entities to independently manage their own internal considerations while still providing “intent” information so as to enable cross-layer optimizations. While the present disclosure is presented in the context of a memory utilization optimization, the principles described herein may be broadly extended to any limited system resource. Examples of such resources include, without limitation, processing cycles, network bandwidth, memory utilization, power utilization, etc.
The exemplary cross-layer packet aggregation scheme described herein provides a plethora of advantages that improve the functioning of a computer process. Notably, the exemplary just in time transformation described herein provides unconventional technical solutions for efficiently allocating limited resources within a computer device. In one specific example, the “just in time” transformation techniques described herein enable the kernel space entity to allocate memory as necessary to perform a data transfer at a particular time. As another benefit, just in time transformation ensures that a device completely utilizes its requested network bandwidth. Many networks throttle bandwidth based on observed utilization; high utilization is rewarded with more resource grants, low utilization results in fewer resource allocations. In other words, a device that maximizes its network bandwidth utilization may be granted more network resources, thereby improving its overall performance. More generally, the various principles described herein address specific packet processing issues that are specific to non-kernel space networking architectures; these are unique and distinct from well-understood, routine, and/or conventional solutions implemented within kernel space networking architectures.
At operation 1402, the operational control flow 1400 requests one or more memory allocations from a pre-allocated packet pool, such as the user space application packet pool 1308A or the user space application packet pool 1308B as described above in
At operation 1404, the operational control flow 1400 generates data packets for transmission and stores these generated data packets in the packet pool from operation 1402. In some embodiments, the operational control flow 1400 can update a nexus, such as the kernel space nexus 1312 as described above in
At operation 1406, the operational control flow 1400 can call a device driver, such as the device driver 1302 as described above in
At operation 1408, the operational control flow 1400 generates fully-formed packets from the queued intents and the queued packet data from operation 1404 and transfers these fully-formed packets from the packet pool from operation 1402 to the packet pool from operation 1406. In some embodiments, the operational control flow 1400 can generate the fully-formed packets from the queued intents and queued packet data when the device driver requests a memory allocation, for example, via a transmit doorbell signal, at operation 1406. In some embodiments, the fully-formed packets are aggregated into the packet pool from operation 1406, a cloned buffer object “just in time” for delivery.
It is to be appreciated that the Detailed Description section, and not the Summary and Abstract sections, is intended to be used to interpret the claims. The Summary and Abstract sections may set forth one or more but not all exemplary embodiments of the disclosure as contemplated by the inventor(s), and thus, are not intended to limit the disclosure and the appended claims in any way.
The disclosure has been described above with the aid of functional building blocks illustrating the implementation of specified functions and relationships thereof. The boundaries of these functional building blocks have been arbitrarily defined herein for the convenience of the description. Alternate boundaries can be defined so long as the specified functions and relationships thereof are appropriately performed.
The foregoing description of the specific embodiments will so fully reveal the general nature of the disclosure that others can, by applying knowledge within the skill of the art, readily modify and/or adapt for various applications such specific embodiments, without undue experimentation, without departing from the general concept of the disclosure. Therefore, such adaptations and modifications are intended to be within the meaning and range of equivalents of the disclosed embodiments, based on the teaching and guidance presented herein. It is to be understood that the phraseology or terminology herein is for the purpose of description and not of limitation, such that the terminology or phraseology of the present specification is to be interpreted by the skilled artisan in light of the teachings and guidance.
It will be recognized the specific embodiments can be described in terms of a sequence of steps or operations, these descriptions are only illustrative of the broader steps or operations described herein, and may be modified as required by the particular application. Certain steps or operations may be rendered unnecessary or optional under certain circumstances. Additionally, certain steps or operations may be added to the disclosed embodiments, or the order of performance of two or more steps permuted. All such variations are considered to be encompassed within the disclosure herein.
The breadth and scope of the disclosure should not be limited by any of the above-described exemplary embodiments, but should be defined only in accordance with the following claims and their equivalents.
The present disclosure contemplates that the entities responsible for the collection, analysis, disclosure, transfer, storage, or other use of such personal information data will comply with well-established privacy policies and/or privacy practices. In particular, such entities should implement and consistently use privacy policies and practices that are generally recognized as meeting or exceeding industry or governmental requirements for maintaining personal information data private and secure. Such policies should be easily accessible by users, and should be updated as the collection and/or use of data changes. Personal information from users should be collected for legitimate and reasonable uses of the entity and not shared or sold outside of those legitimate uses. Further, such collection/sharing should only occur after receiving the informed consent of the users. Additionally, such entities should consider taking any needed steps for safeguarding and securing access to such personal information data and ensuring that others with access to the personal information data adhere to their privacy policies and procedures. Further, such entities can subject themselves to evaluation by third parties to certify their adherence to widely accepted privacy policies and practices. In addition, policies and practices should be adapted for the particular types of personal information data being collected and/or accessed and adapted to applicable laws and standards, including jurisdiction-specific considerations. For instance, in the United States, collection of, or access to, certain health data may be governed by federal and/or state laws, such as the Health Insurance Portability and Accountability Act (HIPAA); whereas health data in other countries may be subject to other regulations and policies and should be handled accordingly. Hence different privacy practices should be maintained for different personal data types in each country.
The present application claims the benefit of U.S. Provisional Patent Application No. 63/077,465, filed Sep. 11, 2020, which is incorporated herein by reference in its entirety. The present application incorporates by reference the following: U.S. patent application Ser. No. 16/144,992, filed Sep. 27, 2018, U.S. patent application Ser. No. 16/146,533, filed Sep. 28, 2018, U.S. patent application Ser. No. 16/146,324, filed Sep. 28, 2018 and entitled “Methods and apparatuses for Preventing Packet Spoofing with User Space Communication Stacks,” U.S. patent application Ser. No. 16/146,916, filed Sep. 28, 2018, U.S. patent application Ser. No. 16/236,032, filed Dec. 28, 2018, U.S. patent application Ser. No. 16/363,495, filed Mar. 25, 2019, U.S. patent application Ser. No. 16/368,396, filed on Mar. 26, 2019, U.S. patent application Ser. No. 16/363,495, filed on Mar. 25, 2019, U.S. patent application Ser. No. 16/368,338, filed on Mar. 28, 2019, U.S. patent application Ser. No. 16/365,484, filed on Mar. 26, 2019, U.S. patent application Ser. No. 16/368,368, filed on Mar. 28, 2019, U.S. patent application Ser. No. 16/368,214, filed on Mar. 28, 2019, U.S. patent application Ser. No. 16/936,228, filed Jul. 22, 2020, U.S. patent application Ser. No. 16/935,982, filed Jul. 22, 2020, and U.S. patent application Ser. No. 16/936,143, filed Jul. 22, 2020, all in their entirety.
| Number | Name | Date | Kind |
|---|---|---|---|
| 4805137 | Grant et al. | Feb 1989 | A |
| 4949299 | Pickett | Aug 1990 | A |
| 5367688 | Croll | Nov 1994 | A |
| 5467459 | Alexander et al. | Nov 1995 | A |
| 5485578 | Sweazey | Jan 1996 | A |
| 5506968 | Dukes | Apr 1996 | A |
| 5613086 | Frey et al. | Mar 1997 | A |
| 5659542 | Bell et al. | Aug 1997 | A |
| 5708779 | Graziano et al. | Jan 1998 | A |
| 5731973 | Takaishi et al. | Mar 1998 | A |
| 5850395 | Hauser et al. | Dec 1998 | A |
| 5903564 | Ganmukhi et al. | May 1999 | A |
| 5943507 | Cornish et al. | Aug 1999 | A |
| 6008992 | Kawakami | Dec 1999 | A |
| 6032179 | Osborne | Feb 2000 | A |
| 6216178 | Stracovsky et al. | Apr 2001 | B1 |
| 6233702 | Horst et al. | May 2001 | B1 |
| 6260152 | Cole et al. | Jul 2001 | B1 |
| 6349355 | Draves et al. | Feb 2002 | B1 |
| 6359863 | Varma et al. | Mar 2002 | B1 |
| 6411997 | Dawes et al. | Jun 2002 | B1 |
| 6485081 | Bingle et al. | Nov 2002 | B1 |
| 6523073 | Kammer et al. | Feb 2003 | B1 |
| 6553446 | Miller | Apr 2003 | B1 |
| 6693895 | Crummey et al. | Feb 2004 | B1 |
| 6815873 | Johnson et al. | Nov 2004 | B2 |
| 6874075 | Jerding et al. | Mar 2005 | B2 |
| 6948094 | Schultz et al. | Sep 2005 | B2 |
| 6973701 | Momoda et al. | Dec 2005 | B2 |
| 6990594 | Kim | Jan 2006 | B2 |
| 7013536 | Golden et al. | Mar 2006 | B2 |
| 7032282 | Powell et al. | Apr 2006 | B2 |
| 7100020 | Brightman et al. | Aug 2006 | B1 |
| 7111307 | Wang | Sep 2006 | B1 |
| 7127600 | Zimmer et al. | Oct 2006 | B2 |
| 7152231 | Galluscio et al. | Dec 2006 | B1 |
| 7281172 | Chujo | Oct 2007 | B2 |
| 7397774 | Holland et al. | Jul 2008 | B1 |
| 7398382 | Rothman et al. | Jul 2008 | B2 |
| 7403542 | Thompson | Jul 2008 | B1 |
| 7506084 | Moerti et al. | Mar 2009 | B2 |
| 7509391 | Chauvel et al. | Mar 2009 | B1 |
| 7587575 | Moertl et al. | Sep 2009 | B2 |
| 7590817 | Moertl et al. | Sep 2009 | B2 |
| 7617377 | Moertl et al. | Nov 2009 | B2 |
| 7681012 | Verma et al. | Mar 2010 | B2 |
| 7685476 | Andre et al. | Mar 2010 | B2 |
| 7802256 | Havens | Sep 2010 | B2 |
| 7853731 | Zeng | Dec 2010 | B1 |
| 7899941 | Hendry et al. | Mar 2011 | B2 |
| 7941682 | Adams | May 2011 | B2 |
| 8214707 | Munson et al. | Jul 2012 | B2 |
| 8230248 | Dance et al. | Jul 2012 | B2 |
| 8239947 | Glick et al. | Aug 2012 | B1 |
| 8255725 | Shimazaki et al. | Aug 2012 | B2 |
| 8271996 | Gould et al. | Sep 2012 | B1 |
| 8352624 | Zimmerman et al. | Jan 2013 | B2 |
| 8468285 | Kobayashi | Jun 2013 | B2 |
| 8555099 | Marinkovic et al. | Oct 2013 | B2 |
| 8561090 | Schneider | Oct 2013 | B2 |
| 8635412 | Wilshire | Jan 2014 | B1 |
| 8656228 | Check et al. | Feb 2014 | B2 |
| 8769168 | Moertl et al. | Jul 2014 | B2 |
| 8788822 | Riddle | Jul 2014 | B1 |
| 8799537 | Zhu et al. | Aug 2014 | B1 |
| 8806640 | Wang | Aug 2014 | B2 |
| 8819386 | Mather | Aug 2014 | B1 |
| 8848809 | Whitby-Strevens | Sep 2014 | B2 |
| 8855120 | Robbins | Oct 2014 | B2 |
| 8876062 | Baghdasarian | Nov 2014 | B1 |
| 9049179 | Luna | Jun 2015 | B2 |
| 9130864 | Keith | Sep 2015 | B2 |
| 9135059 | Ballard et al. | Sep 2015 | B2 |
| 9152580 | Chau et al. | Oct 2015 | B1 |
| 9170957 | Touzni et al. | Oct 2015 | B2 |
| 9280360 | Xu et al. | Mar 2016 | B2 |
| 9319090 | Whitby-Strevens | Apr 2016 | B2 |
| 9483305 | Shmidt et al. | Nov 2016 | B1 |
| 9544069 | Whitby-Strevens et al. | Jan 2017 | B2 |
| 9547535 | Wilt | Jan 2017 | B1 |
| 9594718 | Kaushik et al. | Mar 2017 | B2 |
| 9769756 | Cui et al. | Sep 2017 | B1 |
| 9830289 | Pulyala et al. | Nov 2017 | B2 |
| 9910475 | Kurts et al. | Mar 2018 | B2 |
| 9913305 | Pinheiro et al. | Mar 2018 | B2 |
| 9932757 | Hager | Apr 2018 | B2 |
| 9959124 | Herbeck et al. | May 2018 | B1 |
| 9985904 | Shalev et al. | May 2018 | B2 |
| 10078361 | Sanghi et al. | Sep 2018 | B2 |
| 10230608 | Tsirkin | Mar 2019 | B2 |
| 10289555 | Michaud et al. | May 2019 | B1 |
| 10331600 | Rajadnya et al. | Jun 2019 | B1 |
| 10331612 | Petkov et al. | Jun 2019 | B1 |
| 10534601 | Venkata et al. | Jan 2020 | B1 |
| 10552072 | Bono et al. | Feb 2020 | B1 |
| 10678432 | Dreier et al. | Jun 2020 | B1 |
| 10798059 | Singh et al. | Oct 2020 | B1 |
| 10798224 | Masputra et al. | Oct 2020 | B2 |
| 10819831 | Masputra et al. | Oct 2020 | B2 |
| 10999132 | Sagar et al. | May 2021 | B1 |
| 11095758 | Masputra et al. | Aug 2021 | B2 |
| 11146665 | Masputra et al. | Oct 2021 | B2 |
| 11159651 | Masputra et al. | Oct 2021 | B2 |
| 11178259 | Masputra et al. | Nov 2021 | B2 |
| 11178260 | Masputra et al. | Nov 2021 | B2 |
| 11212373 | Masputra et al. | Dec 2021 | B2 |
| 11368560 | Masputra et al. | Jun 2022 | B2 |
| 11477123 | Masputra et al. | Oct 2022 | B2 |
| 11558348 | Masputra et al. | Jan 2023 | B2 |
| 20010037410 | Gardner | Nov 2001 | A1 |
| 20020013868 | West | Jan 2002 | A1 |
| 20020044553 | Chakravorty | Apr 2002 | A1 |
| 20020053011 | Aiken et al. | May 2002 | A1 |
| 20020065867 | Chauvel | May 2002 | A1 |
| 20020169938 | Scott et al. | Nov 2002 | A1 |
| 20020195177 | Hinkley et al. | Dec 2002 | A1 |
| 20030014607 | Slavin et al. | Jan 2003 | A1 |
| 20030061395 | Kingsbury et al. | Mar 2003 | A1 |
| 20030120935 | Teal et al. | Jun 2003 | A1 |
| 20030200413 | Gurumoorthy et al. | Oct 2003 | A1 |
| 20040010473 | Hsu et al. | Jan 2004 | A1 |
| 20040010545 | Pandya | Jan 2004 | A1 |
| 20040044929 | Chujo | Mar 2004 | A1 |
| 20040105384 | Gallezot et al. | Jun 2004 | A1 |
| 20040128568 | O'Shea | Jul 2004 | A1 |
| 20040179546 | McDaniel et al. | Sep 2004 | A1 |
| 20040201749 | Malloy Desormeaux | Oct 2004 | A1 |
| 20040221056 | Kobayashi | Nov 2004 | A1 |
| 20040228365 | Kobayashi | Nov 2004 | A1 |
| 20040249957 | Ekis et al. | Dec 2004 | A1 |
| 20050055406 | Singhai et al. | Mar 2005 | A1 |
| 20050068897 | Arita et al. | Mar 2005 | A1 |
| 20050076196 | Zimmer et al. | Apr 2005 | A1 |
| 20050076244 | Watanabe | Apr 2005 | A1 |
| 20050108385 | Wechter et al. | May 2005 | A1 |
| 20050114620 | Justen | May 2005 | A1 |
| 20050117601 | Anderson et al. | Jun 2005 | A1 |
| 20050138628 | Bradford et al. | Jun 2005 | A1 |
| 20050140683 | Collins et al. | Jun 2005 | A1 |
| 20050149711 | Zimmer et al. | Jul 2005 | A1 |
| 20050157781 | Ho et al. | Jul 2005 | A1 |
| 20050198777 | Mabe | Sep 2005 | A1 |
| 20050278498 | Ahluwalia et al. | Dec 2005 | A1 |
| 20050285862 | Noda et al. | Dec 2005 | A1 |
| 20060039285 | Chapman et al. | Feb 2006 | A1 |
| 20060047989 | Delgado et al. | Mar 2006 | A1 |
| 20060075119 | Hussain et al. | Apr 2006 | A1 |
| 20060107071 | Girish et al. | May 2006 | A1 |
| 20060136570 | Pandya | Jun 2006 | A1 |
| 20060186700 | Browne et al. | Aug 2006 | A1 |
| 20060186706 | Browne et al. | Aug 2006 | A1 |
| 20060215697 | Olderdissen | Sep 2006 | A1 |
| 20060218301 | O'Toole et al. | Sep 2006 | A1 |
| 20060232051 | Morris et al. | Oct 2006 | A1 |
| 20060248542 | Wang et al. | Nov 2006 | A1 |
| 20070005869 | Balraj et al. | Jan 2007 | A1 |
| 20070008983 | Van Doren et al. | Jan 2007 | A1 |
| 20070043901 | Wu et al. | Feb 2007 | A1 |
| 20070063540 | Browne et al. | Mar 2007 | A1 |
| 20070063541 | Browne et al. | Mar 2007 | A1 |
| 20070070997 | Weitz et al. | Mar 2007 | A1 |
| 20070080013 | Melz et al. | Apr 2007 | A1 |
| 20070086480 | Elzur | Apr 2007 | A1 |
| 20070118831 | Kondo | May 2007 | A1 |
| 20070180041 | Suzuoki | Aug 2007 | A1 |
| 20070183418 | Riddoch et al. | Aug 2007 | A1 |
| 20070201492 | Kobayashi | Aug 2007 | A1 |
| 20070226375 | Chu et al. | Sep 2007 | A1 |
| 20070226417 | Davis | Sep 2007 | A1 |
| 20070255802 | Aloni et al. | Nov 2007 | A1 |
| 20070255866 | Aloni et al. | Nov 2007 | A1 |
| 20070261307 | Alexander | Nov 2007 | A1 |
| 20070286246 | Kobayashi | Dec 2007 | A1 |
| 20080005794 | Inoue et al. | Jan 2008 | A1 |
| 20080007081 | Shibata et al. | Jan 2008 | A1 |
| 20080010563 | Nishimura | Jan 2008 | A1 |
| 20080046689 | Chen et al. | Feb 2008 | A1 |
| 20080077816 | Ravichandran | Mar 2008 | A1 |
| 20080100079 | Herrera et al. | May 2008 | A1 |
| 20080100092 | Gao et al. | May 2008 | A1 |
| 20080120911 | Browne et al. | May 2008 | A1 |
| 20080127292 | Cooper et al. | May 2008 | A1 |
| 20080148291 | Huang et al. | Jun 2008 | A1 |
| 20080183931 | Verm et al. | Jul 2008 | A1 |
| 20080231711 | Glen et al. | Sep 2008 | A1 |
| 20080235355 | Spanier et al. | Sep 2008 | A1 |
| 20080244259 | Zimmer et al. | Oct 2008 | A1 |
| 20080301148 | Lee et al. | Dec 2008 | A1 |
| 20090006920 | Munson et al. | Jan 2009 | A1 |
| 20090024924 | Kim | Jan 2009 | A1 |
| 20090092057 | Doctor et al. | Apr 2009 | A1 |
| 20090113141 | Bullman et al. | Apr 2009 | A1 |
| 20090138650 | Lin et al. | May 2009 | A1 |
| 20090172674 | Bobak et al. | Jul 2009 | A1 |
| 20090177847 | Ceze et al. | Jul 2009 | A1 |
| 20090189442 | Chi | Jul 2009 | A1 |
| 20090225818 | Dapper et al. | Sep 2009 | A1 |
| 20090240874 | Pong | Sep 2009 | A1 |
| 20090265723 | Mochizuki et al. | Oct 2009 | A1 |
| 20090322531 | Estevez et al. | Dec 2009 | A1 |
| 20100005014 | Castle et al. | Jan 2010 | A1 |
| 20100017655 | Gooding et al. | Jan 2010 | A1 |
| 20100049876 | Pope et al. | Feb 2010 | A1 |
| 20100057932 | Pope et al. | Mar 2010 | A1 |
| 20100082859 | Hendry et al. | Apr 2010 | A1 |
| 20100098419 | Levy et al. | Apr 2010 | A1 |
| 20100118041 | Chen et al. | May 2010 | A1 |
| 20100121972 | Samuels | May 2010 | A1 |
| 20100325357 | Reddy | Dec 2010 | A1 |
| 20100329319 | Dai et al. | Dec 2010 | A1 |
| 20110029696 | Uehara | Feb 2011 | A1 |
| 20110035575 | Kwon | Feb 2011 | A1 |
| 20110052142 | Sultenfuss et al. | Mar 2011 | A1 |
| 20110083002 | Albers et al. | Apr 2011 | A1 |
| 20110161619 | Kaminski et al. | Jun 2011 | A1 |
| 20110219208 | Asaad et al. | Sep 2011 | A1 |
| 20110242425 | Zeng | Oct 2011 | A1 |
| 20110246742 | Kogen et al. | Oct 2011 | A1 |
| 20110276710 | Mighani et al. | Nov 2011 | A1 |
| 20110292936 | Wang et al. | Dec 2011 | A1 |
| 20110310296 | Lee et al. | Dec 2011 | A1 |
| 20110320861 | Bayer et al. | Dec 2011 | A1 |
| 20120017063 | Hummel et al. | Jan 2012 | A1 |
| 20120036334 | Horman et al. | Feb 2012 | A1 |
| 20120072658 | Hashimoto | Mar 2012 | A1 |
| 20120084483 | Sanjive | Apr 2012 | A1 |
| 20120084484 | Post et al. | Apr 2012 | A1 |
| 20120102307 | Wong | Apr 2012 | A1 |
| 20120124252 | Kayama | May 2012 | A1 |
| 20120203880 | Kluyt et al. | Aug 2012 | A1 |
| 20120224640 | Sole Rojals et al. | Sep 2012 | A1 |
| 20120229076 | Zhu et al. | Sep 2012 | A1 |
| 20120260017 | Mine et al. | Oct 2012 | A1 |
| 20130039278 | Bouazizi et al. | Feb 2013 | A1 |
| 20130050216 | Whitby-Strevens et al. | Feb 2013 | A1 |
| 20130057567 | Frank et al. | Mar 2013 | A1 |
| 20130067188 | Mehra et al. | Mar 2013 | A1 |
| 20130091772 | Berger et al. | Apr 2013 | A1 |
| 20130111014 | Lawrie et al. | May 2013 | A1 |
| 20130138840 | Kegel et al. | May 2013 | A1 |
| 20130162911 | Glen | Jun 2013 | A1 |
| 20130204927 | Kruglikov et al. | Aug 2013 | A1 |
| 20130205113 | Ahmad et al. | Aug 2013 | A1 |
| 20130275976 | Dawson et al. | Oct 2013 | A1 |
| 20130290947 | Li | Oct 2013 | A1 |
| 20130347131 | Mooring et al. | Dec 2013 | A1 |
| 20140033220 | Campbell et al. | Jan 2014 | A1 |
| 20140068624 | Fuller et al. | Mar 2014 | A1 |
| 20140068636 | Dupont et al. | Mar 2014 | A1 |
| 20140122695 | Kulikov et al. | May 2014 | A1 |
| 20140122828 | Kagan et al. | May 2014 | A1 |
| 20140173236 | Kegel | Jun 2014 | A1 |
| 20140189057 | Sankoda et al. | Jul 2014 | A1 |
| 20140211894 | Yang | Jul 2014 | A1 |
| 20140247983 | MacInnis et al. | Sep 2014 | A1 |
| 20140355606 | Riddoch et al. | Dec 2014 | A1 |
| 20150007262 | Aissi et al. | Jan 2015 | A1 |
| 20150036051 | Broberg et al. | Feb 2015 | A1 |
| 20150058444 | Willmann | Feb 2015 | A1 |
| 20150081985 | Archer et al. | Mar 2015 | A1 |
| 20150156122 | Singh et al. | Jun 2015 | A1 |
| 20150172345 | Mantin et al. | Jun 2015 | A1 |
| 20150189109 | Whitby-Strevens et al. | Jul 2015 | A1 |
| 20150205749 | Whitby-Strevens et al. | Jul 2015 | A1 |
| 20150212806 | Hsieh | Jul 2015 | A1 |
| 20150244804 | Warfield et al. | Aug 2015 | A1 |
| 20150261588 | Liu et al. | Sep 2015 | A1 |
| 20150309940 | Kumar | Oct 2015 | A1 |
| 20150326542 | Serebrin | Nov 2015 | A1 |
| 20150363110 | Batra et al. | Dec 2015 | A1 |
| 20150370582 | Kinsella et al. | Dec 2015 | A1 |
| 20150378737 | Debbage et al. | Dec 2015 | A1 |
| 20160028635 | Wang | Jan 2016 | A1 |
| 20160034195 | Li et al. | Feb 2016 | A1 |
| 20160041852 | Suarez Gracia et al. | Feb 2016 | A1 |
| 20160044143 | Narasimhamurthy | Feb 2016 | A1 |
| 20160063258 | Ackerly | Mar 2016 | A1 |
| 20160077989 | Pulyala et al. | Mar 2016 | A1 |
| 20160103480 | Sanghi et al. | Apr 2016 | A1 |
| 20160103689 | Sanghi et al. | Apr 2016 | A1 |
| 20160103743 | Sanghi et al. | Apr 2016 | A1 |
| 20160142988 | Powell et al. | May 2016 | A1 |
| 20160208539 | Hofmann et al. | Jul 2016 | A1 |
| 20160224442 | Sanghi et al. | Aug 2016 | A1 |
| 20160226957 | Zhang et al. | Aug 2016 | A1 |
| 20160226967 | Zhang et al. | Aug 2016 | A1 |
| 20160231929 | Tsirkin | Aug 2016 | A1 |
| 20160261632 | Kölhi et al. | Sep 2016 | A1 |
| 20160269991 | Van Greunen et al. | Sep 2016 | A1 |
| 20160357443 | Li et al. | Dec 2016 | A1 |
| 20160363955 | Stevens et al. | Dec 2016 | A1 |
| 20160364350 | Sanghi et al. | Dec 2016 | A1 |
| 20160378545 | Ho | Dec 2016 | A1 |
| 20170003977 | Sumida et al. | Jan 2017 | A1 |
| 20170003997 | Kelly et al. | Jan 2017 | A1 |
| 20170075856 | Suzue et al. | Mar 2017 | A1 |
| 20170089641 | Humfeld et al. | Mar 2017 | A1 |
| 20170108912 | Li et al. | Apr 2017 | A1 |
| 20170111283 | Kumar et al. | Apr 2017 | A1 |
| 20170124327 | Kumbhar et al. | May 2017 | A1 |
| 20170126726 | Han | May 2017 | A1 |
| 20170147282 | Seo | May 2017 | A1 |
| 20170149890 | Shamis et al. | May 2017 | A1 |
| 20170187621 | Shalev et al. | Jun 2017 | A1 |
| 20170187846 | Shalev et al. | Jun 2017 | A1 |
| 20170249098 | Petkov et al. | Aug 2017 | A1 |
| 20170264497 | Lim | Sep 2017 | A1 |
| 20170286300 | Doshi et al. | Oct 2017 | A1 |
| 20170286322 | Garg et al. | Oct 2017 | A1 |
| 20170286323 | Garg et al. | Oct 2017 | A1 |
| 20170308460 | Guthula et al. | Oct 2017 | A1 |
| 20170337588 | Chittilappilly et al. | Nov 2017 | A1 |
| 20170353499 | Huang et al. | Dec 2017 | A1 |
| 20170371591 | Xia et al. | Dec 2017 | A1 |
| 20180004690 | Kaminski et al. | Jan 2018 | A1 |
| 20180070341 | Islam et al. | Mar 2018 | A1 |
| 20180081829 | Kaplan | Mar 2018 | A1 |
| 20180129261 | Garg et al. | May 2018 | A1 |
| 20180129269 | Garg et al. | May 2018 | A1 |
| 20180129270 | Garg et al. | May 2018 | A1 |
| 20180173643 | Yu et al. | Jun 2018 | A1 |
| 20180196648 | Henderson et al. | Jul 2018 | A1 |
| 20180219805 | MacNeil et al. | Aug 2018 | A1 |
| 20180219976 | Decenzo et al. | Aug 2018 | A1 |
| 20180239657 | Petrbok et al. | Aug 2018 | A1 |
| 20180248847 | Guri et al. | Aug 2018 | A1 |
| 20180253315 | Norton et al. | Sep 2018 | A1 |
| 20180285561 | Frank et al. | Oct 2018 | A1 |
| 20180295052 | St. Laurent | Oct 2018 | A1 |
| 20180329743 | Pope et al. | Nov 2018 | A1 |
| 20180343206 | White et al. | Nov 2018 | A1 |
| 20180357176 | Wang | Dec 2018 | A1 |
| 20190007850 | DenBoer et al. | Jan 2019 | A1 |
| 20190036893 | Jiang | Jan 2019 | A1 |
| 20190052659 | Weingarten et al. | Feb 2019 | A1 |
| 20190065301 | Tsirkin et al. | Feb 2019 | A1 |
| 20190097938 | Talla et al. | Mar 2019 | A1 |
| 20190102303 | Wang et al. | Apr 2019 | A1 |
| 20190102568 | Hausauer et al. | Apr 2019 | A1 |
| 20190109714 | Clark et al. | Apr 2019 | A1 |
| 20190140983 | Tu et al. | May 2019 | A1 |
| 20190141041 | Bhabbur et al. | May 2019 | A1 |
| 20190147066 | Ben Dayan et al. | May 2019 | A1 |
| 20190147069 | Ben Dayan et al. | May 2019 | A1 |
| 20190205533 | Diehl et al. | Jul 2019 | A1 |
| 20190213044 | Cui et al. | Jul 2019 | A1 |
| 20190213166 | Petkov et al. | Jul 2019 | A1 |
| 20190253351 | Ihlar et al. | Aug 2019 | A1 |
| 20190286466 | Tsirkin et al. | Sep 2019 | A1 |
| 20190303204 | Masputra et al. | Oct 2019 | A1 |
| 20190303205 | Masputra et al. | Oct 2019 | A1 |
| 20190303221 | Masputra et al. | Oct 2019 | A1 |
| 20190303222 | Masputra et al. | Oct 2019 | A1 |
| 20190303280 | Masputra et al. | Oct 2019 | A1 |
| 20190303562 | Masputra et al. | Oct 2019 | A1 |
| 20190303576 | Masputra et al. | Oct 2019 | A1 |
| 20190306076 | Masputra et al. | Oct 2019 | A1 |
| 20190306087 | Masputra et al. | Oct 2019 | A1 |
| 20190306109 | Masputra et al. | Oct 2019 | A1 |
| 20190306281 | Masputra et al. | Oct 2019 | A1 |
| 20190306282 | Masputra et al. | Oct 2019 | A1 |
| 20200019695 | Sovio et al. | Jan 2020 | A1 |
| 20200036615 | Lewis | Jan 2020 | A1 |
| 20200045015 | Nukala et al. | Feb 2020 | A1 |
| 20200065244 | Sanghi et al. | Feb 2020 | A1 |
| 20200073829 | Tsirkin et al. | Mar 2020 | A1 |
| 20200195684 | Linz | Jun 2020 | A1 |
| 20200374238 | Momchilov | Nov 2020 | A1 |
| 20210011856 | Xia et al. | Jan 2021 | A1 |
| 20210097006 | Masputra et al. | Apr 2021 | A1 |
| 20210099391 | Masputra et al. | Apr 2021 | A1 |
| 20210099427 | Masputra et al. | Apr 2021 | A1 |
| 20220030095 | Masputra et al. | Jan 2022 | A1 |
| 20220046117 | Masputra et al. | Feb 2022 | A1 |
| Number | Date | Country |
|---|---|---|
| 3013008 | Apr 2016 | EP |
| H02306082 | Dec 1990 | JP |
| H03169996 | Jul 1991 | JP |
| 2004086792 | Mar 2004 | JP |
| 2012108677 | Jun 2012 | JP |
| 2013246642 | Dec 2013 | JP |
| 2015001867 | Jan 2015 | JP |
| WO 2008070138 | Jun 2008 | WO |
| Entry |
|---|
| Moon-Sang Lee, Joonwon Lee and S. Maeng, “Context-aware address translation for high-performance SMP cluster system,” 2008u IEEE International Conference on Cluster Computing, Tsukuba, 2008, pp. 292-297, doi: 10.1109/CLUSTR.2008.4663784. (Year: 2008). |
| Honda et al., “Rekindling Network Protocol Innovation with User-Level Stacks”, ACM SIGCOMM Computer Communication Review, vol. 44, No. 2, Apr. 2014. |
| Gopalakrishnan R., et al., “Efficient User-Space Protocol Implementations with QoS Guarantees Using Real-Time Upcalls”, IEEE/ACM Transactions on Networking, Aug. 1998, vol. 6 (4), pp. 374-388. |
| ECN L1 PM Substates with CLKREQ approved Aug. 23, 2012. |
| Jackson, “PCI Express Technology”, Sep. 2012 (Sep. 2012), MindShare Press, xP002777351, pp. 49,86,87,712-723. |
| PCI Express base Specification Revision 3.0, published Nov. 10, 2010. |
| PCI Express Base Specification Revision 3.1, published Oct. 8, 2014. |
| Universal Serial Bus, Communication Class, Subclass Specifications for Network Control Model (NCM) Devices; Revision 1.0 (Errata 1), Nov. 24, 2010, published by USB Implementers Forum, Inc. |
| Whitworth, “Improving Networking by moving the network stack to userspace”, Imperial College London, Jun. 14, 2010 [Mar. 17, 2022]; retrieved from the Internet: <URL https://www.doc.ic.ac.uk/teaching/distinguished-projects/2010/m.whitworth.pdf> (Year: 2010). |
| Number | Date | Country | |
|---|---|---|---|
| 20220083405 A1 | Mar 2022 | US |
| Number | Date | Country | |
|---|---|---|---|
| 63077465 | Sep 2020 | US |
