c++ - significado - valgrind windows

Comprender la cantidad de memoria que C++ asigna

Question

Estoy tratando de desarrollar una mejor comprensión de la cantidad de memoria que se asigna en el montón en c ++. He escrito un pequeño programa de prueba que, básicamente, no hace más que llenar una serie de vectores en 2D. Estoy ejecutando esto en una máquina virtual Linux de 64 bits y uso la herramienta de macizo valgrind para perfilar la memoria.

El entorno en el que estoy ejecutando esta prueba: Linux VM ejecutándose en VirtualBox en Win10. Configuración de VM: memoria base: 5248MB, 4CPU''s, cap Al 100%, VDI tipo disco (almacenamiento alocated dinámicamente).

Programa de prueba de perfil de memoria c ++:

/**
 * g++ -std=c++11 test.cpp -o test.o
 */

#include <string>
#include <vector>
#include <iostream>

using namespace std;

int main(int argc, char **arg) {
    int n = stoi(arg[1]);
    vector<vector<int> > matrix1(n);
    vector<vector<int> > matrix2(n);
    vector<vector<int> > matrix3(n);
    vector<vector<int> > matrix4(n);
    vector<vector<int> > matrix5(n);
    vector<vector<int> > matrix6(n);
    vector<vector<int> > matrix7(n);
    vector<vector<int> > matrix8(n);

    for (int i=0; i<n; ++i) {
        for (int j=0; j<n; ++j) {
            matrix1[i].push_back(j);
        }
    }

    for (int i=0; i<n; ++i) {
        for (int j=0; j<n; ++j) {
            matrix2[i].push_back(j);
        }
    }

    for (int i=0; i<n; ++i) {
        for (int j=0; j<n; ++j) {
            matrix3[i].push_back(j);
        }
    }

    for (int i=0; i<n; ++i) {
        for (int j=0; j<n; ++j) {
            matrix4[i].push_back(j);
        }
    }

    for (int i=0; i<n; ++i) {
        for (int j=0; j<n; ++j) {
            matrix5[i].push_back(j);
        }
    }

    for (int i=0; i<n; ++i) {
        for (int j=0; j<n; ++j) {
            matrix6[i].push_back(j);
        }
    }

    for (int i=0; i<n; ++i) {
        for (int j=0; j<n; ++j) {
            matrix7[i].push_back(j);
        }
    }

    for (int i=0; i<n; ++i) {
        for (int j=0; j<n; ++j) {
            matrix8[i].push_back(j);
        }
    }
}

Ejecuto el siguiente script bash para extraer perfiles de memoria a diferentes valores de n (test.o es el programa anterior, compilado con g ++ -std = c ++ 11, g ++ es la versión 5.3.0)

valgrind --tool=massif --massif-out-file=massif-n1000.txt ./test.o 250
valgrind --tool=massif --massif-out-file=massif-n1000.txt ./test.o 500
valgrind --tool=massif --massif-out-file=massif-n1000.txt ./test.o 1000
valgrind --tool=massif --massif-out-file=massif-n2000.txt ./test.o 2000
valgrind --tool=massif --massif-out-file=massif-n4000.txt ./test.o 4000
valgrind --tool=massif --massif-out-file=massif-n8000.txt ./test.o 8000
valgrind --tool=massif --massif-out-file=massif-n16000.txt ./test.o 16000
valgrind --tool=massif --massif-out-file=massif-n32000.txt ./test.o 32000

Esto me da los siguientes resultados:

|--------------------------------|
| n     | peak heap memory usage |
|-------|------------------------|
| 250   | 2.1 MiB                |         
| 500   | 7.9 MiB                |
| 1000  | 31.2 MiB               |
| 2000  | 124.8 MiB              |
| 4000  | 496.5 MiB              |
| 8000  | 1.9  GiB               |
| 16000 | 6.2 GiB                |
| 32000 | 6.1 GiB                |
|--------------------------------|

Cada matriz tendrá un tamaño n ^ 2, tengo un total de 8 matrices, por lo tanto, esperaba que el uso de la memoria fuera de f(n) = 8 * n^2 .

Pregunta 1 De n = 250 a n = 8000, ¿por qué el uso de memoria se multiplica más o menos por 4 a n * = 2?

De n = 16000 a n = 32000 algo muy extraño está sucediendo porque valgrind realmente informa una disminución de la memoria.

Pregunta 2 ¿Qué está pasando entre n = 16000 yn = 32000, cómo puede ser posible que la memoria del montón sea menor, mientras que en teoría se deberían asignar más datos?

Vea a continuación la salida de visualización de macizo para n = 16000 yn = 32000.

Answer 1

1) Porque los tamaños de sus vectores matriciales (y por lo tanto su huella de memoria) crecen como n ² , por lo que doblar n lleva a la cuadruplicación del uso de la memoria. Cualquier desviación de la relación exacta (a diferencia de la asintótica ) se debe a diferentes factores (p. Ej., Metadatos utilizados por malloc / std::allocator , método de duplicación del tamaño de bloque utilizado por el vector )

2) Estás empezando a quedarte sin memoria, por lo que Linux está comenzando a buscar algunas páginas ; use --pages-as-heap=yes si desea ver el uso total de la memoria (activa + paginada). (Fuente: http://valgrind.org/docs/manual/ms-manual.html )