Attachment #2673 for bug #2221

View | Details | Raw Unified | Return to bug 2221
Collapse All | Expand All





NS_LOG_COMPONENT_DEFINE ("PacketTagList");

PacketTagList::TagData *
PacketTagList::CreateTagData (size_t dataSize)
{
  NS_ASSERT_MSG (dataSize
                 < std::numeric_limits<decltype(TagData::size)>::max (),
                 "Requested TagData size " << dataSize
                 << " exceeds maximum "
                 << std::numeric_limits<decltype(TagData::size)>::max () );

  void * p = std::malloc (sizeof (TagData) + dataSize - 1);
  // The matching frees are in RemoveAll and RemoveWriter

  TagData * tag = new (p) TagData;
  tag->size = dataSize;
  return tag;
}

bool
PacketTagList::COWTraverse (Tag & tag, PacketTagList::COWWriter Writer)
{

      NS_ASSERT (cur != 0);
      NS_ASSERT (cur->count > 1);
      cur->count--;                       // unmerge cur
      struct TagData * copy = CreateTagData (cur->size);
      copy->tid = cur->tid;
      copy->count = 1;
      copy->size = cur->size;
      memcpy (copy->data, cur->data, copy->size);
      copy->next = cur->next;             // merge into tail
      copy->next->count++;                // mark new merge
      *prevNext = copy;                   // point prior list at copy


  // found tid
  bool found = true;
  tag.Deserialize (TagBuffer (cur->data, cur->data + cur->size));
                              cur->data + TagData::MAX_SIZE));
  *prevNext = cur->next;            // link around cur

  if (preMerge)
    {
      // found tid before first merge, so delete cur
      cur->~TagData ();
      std::free (cur);
    }
  else
    {

  if (preMerge)
    {
      // found tid before first merge, so just rewrite
      tag.Serialize (TagBuffer (cur->data, cur->data + cur->size));
                                cur->data + tag.GetSerializedSize ()));
    }
  else
    {
      // cur is always a merge at this point
      // need to copy, replace, and link past cur
      cur->count--;                     // unmerge cur
      struct TagData * copy = CreateTagData (tag.GetSerializedSize ());
      copy->tid = tag.GetInstanceTypeId ();
      copy->count = 1;
      tag.Serialize (TagBuffer (copy->data, copy->data + copy->size));
                                copy->data + tag.GetSerializedSize ()));
      copy->next = cur->next;           // merge into tail
      if (copy->next != 0)
        {

  // ensure this id was not yet added
  for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
    {
      NS_ASSERT_MSG (cur->tid != tag.GetInstanceTypeId (),
                     "Error: cannot add the same kind of tag twice.");
    }
  struct TagData * head = CreateTagData (tag.GetSerializedSize ());
  head->count = 1;
  head->next = 0;
  head->tid = tag.GetInstanceTypeId ();
  head->next = m_next;
  tag.Serialize (TagBuffer (head->data, head->data + head->size));
  tag.Serialize (TagBuffer (head->data, head->data + tag.GetSerializedSize ()));

  const_cast<PacketTagList *> (this)->m_next = head;
}

      if (cur->tid == tid) 
        {
          /* found tag */
          tag.Deserialize (TagBuffer (cur->data, cur->data + cur->size));
          return true;
        }
    }




 *       The portion of the list between the first branch and the target is
 *       shared. This portion is copied before the #Remove or #Replace is
 *       performed.
 *
 * \par <b> Memory Management: </b>
 * \n
 * Packet tags must serialize to a finite maximum size, see TagData
 *
 * This documentation entitles the original author to a free beer.
 */
class PacketTagList 
{

