NS-3学习笔记（十四）：NS-3中使用哈希函数（Hash functions）

本章主要介绍NS-3当中的哈希函数的使用。NS-3提供了一个使用哈希函数的通用的接口。可以方便地调用内置的哈希函数来将一个字节数组或者字符串转换成一个哈希值。根据底层算法的不同，哈希值可以是32位或者是64位的整数。NS-3默认使用的哈希算法是murmur3，它可以返回32和64位的值。可以轻易地使用其他哈希算法实现。如果NS-3所提供的哈希实现都无法达到要求，也可以方便地添加自己的实现。

1. 哈希函数简介

Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射pre-image）通过散列算法变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值。

所有哈希函数都有如下一个基本特性：如果两个同一哈希算法生成的值是不相同的，那么这两个散列值的原始输入也是不相同的。这个特性是散列函数具有确定性的结果。但另一方面，散列函数的输入和输出不是一一对应的，如果两个散列值相同，两个输入值很可能是相同的，但不绝对肯定二者一定相等（即可能出现哈希碰撞）。输入一些数据计算出散列值，然后部分改变输入值，一个具有强混淆特性的散列函数会产生一个完全不同的散列值。

哈希函数在不同的领域具有广泛的应用：

• 数据校验 （例如网络数据包当中常用的CRC检验，文件的MD5或SHA-1校验）
• 数字签名 （为了提高认证速度，RSA当中只对摘要部分签名）
• 高速数据查询 （例如Openflow当中的流表查询，Java当中的HashMap查询）
• 网络负载均衡 （例如ECMP协议实现的负载均衡）
• 数据缓存 （例如Redis分布式缓存系统）
• ……

值得注意的是，由于哈希函数的应用的多样性，它们经常是专为某一应用而设计的。例如，加密散列函数假设存在一个要找到具有相同散列值的原始输入的敌人。一个设计优秀的加密散列函数是一个“单向”操作：对于给定的散列值，没有实用的方法可以计算出一个原始输入，也就是说很难伪造。为加密散列为目的设计的函数，如MD5，被广泛的用作检验散列函数。这样软件下载的时候，就会对照验证代码之后才下载正确的文件部分。此代码有可能因为环境因素的变化，如机器配置或者IP地址的改变而有变动。以保证源文件的安全性。对于用于负载均衡的哈希应用，设计的目标就是希望在大量的数据出现的情况下，哈希值尽量呈现均匀分布的特性。

2. NS-3哈希算法的使用

2.1. 简单的用法

在NS-3当中，如果只是简单的想使用哈希算法得到哈希值，那么最简单的方法就是直接调用封装好的哈希函数即可。首先我们自己要明白需要32位哈希值还是64位哈希值。确定好之后才能选择调用不同的版本。NS-3当中为32位版本和64位版本分别提供了两个重载：

hash.h

uint32_t Hash32 (const char * buffer, const std::size_t size);
uint32_t Hash32 (const std::string s);

uint64_t Hash64 (const char * buffer, const std::size_t size);
uint64_t Hash64 (const std::string s);

一个版本接受一个字节数组（以及需要编码的部分的长度），另外一个版本接受一个字符串作为参数。最终返回32位或者64位整数。下面通过一个简单的例子来演示最简单的哈希函数的使用：

try-simple-hash.cc

#include "ns3/core-module.h"

#include <iomanip>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("TrySimpleHash");

int 
main (int argc, char *argv[])
{
  LogComponentEnable("TrySimpleHash", LOG_LEVEL_INFO);

  std::string key ("The quick brown fox jumped over the lazy dogs.");

  uint32_t hash32 = Hash32 (key);
  uint64_t hash64 = Hash64 (key);

  NS_LOG_INFO("32bit hash: 0x"  << std::hex << std::setw (8) << hash32 << std::dec);
  NS_LOG_INFO("64bit hash: 0x"  << std::hex << std::setw (16) << hash64 << std::dec);

  Simulator::Run ();
  Simulator::Destroy ();
}

运行程序，得到如下结果：

Waf: Entering directory `/home/rainsia/Applications/ns-allinone-3.29/ns-3.29/build'
[1928/2051] Compiling scratch/try-simple-hash.cc
[2028/2051] Linking build/scratch/try-simple-hash
Waf: Leaving directory `/home/rainsia/Applications/ns-allinone-3.29/ns-3.29/build'
Build commands will be stored in build/compile_commands.json
'build' finished successfully (9.515s)
32bit hash: 0x463d70e2
64bit hash: 0xa750412079d53e04

