Message context based TCP transmission

A method and system for transmitting packets. Packets may be transmitted when a protocol control block is copied from a host processing system to a network protocol offload engine. Message information that contains packet payload addresses may be provided to the network protocol offload engine to generate a plurality of message contexts in the offload engine. With the message contexts, protocol processing may be performed at the offload engine while leaving the packet payload in the host memory. Thus, packet payloads may be transmitted directly from the host memory to a network communication link during transmission of the packets by the offload engine. Other embodiments are also described.

BACKGROUND

Specific matter disclosed herein relates to the field of computer networking. Networks enable computers and other devices to communicate. For example, networks can carry data representing video, audio, e-mail, and so forth. Typically, data sent across a network is divided into smaller units known as packets. By analogy, a packet is much like an envelope you drop in a mailbox. A packet typically includes “payload” and a “header”. The packet's “payload” is analogous to the letter inside the envelope. The packet's “header” is much like the information written on the envelope itself. The header can include information to help network devices handle the packet appropriately.

A number of network protocols cooperate to handle the complexity of network communication. For example, a protocol known as Transmission Control Protocol (TCP) provides “connection” services that enable remote applications to communicate. That is, much like picking up a telephone and assuming the phone company will make everything in-between work, TCP provides applications with simple primitives for establishing a connection (e.g., CONNECT and CLOSE) and transferring data (e.g., SEND and RECEIVE). Behind the scenes, TCP transparently handles a variety of communication issues such as data retransmission, adapting to network traffic congestion, and so forth.

To provide these services, TCP operates on packets known as segments. Generally, a TCP segment travels across a network within (“encapsulated” by) a larger packet such as an Internet Protocol (IP) datagram. The payload of a segment carries a portion of a stream of data sent across a network. A receiver can restore the original stream of data by collecting the received segments.

Potentially, segments may not arrive at their destination in their proper order, if at all. For example, different segments may travel very different paths across a network. Thus, TCP assigns a sequence number to each data byte transmitted. This enables a receiver to reassemble the bytes in the correct order. Additionally, since every byte is sequenced, each byte can be acknowledged to confirm successful transmission.

Many computer systems and other devices feature host processors (e.g., general purpose Central Processing Units (CPUs)) that handle a wide variety of computing tasks. Often these tasks include handling network traffic. The increases in network traffic and connection speeds have placed growing demands on host processor resources. To at least partially alleviate this burden, a network protocol off-load engine can off-load different network protocol operations from the host processors. For example, a TCP Off-Load Engine (TOE) may perform one or more TCP operations for sent/received TCP segments, e.g., during packet transmissions, a TOE would buffer into its local memory the TCP payload for TCP packet transmissions. This required an additional store-and-forward stage in the TOE for the TCP transmission purpose. This intermediate buffering resulted in an additional latency in the TCP transmission path and an additional load on the TOE memory subsystem.

DETAILED DESCRIPTION

In the following description, specific matter disclosed herein relates to the field of offload engines for a system and method for message context based TCP (Transmission Control Protocol) transmissions/retransmissions (for ease of understanding referred to herein only as “transmissions”). “Message context based” TCP transmissions may be defined as TCP transmissions at an offload engine using message contexts representing TCP payloads rather than the actual TCP payloads. Only a protocol control block for processing TCP transmission instructions (e.g., for generating TCP headers) may necessarily be copied or offloaded to the offload engine. TCP data to be transmitted by the offload engine may be stored in a host memory until the TCP transmission occurs. Subsequently, the TCP data may be moved from a transmit buffer in the host memory to payload in a TCP segment of the TCP transmission where header information was calculated from the protocol control block that was copied to the offload engine. Specific details of exemplary embodiments of the present invention are set forth. However, it is understood that embodiments of the invention may be practiced without these specific details.

The phrase “cut-through transmissions” as used herein refers to a technique that avoids memory to memory copying in data transmissions. Cut-through transmissions may pass messages by reference through multiple protocol layers to avoid memory to memory copying for processing at each protocol layer. However, this is merely an example of cut-through transmissions and embodiments of the present invention are not limited in this respect.

The phrase “message context” as used herein refers to information that indicates the location/address of a packet payload in a memory. However, this is merely an example of a message context and embodiments of the present invention are not limited in this respect.

The phrase “network communication link” as used herein refers to a link for signals to be transmitted onto a network, i.e., a means for accessing any one of several entities coupled to a communication network, e.g., unshielded twisted pair wire, coaxial cable, fiber optic, etc. However, this is merely an example of a network communication link and embodiments of the present invention are not limited in this respect.

