Question

我尝试使用unordered_map，其中的密钥（存储在位集中）是通过Morton编码生成的。当密钥在2 ^ 0-2 ^ 6、2 ^ 3-2 ^ 9（最后3位为零），2 ^ 6-2 ^ 12（最后6位为零）范围内时，我测试了几种情况）和2 ^ 9-2 ^ 15（最后9位为零）。

当我将默认哈希函数用于Visual Studio提供的位集时，一切似乎都很好。在所有情况下，在unordered_map中查找元素的时间都是相同的，并且会随着容器的大小单调增加。

当我尝试减少查找元素的时间时，出现了问题。我使用哈希函数

class my_bitset_hash
{
public:
    size_t operator()(const bitset<64>& key) const
    {
        size_t hashVal = 0;
        hashVal = key.to_ullong();
        return hashVal;
    }
};

键在2 ^ 9-2 ^ 15范围内时查找元素的时间至少比键在2 ^ 0-2 ^ 6范围内时查找元素的时间大两个数量级，即使unorder_map的大小相同。据我所知，如果没有冲突，查找所需的时间应为最低，时间复杂度应为O（1）。此外，与使用默认功能的情况相比，所有情况下都需要更多的时间进行查找。

有人对此有一些想法吗，以及如何为比特集找到一个好的哈希函数？

谢谢

Answer 1

有人对此有一些想法吗，以及如何为比特集找到一个好的哈希函数？

尝试使用其他哈希函数。

如果使用运行时数据创建字典后它仍然是不变的，请尝试强制使用哈希函数种子。

试图最小化冲突的示例：

#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);
}

输出：

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的函数，即查找时间随以下时间而增长：

存储桶数量-更多存储桶会导致更多CPU缓存未命中。
冲突次数-当不同元素最终出现在同一存储桶中时。标准容器存储区是链接列表，因此每次冲突都需要在列表之后跟随下一个元素，这是潜在的CPU缓存未命中。和另一个关键比较。
具有哈希功能的CPU时间。

您还可以尝试使用不同的哈希表，例如skarupke::flat_hash_map和C++Now 2018: You Can Do Better than std::unordered_map: New Improvements to Hash Table Performance，这些哈希表不使用链接列表来解决冲突，通常可以提供最佳性能。

请注意，哈希表的性能在很大程度上取决于键，哈希函数和大小，因此通用基准测试可能无法反映您特定工作负载上的性能。您需要根据实际工作量/数据集对它进行基准测试。

如何为位集查找/实现良好的哈希函数

1 个答案: