NDN代码分析(2) tlv编码和cs代码

ndnSIM的data包和interest包的tlv编码、解码过程及如何判断包的类型。

ndnSIM学习（五）——data包和interest包的tlv编码、解码过程以及如何判断包的类型_间宫羽咲sama的博客-CSDN博客_tlv编码规则

首先，ndn对于非负整数的编码规则是按照官网上的Non-Negative Integer Encoding规则进行编码的。

• 如果这个数 ⩽ 252，那么就用1字节表示它本身
• 如果这个数 ⩽ 2^16 ，那么用3字节表示它。其中首字节为 253 ，用于标志长度为 2 ，代表真正表示这个数的是后面 2 字节
• 如果这个数 ⩽ 2^32 ，那么用3字节表示它。其中首字节为 254 ，用于标志长度为 4 ，代表真正表示这个数的是后面 4 字节
• 如果这个数 ⩽ 2^64 ，那么用3字节表示它。其中首字节为 255，用于标志长度为 8 ，代表真正表示这个数的是后面 8 字节

0      ⇒  0x00
127    ⇒  0x7F
252    ⇒  0xFC
253    ⇒  0xFD00FD
256    ⇒  0xFD0100
65535  ⇒  0xFDFFFF
65536  ⇒  0xFE00010000

所谓的TLV编码，全名就是 Type(T)-Length(L)-Value(V) 编码。说白了，每个包都被切成 TLV 的格式，前面 Type 代表类型，给大家摘录一段 tlv.hpp 的代码就懂了

namespace tlv {
enum : uint32_t {
  Invalid                         = 0,
  Interest                        = 5,
  Data                            = 6,
  Name                            = 7,
  GenericNameComponent            = 8,
  ImplicitSha256DigestComponent   = 1,
  ParametersSha256DigestComponent = 2,
  CanBePrefix                     = 33,
  MustBeFresh                     = 18,
  ...  // 以下太长了，不再全部摘录，自己去 <ns-3 folder>/build/ns3/ndnSIM/ndn-cxx/encoding/tlv.hpp 看吧
};
}

注意：T和L都是按照非负整数编码规则编码的！

举个例子：假设 Type=256, Length=65535 ，按照非负整数编码规则，这个TLV就应当是 (0xFD0100)(0xFDFFFF)(xxxxxxxxxxxxxx) ，其中加括号只是为了方便读者理解， (xxxxxxxxxxxxxx) 代表65535字节长的包。

xxxxxxx 中包含了数据、签名等各种信息，每种信息都用 tlv 编码进行。或者跟具体地说，最外层的 tlv=(Type=Name)(Length)(V) 的 V 里面

咱们还是拿一具体的例子来说吧。比如data包，假设其中含有 Name+Content+SignatureInfo+SignatureValue 的信息。所以，实际上，这个data包里面真正包含的内容如下图所示：

/4.png)

/5.png)

• Face::onReceiveElement 将 Block 类型的内容，通过其 type 解码判别出它是 Interest 类还是 Data 类，从而将 Block 转化为对应的类型。
• 转化为对应类型后，由对应的构造函数执行 wireDecode 函数。
• 每个类的 wireDecode 函数都配备有 m_wire.parse() 函数，对 Block 类的 m_wire 进行参数解析。
• 参数解析方式基于前面的非负整数编码规则、TLV编码和data包和interest包的编码规则的前置知识，对于 Block 类型执行对应的解码。具体不想细讲了，前面已经讲得很细了。

ndnSIM学习（六）——内容缓存CS、cs.cpp、cs.hpp_间宫羽咲sama的博客-CSDN博客

ndnSIM学习（六）——内容缓存CS、cs.cpp、cs.hpp

