NFD » ndn-cxx

Is there a benchmark to support the claim of this copying of memory block being a bottleneck?

#3567-42 has the benchmark.

I'll investigate a solution.
My solution would be designed for a common case where the Fragment is a complete network layer packet (Block API requires consecutive memory, so there's no easy solution when packet is sliced), and it's most likely not backwards compatible (because lp::Packet would need a reference to Buffer, not just iterators).

After some reading, I realize that there's no easy solution for this issue.

My idea was: when a network layer packet is being sent as one fragment, other NDNLPv2 headers are prepended to the underlying Buffer of this network layer packet.

However, there's no safe way to achieve this goal:

• Block::getBuffer returns a constant Buffer. We cannot mess with this Buffer, because if a network layer packet is being sent out of multiple faces with different NDNLPv2 headers, the modifications would conflict.
• A mutable Buffer can be obtained by invoking WireEncodable::wireEncode(Encoder&). However, in the common case that the network layer packet has not been modified since received (this is true for most Data), this operation already incurs a memory copy.

A simple copy-on-write buffer that duplicates the entire buffer upon write is also ineffective.

When NFD receives an LpPacket, the headroom before network layer packet contains incoming NDNLPv2 headers.
When NFD wants to prepend some other NDNLPv2 headers before sending the network layer packet, the buffer would be duplicated, even if the headroom of the original buffer is no longer needed.

To solve this problem, the buffer must keep track of which portions are being used.
When the incoming LpPacket is destructed but the network layer packet is retained, the buffer knows the headroom isn't being used, so that outgoing LpPacket can safely reused the headroom.

An improvement is to allow non-consecutive memory in the buffer, so that when NFD sends the network layer packet to multiple faces, each outgoing LpPacket only needs allocation of its NDNLPv2 headers, but the network layer packet isn't copied.
However, this would break Buffer::get (or require a full copy when this API is used).

I have a new solution.

class LpPacket
{
public:
  /** \brief Encode NDNLP headers and outer Type-Length
   *  \param encoder Encoder or Estimator to prepend the wire encoding
   *  \param fragmentLength TLV-LENGTH of Fragment element
   *  \pre !has<FragmentField>()
   *
   *  This function allows encoding an LpPacket without copying the payload into Fragment field.
   *  The output wire encoding contains the outer Type-Length for LpPacket, headers, and Type-Length for the Fragment element,
   *  but excludes TLV-VALUE of the Fragment element.
   *  This encoding is intended to be transmitted together with an encoded Interest or Data packet via scatter/gather I/O.
   *
   *  If this LpPacket has no header fields, the generated encoding would be empty.
   *
   *  This function cannot be used to encode an IDLE packet. Passing zero as fragmentLength creates a zero-length Fragment element.
   */
  template<encoding::Tag TAG>
  size_t
  encodeHeaders(EncodingImpl<TAG>& encoder, size_t fragmentLength) const;
};

This solution requires modifying Face::Impl and GenericLinkService (and all the way down to Transport) to take advantage of the benefits. It does not depend on #3216.