FIG. 1illustrates a system100according to an exemplary embodiment. The system100includes a host processor102illustrated as having various host elements being processed, e.g., applications104. The applications104may make use of other host elements such as a socket layer106and/or a TCP/IP offload stack108. The host elements interoperate with a host memory110that includes, among other things, memory fragments112that may become the payload of different packets in packet transmissions.

The packets may be organized to make up, among other things, a TCP segment. A TOE NIC (TOE Network Interface Controller)114is illustrated communicating with the host processor102and host memory110during TCP communications.

A memory and I/O (input/output) controller116acts as the interface between the host processor102and the host memory110as well as the interface between the host processor102and the TOE NIC114. Thus, the memory and I/O controller116provides the host processor102with the ability to utilize the TOE NIC114operations as they relate to host memory110during packet transmissions.

The illustrated embodiment TOE NIC114may transmit the TCP payload directly from host memory110without the need for intermediate buffering of the TCP payload by the TOE NIC114, thus eliminating overheads associated with a store-and-forward stage in the TCP transmission path in a TOE.

In the illustrated embodiment, TOE NIC114includes TOE118for, among other things, organization of TCP segments to be transmitted via MAC/PHY (medium access control)/(physical layer)120on a network communication link121. Among other types of link, the network communication link121may operate according to different physical specifications or network protocols, e.g., the link121may operate according to communication standards such as IEEE Std. 802.3, IEEE Std. 802.11, IEEE Std. 802.16, etc. and be an Ethernet link, a wireless link, etc. implemented with a media such as fiber, unshielded twisted pair, etc.

The TCP segments are generated based on the information found in a TCP Connection Block (TCB)122that may be copied to the TOE118from the host processor102. The TCB122may be used to organize message contexts124that contain message information for generating payloads for different TCP segments that are to be transmitted. This message information may facilitate TOE118creation of many different headers for packet transmissions such as TCP headers, IP headers, and Ethernet headers.

As described in more detail below, the TOE NIC114may also include a Direct Memory Access (DMA) engine126for the direct memory transfers of packet payloads from host memory110to the network communication link to avoid store and forward operations.

Each message context124may include information such as the length of the message to be transmitted and the addresses of memory fragments112that make up the message buffer. For each message, the host processor102passes information describing the location of the relevant memory fragments112in the host system memory110that make up a message buffer. The message buffer may be used by the TOE118until the entire message buffer is delivered on the network. The host processor102may ensure that the message buffer resides in the host system memory110at the location described in the message contexts124until the message buffer is transmitted and acknowledged as directed by the message contexts124of the TOE NIC114. In turn, each message is transmitted via TCP in the form of one or more TCP segments where the TCP header is formed based on information found in the TCB122, and the TCP segment payload is accessed in a DMA transaction with the address information stored in one or more of the message contexts124.

In other words, during the transmission from the TOE NIC114, the headers of the TCP segments are formed from the TCB122and the TCP segments receive their payloads via DMA from the host system memory110to the network communication link based on information found in the message contexts124(e.g., cut-through transmissions). Thus, copying of the TCP segment payloads to a TOE NIC114is avoided with the TOE118because the payloads remain in host system memory110until transmission of the TCP segment, i.e., during TCP transmissions, the information stored in the message contexts124is used to allow the TCP payloads to remain in host memory110until transmission of the TCP segment.

FIG. 2illustrates relationships among certain portions of the system100as they relate to packet formation and transmission. For each offloaded TCP connection, the TOE118may maintain a virtual transmit buffer that is described by a linked list of the message contexts124. For example, during the transmission of a TCP segment, the TOE118may prepare a TCP, IP, Ethernet, etc. header202of the segment from the TCB122. To complete formation of the TCP segment, the TOE118DMA copies the TCP segment payload204based on the buffer address information contained in one or more of the message contexts124spanning the TCP segment. With header202and payload204, the TCP segment206may be transmitted on the network communication link121.

Upon receiving a TCP acknowledgement (ACK) acknowledging the successful transmission of the TCP segments with the data described by the relevant message contexts124, the TOE118may complete the transmission of the messages by reporting the message completions to the host stack of the host processor102. The TCB122containing the TCP connection state may be maintained by the TOE118for the offloaded connection.