• <ndnSIM-folder>/NFD/daemon/table/cs.hpp
• <ndnSIM-folder>/NFD/daemon/table/cs.cpp
• <ndnSIM-folder>/NFD/daemon/table/cs-entry.hpp
• <ndnSIM-folder>/NFD/daemon/table/cs-entry.cpp
• <ndnSIM-folder>/NFD/daemon/table/cs-policy.hpp
• <ndnSIM-folder>/NFD/daemon/table/cs-policy.cpp

class Cs : noncopyable  //Cs是一个内容缓存类，其父类为noncopyable，缓存内容存在m_table中
{
public:
  // 构造函数，默认最大存10个包,显式调用构造函数
  explicit
  Cs(size_t nMaxPackets = 10);

  // 识别数据的缓存策略+把data塞进m_table且Fresh data+
  // +使用当前FIFO缓存策略处理data在队列中的位置
  void
  insert(const Data& data, bool isUnsolicited = false);//isUnsolicited是未经请求的数据包？

  // 异步擦除前缀名为prefix下的条目，得到擦除的条目数nErased
  // 擦除后执行回调函数cb
  template<typename AfterEraseCallback>
  void
  erase(const Name& prefix, size_t limit, AfterEraseCallback&& cb)
  {
    size_t nErased = eraseImpl(prefix, limit);
    cb(nErased);
  }

  // 用发的interest在CS中最匹配的data包，得到目标对应m_table中的迭代器
  // 如果找到，执行回调函数hit，否则执行回调函数miss
  template<typename HitCallback, typename MissCallback>
  void
  find(const Interest& interest, HitCallback&& hit, MissCallback&& miss) const
  {
    auto match = findImpl(interest);
    if (match == m_table.end()) {  //m_table是一个set，相当于没找到interest需要的包
      miss(interest);
      return;
    }
    hit(interest, match->getData());
  }

  // 返回m_table的size，即CS储存的条目数
  size_t size() const { return m_table.size(); }//size_t是unsigned类型，其大小足以保证存储内存中对象的大小。函数是const类型，class 可以调用 func()、func() const，const class 只能调用 func() const.

public: // configuration
  // 返回储存上限
  size_t getLimit() const { return m_policy->getLimit(); }

  // 设置储存上限
  void setLimit(size_t nMaxPackets) { return m_policy->setLimit(nMaxPackets); }

  // 获取缓存替换策略
  Policy* getPolicy() const { return m_policy.get(); }

  // 更改缓存策略（必须size() == 0才能执行）
  void setPolicy(unique_ptr<Policy> policy);

  // 返回m_shouldAdmit (if false, no Data will be admitted)
  bool shouldAdmit() const { return m_shouldAdmit; }

  // Set m_shouldAdmit
  void enableAdmit(bool shouldAdmit);

  // 返回m_shouldServe (if false, all lookups will miss)
  bool shouldServe() const { return m_shouldServe; }

  // Set m_shouldServe
  void enableServe(bool shouldServe);

public: // enumeration
  using const_iterator = Table::const_iterator;//using取代typedef

  // 头尾迭代器，应该不必多说吧，很简单
  const_iterator begin() const { return m_table.begin(); }
  const_iterator end() const { return m_table.end(); }

private:
  // 用Table进行二分查找，获得前缀为prefix的区间
  std::pair<const_iterator, const_iterator>
  findPrefixRange(const Name& prefix) const;

  // 前面的erase函数会调用eraseImpl函数作为具体实现
  // 擦除方式是调用findPrefixRange函数获得区间，然后擦掉所有元素
  // limit是擦除的上限，超过了就不擦了，不然全擦
  size_t
  eraseImpl(const Name& prefix, size_t limit);

  // 前面的find函数会调用findImpl函数作为具体实现
  // 擦除方式是调用findPrefixRange函数获得区间，然后用find_if函数遍历查找
  const_iterator
  findImpl(const Interest& interest) const;

