c++ - ¿Por qué la asignación de memoria de montón es mucho más rápida que la asignación de memoria de pila?

performance heap-memory

Question

He intentado asignar espacio para 10 ^ 7 enteros en la memoria de pila y pila para ver cuál es más rápido. Obviamente, la asignación en la memoria de almacenamiento dinámico fue mucho más rápida, pero no entiendo la razón.

#include <bits/stdc++.h>
#include <chrono>
using namespace std;
using namespace std::chrono;
int main()
{
high_resolution_clock::time_point t1 = high_resolution_clock::now();
int *p = new int[1e7];
high_resolution_clock::time_point t2 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>( t2 - t1 ).count();
cout << duration / 1e6 << "/n"; // 5e-06
t1 = high_resolution_clock::now();
vector<int> v(1e7);
t2 = high_resolution_clock::now();
duration = duration_cast<microseconds>( t2 - t1 ).count();
cout << duration / 1e6 << "/n"; // 0.112284
return 0;
}

Answer 1

Otras respuestas señalaron que hay al menos una inicialización "oculta" en el constructor de vectores.

Pero su ejemplo tiene otro problema: tal vez ni siquiera mide lo que cree que hace. La evaluación comparativa del código no optimizado en C ++ no tiene sentido y el código optimizado correctamente es difícil.

Echemos un vistazo a su ejemplo (modificado para facilitar la lectura) compilado por Clang con un nivel de optimización -O3 : enlace godbolt .

double test1() {
high_resolution_clock::time_point t1 = high_resolution_clock::now();
int *p = new int[1e7];
high_resolution_clock::time_point t2 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>( t2 - t1 ).count();
return duration / 1e6; // 5e-06
}

compilado a:

test1(): # @test1()
push rbx
call std::chrono::_V2::system_clock::now()
mov rbx, rax
call std::chrono::_V2::system_clock::now()
sub rax, rbx
movabs rcx, 2361183241434822607
imul rcx
mov rax, rdx
shr rax, 63
sar rdx, 7
add rdx, rax
cvtsi2sd xmm0, rdx
divsd xmm0, qword ptr [rip + .LCPI0_0]
pop rbx
ret
.LCPI1_0:
.quad 4696837146684686336 # double 1.0E+6

¡La primera parte ni siquiera llama al operador nuevo! El compilador vio a través de su programa y se dio cuenta de que nunca utilizó la matriz asignada, por lo que eliminó la asignación del ejecutable resultante.

Entonces, la primera parte de su programa no asigna la matriz en el montón cuando se compila con tales configuraciones, lo que hace que las mediciones no tengan sentido.

Recomiendo leer sobre benchmarking y usar marcos de micro benchmark especializados para hacer tales pruebas. Eche un vistazo a Google Benchmark (y QuickBench línea) y su documentación.

Answer 2

Solo soy un principiante, pero déjame dar lo que entiendo principalmente para ponerme a prueba.

En

int *p = new int[1e7];

está asignando memoria consecutiva para 10 millones de enteros en el montón.

En

vector<int> v(1e7);

está asignando en la memoria de pila para un objeto vector<int> . Entre los miembros de ese objeto hay un puntero a un int[1e7] en el montón, que también se asigna. Además, todos los valores en él se inicializan con el valor de int() (con 0s). Ver constructor (2) de std::vector .

Answer 3

new int[1e7] asigna espacio para los valores 1e7 int y no los inicializa.

vector<int> v(1e7); crea un objeto vector<int> en la pila, y el constructor para ese objeto asigna espacio para 1e7 valores int en el montón. También inicializa cada valor int a 0.

La diferencia en velocidad se debe a la inicialización.

Para comparar la velocidad de la asignación de la pila, debe asignar una matriz en la pila:

int data[1e7];

pero tenga cuidado: hay una buena posibilidad de que esto falle porque la pila no es lo suficientemente grande para una matriz tan grande.