NS3 Node聚合对象说明

在src/internet/helper/internet-stack-helper.cc源文件中有install方法，对所有节点安装必备的协议。

install方法的源代码如下：

void
InternetStackHelper::Install (Ptr<Node> node) const
{
//  InternetStackHelper::Install->1 name=ns3::Node
//  InternetStackHelper::Install->1 name=ns3::ConstantPositionMobilityModel
  if (m_ipv4Enabled)
    {
      if (node->GetObject<Ipv4> () != 0)//这里的Ipv4指的就是ns3::Ipv4L3Protocol
        {
          NS_FATAL_ERROR ("InternetStackHelper::Install (): Aggregating " 
                          "an InternetStack to a node with an existing Ipv4 object");
          return;
        }

      CreateAndAggregateObjectFromTypeId (node, "ns3::ArpL3Protocol");
      CreateAndAggregateObjectFromTypeId (node, "ns3::Ipv4L3Protocol");
      CreateAndAggregateObjectFromTypeId (node, "ns3::Icmpv4L4Protocol");
      if (m_ipv4ArpJitterEnabled == false)
        {
          Ptr<ArpL3Protocol> arp = node->GetObject<ArpL3Protocol> ();
          NS_ASSERT (arp);
          arp->SetAttribute ("RequestJitter", StringValue ("ns3::ConstantRandomVariable[Constant=0.0]"));
        }
      // Set routing
      Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
      Ptr<Ipv4RoutingProtocol> ipv4Routing = m_routing->Create (node);
      ipv4->SetRoutingProtocol (ipv4Routing);
    }

  if (m_ipv4Enabled || m_ipv6Enabled)
    {
      CreateAndAggregateObjectFromTypeId (node, "ns3::TrafficControlLayer");
      CreateAndAggregateObjectFromTypeId (node, "ns3::UdpL4Protocol");
      node->AggregateObject (m_tcpFactory.Create<Object> ());//该类初始化方法中，设置值为ns3::TcpL4Protocol
      Ptr<PacketSocketFactory> factory = CreateObject<PacketSocketFactory> ();
      node->AggregateObject (factory);
    }
}

其中的几行代码如下：

CreateAndAggregateObjectFromTypeId (node, "ns3::ArpL3Protocol");
CreateAndAggregateObjectFromTypeId (node, "ns3::Ipv4L3Protocol");
CreateAndAggregateObjectFromTypeId (node, "ns3::Icmpv4L4Protocol");
CreateAndAggregateObjectFromTypeId (node, "ns3::TrafficControlLayer");
CreateAndAggregateObjectFromTypeId (node, "ns3::UdpL4Protocol");
node->AggregateObject (m_tcpFactory.Create<Object> ());//该类初始化方法中，设置值为ns3::TcpL4Protocol
Ptr<PacketSocketFactory> factory = CreateObject<PacketSocketFactory> ();
node->AggregateObject (factory);

这几行代码是关键的代码，也是代码运行过程中核心。

为什么这么说呢？
从internet-stack-helper.cc的文件的名字可以看出，这个类完成的功能就是完成协议安装，就是将必要的协议安装到节点上。

从互联网七层模型：

应用层
表示层
会话层
传输层
网络层
数据链路层
物理层

其中这个internet-stack-helper.cc完成的就是上面的前五层，其中应用层、表示层、会话层统一为应用层。

上面的代码明显在节点上安装了ARP IP UPD TCP ICMP等协议。

packet在上面的几个协议上发送和被接收。

上面的代码完成了将协议安装到节点的功能，以及将各个对象聚合到节点上。

那么如何获取节点上聚合的对象呢？
下面的代码就可以实现：

/**
   * 以下代码用于输出一个Node节点经过install()方法的安装后，
   * 已经聚合的所有对象
   */
  Node::AggregateIterator iterator = node->GetAggregateIterator();
    while(iterator.HasNext()){
      Ptr<const Object> obj = iterator.Next();
      NS_LOG_LOGIC("InternetStackHelper::Install    name="<<obj->GetInstanceTypeId().GetName());
    }

输出：
name=ns3::Ipv4L3Protocol
name=ns3::Node
name=ns3::GlobalRouter
name=ns3::TrafficControlLayer
name=ns3::ArpL3Protocol
name=ns3::ConstantPositionMobilityModel
name=ns3::UdpSocketFactory
name=ns3::Icmpv4L4Protocol
name=ns3::Ipv4RawSocketFactory
name=ns3::UdpL4Protocol
name=ns3::TcpL4Protocol
name=ns3::TcpSocketFactory
name=ns3::PacketSocketFactory

通过以上代码的输出，可以确定node节点经过上面的代码后，已经聚合的全部对象：
1、

name=ns3::Node

该对象的聚合是在节点被创建的时候就实现的。可参考Object类的构造器代码实现。

2、

name=ns3::ConstantPositionMobilityModel

