字数统计: 2k字   |   阅读时长: 9分

NLSR路由协议HELLO包机制修改

修改NLSR的hello包机制，为ndnSIM增加优先级队列的机制

修改移动模型：

注释掉nlsr-conf-reader中的269-276行，发现原来读配置文件的信息时节点初始位置距离过远，在划定边界时越界，节点之间不能正常通信，由配置文件分配位置信息改成自己分配位置信息，使用随机位置生成，减小节点之间的初始距离。

1
2
3
nlsrConfReader.m_mobility.SetPositionAllocator ("ns3::RandomRectanglePositionAllocator",
									"X", StringValue ("ns3::UniformRandomVariable[Min=0.0|Max=100.0]"),
									"Y", StringValue ("ns3::UniformRandomVariable[Min=0.0|Max=100.0]"));

修改hello-broadcast-protocal：

目标是想记录每次邻居状态信息active和inactive之间相互转换的时间戳。

发现的几个问题，一个是在超时回调的逻辑中原来用的ndn的schedule，sendHelloInterest中也用到了ndn的schedule，两者之间产生冲突。将超时回调改为了ns3的schedule。

另外就是超时处理的逻辑中抽取兴趣包信息时提取字段出错，应该是/n/e/c1r0，但是提取出了/n/e/Hello，导致后序根据名称遍历邻居修改状态时不能找到对应的邻居，status状态一直为UNKNOWN，出错。

1
2
3
4
//LZH：2023/10/10 发现neighbor是/n/e/hello，与邻居表中的前缀都不一样，故改成下面的形式
//ndn::Name neighbor = interestName.getPrefix(-3);
ndn::Name neighbor;
neighbor.wireDecode(interestName.get(-1).blockFromValue()); //希望变成/n/e/c1r0

然后在setStatusOfNeighbor中打印时间戳即可。

lsdb的更新逻辑：

发送hello兴趣包后收到数据包并通过校验后进入onContentValidated函数，说明邻居是活跃的，这时候就对原来的邻居状态进行判断，如果原来是inactive，就进入scheduleAdjLsaBuild，将插入新的LSA。

scheduleAdjLsaBuild会计划在m_adjLsaBuildInterval时间后触发 buildAdjLsa()函数。

进入函数后，判断LSA是否是可构造的，如果是，进入buildAndInstallOwnAdjLsa，向LSDB中插入新的LSA。

实际读取的拓扑定义写在/home/zhangyu/ndnSIMAll29（复件）/ns-3/src/ndnSIM/utils/topology/ndn-nlsr-topo-parameters.hpp文件中。

onLsdbModified触发后面的FIB更新

超时处理：

hello-broadcast-protocol.hpp增加超时时间记录。用的是ns3的Schedule不是ndnSIM的Schedule。用ndnSIM的Schedule与前面expressinterest中的回调冲突了。

1
std::map<ndn::Name, ns3::EventId> m_timeout_event;

HelloBroadcastProtocol::processBroadcastInterest修改超时逻辑

1
2
3
4
5
6
7
8
      // 定时新的超时事件
      m_timeout_event[neighbor] = ns3::Simulator::Schedule (ns3::MilliSeconds (m_confParam.getInterestResendTime () + m_confParam.getInfoInterestInterval ()),
                     &HelloBroadcastProtocol::processInterestTimedOut, this, interest);

// 取消掉当前的超时事件
      if (m_timeout_event.find (neighbor) != m_timeout_event.end ()) {
        m_timeout_event[neighbor].Cancel ();
      }

ndn-cxx的face和nfd的face：

重新梳理了一下ndn-cxx的face和nfd的face的联系，以hello-protocal来说明的使用来说明其关系。

ndn-cxx的face功能主要在于联系上层的应用和转发层forwarder。HelloBroadcastProtocol::expressInterest调用了cxx的face发送兴趣包，在face-impl中对兴趣包编码并通过internal-face发送，实际调用的是internal-face-client的send，其会调用internal-face-forwarder的receive，其进一步调用linkservice对兴趣包解码，然后触发afterreceiveinterest，afterreceiveinterest触发NFD转发程序，再根据兴趣包的ingress和ongress决定如何将兴趣包转发。

