记一次离谱的unordered_map性能退化

问题背景

在一次处理大规模数据时，发现内存和CPU占用率高，程序运行异常耗时，经Vs性能分析工具分析，发现某个函数中，一个unordered_map的find函数居然耗时占用了20%多，unordered_map中存储的数据大约100万个。

问题分析

unordered_map底层实现为hashtable，而一般情况下哈希表的查找为O(1)，这明显和直觉相悖。STL之(哈希表)hashtable

• 猜想一
  哈希表撞车，如果哈希函数导致哈希疯狂撞车，极端情况下哈希表将退化成链表，查找变为O(n)，经查看hash函数如下，直观看上去这个哈希函数还挺复杂的，看起来并不会造成撞车。

template<>
struct std::hash<MyStruct>
{
    size_t operator()(const MyStruct& st) const
    {
        return ((st.x << 16) + st.y);
    }
};

• 猜想二
  程序运行时内存和cpu都比较吃紧，由于次案例中哈希表是随机访问，可能是频繁的缓存不命中(cache miss)和缺页中断造成的[cache miss经典实例]，stackoverflow上也有一篇关于hash table性能退化的帖子：

[c - Why does my program slow down on increasing the size of my hashtable - Stack Overflow]

问题验证

• 换更大内存的机器测试，不存在内存问题，find函数仍然占用很高的cpu时间。
• 将unordered_map 换成map ，find效率急剧提升，cpu占比变得很小。
• 对unordered_map 和map进行了一些基本测试。创建不同大小的map，并对每个元素执行一次find， 可以看出，hashtable中存储MyStruct时，性能表现得异常的离谱了。

unordered_map元素分布

在插入元素过程中，输出unordered_map的桶和桶内元素等信息，可以发现，容器一直在扩容，输出桶的增长过程

unordered_map桶增长函数如下：

   _NODISCARD size_type _Desired_grow_bucket_count(const size_type _For_size) const noexcept {
        const size_type _Old_buckets = bucket_count();
        const size_type _Req_buckets = (_STD max) (_Min_buckets, _Min_load_factor_buckets(_For_size));
        if (_Old_buckets >= _Req_buckets) {
            // we already have enough buckets so there's no need to change the count
            return _Old_buckets;
        }

        if (_Old_buckets < 512 && _Old_buckets * 8 >= _Req_buckets) {
            // if we are changing the bucket count and have less than 512 buckets, use 8x more buckets
            return _Old_buckets * 8;
        }

        // power of 2 invariant means this will result in at least 2*_Old_buckets after round up in _Forced_rehash
        return _Req_buckets;
    }

输出size不为0的桶

至此，哈希表的性能内鬼一目了然，我们的哈希函数居然离谱的把元素塞到了少数几个桶里面，整个哈希表退化成几条链表。根本原因是桶的数量是2^N ，而哈希函数前半部分base<<16， 在计算hash值定位桶的位置时，是将hash值对桶的数量取余(%)，因此哈希函数前半部分完美的失效了，MyStruct的y值刚好变化范围较小，所以数据最终只落到了少数几个桶之中。

解决方案

• 直接用map
• 修改hash函数： 整数对哈希函数1， 整数对哈希函数2

总结

• 有时候直觉是不准确的
• 数据结构和算法有时候还是有点用处

附unordered_map测试代码：

#include <iostream>
#include <unordered_map>
#include <map>
#include <chrono>

struct MyStruct
{
    int x;
    int y;
};

template<>
struct std::hash<MyStruct>
{
    size_t operator()(const MyStruct& st) const
    {
        return ((st.x << 16) + st.y);
    }
};

bool operator ==(const MyStruct& st1, const MyStruct& st2)
{
    return st1.x == st2.x && st1.y == st2.y;
}

bool operator < (const MyStruct& st1, const MyStruct& st2)
{
    if (st1.x == st2.x) {
        return st1.y < st2.y;
    }
    else {
        return st1.x < st2.x;
    }
}

int main()
{
    std::unordered_map<MyStruct, int> testMap;
    
    for (int i = 0; i < 10000; i++) {
        MyStruct st{ i, i%4 };
        testMap.insert(std::make_pair(st,i));
    }

    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < 10000; i++) {
        MyStruct st{ i, i%4 };
        auto iter = testMap.find(st);
    }

    auto end = std::chrono::high_resolution_clock::now();
    auto cost = std::chrono::duration_cast<std::chrono::microseconds>(end - start)/1000.0;
    std::cout << "find tiem cost: " << cost.count() << std::endl;

    size_t size = testMap.bucket_count();
    std::cout << "bucket count: " << size << std::endl;

    for (int i = 0; i < size; i++) {
        if (testMap.bucket_size(i) > 0) {
            std::cout << "bucket " << i << " size: " << testMap.bucket_size(i) << std::endl;
        }      
    }
    return 1;
}