哈希一个32位整数比对3个16位整数进行哈希运算要慢？

Question

我正在研究对延迟敏感的软件。 今天，我决定通过在联合体内使用BitField结构来使结构更小，并读取该BitField结构为整数，并将其用作哈希函数的唯一键。 我期望从我对唯一键的哈希中获得的性能略好于（如果不是很多的话），比对类的属性的哈希按位操作获得更好的性能，但是事实证明，执行按位操作以获取哈希键要快得多吗？ 我一直在试图找出原因，但是我无法得出任何结论。

这是我的代码： http : //quick-bench.com/OkNuVOxdVtW8g7OWUXjqcvYlNrs

#include <functional>

struct GroupTupleInformation {
  unsigned int src : 12;
  unsigned int dst : 12;
  unsigned int flow_id : 8;
};

union GroupTupleData {
  GroupTupleInformation info;
  uint32_t hash_key;
};

struct GroupTuple {
  constexpr void setSrc(uint16_t s) noexcept { data.info.src = s; }

  constexpr uint16_t getSrc() const noexcept { return data.info.src; }

  constexpr void setDst(uint16_t d) noexcept { data.info.dst = d; }

  constexpr uint16_t getDst() const noexcept { return data.info.dst; }

  constexpr void setFlowId(uint8_t f) noexcept { data.info.flow_id = f; }

  constexpr uint8_t getFlowId() const noexcept { return data.info.flow_id; }

  constexpr uint32_t getHashKey() const noexcept { return data.hash_key; }

 private:
  GroupTupleData data;
};

struct UnionHashFn {
  constexpr std::size_t operator()(const GroupTuple& gtup) const noexcept {
    return gtup.getHashKey();
  }
};

struct CombinedHashFn {
  std::size_t operator()(const GroupTuple& gtup) const noexcept {
    std::hash<uint16_t> hasher{};
    return hasher(gtup.getSrc()) ^ hasher(gtup.getDst()) ^
           hasher(gtup.getFlowId());
  }
};


static void UnionHashFnBench(benchmark::State& state) {
  unsigned long i = 0;
  UnionHashFn hasher;
  GroupTuple group_tuple;

  size_t key = 0;
  for (auto _ : state) {
    group_tuple.setSrc(i++ % 32);
    group_tuple.setDst(i++ % 32);
    group_tuple.setFlowId(i++ % 32);
    key = hasher(group_tuple);
    benchmark::DoNotOptimize(key);
  }
}
BENCHMARK(UnionHashFnBench);

static void CombinedHashFnBench(benchmark::State& state) {
  unsigned long i = 0;
  CombinedHashFn hasher;
  GroupTuple group_tuple;

  size_t key = 0;
  for (auto _ : state) {
    group_tuple.setSrc(i++ % 32);
    group_tuple.setDst(i++ % 32);
    group_tuple.setFlowId(i++ % 32);
    key = hasher(group_tuple);
    benchmark::DoNotOptimize(key);
  }
}
BENCHMARK(CombinedHashFnBench);

PS：我知道对基准图或unordered_map进行基准测试要比对散列函数的基准进行基准测试更为复杂，而且我也知道我为从类中获取散列所做的按位操作不是获取散列的好方法，这只是为了有一个简单的例子

Answer 1

std::hash<uint16_t>只是身份（说实话，这是有问题的），因此表达式：

hasher(gtup.getSrc()) ^ hasher(gtup.getDst()) ^ hasher(gtup.getFlowId())

将被优化为一个非常简单的表达式。 它的代码是：

   lea    -0x2(%rax),%ecx
   lea    -0x1(%rax),%edx
   xor    %ecx,%edx
   xor    %eax,%edx
   and    $0x1f,%edx

另一方面，计算hash_key需要付出更多努力：

   mov    %edx,%esi
   and    $0x1f,%esi
   mov    %ecx,%edi
   and    $0x1f000,%edi
   or     %rsi,%rdi
   add    $0x3,%rdx
   mov    %eax,%esi
   and    $0x1f000000,%esi
   or     %rdi,%rsi

因此， hash_key方法较慢并不奇怪。