FIG. 3illustrates other aspects of the TOE NIC114. Although many computer systems feature processors that handle a wide variety of tasks, as described above, the TOE NIC114may have the responsibility of handling network traffic. TOE NIC114may perform network protocol operations for a host to at least partially reduce the burden of network communication on a host processor. As stated earlier, the TOE NIC114may perform operations for a wide variety of protocols. For example, the TOE NIC114may be configured to perform operations for transport layer protocols (e.g., TCP and User Datagram Protocol (UDP)), network layer protocols (e.g., IP), and application layer protocols (e.g., sockets programming).

In addition to conserving host processor resources by handling protocol operations, the TOE NIC114may provide “wire-speed” processing, even for very fast connections such as 10-gigabit per second connections. In other words, the TOE NIC114may, generally, complete processing of one packet before another arrives. By keeping pace with a high-speed connection, the TOE NIC114can potentially avoid or reduce the cost and complexity associated with queuing large volumes of backlogged packets.

The sample TOE NIC114shown may include an interface111for transmitting data traveling between one or more hosts and a network101. The TOE NIC114interface111transmits data from the host(s) and generates packets for network transmission, for example, via a PHY and MAC device (see MAC/PHY120fromFIG. 1) offering a network connection (e.g., an Ethernet or wireless connection).

In addition to the interface111, the TOE NIC114also includes processing logic113that implements protocol operations. Like the interface111, the logic113may be designed using a wide variety of techniques. For example, the TOE NIC114may be designed as a hard-wired ASIC (Application Specific Integrated Circuit), a FPGA (Field Programmable Gate Array), and/or as another combination of digital logic gates.

As shown, the logic113may also be implemented by a TOE NIC114that includes a processor123(e.g., a micro-controller or micro-processor) and storage125(e.g., ROM (Read-Only Memory) or RAM (Random Access Memory)) for instructions that the processor123can execute to perform network protocol operations. The instruction-based TOE NIC114offers a high degree of flexibility. For example, as a network protocol undergoes changes or is replaced, the TOE NIC114can be updated by replacing the instructions instead of replacing the TOE NIC114itself. For example, a host may update the TOE NIC114by loading instructions into storage125from external FLASH memory or ROM on the motherboard, for instance, when the host boots.

ThoughFIG. 3depicts a single TOE NIC114performing operations for a host, a number of off-load engines114may be used to handle network operations for a host to provide a scalable approach to handling increasing traffic. For example, a system may include a collection of engines114and logic for allocating connections to different engines114. To conserve power, such allocation may be performed to reduce the number of engines114actively supporting on-going connections at a given time.

In operation, for example, as described herein for the TCP protocol, communication information known as TCB data (see TCB122) may be processed for a given network connection. For a given packet, the TOE NIC114looks-up the corresponding connection context in the memory and makes this connection information available to the processor123, e.g., via a working register (not shown). Using context data, the processor123executes an appropriate set of protocol implementation instructions from storagel25. Context data, potentially modified by the processor123, may be returned to the appropriate message context124for DMA transmission.

The TOE NIC114may perform protocol operations for the packet, for example, by processor123execution of protocol implementation instructions stored in storage125. The processor123may determine the state of the current connection and identify the starting address of instructions for handling this state. The processor123then executes the instructions beginning at the starting address. Depending on the instructions, the processor123may alter context data (e.g., by altering the working register). Again, context data, potentially modified by the processor123, is returned to the appropriate message context124.

FIG. 4illustrates an example of message context related TCB fields402maintained by the TOE118, and their relationship to the message contexts124. The TOE NIC114may maintain the TCB122with the illustrated TCB fields402, e.g., msg_ctx_tail404, snd_una_ptr406, snd_una408, snd_nxt_ptr410, snd_nxt412, snd_max_ptr414, snd_max416, and snd_wnd418. The message context related TCB fields402maintained by the TOE118of the TOE NIC114for the TCP transmissions per connection are described briefly as follows, the pointer fields ofFIG. 4being illustrated with arrows pointing to a respective one of the message contexts124:msg_ctx_tail—Pointer to the tail of the linked list of message contextssnd_una_ptr—Pointer to the message context that contains the location of the first unacknowledged byte (this is also the head of the linked list of message contexts)snd_una—Sequence number of the first unacknowledged bytesnd_nxt ptr—Pointer to the message context that contains the location of the payload to be sent next (also pointer to the head of the linked list of message contexts)snd_nxt—Sequence number of the first byte to be sent nextsnd_max ptr—Pointer to the message context that contains the location of byte with the highest sequence number sentsnd_max—Highest sequence number sent

