大文件上的c ++疯狂内存消耗答案

【问题标题】：c++ insane memory consumption on large file大文件上的c ++疯狂内存消耗
【发布时间】：2014-07-31 18:09:53
【问题描述】：

我正在将一个 10GB 的文件加载到内存中，我发现即使我去掉任何额外的开销并将数据存储在一个数组中，它仍然占用 53GB 的内存。这对我来说似乎很疯狂，因为我正在将一些文本数据转换为占用较少空间的 long，并将其余的转换为 char *，它应该占用与文本文件相同的空间。我要加载的文件中有大约 150M 行数据。当我按照下面的方式加载它时，有什么理由会占用这么多内存吗？

这里有三个文件，一个 fileLoader 类及其头文件和一个简单地运行它们的 main。回答一些问题：操作系统是 UBUNTU 12.04 64bit 这是在具有 64GB RAM 和 SSD hd 的机器上，我为 RAM 提供了 64GB 交换空间由于需要速度，我一次加载所有数据。这对应用程序至关重要。所有排序、索引和大量数据密集型工作都在 GPU 上运行。另一个原因是一次加载所有数据使我编写代码变得更加简单。例如，我不必担心索引文件以及到另一个文件中位置的映射。

这是头文件：

#ifndef FILELOADER_H_
#define FILELOADER_H_
#include <iostream>
#include <fstream>

#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <string>

class fileLoader {
public:
    fileLoader();
    virtual ~fileLoader();
    void loadFile();
private:
    long long ** longs;
    char *** chars;
    long count;
    long countLines(std::string inFile);
};


#endif /* FILELOADER_H_ */

这是 CPP 文件

#include "fileLoader.h"



fileLoader::fileLoader() {
    // TODO Auto-generated constructor stub
    this->longs = NULL;
    this->chars = NULL;
}

char ** split(char * line,const char * delim,int size){
    char ** val = new char * [size];


    int i = 0;
    bool parse = true;
    char * curVal = strsep(&line,delim);
    while(parse){


        if(curVal != NULL){
            val[i] = curVal;
            i++;
            curVal = strsep(&line,delim);
        }else{
            parse = false;
        }

    }

    return val;
}

void fileLoader::loadFile(){
    const char * fileName = "/blazing/final/tasteslikevictory";

    std::string fileString(fileName);
    //-1 since theres a header row and we are skipinig it
    this->count = countLines(fileString) -1;

    this->longs = new long long*[this->count];
    this->chars = new char **[this->count];
    std::ifstream inFile;

    inFile.open(fileName);
    if(inFile.is_open()){
        std::string line;
        int i =0;
        getline(inFile,line);
        while(getline(inFile,line)){
            this->longs[i] = new long long[6];
            this->chars[i] = new char *[7];
            char * copy = strdup(line.c_str());
            char ** splitValues = split(copy,"|",13);

            this->longs[i][0] = atoll(splitValues[4]);
            this->longs[i][1] = atoll(splitValues[5]);
            this->longs[i][2] = atoll(splitValues[6]);
            this->longs[i][3] = atoll(splitValues[7]);
            this->longs[i][4] = atoll(splitValues[11]);
            this->longs[i][5] = atoll(splitValues[12]);

            this->chars[i][0] = strdup(splitValues[0]);
            this->chars[i][1] = strdup(splitValues[1]);
            this->chars[i][2] = strdup(splitValues[2]);
            this->chars[i][3] = strdup(splitValues[3]);
            this->chars[i][4] = strdup(splitValues[8]);
            this->chars[i][5] = strdup(splitValues[9]);
            this->chars[i][6] = strdup(splitValues[10]);
            i++;
            delete[] splitValues;
            free(copy);
        }
    }
}

fileLoader::~fileLoader() {
    // TODO Auto-generated destructor stub
    if(this->longs != NULL){
        delete[] this->longs;
    }

    if(this->chars != NULL){
        for(int i =0; i <this->count;i++ ){
            free(this->chars[i]);
        }
        delete[] this->chars;
    }

}

long fileLoader::countLines(std::string inFile){
    int BUFFER_SIZE = 16*1024;
    int fd = open(inFile.c_str(), O_RDONLY);
    if(fd == -1)
    return 0;

    /* Advise the kernel of our access pattern.  */
    posix_fadvise(fd, 0, 0, 1);  // FDADVICE_SEQUENTIAL

    char buf[BUFFER_SIZE + 1];
    long lines = 0;

    while(size_t bytes_read = read(fd, buf, BUFFER_SIZE))
    {
    if(bytes_read == (size_t)-1)
        return 0;
    if (!bytes_read)
        break;

    for(char *p = buf; (p = (char*) memchr(p, '\n', (buf + bytes_read) - p)); ++p)
        ++lines;
    }

    return lines;

}

这是我的主要功能的文件：

#include "fileLoader.h"

int main()
{

fileLoader loader;
loader.loadFile();
return 0;
}

这是我正在加载的数据的示例：

