Detectando que la pila está llena

Question

Al escribir el código C++, aprendí que usar la pila para almacenar memoria es una buena idea.

Pero recientemente me encontré con un problema:

tuve un experimento que tenía código que se veía así:

void fun(const unsigned int N) { 
    float data_1[N*N]; 
    float data_2[N*N]; 

    /* Do magic */ 
} 

El código exploted con un fallo seqmentation al azar, y no tenía ni idea por qué.

Resultó que el problema era que estaba tratando de almacenar cosas que eran grandes en mi pila, ¿hay alguna forma de detectar esto? ¿O al menos detectar que ha salido mal?

Answer 1

float data_1[N*N]; 
float data_2[N*N]; 

Estos son matrices de longitud variable (VLA), como N no es una expresión constante. La const-ness en el parámetro solo asegura que N es de solo lectura. No le dice al compilador que N es una expresión constante.

Los VLA solo están permitidos en C99; en otra versión de C, y todas las versiones de C++ no están permitidas. Sin embargo, algunos compiladores proporcionan VLA como característica de extensión del compilador. Si está compilando con GCC, intente usando la opción -pedantic, le dirá que no está permitido.

ahora por qué su programa da error de segmentación, probablemente a causa de stack-overflow debido al gran valor de N * N:

---

considerar el uso de std::vector como:

#include <vector> 

void fun(const unsigned int N) 
{ 
    std::vector<float> data_1(N*N); 
    std::vector<float> data_2(N*N); 

    //your code 
} 

Answer 2

Trate de usar en su lugar funciona como malloc. Devolverá nulo explícitamente, si no pudo encontrar un bloque de memoria del tamaño que solicitó.

Por supuesto, en ese caso no olvide liberar esta memoria al final de la función, una vez que haya terminado.

Además, puede verificar la configuración de su compilador, con qué límite de memoria de pila genera los binarios.

Answer 3

Una de las razones por las que las personas dicen que es mejor usar la pila en lugar de la memoria del montón puede deberse al hecho de que las variables asignadas en la parte superior de la pila aparecerán automáticamente cuando salga del cuerpo de la función. Para almacenar grandes bloques de información, es habitual utilizar la memoria de pila y otras estructuras de datos como listas vinculadas o árboles. También los recuerdos asignados en la pila son limitados y mucho menos de lo que puede asignar en el espacio de pila. Creo que es mejor administrar la asignación de memoria y liberarla más cuidadosamente en lugar de tratar de usar la pila para almacenar datos grandes.

Puede utilizar la infraestructura que gestiona sus asignaciones de memoria. Además, puede usar VDL para verificar sus pérdidas de memoria y recuerdos que no se liberan.

Answer 4

¿hay alguna manera de detectar esto?

No, en general.

El tamaño de la pila depende de la plataforma.Normalmente, sistema operativo decide el tamaño de la pila. De modo que puede verificar su sistema operativo (ulimit -s en Linux) para ver cuánta memoria de pila asigna para su programa.

Si su compilador es compatible con stackavail(), puede verificarlo. Es mejor ir a la memoria asignada en el montón en situaciones en las que no está seguro de si excedería el límite de la pila.

Answer 5

Es extremadamente difícil detectar que la pila esté llena, y para nada portátil. Uno de los mayores problemas es que los marcos de pila son de tamaño variable (especialmente cuando se usan matrices de longitud variable, que en realidad son solo una forma más estándar de hacer lo que las personas estaban haciendo anteriormente con alloca()) por lo que no se pueden usar proxys simples como cantidad de cuadros de pila

Uno de los métodos más simples que es mayoría portátil es poner una variable (probablemente de tipo char de modo que un puntero a que es un char*) a una profundidad conocida en la pila y a continuación, medir la distancia desde que apunta a una variable (del mismo tipo) en el marco de pila actual mediante aritmética de puntero simple. Agregue una estimación de cuánto espacio está a punto de asignar, y puede tener una buena idea de si la pila está a punto de explotar. Los problemas con esto son que no se sabe en qué dirección está creciendo la pila (no, ¡no todos crecen en la misma dirección!) Y calcular el tamaño del espacio de la pila en sí mismo es bastante desordenado (se puede Probar cosas como los límites del sistema, pero son realmente bastante incómodas). Además, el factor de pirateo es muy alto.

El otro truco que he visto aplicar en Windows de 32 bits solamente era tratar de alloca() espacio suficiente y controlar la excepción del sistema que se produciría si había espacio suficiente.

int have_enough_stack_space(void) { 
    int enough_space = 0; 

    __try {   /* Yes, that's got a double-underscore. */ 
     alloca(SOME_VALUE_THAT_MEANS_ENOUGH_SPACE); 
     enough_space = 1; 
    } __except (EXCEPTION_EXECUTE_HANDLER) {} 

    return enough_space; 
} 

Este código es muy no portátil (por ejemplo, no contar con ella trabajando en Windows de 64 bits) y la construcción con gcc mayores requiere un poco de ensamblador en línea desagradable en su lugar! El manejo estructurado de excepciones (de lo que se trata) se encuentra entre las artes negras más negras de Windows. (Y no return desde el interior de la construcción __try.)