程序最后输出了32位和64位版本的哈希值，可见，在NS-3当中如果只是想简单地获取哈希值，用法是非常方便。

继续查看代码：

hash.cc

Hasher::Hasher ()
{
  m_impl = Create <Hash::Function::Murmur3> ();
  NS_ASSERT (m_impl != 0);
}

inline
uint32_t
Hash32 (const std::string s)
{
  return Hasher ().GetHash32 (s);
}

inline
uint64_t
Hash64 (const std::string s)
{
  return Hasher ().GetHash64 (s);
}

从代码中可以看出，默认的哈希实现算法是murmur3。这个算法运算速度非常快，但是碰撞率比较低，其最新版本是3，是作者加入Google之后对murmur2的改进。其实现原理在这里。

2.2. 进阶版用法

哈希函数的简单用法的问题在于只能使用默认的murmur3算法，虽然这种算法已经很好了，但是正如前面所说的，不同的应用领域对哈希算法的需求是不一样的。因此，我们更希望能够自己指定哈希算法。

实际上，从刚刚的源代码分析也不难看出，其最终还是依赖于一个名为Hasher的类。这个类当中提供了两个构造方法：

hash.cc

Hasher::Hasher ()
{
  m_impl = Create <Hash::Function::Murmur3> ();
  NS_ASSERT (m_impl != 0);
}

Hasher::Hasher (Ptr<Hash::Implementation> hp)
  : m_impl (hp)
{
  NS_ASSERT (m_impl != 0);
}

第一个构造方法默认创建了Murmur3对象。第二个构造函数可以让用户自己传入需要的哈希算法实现类。目前NS-3当中只默认提供了两种实现：一个就是刚刚用过的murmur3算法，另外一个就是FNV-1a算法，其实现原理可以看这里。下面我们通过一个简单的例子来演示如何指定哈希算法：

try-fnv-hash.cc

#include "ns3/core-module.h"

#include <iomanip>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("TryFnvHash");

int 
main (int argc, char *argv[])
{
  LogComponentEnable("TryFnvHash", LOG_LEVEL_INFO);

  std::string key ("The quick brown fox jumped over the lazy dogs.");

  Hasher hasher(Create<Hash::Function::Fnv1a> ());
  uint32_t hash32 = hasher.GetHash32(key);
  //要清空
  uint64_t hash64 = hasher.clear().GetHash64(key);

  NS_LOG_INFO("32bit hash: 0x"  << std::hex << std::setw (8) << hash32 << std::dec);
  NS_LOG_INFO("64bit hash: 0x"  << std::hex << std::setw (16) << hash64 << std::dec);

  Simulator::Run ();
  Simulator::Destroy ();
}

程序关键点在于创建Hasher的时候通过构造函数参数制定了底层使用的哈希算法。另外一个值得注意的点在于使用这种方法，每次计算全新的数据的时候必须先清空（调用clear()方法），否则会变成和前面的数据累加，结果会不正确。运行程序，得到如下结果：

Waf: Entering directory `/home/rainsia/Applications/ns-allinone-3.29/ns-3.29/build'
[1968/2053] Compiling scratch/try-fnv-hash.cc
[2043/2053] Linking build/scratch/try-fnv-hash
Waf: Leaving directory `/home/rainsia/Applications/ns-allinone-3.29/ns-3.29/build'
Build commands will be stored in build/compile_commands.json
'build' finished successfully (7.826s)
32bit hash: 0xa3fc0d6d
64bit hash: 0x88f6cdbe0a31098d

2.3. 分段（增量）哈希

通过上面的例子，我们可以看到，每次要计算新的哈希值时，必须先调用clear()方法，把之前的数据清空。而如果没有清空数据，将会和上次的数据进行累加。这可以实现一种称为增量哈希的方法。你通过一个简单的例子来解释。

try-incremental-hash.cc

#include "ns3/core-module.h"

#include <iomanip>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("TryIncrementalHash");

int 
main (int argc, char *argv[])
{
  LogComponentEnable("TryIncrementalHash", LOG_LEVEL_INFO);

  std::string key1 ("The quick brown fox ");
  std::string key2 ("jumped over the lazy dogs.");

  Hasher hasher(Create<Hash::Function::Fnv1a> ());
  uint32_t hash32 = hasher.GetHash32(key1);
  hash32 = hasher.GetHash32(key2);

  uint64_t hash64 = hasher.clear().GetHash64(key1);
  hash64 = hasher.GetHash64(key2);

  NS_LOG_INFO("32bit hash: 0x"  << std::hex << std::setw (8) << hash32 << std::dec);
  NS_LOG_INFO("64bit hash: 0x"  << std::hex << std::setw (16) << hash64 << std::dec);

  Simulator::Run ();
  Simulator::Destroy ();
}