   *
   * See PacketTagList for a discussion of the data structure.
   *
   * \internal
   * Unfortunately this has to be public, because
   * PacketTagIterator::Item::GetTag() needs the data and size values.
   * The Item nested class can't be forward declared, so friending isn't
   * possible.
   *
   * We use placement new so we can allocate enough room for the Tag
   * type which will be serialized into data.  See Object::Aggregates
   * for a similar construction.
   */
  struct TagData
  {
    struct TagData * next;      /**< Pointer to next in list */
    uint32_t count;             /**< Number of incoming links */
    TypeId tid;                 /**< Type of the tag serialized into #data */
    uint32_t size;              /**< Size of the \c data buffer */
    uint8_t data[1];            /**< Serialization buffer */
     *
     * \internal
     * Ideally, TagData would be 32 bytes in size, so they require
     * no padding on 64-bit architectures.  (The architecture
     * affects the size because of the \c #next pointer.)
     * This would leave 18 bytes for \c #data.  However,
     * ns3:Ipv6PacketInfoTag needs 19 bytes!  The current
     * implementation allows 20 bytes, which gives TagData
     * a size of 30 bytes on 32-byte machines (which gets
     * padded with 2 bytes), and 34 bytes on 64-bit machines, which
     * gets padded to 40 bytes.
     */
    enum TagData_e
    {
      MAX_SIZE = 21           /**< Size of serialization buffer #data */
  };

    uint8_t data[MAX_SIZE];   /**< Serialization buffer */
    struct TagData * next;   /**< Pointer to next in list */
    TypeId tid;               /**< Type of the tag serialized into #data */
    uint32_t count;           /**< Number of incoming links */
  };  /* struct TagData */

  /**


private:
  /**
   * Allocate and construct a TagData struct, sizing the data area
   * large enough to serialize dataSize bytes from a Tag.
   *
   * \param [in] dataSize The serialized size of the Tag.
   * \returns The newly constructed TagData object.
   */
  static
  TagData * CreateTagData (size_t dataSize);
  
  /**
   * Typedef of method function pointer for copy-on-write operations
   *
   * \param [in] tag The tag type to operate on.

   *          pointing to \pname{cur}.
   * \returns True, since tag will definitely be removed.
   */
  bool RemoveWriter  (Tag & tag, bool preMerge,
                      struct TagData * cur, struct TagData ** prevNext);
  /**
   * Copy-on-write implementing Replace

   *          pointing to \pname{cur}.
   * \returns True, since tag value will definitely be replaced.
   */
  bool ReplaceWriter (Tag & tag, bool preMerge,
                      struct TagData * cur, struct TagData ** prevNext);

  /**
   * Pointer to first \ref TagData on the list

        }
      if (prev != 0) 
        {
          prev->~TagData ();
          std::free (prev);
        }
      prev = cur;
    }
  if (prev != 0) 
    {
      prev->~TagData ();
      std::free (prev);
    }
  m_next = 0;
}

(-)a/src/network/model/packet.cc (-2 / +1 lines)

Lines 113-120	Link Here

113

114

  NS_ASSERT (tag.GetInstanceTypeId () == m_data->tid);

114

  NS_ASSERT (tag.GetInstanceTypeId () == m_data->tid);

115

  tag.Deserialize (TagBuffer ((uint8_t*)m_data->data,

115

  tag.Deserialize (TagBuffer ((uint8_t*)m_data->data,

116

                              (uint8_t*)m_data->data

116

                              (uint8_t*)m_data->data + m_data->size));

117

                              + PacketTagList::TagData::MAX_SIZE));

118

117

119

118

120

119

(-)a/src/network/utils/packet-socket.cc (-3 lines)

Lines 643-649	Link Here

643

DeviceNameTag::GetSerializedSize (void) const

643

DeviceNameTag::GetSerializedSize (void) const

644

645

  uint32_t s = 1 + m_deviceName.size();  // +1 for name length field

645

  uint32_t s = 1 + m_deviceName.size();  // +1 for name length field

646

  s = std::min (s, (uint32_t)PacketTagList::TagData::MAX_SIZE);

647

  return s;

646

  return s;

648

647

649

void

648

void

Lines 652-659	Link Here

652

  const char *n = m_deviceName.c_str();

651

  const char *n = m_deviceName.c_str();

653

  uint8_t l = (uint8_t) m_deviceName.size ();

652

  uint8_t l = (uint8_t) m_deviceName.size ();

654

653

655

  l = std::min ((uint32_t)l, (uint32_t)PacketTagList::TagData::MAX_SIZE - 1);

656

657

  i.WriteU8 (l);

654

  i.WriteU8 (l);

658

  i.Write ( (uint8_t*) n , (uint32_t) l);

655

  i.Write ( (uint8_t*) n , (uint32_t) l);

659

656

Return to bug 2221