我正在将10GB文件加载到内存中,我发现即使我剥离了任何额外的开销并将数据存储在一个数组中,它仍然需要53 GB的内存.这对我来说似乎很疯狂,因为我将一些文本数据转换为longs,占用较少的空间并将其余部分转换为char*,这将占用与文本文件相同的空间量.我正在尝试加载的文件中有大约150M行数据.当我按照下面的方式加载它时,有什么理由可以占用这么多内存吗？

这里有三个文件,一个fileLoader类及其头文件和一个只运行它们的main.回答一些问题:操作系统是UBUNTU 12.04 64位这是一个64GB内存和SSD高清,我为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 …

附加的,简单的测试程序测试清空一个简单的std :: map的性能.使用MSVC 2008和2010,从命令提示符执行调试构建将花费<30秒,但在调试器中执行时将花费大约3分钟.对clear()的调用完全是对差异的责任.如果我进入调试器,callstack将始终指向HeapFree.
问题:为什么巨大差异？我可以以某种方式更改调试堆设置,以便在调试器中执行时会很快吗？

#include <map>

int
main ( int, char )
{
    std::map< time_t, double > test;
    for ( int i = 0; i < 1000000; ++i )
    {
        test[i] = i / 3.14;
    }
    test.clear();
    return 0;
}

我想了解为什么动态分配多次调用的数据使用的内存比在代码上直接指定的内存或通过单次调用分配的那样多malloc.

例子

例如,我在C中制作了以下两个代码:

test1.c:int x分配有malloc

int main (void)
{
    int *x;
    int i, n=1048576; //n=1024*1024;

    printf("size = %lu\n", n* sizeof(int));

    for(i=0; i<n; i++)
    {
        x = malloc(sizeof(int));
        *x=i;
    }
    printf("Look at top and then press something to finish.");fflush(stdout);
    getc(stdin);
    return 0;
}

我没有在这里免费使用它来保持简单.当程序等待交互时,我查看另一个终端中的top函数,它显示了这个:

PID  USER   PR  NI  VIRT   RES    SHR  S  %CPU %MEM  TIME+   COMMAND                                    
1384 root   20  0   41300  34076  1300 S  0.0  3.3   0:00.47 test1

test2.c:int x未动态分配

int main (void)
{ …

人们似乎在使用数组时会说malloc是如此之大,如果你不知道数组在编译时有多少元素(？),你可以使用它.好吧,没有malloc,你不能这样做吗？例如,如果我们知道我们有一个字符串,其最大长度为10,那么以下内容是否足够接近同一个东西？...除了能够释放内存之外.

char name[sizeof(char)*10]; 

和

char *name = malloc(sizeof(char)*10); 

我期望以下代码段使用来为五个成员分配内存calloc。

$ cat calloc.c
// C program to demonstrate the use of calloc() 
// and malloc() 
#include <stdio.h> 
#include <stdlib.h> 

int main() 
{ 
  int *arr; 
  arr = (int *)calloc(5, sizeof(int)); 
  printf("%x\n", *arr);
  printf("%x\n", *(arr+1));
  printf("%x\n", *(arr+2));
  printf("%x\n", *(arr+3));
  printf("%x\n", *(arr+4));
  printf("%x\n", *(arr+5));
  printf("%x\n", *(arr+6));
  // Deallocates memory previously allocated by calloc() function 
  free(arr); 

  return(0); 
} 

但是它似乎分配了五个以上的空间。它分配了六个成员，为什么呢？

./a.out 
0
0
0
0
0
0
411