程序中，我们将原来要计算哈希值的字符串分成了两段，每次只往hasher里面添加一段，然后再添加另一段。而在计算32位和64位的哈希值时，中间做了清空。运行程序之后，得到如下结果：

Waf: Entering directory `/home/rainsia/Applications/ns-allinone-3.29/ns-3.29/build'
[1984/2055] Compiling scratch/try-incremental-hash.cc
[2054/2055] Linking build/scratch/try-incremental-hash
Waf: Leaving directory `/home/rainsia/Applications/ns-allinone-3.29/ns-3.29/build'
Build commands will be stored in build/compile_commands.json
'build' finished successfully (7.911s)
32bit hash: 0xa3fc0d6d
64bit hash: 0x88f6cdbe0a31098d

对比前面的运行结果，我们发现，分段计算的结果和完整计算的结果完全相同，说明他们具有一样的效果。

总结：如果不希望使用增量哈希，那么请习惯每次计算哈希值的时候都清空，养成如下调用哈希算法的习惯：

hasher.clear ().GetHash32 (key)

3. 添加自定义的哈希算法

不同的应用对哈希算法性能的诉求是不一样的，因此，NS-3的内置哈希算法多半都不能满足需求。我们可以使用满足NS-3哈希算法接口的方式实现自己的哈希算法来满足自己的需求。如果哈希算法比较简单，可以使用一个函数表示，那么可以使用添加哈希函数的方式来实现。如果哈希算法比较复杂，内部必须有复杂的数据传递和方法调用，那么更建议使用添加类的方法来实现。

3.1. 添加哈希函数

如果你自己实现的哈希算法比较简单，完全可以使用一个函数来实现，那么推荐使用添加哈希函数的方法来实现。只需添加一组符合NS-3哈希算法接口的函数即可。下面通过一个简单的例子来演示如何通过函数的方式来添加哈希算法实现。

例如，NS-3当中我们想在NS-3当中添加ELF哈希算法。这是一个Unix和Linux系统内核当中使用的一个哈希算法，由于它主要在Linux的可执行文件格式ELF(Executable and Linking Format)中使用，所以取名为ELF哈希。这个算法中，字符串中每个字符都有同样的作用，它巧妙地对字符的ASCII编码值进行计算，ELF哈希函数对于能够比较均匀地把字符串分布在散列表中。因此，任意修改一个字符对哈希值都有很大影响，符合哈希函数的需求。

实现的算法函数必须符合如下的文件签名：

uint32_t hash_name32(const char * data, const std::size_t size);
uint64_t hash_name64(const char * data, const std::size_t size);

随后可以通过如下方法来创建哈希函数类：

Hasher hasher = Hasher ( Create<Hash::Function::Hash32> (&hash_name32) );
Hasher hasher = Hasher ( Create<Hash::Function::Hash64> (&hash_name64) );

然后即可通过hasher来计算哈希值，过程和之前的例子一致。下面我们就开始实现ELFHash算法。

try-function-hash.cc

#include "ns3/core-module.h"

#include <iomanip>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("TryFunctionHash");

uint32_t ELFHash(const char* str, const std::size_t length)
{
   uint32_t hash = 0;
   uint32_t x    = 0;
   uint32_t i    = 0;

   for (i = 0; i < length; ++str, ++i)
   {
      hash = (hash << 4) + (*str);

      if ((x = hash & 0xF0000000L) != 0)
      {
         hash ^= (x >> 24);
         hash &= ~x;
      }
   }
   return hash;
}

int 
main (int argc, char *argv[])
{
  LogComponentEnable("TryFunctionHash", LOG_LEVEL_INFO);

  std::string key ("The quick brown fox jumped over the lazy dogs.");

  Hasher hasher(Create<Hash::Function::Hash32> (&ELFHash));
  uint32_t hash32 = hasher.GetHash32(key);

  NS_LOG_INFO("32bit hash: 0x"  << std::hex << std::setw (8) << hash32 << std::dec);

  Simulator::Run ();
  Simulator::Destroy ();
}

运行程序得到如下结果：

Waf: Entering directory `/home/rainsia/Applications/ns-allinone-3.29/ns-3.29/build'
[1912/2057] Compiling scratch/try-function-hash.cc
[2017/2057] Linking build/scratch/try-function-hash
Waf: Leaving directory `/home/rainsia/Applications/ns-allinone-3.29/ns-3.29/build'
Build commands will be stored in build/compile_commands.json
'build' finished successfully (14.754s)
32bit hash: 0x e75160e

