Asignación de memoria para una matriz en C

Question

¿Por qué el siguiente código da como resultado un error de segmentación? (Estoy intentando crear dos matrices del mismo tamaño, uno con estática y el otro con la asignación dinámica)

#include <stdio.h> 
#include <stdlib.h> 

//Segmentation fault! 
int main(){ 
    #define X 5000 
    #define Y 6000 

    int i; 
    int a[X][Y]; 

    int** b = (int**) malloc(sizeof(int*) * X); 
    for(i=0; i<X; i++){ 
     b[i] = malloc (sizeof(int) * Y); 
    } 
} 

Extrañamente, si comento hacia fuera una de las definiciones de la matriz, el código se ejecuta correctamente. De esta manera:

#include <stdio.h> 
#include <stdlib.h> 

//No Segmentation fault! 
int main(){ 
    #define X 5000 
    #define Y 6000 

    int i; 
    //int a[X][Y]; 

    int** b = (int**) malloc(sizeof(int*) * X); 
    for(i=0; i<X; i++){ 
     b[i] = malloc (sizeof(int) * Y); 
    } 
} 

o

#include <stdio.h> 
#include <stdlib.h> 

//No Segmentation fault! 
int main(){ 
    #define X 5000 
    #define Y 6000 

    int i; 
    int a[X][Y]; 

    //int** b = (int**) malloc(sizeof(int*) * X); 
    //for(i=0; i<X; i++){ 
    // b[i] = malloc (sizeof(int) * Y); 
    //} 
} 

estoy corriendo gcc en Linux en una máquina de 32 bits.

Editar: Verificando si malloc() tiene éxito:

#include <stdio.h> 
#include <stdlib.h> 

//No Segmentation fault! 
int main(){ 
    #define X 5000 
    #define Y 6000 

    int i; 
    int a[X][Y]; 

    int* tmp; 
    int** b = (int**) malloc(sizeof(int*) * X); 
    if(!b){ 
     printf("Error on first malloc.\n"); 
    } 
    else{ 
     for(i=0; i<X; i++){   
      tmp = malloc (sizeof(int) * Y); 
      if(tmp) 
       b[i] = tmp; 
      else{ 
       printf("Error on second malloc, i=%d.\n", i); 
       return; 
      } 
     } 
    }  
} 

No se imprime nada cuando lo ejecuto (esperar, por supuesto, de "Fallo de segmentación")

Answer 1

Se produce un error de segmentación, lo que significa que su programa está intentando acceder a una dirección de memoria que no ha sido asignada a su proceso. La matriz a es una variable local y, por lo tanto, memoria asignada de la pila. Como unwind señaló a requiere 120 Mbytes de almacenamiento. Esto es casi seguramente más grande que el espacio de pila que el sistema operativo ha asignado a su proceso. Tan pronto como el bucle for se aleja del final de la pila, se produce un error de segmentación.

En Linux el tamaño de pila es controlado por el sistema operativo no el compilador así que pruebe lo siguiente: -

$ ulimit -a 

En la respuesta debería ver una línea como la siguiente: -

stack size (kbytes)   (-s) 10240 

Esto significa que cada proceso obtiene 10Mbyte de almacenamiento, ni mucho menos para su gran matriz.

Puede ajustar el tamaño de la pila con un comando ulimit -s <stack size>, pero sospecho que no le permitirá seleccionar un tamaño de pila de 120 MB.

La solución más simple es hacer que a sea una variable global en lugar de una variable local.

Answer 2

Esas son las asignaciones de tamaño considerable. ¿Ha intentado verificar para asegurarse de que malloc() tiene éxito?

Puede usar malloc() para todas sus matrices y comprobar para asegurarse de que tenga éxito cada vez.

Answer 3

Su variable a requiere, en un sistema de 32 bits, 5000 * 6000 * 4 = 120 MB de espacio de pila. Es posible que esto viole algún límite, lo que causa la falla de segmentación.

Además, es posible que malloc() falle en algún momento, lo que puede provocarle la eliminación de un puntero NULL.

Answer 4

Su tercer código tampoco funciona (en mi sistema al menos).

Intente asignar memoria a la matriz a en el montón (cuando las dimensiones son grandes).

Answer 5

tratar de aumentar los límites del montón y pila de GCC:

gcc -Wl,--stack=xxxxx -Wl,--heap=yyyyy 

Answer 6

Ambas matrices no caben en los límites de su memoria. Puede asignar solo uno a la vez.

Si define Y como 3000 en vez de 6000, su programa no debería emitir segfault.

Answer 7

Un desbordamiento de la pila (¡qué apropiado!) Puede provocar un error de segmentación, que es lo que parece que está viendo aquí.

En su tercer caso, el puntero de pila se mueve a una dirección no válida pero no se usa para nada, ya que el programa se cierra. Si pone cualquier operación después de la asignación de la pila, debería obtener una segfault.

Answer 8

Quizás el compilador simplemente está cambiando el puntero de la pila a un valor grande pero nunca lo usa, y por lo tanto nunca causa una violación de acceso a la memoria.

Intente inicializar todos los elementos de A en su tercer ejemplo? Su primer ejemplo intenta asignar B después de A en la pila, y acceder a la pila tan alta (en la primera asignación a B) podría ser lo que está causando la segfault.