In operation, for each send message, the host stack passes an identifier for the offloaded TCP connection (tcb_id) on which the data is to be transmitted, a list of scatter-gather elements (SGEs) describing the host system memory fragments of the message buffer, the number of SGEs in the message buffer, a flag describing whether no completion response is required for this message (flag_nr), and the length of the message to the TOE. Procedurally, the send message can be described as the following:toe_sendmsg(tcb_id, flag_nr, msg_len, num_frags, frag_addr[ ], frag_len[ ]), wheretcb_id—TCP connection identifierflag_nr—No response flagmsg_len—Total length of the messagenum_frags—Number of memory fragmentsfrag_addr[ ]—Array of the starting memory addresses of the fragmentsfrag_len[ ]—Array of the lengths of the fragments

Procedurally, the TOE118provides the following completion notification for the send messages:toe_sendmsg completion(tcb_id, num_msgs), wheretcb_id—TCP connection identifiernum_msgs—Number of completed messages with no response flag set to 0

With this scheme, the host102may transfer control of the send message buffer to the TOE118upon submission of the send message and the TOE118may return control of the send message buffer to the host102upon completion of the send message.

Upon receiving a send message command, the TOE NIC114performs the steps described in the following pseudo-code where error handling has been simplified for ease of understanding. Other similar algorithms may be constructed to accomplish the same tasks:

if (msg_ctx_tail->msg_flag_nr ==1 &&the message can fit into the message context pointed by msg_ctx_tail){Update the message context pointed by msg_ctx_tail with theinformation for this send message;if (flag_nr == 0)msg_ctx_tail->msg_flag_nr = 0;}else{Determine the number of message contexts (req_msg_ctxs) needed forthis message;Wait for req_msg_ctxs numbers of message contexts to be available;Obtain req_msg_ctxs numbers of message contexts;Store the send message information in the new message contexts;if (req_msg_ctxs > 1)For each of the first req_msg_ctxs-1 numbers of new messagecontexts set msg_flag_nr to 1;Set msg_flag_nr of the last message context to flag_nr;Update msg_ctx_tail &  message context list by adding the newmessage contexts to the end of the list;Update snd_una_ptr, snd_nxt_ptr, and snd_max_ptr if necessary;}

The TCP transmission scheme for the TOE NIC114when using message contexts124may be described by the following pseudo-code:

tcp_output(tcb){Determine the length of the data to be transmitted;While (the data is not transmitted){Compute the length of the next TCP segment to be transmitted;Construct TCP/IP headers for this TCP segment;Construct memory fragment list describing the TCP segment payloadfrom one or more message contexts starting with the message contextpointed by snd_nxt_ptr;DMA TCP segment payload based on the constructed memoryfragment list;Transmit TCP segment;Update TCB variables including snd_nxt_ptr, snd_nxt, snd_max (ifnecessary), and snd_max_ptr (if necessary);}}

Upon receiving a TCP ACK for the TCP segment, the following processing may be performed by the TOE NIC114for the send message completion command that may be sent to the host processor102:

if (new data is being acked){Based on the snd_una of TCB and ACK field of the TCP header,compute the number of new bytes being ACKed;Starting with snd_una_ptr, compute the number of message contexts(num_msgs) with msg_flag_nr set to 0 are completely ACKed;Free message contexts which are completely ACKed by this TCP ACK;Update TCB variables including snd_una and snd_una_ptr(snd_una_ptr now points to the message contextwhich contains the first unacknowledged TCP payload byte);If the number of ACKed message contexts (num_msgs) withmsg_flag_nr set to 0 is greater than 1, then notify send messagecompletion to the host stack with num_msgs count;Update msg_ctx_tail if necessary;}

The host stack tracks the outstanding send messages per connection. Based on the num_msgs count it receives in the send completion notification from the TOE NIC114, the host stack may complete one or more buffers associated with the send message(s).

FIG. 5illustrates a method500for transmitting packets in the system100. In step502, packets are accessed through a network protocol engine such as TOE NIC114. In step504, a control block is copied from a host processing system to the network protocol engine. In step506, processing of the control block may be used to generate header information for the packets to be transmitted at the offload engine while leaving the packet payloads in host memory. As described in more detail in relation toFIG. 2, the message contexts124may be used to locate packet payloads for the headers that are generated from the TCB122for the packets206. In step508, the offload engine transmits the packet payload directly from the host memory to a network communication link during transmission of the packets. Among other things, this payload transmission avoids the additional overhead required by a store and forward or other memory copying operation.