对于常规的NDN的管理信息，其可能会发送到forwarder中发现FIB中没有下一跳，于是就不转发了。而对于Hello包来说，到forwarder中发现FIB中有下一跳，就会将其转发。

lambda表达式：本质上重载了()运算符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
txop->m_callbackDispatchTable = [&egress, this]() {
        this->SendPacket (egress);
      };

struct {
    .. {
       e = egress;
       t = this;
    }
    Face& egress;
    DispatchTable *t;
    operator() (void) {
      this->SendPacket (egress);
    }
  }

增加优先级tag：

参考NDN新增tag的方案_nclientv2网页-CSDN博客

修改forwarder的逻辑：

原来是直接通过face发送，现在是先发送到优先级队列，再由底层队列取。

发现nlsr的同步包前缀是localhop，希望其不入队，只希望Hello包和业务数据入队。

if(GetWifiMacQueue(egress)会对face进行一系列处理，dynamic_cast可以将基类对象转换为派生类对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
  //LZH 2023/10/26, egress是face类型，不是FaceEndPoint
  if(GetWifiMacQueue(egress) && !(scope_prefix::LOCALHOST.isPrefixOf(interest2->getName())) && !(scope_prefix::LOCALHOP.isPrefixOf(interest2->getName()))) {
    NFD_LOG_DEBUG("onOutgoingInterest GetWifiMacQueue(egress) = " << interest2->getName());
    pushIDispatchTable(*interest2, egress);
  }
  else {
    NFD_LOG_DEBUG("onOutgoingInterest egress.sendInterest = " << interest2->getName());
    egress.sendInterest(*interest2);
  }

  // send Interest
  //egress.sendInterest(*interest2);

//对face的一系列处理，最终得到txop的queue
ns3::Ptr<ns3::WifiMacQueue>
GetWifiMacQueue(Face& face)
{
    face::Transport *transport = face.getTransport ();
    ns3::ndn::NetDeviceTransport *netDeviceTransport = dynamic_cast<ns3::ndn::NetDeviceTransport *> (transport);
    ns3::Ptr<ns3::NetDevice> netdevice = netDeviceTransport->GetNetDevice ();
    ns3::Ptr<ns3::WifiNetDevice> wifi = ns3::DynamicCast<ns3::WifiNetDevice> (netdevice);
    ns3::Ptr<ns3::WifiMac> wifiMac = wifi->GetMac ();
    ns3::Ptr<ns3::RegularWifiMac> mac = ns3::DynamicCast<ns3::RegularWifiMac> (wifiMac);
    ns3::Ptr<ns3::Txop> txop = mac->GetTxop ();
    ns3::Ptr<ns3::WifiMacQueue> queue = txop->GetWifiMacQueue ();
    return queue;
}

在底层txop添加回调事件

当信道是空闲状态时，触发

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//txop.h
public:
//LZH 2023/10/25
  /// @brief V2.1 如果队列空了, 就找调度表要. m_callbackDispatchTable 由调度表进行初始化和绑定
  std::function<void(void)> m_callbackDispatchTable;

//txop.cc
void
Txop::NotifyChannelReleased (void)
{
  std::cout << "Txop::NotifyChannelReleased start" << std::endl;
  NS_LOG_FUNCTION (this);
  m_access = NOT_REQUESTED;
  GenerateBackoff ();
  if (HasFramesToTransmit ())
    {
      Simulator::ScheduleNow (&Txop::RequestAccess, this);
    }
  // LZH 2023/10/25 
  else
    {
      //NS_ASSERT(m_callbackDispatchTable);
      if(m_callbackDispatchTable)
      {
        m_callbackDispatchTable(); 
      }
    }
}

在dispatchtable中添加包入队和底层队列从上层取包的逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
void
DispatchTable::PushInterest(const Interest& interest, Face& egress)
{
  NFD_LOG_DEBUG("----------LZH 2023/10/30 DispatchTable::PushInterest start ");
  // 1. 插入调度表
  // 生成 Item
  std::shared_ptr<Interest> pInterest = std::make_shared<Interest> (interest);
  NFD_LOG_DEBUG("pInterest = " << &pInterest);
  Priority prior = GetIPriority (pInterest);
  NFD_LOG_DEBUG( "pInterest prior = " << prior );
  // 查 face 对应的表, 查不到会自动创建
  face::FaceId id = egress.getId ();
  bool isFind = m_allTable.find (id) != m_allTable.end ();
  DispatchTable::NowFaceTable& fTable = m_allTable[id];
  NFD_LOG_DEBUG("FaceId id = " << id << ";isFind = " << isFind << ";fTable = " << &fTable);
  // 在对应优先级的表中插入 (pInterest)
  /// @brief V2.3 添加调度表聚合功能
  bool isExist = false;
  auto fullName = pInterest->getName ();
  NFD_LOG_DEBUG("fullName = " << fullName);
  ndn::Name name = interest.getName ().getPrefix (-1);
  DispatchTable::NowPriorTable& pTable = fTable[prior];
  NFD_LOG_DEBUG("DispatchTable::PushInterest = " << interest.getName ());
  PushITable (pInterest, pTable, name);

  /// @brief V2.1: 如果底层队列为空, 就从调度表里取
  if (isFind) {
    SendPacket (egress);
  }
  else {
    SetTxTraceDequeue (egress);
  }
}

实际的入队函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void 
DispatchTable::PushITable(std::shared_ptr<const Interest> interest, DispatchTable::NowPriorTable& pTable, const ndn::Name& name)
{
  NFD_LOG_DEBUG("----------LZH 2023/10/30 DispatchTable::PushITable start ");
  DispatchTable::NowNameTable& nTable = pTable[name];
  
  // 如果名称前缀对应的表为空, 等效于有新流加入, 重置计数
  if (nTable.qTable.empty ()) {
    for (auto &nTables : pTable) {
      nTables.second.byte = 0;
    }
  }
  // 总之要入队
  Item tmp = {interest, NULL, interest->wireEncode ().size ()};
  nTable.qTable.emplace_back (std::move (tmp));
  NFD_LOG_DEBUG("----------LZH 2023/10/30 DispatchTable::PushITable qTable.size() =  " << nTable.qTable.size());
}

实际的发包流程，底层队列为空，就来调用发包流程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
void
DispatchTable::SendPacket(Face& egress)
{
  NFD_LOG_DEBUG("----------LZH 2023/10/30 DispatchTable::SendPacket egress = " << egress);
  std::cout << "----------LZH 2023/10/30 DispatchTable::SendPacket start " << std::endl;
  /// @brief V2.1: 如果底层队列为空, 就从调度表里取
  // 2.1. 获取底层队列
  ns3::Ptr<ns3::WifiMacQueue> queue = GetWifiMacQueue (egress);
  if (queue == NULL) {
    NFD_LOG_DEBUG ("[Critical Error] GetQueue 的 queue 为空!!!");
    return;
  }
  std::cout << "----------LZH 2023/10/30 DispatchTable::SendPacket SendPacket queue = " << queue << std::endl; 
  // 2.2. 获取调度表
  face::FaceId id = egress.getId ();
  DispatchTable::NowFaceTable& fTable = m_allTable[id];

  // 2.3. 如果当前底层队列没有条目，则按照策略取出 Data 放进去
  if (queue->GetNPackets() == 0) {
    Item p = GetPacket (fTable);
    if (p.interest == NULL && p.data == NULL) {
      std::cout << "p.interest == NULL && p.data == NULL" << std::endl;
      return;
    }
    std::cout << "p.interest == " << p.interest << " ; p.data ==" << p.data << std::endl;
    NS_ASSERT(p.interest == NULL || p.data == NULL);
    if(p.interest != NULL && p.data == NULL) {
      const Interest& interest = *p.interest;
      auto fullName = p.interest->getName ();
      NFD_LOG_DEBUG ("GetPacket获取到的是Interest包!!:" << fullName);
      egress.sendInterest(interest);
    }
    if(p.interest == NULL && p.data != NULL) {
      const Data& data = *p.data;
      auto fullName = p.data->getName ();
      NFD_LOG_DEBUG ("GetPacket获取到的是Data包!!:" << fullName);
      egress.sendData(data);
    }
  }
}

扫一扫，分享到微信

微信分享二维码
本站总访问量次 |

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

这一定是一个<br><br>很长很长的一生啊