3.2. 添加哈希类

如果算法比较复杂，则可以通过类的方式来实现。这个类必须继承ns3::Hash::Implementation类。其中ns3、Hash是名称空间，而Implementation才是类名。然后实现其中的GetHash32()和clear()方法，而GetHash64()方法可以不实现，也可以实现，如果不实现，那么自动返回32位的结果值。

例如，我们需要实现CRC(Cyclic Redundant Checksum)这个算法。可以实现CRC类，然后实现32位或者64位算法。然后即可按照之前的方法创建Hasher类的实例即可。当然这个例子选得不好，即无需增量计算，也没有复杂的内部调用或者中间变量需要在类的内部传递。就凑合着看看吧。按照NS-3的管理，我们还是将哈希算法的类放到ns3::Hash::Function::名称空间下，这样可以避免和其他用途的类重名的风险。代码如下：

try-class-hash.cc

#include "ns3/core-module.h"

#include <iomanip>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("TryClassHash");

namespace ns3 {
  namespace Hash {
    namespace Function {
      class CRC : public ns3::Hash::Implementation
      {
      public:
        uint32_t  GetHash32  (const char * buffer, const size_t size);
        uint64_t  GetHash64  (const char * buffer, const size_t size);
        virtual void clear (void);
      private:
        uint32_t m_CRC32_Table[256] = {
          0x00000000L, 0x77073096L, 0xEE0E612CL,
          0x990951BAL, 0x076DC419L, 0x706AF48FL,
          0xE963A535L, 0x9E6495A3L, 0x0EDB8832L,
          0x79DCB8A4L, 0xE0D5E91EL, 0x97D2D988L,
          0x09B64C2BL, 0x7EB17CBDL, 0xE7B82D07L,
          0x90BF1D91L, 0x1DB71064L, 0x6AB020F2L,
          0xF3B97148L, 0x84BE41DEL, 0x1ADAD47DL,
          0x6DDDE4EBL, 0xF4D4B551L, 0x83D385C7L,
          0x136C9856L, 0x646BA8C0L, 0xFD62F97AL,
          0x8A65C9ECL, 0x14015C4FL, 0x63066CD9L,
          0xFA0F3D63L, 0x8D080DF5L, 0x3B6E20C8L,
          0x4C69105EL, 0xD56041E4L, 0xA2677172L,
          0x3C03E4D1L, 0x4B04D447L, 0xD20D85FDL,
          0xA50AB56BL, 0x35B5A8FAL, 0x42B2986CL,
          0xDBBBC9D6L, 0xACBCF940L, 0x32D86CE3L,
          0x45DF5C75L, 0xDCD60DCFL, 0xABD13D59L,
          0x26D930ACL, 0x51DE003AL, 0xC8D75180L,
          0xBFD06116L, 0x21B4F4B5L, 0x56B3C423L,
          0xCFBA9599L, 0xB8BDA50FL, 0x2802B89EL,
          0x5F058808L, 0xC60CD9B2L, 0xB10BE924L,
          0x2F6F7C87L, 0x58684C11L, 0xC1611DABL,
          0xB6662D3DL, 0x76DC4190L, 0x01DB7106L,
          0x98D220BCL, 0xEFD5102AL, 0x71B18589L,
          0x06B6B51FL, 0x9FBFE4A5L, 0xE8B8D433L,
          0x7807C9A2L, 0x0F00F934L, 0x9609A88EL,
          0xE10E9818L, 0x7F6A0DBBL, 0x086D3D2DL,
          0x91646C97L, 0xE6635C01L, 0x6B6B51F4L,
          0x1C6C6162L, 0x856530D8L, 0xF262004EL,
          0x6C0695EDL, 0x1B01A57BL, 0x8208F4C1L,
          0xF50FC457L, 0x65B0D9C6L, 0x12B7E950L,
          0x8BBEB8EAL, 0xFCB9887CL, 0x62DD1DDFL,
          0x15DA2D49L, 0x8CD37CF3L, 0xFBD44C65L,
          0x4DB26158L, 0x3AB551CEL, 0xA3BC0074L,
          0xD4BB30E2L, 0x4ADFA541L, 0x3DD895D7L,
          0xA4D1C46DL, 0xD3D6F4FBL, 0x4369E96AL,
          0x346ED9FCL, 0xAD678846L, 0xDA60B8D0L,
          0x44042D73L, 0x33031DE5L, 0xAA0A4C5FL,
          0xDD0D7CC9L, 0x5005713CL, 0x270241AAL,
          0xBE0B1010L, 0xC90C2086L, 0x5768B525L,
          0x206F85B3L, 0xB966D409L, 0xCE61E49FL,
          0x5EDEF90EL, 0x29D9C998L, 0xB0D09822L,
          0xC7D7A8B4L, 0x59B33D17L, 0x2EB40D81L,
          0xB7BD5C3BL, 0xC0BA6CADL, 0xEDB88320L,
          0x9ABFB3B6L, 0x03B6E20CL, 0x74B1D29AL,
          0xEAD54739L, 0x9DD277AFL, 0x04DB2615L,
          0x73DC1683L, 0xE3630B12L, 0x94643B84L,
          0x0D6D6A3EL, 0x7A6A5AA8L, 0xE40ECF0BL,
          0x9309FF9DL, 0x0A00AE27L, 0x7D079EB1L,
          0xF00F9344L, 0x8708A3D2L, 0x1E01F268L,
          0x6906C2FEL, 0xF762575DL, 0x806567CBL,
          0x196C3671L, 0x6E6B06E7L, 0xFED41B76L,
          0x89D32BE0L, 0x10DA7A5AL, 0x67DD4ACCL,
          0xF9B9DF6FL, 0x8EBEEFF9L, 0x17B7BE43L,
          0x60B08ED5L, 0xD6D6A3E8L, 0xA1D1937EL,
          0x38D8C2C4L, 0x4FDFF252L, 0xD1BB67F1L,
          0xA6BC5767L, 0x3FB506DDL, 0x48B2364BL,
          0xD80D2BDAL, 0xAF0A1B4CL, 0x36034AF6L,
          0x41047A60L, 0xDF60EFC3L, 0xA867DF55L,
          0x316E8EEFL, 0x4669BE79L, 0xCB61B38CL,
          0xBC66831AL, 0x256FD2A0L, 0x5268E236L,
          0xCC0C7795L, 0xBB0B4703L, 0x220216B9L,
          0x5505262FL, 0xC5BA3BBEL, 0xB2BD0B28L,
          0x2BB45A92L, 0x5CB36A04L, 0xC2D7FFA7L,
          0xB5D0CF31L, 0x2CD99E8BL, 0x5BDEAE1DL,
          0x9B64C2B0L, 0xEC63F226L, 0x756AA39CL,
          0x026D930AL, 0x9C0906A9L, 0xEB0E363FL,
          0x72076785L, 0x05005713L, 0x95BF4A82L,
          0xE2B87A14L, 0x7BB12BAEL, 0x0CB61B38L,
          0x92D28E9BL, 0xE5D5BE0DL, 0x7CDCEFB7L,
          0x0BDBDF21L, 0x86D3D2D4L, 0xF1D4E242L,
          0x68DDB3F8L, 0x1FDA836EL, 0x81BE16CDL,
          0xF6B9265BL, 0x6FB077E1L, 0x18B74777L,
          0x88085AE6L, 0xFF0F6A70L, 0x66063BCAL,
          0x11010B5CL, 0x8F659EFFL, 0xF862AE69L,
          0x616BFFD3L, 0x166CCF45L, 0xA00AE278L,
          0xD70DD2EEL, 0x4E048354L, 0x3903B3C2L,
          0xA7672661L, 0xD06016F7L, 0x4969474DL,
          0x3E6E77DBL, 0xAED16A4AL, 0xD9D65ADCL,
          0x40DF0B66L, 0x37D83BF0L, 0xA9BCAE53L,
          0xDEBB9EC5L, 0x47B2CF7FL, 0x30B5FFE9L,
          0xBDBDF21CL, 0xCABAC28AL, 0x53B39330L,
          0x24B4A3A6L, 0xBAD03605L, 0xCDD70693L,
          0x54DE5729L, 0x23D967BFL, 0xB3667A2EL,
          0xC4614AB8L, 0x5D681B02L, 0x2A6F2B94L,
          0xB40BBE37L, 0xC30C8EA1L, 0x5A05DF1BL,
          0x2D02EF8DL };