13|0|1|1997|113|1|4|12408012|C9FF921CA04ADA3D606BF6DAC4A0B092|SEMANAL|66C5E828DC69F857ADE060B8062C923E|113|1
14|0|1|1997|113|1|5|12408012|C9FF921CA04ADA3D606BF6DAC4A0B092|SEMANAL|66C5E828DC69F857ADE060B8062C923E|113|1
15|0|1|1997|113|1|6|12408012|C9FF921CA04ADA3D606BF6DAC4A0B092|SEMANAL|66C5E828DC69F857ADE060B8062C923E|113|1
16|0|1|1997|113|1|7|12408012|C9FF921CA04ADA3D606BF6DAC4A0B092|SEMANAL|66C5E828DC69F857ADE060B8062C923E|113|1
17|0|1|1997|113|1|8|12408012|C9FF921CA04ADA3D606BF6DAC4A0B092|SEMANAL|66C5E828DC69F857ADE060B8062C923E|113|1
18|0|1|1997|113|1|9|12408012|C9FF921CA04ADA3D606BF6DAC4A0B092|SEMANAL|66C5E828DC69F857ADE060B8062C923E|113|1
19|0|1|1997|113|1|10|12408012|C9FF921CA04ADA3D606BF6DAC4A0B092|SEMANAL|66C5E828DC69F857ADE060B8062C923E|113|1
20|0|1|1997|113|1|11|12408012|C9FF921CA04ADA3D606BF6DAC4A0B092|SEMANAL|66C5E828DC69F857ADE060B8062C923E|113|1
21|0|1|1997|113|1|12|12408012|C9FF921CA04ADA3D606BF6DAC4A0B092|SEMANAL|66C5E828DC69F857ADE060B8062C923E|113|1
9|0|1|1997|113|1|13|12408012|C9FF921CA04ADA3D606BF6DAC4A0B092|SEMANAL|66C5E828DC69F857ADE060B8062C923E|113|1
27|0|1|1992|125|1|1|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
28|0|1|1992|125|1|2|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
29|0|1|1992|125|1|3|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
30|0|1|1992|125|1|4|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
31|0|1|1992|125|1|5|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
32|0|1|1992|125|1|6|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
33|0|1|1992|125|1|7|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
34|0|1|1992|125|1|8|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
35|0|1|1992|125|1|9|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
36|0|1|1992|125|1|10|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
37|0|1|1992|125|1|11|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
38|0|1|1992|125|1|12|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
39|0|1|1992|125|1|13|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
40|0|1|1992|125|1|14|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
41|0|1|1992|125|1|15|10183|9EF534D2CF74B24AC28CBD9BE937A412|SEMANAL|375CCE505F5353CCDE85D4E84A9888D8|125|1
10|0|1|1996|126|1|1||||||

【问题讨论】：

你如何衡量你的内存消耗？
使用 htop 我还没有使用任何内存管理工具。我对 C++ 很陌生，我是一名 Java 开发人员。所以我只看到消耗了多少内存，但是当我加载数据时峰值从 2GB 到 56GB。
为什么将 10GB 加载到内存中 - 我认为这不是真的。有很多更好的数据处理方法
你有 53gb 的内存吗？
64GB 交换加上 64GB 内存。 Ed 我已经将它加载到内存中，因为我可以通过这种方式非常快速地对其进行索引，这使我可以对数据做我需要做的事情。加入不同的数据集，然后根据数据和目标创建归纳决策树。只要我只坚持数字，我就可以让它工作，尽管我最终使用了大约 64GB 的 RAN 和另外 20GB 的交换空间来处理我当前的数据集。我需要开始分析 char *，这将比我在这个钻机上处理的要大。

标签： c++ memory memory-management memory-leaks ubuntu-12.04

【解决方案1】：

您为每一行分配了九块内存，因此您总共分配了 13.5 亿块内存。这些分配有一定的开销，通常至少是指针大小的两倍，甚至可能更多。在 64 位机器上，这已经是 16 字节，因此您会得到 21.6 GB 的开销。

除此之外，您还会获得堆碎片和对齐的开销：即使您只在其中存储了一个字符串，分配器也必须对齐内存分配，以便您可以在其中存储最大可能的值而不会触发错位。对齐方式可能取决于 CPU 的矢量单元，这可能需要非常重要的对齐方式，16 字节对齐并不少见。

使用 16 字节分配开销和 16 字节对齐进行计算，我们得到 43.2 GB 的分配没有原始数据。使用原始数据，此计算已经非常接近您的测量值。

【讨论】：

谢谢！我想我知道为什么会这样，以及我可以采取哪些措施来改善内存消耗（例如，将所有字符存储在一起）。所以最大的问题就像别人说的那样。进行大量小分配是不好的。
+1 我数了10，但我开始头晕，所以我可能重复数了一些东西。

【解决方案2】：

您创建的每个对象和字符串都有单独的内存管理开销。因此，您从第 2 列加载字符串“0”，具体取决于您的内存管理器，它可能需要两到四个完整的单词（可能更多）。将其称为 16 到 32 字节的存储空间来保存一个字节的字符串。然后从第 3 列加载“1”。依此类推。

【讨论】：

这似乎有很多开销让我直截了当。所以我存储的每个 char * 和每一行 long 值都有一个 8 字节指针，除了数据之外我还必须存储。在我看来，我只需要 56 字节的字符和 8 字节的长度。所以那将是 9.6GB，不是吗？
是的。分配非常多非常小的对象是非常浪费的。看看stackoverflow.com/questions/13064850/…中的第一个答案。
考虑定义一个结构，该结构在文件中的每一列都有一个字段，并将数据存储为这些结构的向量。并且使用char[n] 而不是动态分配的char* 用于其值将始终保持相同长度的字符串列。
你能快速解释一下为什么定义一个结构来封装这些数据可能比这些公认的非常愚蠢的巨大数组更有效吗？我制作数组是因为我实际上认为它们会比我实现的包含它的类消耗更少的内存。
定义结构只有在您可以定义其中的字符串的存储空间时才会有所帮助（因此每个字符串必须具有已知的最大长度）。如果你这样做，你只为每一行分配一个大的“对象”，因此几个单词（或者可能只是四舍五入到 16 字节边界）的开销变得更少。