我有一个模拟，有 N 个粒子，运行 T 个时间步长。在每个时间步，每个粒子都会计算一些关于自身和附近(半径内)其他粒子的数据，这些数据被打包成一个 4-22 字节长的 c 字符串(取决于附近有多少粒子)。我称之为状态字符串。

我需要计算每个状态字符串出现的次数，以形成直方图。我试过使用 Google 的稀疏 HashMap ，但内存开销太高了。

我一直在为 500 个粒子运行超过 100,000 个时间步的一些精简测试(已附上)。这导致在 5000 万个可能的状态字符串中超过 1820 万个唯一状态字符串，这与需要完成的实际工作一致。

它最终使用 323 MB 的空间来存储每个唯一条目的 char* 和 int 以及实际状态字符串本身。但是，任务管理器报告已使用 870M。这是 547M 的开销，或 ~251.87 位/条目，远远超过谷歌宣传的大约 4-5 位。

所以我认为我一定是做错了什么。但后来我发现了这个 site ，它显示了类似的结果，但是，我不确定他的图表是否只显示哈希表大小，或者也包括实际数据的大小。此外，他的代码不会释放任何插入到已经存在的 HashMap 中的字符串(这意味着如果他的图表确实包含实际数据的大小，它就会结束)。

这是一些显示输出问题的代码:

#include <google/sparse_hash_map>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

//String equality
struct eqstrc
{
    bool operator()(const char* s1, const char* s2) const
    {
        return (s1 == s2) || (s1 && s2 && !strcmp(s1,s2));
    }   
};

//Hashing function
template <class T>
class fnv1Hash
{
public:
    size_t operator()(const T& c) const {
            unsigned int hash = 2166136261;
            const unsigned char *key = (const unsigned char*)(c);
            size_t L = strlen((const char*)c);
            size_t i = 0;
            for(const unsigned char *s = key; i < L; ++s, ++i)
                hash = (16777619 * hash) ^ (*s);
            return (size_t)hash;
    }
};

//Function to form new string
char * new_string_from_integer(int num)
{
    int ndigits = num == 0 ? 1 : (int)log10((float)num) + 1;
    char * str = (char *)malloc(ndigits + 1);
    sprintf(str, "%d", num);
    return str;
}

typedef google::sparse_hash_map<const char*, int, fnv1Hash<const char*>, eqstrc> HashCharMap;


int main()
{
    HashCharMap hashMapChar;
    int N = 500;
    int T = 100000;
    
    //Fill hash table with strings
    for(int k = 0; k < T; ++k)
    {
        for(int i = 0; i < N; ++i)
        {
            char * newString = new_string_from_integer(i*k);
            std::pair<HashCharMap::iterator, bool> res =  hashMapChar.insert(HashCharMap::value_type(newString, HashCharMap::data_type()));
            (res.first)->second++;

            if(res.second == false) //If the string already in hash map, don't need this memory
                free(newString);
        }
    }

    //Count memory used by key 
    size_t dataCount = 0;
    for(HashCharMap::iterator hashCharItr = hashMapChar.begin(); hashCharItr != hashMapChar.end(); ++hashCharItr)
    {
        dataCount += sizeof(char*) + sizeof(unsigned int); //Size of data to store entries
        dataCount += (((strlen(hashCharItr->first) + 1) + 3) & ~0x03); //Size of entries, padded to 4 byte boundaries
    }
    printf("Hash Map Size: %lu\n", (unsigned long)hashMapChar.size());
    printf("Bytes written: %lu\n", (unsigned long)dataCount);

    system("pause");
}

输出

Hash Map Size: 18218975
Bytes written: 339018772
Peak Working Set (Reported by TaskManager): 891,228 K
Overhead: 560,155 K, or 251.87 bits/entry

我已经尝试过 Google Sparse Hash Map v1.10 和 v2.0.2。

我在使用 HashMap 时做错了什么吗？或者有没有更好的方法来解决这个问题，因为有了这些字符串，我几乎可以只存储字符串列表、排序，然后对连续的条目进行计数。

感谢您的帮助

编辑

因为有人问我，这里是实际数据的格式: 每个组件是 2 个字节，分为两个子部分。 12 位和 4 位。

• 前两个字节(短):[当前粒子的id(12位)|的角度 当前粒子(4 位)]
• 第二个短:[互动次数 粒子(12 位)(N) |当前粒子的先前角度(4 位)]
• 对于接下来的 N 条短裤:[第 i 个粒子的 id(12 位)|粒子i的先前角度(4位)]

角度是近似值(除以 16)，以 4 位存储。

说的有点啰嗦，我写个例子:

0x120A 0x001B 0x136F = 粒子 288 (0x120)，角度 10 (0xA)。在上一个时间步中有角度 11 (0xB)。与 1 (0x001) 个其他粒子交互。这另一个粒子是粒子 310 (0x136)，在之前的时间步长中有 15 个角度 (0xF)。

粒子与 0 到 9 个其他粒子相互作用，因此我上面提到的 4-22 个字节(尽管很少，可以与多达 12 个或更多其他粒子相互作用。没有限制。如果所有 500 个粒子都在radius，则字符串长度为 1004 字节)

附加信息:我实际代码中的哈希函数和比较函数使用存储在第二个 short 的最高有效 12 位中的大小来进行处理，因为非终结符 0x0000s 可以出现在我的状态字符串中。一切正常。

最佳答案

这些数字来自 Linux 上的 gcc 实验。分配 4-22 字节的短 block 需要 16 字节用于 1-12 的长度，24 字节用于 13-20 和 32 字节用于其余部分。

这意味着您对 18218975 个字符串(“0”..“50000000”)的实验需要堆上 291503600 个字节，它们的长度总和(加上尾随 0)为 156681483。

因此，仅仅由于 malloc，您就有 135MB 的开销。

(这个峰值工作集大小是一个可靠的数字吗？)

关于c++ - 统计大数据流中每个元素出现的次数，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/24186015/