        uint64_t m_CRC64_Table[256] = {
          0x0000000000000000ULL, 0x7ad870c830358979ULL,
          0xf5b0e190606b12f2ULL, 0x8f689158505e9b8bULL,
          0xc038e5739841b68fULL, 0xbae095bba8743ff6ULL,
          0x358804e3f82aa47dULL, 0x4f50742bc81f2d04ULL,
          0xab28ecb46814fe75ULL, 0xd1f09c7c5821770cULL,
          0x5e980d24087fec87ULL, 0x24407dec384a65feULL,
          0x6b1009c7f05548faULL, 0x11c8790fc060c183ULL,
          0x9ea0e857903e5a08ULL, 0xe478989fa00bd371ULL,
          0x7d08ff3b88be6f81ULL, 0x07d08ff3b88be6f8ULL,
          0x88b81eabe8d57d73ULL, 0xf2606e63d8e0f40aULL,
          0xbd301a4810ffd90eULL, 0xc7e86a8020ca5077ULL,
          0x4880fbd87094cbfcULL, 0x32588b1040a14285ULL,
          0xd620138fe0aa91f4ULL, 0xacf86347d09f188dULL,
          0x2390f21f80c18306ULL, 0x594882d7b0f40a7fULL,
          0x1618f6fc78eb277bULL, 0x6cc0863448deae02ULL,
          0xe3a8176c18803589ULL, 0x997067a428b5bcf0ULL,
          0xfa11fe77117cdf02ULL, 0x80c98ebf2149567bULL,
          0x0fa11fe77117cdf0ULL, 0x75796f2f41224489ULL,
          0x3a291b04893d698dULL, 0x40f16bccb908e0f4ULL,
          0xcf99fa94e9567b7fULL, 0xb5418a5cd963f206ULL,
          0x513912c379682177ULL, 0x2be1620b495da80eULL,
          0xa489f35319033385ULL, 0xde51839b2936bafcULL,
          0x9101f7b0e12997f8ULL, 0xebd98778d11c1e81ULL,
          0x64b116208142850aULL, 0x1e6966e8b1770c73ULL,
          0x8719014c99c2b083ULL, 0xfdc17184a9f739faULL,
          0x72a9e0dcf9a9a271ULL, 0x08719014c99c2b08ULL,
          0x4721e43f0183060cULL, 0x3df994f731b68f75ULL,
          0xb29105af61e814feULL, 0xc849756751dd9d87ULL,
          0x2c31edf8f1d64ef6ULL, 0x56e99d30c1e3c78fULL,
          0xd9810c6891bd5c04ULL, 0xa3597ca0a188d57dULL,
          0xec09088b6997f879ULL, 0x96d1784359a27100ULL,
          0x19b9e91b09fcea8bULL, 0x636199d339c963f2ULL,
          0xdf7adabd7a6e2d6fULL, 0xa5a2aa754a5ba416ULL,
          0x2aca3b2d1a053f9dULL, 0x50124be52a30b6e4ULL,
          0x1f423fcee22f9be0ULL, 0x659a4f06d21a1299ULL,
          0xeaf2de5e82448912ULL, 0x902aae96b271006bULL,
          0x74523609127ad31aULL, 0x0e8a46c1224f5a63ULL,
          0x81e2d7997211c1e8ULL, 0xfb3aa75142244891ULL,
          0xb46ad37a8a3b6595ULL, 0xceb2a3b2ba0eececULL,
          0x41da32eaea507767ULL, 0x3b024222da65fe1eULL,
          0xa2722586f2d042eeULL, 0xd8aa554ec2e5cb97ULL,
          0x57c2c41692bb501cULL, 0x2d1ab4dea28ed965ULL,
          0x624ac0f56a91f461ULL, 0x1892b03d5aa47d18ULL,
          0x97fa21650afae693ULL, 0xed2251ad3acf6feaULL,
          0x095ac9329ac4bc9bULL, 0x7382b9faaaf135e2ULL,
          0xfcea28a2faafae69ULL, 0x8632586aca9a2710ULL,
          0xc9622c4102850a14ULL, 0xb3ba5c8932b0836dULL,
          0x3cd2cdd162ee18e6ULL, 0x460abd1952db919fULL,
          0x256b24ca6b12f26dULL, 0x5fb354025b277b14ULL,
          0xd0dbc55a0b79e09fULL, 0xaa03b5923b4c69e6ULL,
          0xe553c1b9f35344e2ULL, 0x9f8bb171c366cd9bULL,
          0x10e3202993385610ULL, 0x6a3b50e1a30ddf69ULL,
          0x8e43c87e03060c18ULL, 0xf49bb8b633338561ULL,
          0x7bf329ee636d1eeaULL, 0x012b592653589793ULL,
          0x4e7b2d0d9b47ba97ULL, 0x34a35dc5ab7233eeULL,
          0xbbcbcc9dfb2ca865ULL, 0xc113bc55cb19211cULL,
          0x5863dbf1e3ac9decULL, 0x22bbab39d3991495ULL,
          0xadd33a6183c78f1eULL, 0xd70b4aa9b3f20667ULL,
          0x985b3e827bed2b63ULL, 0xe2834e4a4bd8a21aULL,
          0x6debdf121b863991ULL, 0x1733afda2bb3b0e8ULL,
          0xf34b37458bb86399ULL, 0x8993478dbb8deae0ULL,
          0x06fbd6d5ebd3716bULL, 0x7c23a61ddbe6f812ULL,
          0x3373d23613f9d516ULL, 0x49aba2fe23cc5c6fULL,
          0xc6c333a67392c7e4ULL, 0xbc1b436e43a74e9dULL,
          0x95ac9329ac4bc9b5ULL, 0xef74e3e19c7e40ccULL,
          0x601c72b9cc20db47ULL, 0x1ac40271fc15523eULL,
          0x5594765a340a7f3aULL, 0x2f4c0692043ff643ULL,
          0xa02497ca54616dc8ULL, 0xdafce7026454e4b1ULL,
          0x3e847f9dc45f37c0ULL, 0x445c0f55f46abeb9ULL,
          0xcb349e0da4342532ULL, 0xb1eceec59401ac4bULL,
          0xfebc9aee5c1e814fULL, 0x8464ea266c2b0836ULL,
          0x0b0c7b7e3c7593bdULL, 0x71d40bb60c401ac4ULL,
          0xe8a46c1224f5a634ULL, 0x927c1cda14c02f4dULL,
          0x1d148d82449eb4c6ULL, 0x67ccfd4a74ab3dbfULL,
          0x289c8961bcb410bbULL, 0x5244f9a98c8199c2ULL,
          0xdd2c68f1dcdf0249ULL, 0xa7f41839ecea8b30ULL,
          0x438c80a64ce15841ULL, 0x3954f06e7cd4d138ULL,
          0xb63c61362c8a4ab3ULL, 0xcce411fe1cbfc3caULL,
          0x83b465d5d4a0eeceULL, 0xf96c151de49567b7ULL,
          0x76048445b4cbfc3cULL, 0x0cdcf48d84fe7545ULL,
          0x6fbd6d5ebd3716b7ULL, 0x15651d968d029fceULL,
          0x9a0d8ccedd5c0445ULL, 0xe0d5fc06ed698d3cULL,
          0xaf85882d2576a038ULL, 0xd55df8e515432941ULL,
          0x5a3569bd451db2caULL, 0x20ed197575283bb3ULL,
          0xc49581ead523e8c2ULL, 0xbe4df122e51661bbULL,
          0x3125607ab548fa30ULL, 0x4bfd10b2857d7349ULL,
          0x04ad64994d625e4dULL, 0x7e7514517d57d734ULL,
          0xf11d85092d094cbfULL, 0x8bc5f5c11d3cc5c6ULL,
          0x12b5926535897936ULL, 0x686de2ad05bcf04fULL,
          0xe70573f555e26bc4ULL, 0x9ddd033d65d7e2bdULL,
          0xd28d7716adc8cfb9ULL, 0xa85507de9dfd46c0ULL,
          0x273d9686cda3dd4bULL, 0x5de5e64efd965432ULL,
          0xb99d7ed15d9d8743ULL, 0xc3450e196da80e3aULL,
          0x4c2d9f413df695b1ULL, 0x36f5ef890dc31cc8ULL,
          0x79a59ba2c5dc31ccULL, 0x037deb6af5e9b8b5ULL,
          0x8c157a32a5b7233eULL, 0xf6cd0afa9582aa47ULL,
          0x4ad64994d625e4daULL, 0x300e395ce6106da3ULL,
          0xbf66a804b64ef628ULL, 0xc5bed8cc867b7f51ULL,
          0x8aeeace74e645255ULL, 0xf036dc2f7e51db2cULL,
          0x7f5e4d772e0f40a7ULL, 0x05863dbf1e3ac9deULL,
          0xe1fea520be311aafULL, 0x9b26d5e88e0493d6ULL,
          0x144e44b0de5a085dULL, 0x6e963478ee6f8124ULL,
          0x21c640532670ac20ULL, 0x5b1e309b16452559ULL,
          0xd476a1c3461bbed2ULL, 0xaeaed10b762e37abULL,
          0x37deb6af5e9b8b5bULL, 0x4d06c6676eae0222ULL,
          0xc26e573f3ef099a9ULL, 0xb8b627f70ec510d0ULL,
          0xf7e653dcc6da3dd4ULL, 0x8d3e2314f6efb4adULL,
          0x0256b24ca6b12f26ULL, 0x788ec2849684a65fULL,
          0x9cf65a1b368f752eULL, 0xe62e2ad306bafc57ULL,
          0x6946bb8b56e467dcULL, 0x139ecb4366d1eea5ULL,
          0x5ccebf68aecec3a1ULL, 0x2616cfa09efb4ad8ULL,
          0xa97e5ef8cea5d153ULL, 0xd3a62e30fe90582aULL,
          0xb0c7b7e3c7593bd8ULL, 0xca1fc72bf76cb2a1ULL,
          0x45775673a732292aULL, 0x3faf26bb9707a053ULL,
          0x70ff52905f188d57ULL, 0x0a2722586f2d042eULL,
          0x854fb3003f739fa5ULL, 0xff97c3c80f4616dcULL,
          0x1bef5b57af4dc5adULL, 0x61372b9f9f784cd4ULL,
          0xee5fbac7cf26d75fULL, 0x9487ca0fff135e26ULL,
          0xdbd7be24370c7322ULL, 0xa10fceec0739fa5bULL,
          0x2e675fb4576761d0ULL, 0x54bf2f7c6752e8a9ULL,
          0xcdcf48d84fe75459ULL, 0xb71738107fd2dd20ULL,
          0x387fa9482f8c46abULL, 0x42a7d9801fb9cfd2ULL,
          0x0df7adabd7a6e2d6ULL, 0x772fdd63e7936bafULL,
          0xf8474c3bb7cdf024ULL, 0x829f3cf387f8795dULL,
          0x66e7a46c27f3aa2cULL, 0x1c3fd4a417c62355ULL,
          0x935745fc4798b8deULL, 0xe98f353477ad31a7ULL,
          0xa6df411fbfb21ca3ULL, 0xdc0731d78f8795daULL,
          0x536fa08fdfd90e51ULL, 0x29b7d047efec8728ULL,
          };

      };