  // 前面的setPolicy函数会调用setPolicyImpl函数作为具体实现
  void
  setPolicyImpl(unique_ptr<Policy> policy);

PUBLIC_WITH_TESTS_ELSE_PRIVATE:  // 测试public，运行时private
  void dump();  // 显示m_table里全部内容，仅测试时可用

private:
  Table m_table;  // 存CS内容的表
  unique_ptr<Policy> m_policy;  // 存缓存策略
  signal::ScopedConnection m_beforeEvictConnection;

  bool m_shouldAdmit = true; ///< if false, no Data will be admitted
  bool m_shouldServe = true; ///< if false, all lookups will miss
};

cs.cpp的Cs::insert函数详解

整个 cs.hpp 都很简单，对应的函数功能我都给了详细注释。对于 cs.cpp ，我只对 Cs::insert 这一个函数进行一些分析说明，具体说明以注释的形式给出——

void
Cs::insert(const Data& data, bool isUnsolicited)
{
  // 如果不Admit或者缓存上限为0，直接返回
  if (!m_shouldAdmit || m_policy->getLimit() == 0) {
    return;
  }
  NFD_LOG_DEBUG("insert " << data.getName());

  // 尝试取出data的CachePolicyType，如果data没Tag，视为要求缓存
  // 如果有Tag，Tag上的Type都说不缓存，那还insert个鬼，直接return吧
  shared_ptr<lp::CachePolicyTag> tag = data.getTag<lp::CachePolicyTag>();
  if (tag != nullptr) {
    lp::CachePolicyType policy = tag->get().getPolicy();
    if (policy == lp::CachePolicyType::NO_CACHE) {
      return;
    }
  }

  // 尝试把(data, isUnsolicited)压入m_table表
  // 压入后把自己在表中的迭代器返回给it（无论是否重复）
  // 因为是set类型，所以会调用data的重载operator==分析是否重复
  // 如果有重复元素，说明不是NewEntry，isNewEntry=false
  const_iterator it;
  bool isNewEntry = false;
  std::tie(it, isNewEntry) = m_table.emplace(data.shared_from_this(), isUnsolicited);//如果发成插入，返回一个迭代器，第一个组件为指向插入元素的迭代器，第二个元素为true。isUnsolicited是未经请求的，相当于PIT不需要这个东西
  Entry& entry = const_cast<Entry&>(*it);//将it的索引的值变为引用

  // Fresh一下新来的包
  entry.updateFreshUntil();

  // 善后工作
  if (!isNewEntry) { // existing entry
    // 刷新新来的包的isUnsolicited
    if (entry.isUnsolicited() && !isUnsolicited) {
      entry.clearUnsolicited();
    }

    m_policy->afterRefresh(it);
  }
  else {
    m_policy->afterInsert(it);
  }
}

总结 ：

• 类 Cs 就是一个内容缓存器，其中缓存内容都存放在一个 m_table 中。
• m_table 的类型为 Table ，相当于 std::set 。因为是集合，所以禁止存在相同元素。
• std::set 的底层实现用到了红黑树，需要重载 operator < ，所以在文件 cs-entry.cpp 中 Entry 类型重载了 < 符号。
• 缓存策略由 m_policy 进行维护，其中维护了缓存策略和缓存上限。

cs.hpp 的类 Cs 的数据成员如下——

private:
  Table m_table;  // 存CS内容的表
  unique_ptr<Policy> m_policy;  // 存缓存策略
  signal::ScopedConnection m_beforeEvictConnection;
  bool m_shouldAdmit = true; ///< if false, no Data will be admitted
  bool m_shouldServe = true; ///< if false, all lookups will miss

cs-entry.hpp 的类 Entry 的数据成员如下——

private:
  shared_ptr<const Data> m_data;  // 数据内容
  bool m_isUnsolicited;  // 未经请求的数据？（PIT里没有就是未经请求的）
  time::steady_clock::TimePoint m_freshUntil;  // Fresh截止时间

cs-policy.hpp 的类 Policy 的数据成员如下——

private:
  std::string m_policyName;  // 策略名
  size_t m_limit;  // 容量
  Cs* m_cs;  // 指向被维护的Cs的指针