统计大数据流中每个元素的出现次数

Question

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

我需要计算每个状态字符串出现的次数，以形成直方图。我尝试过使用 Google 的 Sparse Hash Map，但是内存开销太疯狂了。

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

它最终为每个唯一条目的 char* 和 int 以及实际状态字符串本身使用了 323 MB 的空间。但是，任务管理器报告已使用 870M。这是 547M 的开销，或约 251.87 位/条目，远远超过 Google 宣传的大约 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。

我在使用哈希映射时是否做错了什么。或者有没有更好的方法来解决这个问题，因为有了这些字符串，我几乎可以只存储字符串列表，排序，然后计算连续条目。

感谢您的帮助

编辑

因为有人问我，这里是实际数据的格式： 每个组件为 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 个粒子都在半径，则字符串长度为 1004 字节）

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

Answer 1

这些数字来自在 Linux 上使用 gcc 进行的实验。分配 4-22 字节的短块需要 16 字节用于长度从 1 到 12 的长度，24 字节用于 13 到 20 字节，其余的需要 32 字节。

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

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

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