该对象的聚合是在install方法之前就已经实现。

3、

name=ns3::ArpL3Protocol
name=ns3::Ipv4L3Protocol
name=ns3::Icmpv4L4Protocol

这三个对象的聚合是在install方法中明确实现的。

4、

name=ns3::GlobalRouter

这个对象的聚合是在install方法中明确实现的。

5、

name=ns3::Ipv4RawSocketFactory

该对向的聚合是在node与ns3::Icmpv4L4Protocol对象聚合的时候，调用NotifyNewAggregate ()方法时，聚合的。
可参看NotifyNewAggregate ()的代码可知。

6、

name=ns3::TrafficControlLayer
name=ns3::UdpL4Protocol
name=ns3::TcpL4Protocol
name=ns3::PacketSocketFactory

这四个对象的聚合是在install方法中明确实现的。

7、

name=ns3::UdpSocketFactory
name=ns3::TcpSocketFactory

以上两个对象的聚合，分别是在name=ns3::UdpL4Protocol,name=ns3::TcpL4Protocol
这两个对象聚合完成时实现的。可参看name=ns3::UdpL4Protocol，name=ns3::TcpL4Protocol
这两个类的NotifyNewAggregate ()代码。

以上所有Node所聚合的对象，代码调用过程可以解释Socket的创建过程。

聚合对象有什么用？
这些聚合的对象我们可以方便的通过一个Node对象获取到。并且这些对象之间都是相互聚合的。通过一个Node对象，可以获取到该对象上面聚合的所有对象。也可以通过Node上面聚合的对象获取到Node对象和Node对象中聚合的其他对象。

为什么能够实现对象之间的相互聚合呢？
可以查看Object类的源代码：

void 
Object::AggregateObject (Ptr<Object> o)
{
  NS_LOG_FUNCTION (this << o);
  NS_ASSERT (!m_disposed);
  NS_ASSERT (!o->m_disposed);
  NS_ASSERT (CheckLoose ());
  NS_ASSERT (o->CheckLoose ());

  Object *other = PeekPointer (o);
  // first create the new aggregate buffer.
  uint32_t total = m_aggregates->n + other->m_aggregates->n;
  struct Aggregates *aggregates = 
    (struct Aggregates *)std::malloc (sizeof(struct Aggregates)+(total-1)*sizeof(Object*));
  aggregates->n = total;

  // copy our buffer to the new buffer
  std::memcpy (&aggregates->buffer[0], 
          &m_aggregates->buffer[0], 
          m_aggregates->n*sizeof(Object*));

  // append the other buffer into the new buffer too
  for (uint32_t i = 0; i < other->m_aggregates->n; i++)
    {
      aggregates->buffer[m_aggregates->n+i] = other->m_aggregates->buffer[i];
      const TypeId typeId = other->m_aggregates->buffer[i]->GetInstanceTypeId ();
      if (DoGetObject (typeId))
        {
          NS_FATAL_ERROR ("Object::AggregateObject(): "
                          "Multiple aggregation of objects of type " <<
                          other->GetInstanceTypeId () <<
                          " on objects of type " << typeId);
          //在typeId类型的对象上对other->GetInstanceTypeId ()类型的对象进行多次聚合
        }
      UpdateSortedArray (aggregates, m_aggregates->n + i);//对最后一位进行排序
      /**
      * 这是尝试“缓存”此查找的结果。 这个想法是，如果我们对该对象执行
      * 一个TypeId的查找，我们可能以后执行相同的查找，所以我们确保聚
      * 合数组按照对每个对象的访问次数排序。
      */
    }

  // keep track of the old aggregate buffers for the iteration
  // of NotifyNewAggregates
  struct Aggregates *a = m_aggregates;
  struct Aggregates *b = other->m_aggregates;

  // Then, assign the new aggregation buffer to every object
  // 为每个对象分配新的聚合缓冲区
  uint32_t n = aggregates->n;
  for (uint32_t i = 0; i < n; i++)
    {
      Object *current = aggregates->buffer[i];
      current->m_aggregates = aggregates;
    }

  /**
   * 最后，对所有对象调用NotifyNewAggregate聚合在一起。 我们希望使用
   * 旧的聚合缓冲区来遍历对象，因为这允许我们假设它们不会从我们的脚下
   * 改变，即使我们的用户从他们的NotifyNewAggregate方法中调用AggregateObject。
   */
  for (uint32_t i = 0; i < a->n; i++)
    {
      Object *current = a->buffer[i];
      current->NotifyNewAggregate ();
    }
  for (uint32_t i = 0; i < b->n; i++)
    {
      Object *current = b->buffer[i];
      current->NotifyNewAggregate ();
    }

  // Now that we are done with them, we can free our old aggregate buffers
  std::free (a);
  std::free (b);
}

Object::AggregateObject方法实现了对象之间聚合对象之间的聚合。