      uint32_t CRC::GetHash32 (const char* buffer, const size_t size)
      {
        uint32_t uiCRC32 = 0xFFFFFFFF;
        unsigned char *pszData = (unsigned char*)buffer;

        for (size_t i = 0; i<size; ++i)
          uiCRC32 = ((uiCRC32 >> 8) & 0x00FFFFFF) ^ m_CRC32_Table[(uiCRC32 ^ (uint32_t)*pszData++) & 0xFF];

        return (uiCRC32 ^ 0xFFFFFFFF);
      }

      uint64_t CRC::GetHash64 (const char* buffer, const size_t size)
      {
        uint32_t j = 0;
        uint64_t crc = 0;

        for (j = 0; j < size; j++) {
          uint8_t byte = buffer[j];
          crc = m_CRC64_Table[(uint8_t)crc ^ byte] ^ (crc >> 8);
        }
        return crc;
      }

      void CRC::clear (void)
      {
      }

    }//end of namespace Function
  }//end of namespace Hash
}//end of namespace ns3


int 
main (int argc, char *argv[])
{
  LogComponentEnable("TryClassHash", LOG_LEVEL_INFO);

  std::string key ("The quick brown fox jumped over the lazy dogs.");

  Hasher hasher(Create<ns3::Hash::Function::CRC> ());
  uint32_t hash32 = hasher.clear().GetHash32(key);  //对于我们的实现调不调用clear都一样
  uint64_t hash64 = hasher.clear().GetHash64(key);

  NS_LOG_INFO("32bit hash: 0x"  << std::hex << std::setw (8) << hash32 << std::dec);
  NS_LOG_INFO("64bit hash: 0x"  << std::hex << std::setw (16) << hash64 << std::dec);

  Simulator::Run ();
  Simulator::Destroy ();
}

运行得到如下结果：

Waf: Entering directory `/home/rainsia/Applications/ns-allinone-3.29/ns-3.29/build'
[1918/2059] Compiling scratch/try-class-hash.cc
[2019/2059] Linking build/scratch/try-class-hash
Waf: Leaving directory `/home/rainsia/Applications/ns-allinone-3.29/ns-3.29/build'
Build commands will be stored in build/compile_commands.json
'build' finished successfully (12.296s)
32bit hash: 0x999142a1
64bit hash: 0xc417fd9c29ee4733

可见，轻松的实现自己的哈希算法。

到本章为止，NS-3网络仿真的基础部分的知识都已经完全介绍完了。这部分的内容都主要集中在core这个模块中，这个模块是所有NS-3功能的基础。从下一章开始主要介绍NS-3网络建模仿真的基本概念，主要涉及core以外的其他模块，包括network、internet、traffic-control、point-to-point、point-to-point-layout、csma、application、internet-apps等模块，当然也可能涉及到其他的模块。