c ++读取文件并将整数存储在向量中。最终占用的内存比实际文件大小多 5 倍

Question

我需要读取几个输入文件（每个文件都包含一个二维整数矩阵）并将它们存储在一个二维向量向量中。下面是我写的代码：

int main(int argc, char *argv[]) {
  /*
    int my_rank;
    int p;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
    MPI_Comm_size(MPI_COMM_WORLD, &p);
  */

  std::vector<std::vector<std::vector<int > > > matrices(argc);
  for(int i=1; i<argc; ++i){
      std::string line;
      std::ifstream fp(argv[i]);
      std::vector<std::vector<int> > matrix;

      if (fp.is_open()) {
          while (getline(fp, line)) {
              if(line!=""){
                  //add a new row to file
                  std::vector<int> newRow;
                  //parse each row put the values in the file buffer
                  std::stringstream buff(line);
                  //buffValue is each number in a row
                  int buffValue;
                  while (buff >> buffValue) {
                      newRow.push_back(buffValue);
                  }
                  matrix.push_back(newRow);
              }
          }
      }
      else {
          std::cout << "Failed to read files" << std::endl;
      }
     matrices.push_back(matrix);
  }
  //MPI_Finalize();
  return 0;
}

我这里有两个问题：

当我读取一个 175M 的文件时，程序最终占用了 900M 的常驻内存。这是一个问题，因为我通常需要读入 4 个文件，每个文件有几百 M。它最终会占用多个 G 的内存。这是因为我 read/store 整数的方式吗？
如果我取消注释涉及 MPI 的行，常驻内存使用量会上升到 1.7G，这是正常的还是我这里做错了什么，我正在使用 MPICH。

Answer 1

Vector-of-vector-of-vector 不是一个有效的结构。您有向量类本身的内存开销，加上 push_back.

的标准行为

一个vector在push_back之后需要调整大小时，内存会呈指数增长，以满足时间复杂度要求。如果您的矢量容量当前为 10 个值，并且您添加 11 个值，那么它很可能会将其容量调整为 20 个值。

这种增长的一个副作用是潜在的内存碎片。向量内存被定义为连续的。标准分配器没有 realloc 能力，就像在 C 中一样。因此，它们必须在别处分配更多内存、移动数据并释放旧存储。这会在内存中留下漏洞，您的程序无法将其用于其他任何用途。更不用说减少数据的缓存位置，从而导致性能不佳。

你最好为你的矩阵创建一个内存效率更高的二维结构，然后将它们推到 deque 而不是 vector。 Here's one I prepared earlier ;)。至少，如果您必须对矩阵使用向量向量，则使用 vector::reserve.

预分配它

如果内存对您来说比I/O更重要，那么读取文件两次也不是不可能的。第一次，您获得有关矩阵大小和行长度的信息。然后你预先分配你所有的结构，并再次读取文件。

否则，使用某种临时池来存储矩阵的值是可以接受的：

std::deque< std::vector< std::vector< int > > > matrices;
std::vector< size_t > columns;  // number of columns, indexed by row
std::vector< int > values;      // all values in matrix

columns.reserve( 1000 );   // Guess a reasonable row count to begin with
values.reserve( 1000000 ); // Guess reasonable value count to begin with

while( getline(fp, line) ) {
    if( line.empty() ) {
        AddMatrix( matrices, columns, values );
    } else {
        std::istringstream iss( line );
        size_t count = 0;
        for( int val; iss >> val; ) {
            values.push_back( val );
            count++;
        }
        columns.push_back( count );
    }
}

// In case last line in file was not empty, add the last matrix.
AddMatrix( matrices, columns, values );

然后像这样添加矩阵：

void AddMatrix( std::deque< std::vector< std::vector< int > > > & matrices,
                std::vector< size_t > & columns,
                std::vector< int > & values )
{
    if( columns.empty() ) return;

    // Reserve matrix rows
    size_t num_rows = columns.size();
    std::vector< std::vector< int > > matrix;
    matrix.reserve( num_rows );

    // Copy rows into matrix
    auto val_it = values.begin();
    for( size_t num_cols : columns )
    {
        std::vector< int > row;
        row.reserve( num_cols );
        std::copy_n( val_it, num_cols, std::back_inserter( row ) );
        matrix.emplace_back( row );
        val_it += num_cols;
    }

    // Clear the column and value pools for re-use.
    columns.clear();
    values.clear();
}

最后，我建议您从 <cstdint> 中选择一个合适的整数类型，而不是将其留给编译器。如果您只需要 32 位整数，请使用 int_least32_t。如果您的数据范围适合 16 位整数，您将通过使用 int_least16_t.

节省大量内存

Answer 2

我猜您看到了两种效果的组合：不同大小的 int + vector 中的额外内存。

我不确定你是否能看到第一个效果，虽然一个 int 占用大约 4 个字节的内存（我认为他们被允许使用这 8 个字节，虽然我还没有看到它的实现).另一端的字符每 digit/char 仅占用 1 个字节 + space 占用 1 个字节。所以如果你有很多小整数，内部表示会更大，但如果你有很多大数字，它会更小。还要检查你是在比较文件的大小，还是在磁盘上的大小，因为有些文件系统支持压缩！

您很可能会注意到的下一个影响是向量的容量，因为您很可能有很多，这会产生相当大的开销。为了不必重新分配每个插入，std::vector class 有一个容量，这是它实际使用的大小，并将填充您添加的对象。

根据实施情况，容量可能会增加。一个例子：每次超过它时容量加倍：如果你从容量 10 开始，你达到 11，容量可以达到 20，如果你达到 21，容量可以达到 40 ...（注：这也是保留重要的原因，因为它会直接给你合适的尺寸）

因此，如果您检查每个向量的容量和大小，这可能会有所不同。如果这对您来说真的很戏剧化，您可以调用向量上的 shrink_to_fit 以将容量重新分配到实际存储的大小。

最后，程序的大小也受应用程序本身的影响。我不认为它会影响到这里，但如果你碰巧 link 有很多共享对象并且所有这些都在启动期间加载，一些内存测量可以包括这些共享对象的大小作为你程序内存的一部分.

c ++读取文件并将整数存储在向量中。最终占用的内存比实际文件大小多 5 倍

c++ read file and store integer in vectors. ends up taking around 5 time more resident memory than actual file size

c++

memory-management

vector

mpi