[英]how to find/implement a good hash function for bitset
我正在尝试使用 unordered_map,其中密钥(存储在 bitset 中)由 Morton 编码生成。 我测试了几种情况,密钥在 2^0-2^6、2^3-2^9(最后 3 位为零)、2^6-2^12(最后 6 位为零)范围内) 和 2^9-2^15 (最后 9 位为零)。
当我将默认的 hash function 用于 Visual Studio 提供的 bitset 时,一切似乎都很好。 对于所有情况,在 unordered_map 中查找元素的时间是相同的,并且随着容器的大小单调增加。
当我试图减少查找元素的时间时,出现了问题。 我使用 hash function
class my_bitset_hash
{
public:
size_t operator()(const bitset<64>& key) const
{
size_t hashVal = 0;
hashVal = key.to_ullong();
return hashVal;
}
};
key 在 2^9-2^15 范围内查找元素的时间至少比 key 在 2^0-2^6 范围内的时间长两个数量级,即使unorder_map 的大小是相同的。 据我所知,如果没有碰撞,查找的时间消耗应该是最低的,时间复杂度应该是 O(1)。 此外,与使用默认 function 的案例相比,所有案例都需要更多时间进行查找。
有没有人对此有一些想法以及如何为位集找到一个好的 hash function?
谢谢
有没有人对此有一些想法以及如何为位集找到一个好的 hash function?
尝试不同的 hash 功能。
如果您的字典在使用运行时数据创建后保持不变,请尝试强制使用 hash function 种子。
试图最小化碰撞的示例:
#include <unordered_set>
#include <iostream>
#include <cmath>
struct Stats {
static int constexpr BINS = 8;
size_t size = 0;
size_t buckets = 0;
double load_pct = 0;
double collision_pct = 0;
unsigned collisions[BINS] = {};
};
std::ostream& operator<<(std::ostream& o, Stats const s) {
o << "size: " << s.size << ", ";
o << "buckets: " << s.buckets << ", ";
o << "load: " << std::round(s.load_pct) << "%, ";
o << "collisions: " << std::round(s.collision_pct) << "% [";
for(auto const& bin : s.collisions)
o << bin << ',';
return o << "]\n";
}
template<class C>
Stats stats(C const& c) {
Stats s;
s.size = c.size();
s.buckets = c.bucket_count();
s.load_pct = 100. * c.size() / c.bucket_count();
size_t collisions = 0;
for(auto bucket_idx = c.bucket_count(); bucket_idx--;) {
auto elements_in_bucket = std::distance(c.begin(bucket_idx), c.end(bucket_idx));
if(elements_in_bucket > 1) {
++collisions;
++s.collisions[std::min<unsigned>(Stats::BINS - 1, elements_in_bucket - 2)];
}
}
s.collision_pct = 100. * collisions / c.size();
return s;
}
// https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
struct Fnv1a32 {
static constexpr unsigned BASIS = 16777619;
static constexpr unsigned PRIME = 2166136261;
unsigned const state_;
static constexpr unsigned hash(void const* key, size_t len, unsigned state) noexcept {
unsigned char const* p = static_cast<unsigned char const*>(key);
unsigned char const* const e = p + len;
for(; p < e; ++p)
state = (state ^ *p) * PRIME;
return state;
}
public:
constexpr Fnv1a32(unsigned seed = 0)
: state_(seed ? hash(&seed, sizeof seed, BASIS) : BASIS)
{}
template<class T>
std::enable_if_t<std::is_integral<T>::value, unsigned> operator()(T key) const {
return hash(&key, sizeof key, state_);
}
};
int main() {
// Using std::hash.
std::unordered_set<unsigned> s;
for(unsigned n = 1000; n--;)
s.insert(static_cast<unsigned>(std::rand()) << 6);
std::cout << "std::hash: " << stats(s);
// Using Fnv1a32.
std::unordered_set<unsigned, Fnv1a32> s2(s.bucket_count());
s2.insert(s.begin(), s.end());
std::cout << "Fnv1a32: " << stats(s2);
// Brute-force Fnv1a32 seed.
double best_collision_pct = std::numeric_limits<double>::infinity();
unsigned best_seed = 0;
for(unsigned seed = 0; seed < 10000; ++seed) {
std::unordered_set<unsigned, Fnv1a32> s3(s2.bucket_count(), Fnv1a32{seed});
s3.insert(s2.begin(), s2.end());
auto const stats3 = stats(s3);
if(stats3.collision_pct < best_collision_pct) {
best_collision_pct = stats3.collision_pct;
best_seed = seed;
}
}
// Using Fnv1a32 with the best seed.
std::unordered_set<unsigned, Fnv1a32> s4(s2.bucket_count(), Fnv1a32{best_seed});
s4.insert(s2.begin(), s2.end());
std::cout << "Fnv1a32 best: " << stats(s4);
}
Output:
std::hash: size: 1000, buckets: 1493, load: 67%, collisions: 21% [152,46,6,1,0,0,0,0,]
Fnv1a32: size: 1000, buckets: 1613, load: 62%, collisions: 21% [177,29,3,1,0,0,0,0,]
Fnv1a32 best: size: 1000, buckets: 1741, load: 57%, collisions: 17% [135,24,5,1,0,0,0,0,]
您可能希望以类似方式最小化的另一个指标是查找时间。
对于std::unordered_set
和std::unordered_map
,查找时间可能是α*buckets + β*collisions + γ*hashtime
的 function ,即查找时间随着:
您还可以尝试不同的哈希表,例如skarupke::flat_hash_map
和C++Now 2018: You Can Do Better than std::unordered_map: New Improvements to Hash Table Performance ,它不使用链接列表来解决冲突,并且通常提供最佳性能。
请注意,哈希表性能很大程度上取决于键 hash function 和大小,因此通用基准测试可能无法反映特定工作负载的性能。 您需要根据您的实际工作负载/数据集对其进行基准测试。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.