[dpdk-dev] zero copy of received segmented IP packet

David P. Reed david.reed at tidalscale.com
Sun Mar 30 16:17:32 CEST 2014


Yossi -

You may already understand this, but fragments of IP datagrams ("IP packet" is non-standard slang that confuses IP fragments - packets - with the end-to-end data unit of IP) need to be checksummed together with items from the “virtual header” before delivery to TCP and then userspace.  Also, TCP datagrams can overlap each other’s sequence space and also be partially “old”.  There is no rule that says that a later IP datagram cannot transmit the part of the sequence-number range of earlier received IP datagrams.  The bytes must be identical, of course.

So, for example, if a prior TCP datagram had been received covering sequence numbers 504-508, a subsequent TCP segment might cover sequence number 500-535 (if the sender has not seen the ack up to 508, which can happen for many reasons).   504-508 would be covered by the segment’s TCP checksum (along with that  segment’s virtual header).  

Whatever you do to handle zero-copy implementation of TCP direct into TCP receiver buffers must, for example, be able to deliver bytes 509-535 directly into the user buffer, if bytes 504-508 have already been delivered.  Otherwise it is a non-standard implementation.

A simpler approach might work with certain sender-stacks  (those that use the same “datagram-boundaries” for retransmission), but hardly all, since the standard does not require retransmission on such boundaries.  In the old days, terminal concentrators that used telnet over TCP would retransmit larger segments than the “single character” segments in order to reduce the overhead of catching up with packets dropped.  It’s dangerous to presume that one’s “sending stack” and one’s “receiving stack” are in the same version of the same OS - especially dangerous to promote a technique that fails on certain standard cases as a performance improving win.

I suspect that a zero-copy TCP requires that at least sometimes, given fragmentation and this “overlapping sequence number” issue, actual copying, especially with fragmentation involved.

So if you are talking about “almost always zero-copy with certain senders” that might make the complexity far less.  Zero-copy fragment assembly only in the IP layer is much more doable, but it still requires a copy from the reassembled IP datagram into TCP sequence number space.


David P. Reed, Ph.D.
TidalScale, Inc.




On Mar 30, 2014, at 2:52 AM, Yossi Barshishat <yossi at imvisiontech.com> wrote:

> Hi,
> 
> 
> 
> Assuming I know ahead that all IP segments related to one single IP packet
> ID arrive consequently and I need to forward the entire IP payload toward
> the application layer.
> 
> One way to handle this is using a hash table for reassembly of the packet
> data (like the ipv4_reassembly example), another way would be to assume one
> single bucket (following the above assumption).
> 
> 
> 
> However any means the DPDK provides doesn't enable a zero copy mechanism (it
> will be required to copy the segments payloads into one larger buffer).
> 
> 
> 
> Does anybody has any idea regarding a method to control the place where each
> part of the packet will be written to?
> 
> e.g. allocating the first segment regularly while the packet data buffer is
> set to the maximum packet length (rather than to MTU size), and then reading
> n bytes after the start of each following segment into the data buffer.
> 
> 
> 
> That way I can forward the app layer the buffer without copying it.
> 
> 
> 
> Thanks,
> 
> 
> 
> 
> 



More information about the dev mailing list