Proceso asesinado por SIGKILL

Question

Tengo un proceso que se mata inmediatamente después de ejecutar el programa. Este es el código del ejecutable compilado, y es un pequeño programa que lee varios gráficos representados por números de entrada estándar (un archivo descriptivo por lo general) y encuentra el árbol de expansión mínimo para cada gráfico usando el algoritmo de Prim (no muestra el resultados aún, solo encuentra la solución).

#include <stdlib.h> 
#include <iostream> 

using namespace std; 

const int MAX_NODOS = 20000; 
const int infinito = 10000; 

int nnodos; 
int nAristas; 
int G[MAX_NODOS][MAX_NODOS]; 
int solucion[MAX_NODOS][MAX_NODOS]; 
int menorCoste[MAX_NODOS]; 
int masCercano[MAX_NODOS]; 



void leeGrafo(){ 
    if (nnodos<0 || nnodos>MAX_NODOS) { 
     cerr << "Numero de nodos (" << nnodos << ") no valido\n"; 
     exit(0); 
    } 
    for (int i=0; i<nnodos ; i++) 
     for (int j=0; j<nnodos ; j++) 
      G[i][j] = infinito; 
    int A,B,P; 
    for(int i=0;i<nAristas;i++){ 
     cin >> A >> B >> P; 
     G[A][B] = P; 
     G[B][A] = P; 
    } 
} 


void prepararEstructuras(){ 
    // Grafo de salida 
    for(int i=0;i<nnodos;i++) 
     for(int j=0;j<nnodos;j++) 
      solucion[i][j] = infinito; 
    // el mas cercaano 
    for(int i=1;i<nnodos;i++){ 
     masCercano[i]=0; 
     // menor coste 
     menorCoste[i]=G[0][i]; 
    }   
} 

void prim(){ 
    prepararEstructuras(); 
    int min,k; 
    for(int i=1;i<nnodos;i++){ 
     min = menorCoste[1]; 
     k = 1; 
     for(int j=2;i<nnodos;j++){ 
      if(menorCoste[j] < min){ 
       min = menorCoste[j]; 
       k = j; 
      } 
     } 
     solucion[k][masCercano[k]] = G[k][masCercano[k]]; 
     menorCoste[k] = infinito; 
     for(int j=1;j<nnodos;j++){ 
      if(G[k][j] < menorCoste[j] && menorCoste[j]!=infinito){ 
       menorCoste[j] = G[k][j]; 
       masCercano[j] = k; 
      }  
     }   
    } 
} 

void output(){ 
    for(int i=0;i<nnodos;i++){ 
     for(int j=0;j<nnodos;j++) 
      cout << G[i][j] << ' '; 
     cout << endl; 
    } 
} 

int main(){ 
    while(true){ 
     cin >> nnodos; 
     cin >> nAristas; 
     if((nnodos==0)&&(nAristas==0)) break; 
     else{ 
      leeGrafo(); 
      output(); 
      prim(); 
     } 
    } 
} 

he aprendido que debo usar strace para encontrar lo que está pasando, y esto es lo que me sale:

execve("./412", ["./412"], [/* 38 vars */] <unfinished ...> 
+++ killed by SIGKILL +++ 
Killed 

estoy runing ubuntu y esta es la primera vez que consigo este tipo de errores Se supone que el programa se detiene después de leer dos ceros seguidos de la entrada que puedo garantizar que tengo en mi archivo descriptivo de gráficos. También el problema ocurre incluso si ejecuto el programa sin hacer una redirección de entrada a mi archivo de gráficos.

Answer 1

Aunque no estoy 100% seguro de que este es el problema, echar un vistazo a los tamaños de las matrices globales:

const int MAX_NODOS = 20000; 

int G[MAX_NODOS][MAX_NODOS]; 
int solucion[MAX_NODOS][MAX_NODOS]; 

Suponiendo int es de 4 bytes, necesitará:

20000 * 20000 * 4 bytes * 2 = ~3.2 GB 

Por un lado, es posible que incluso no tenga tanta memoria. En segundo lugar, si tiene 32 bits, es probable que el sistema operativo no permita que un solo proceso tenga tanta memoria.

Suponiendo que tiene 64 bits (y suponiendo que tiene suficiente memoria), la solución sería asignarlo todo en tiempo de ejecución.

Answer 2

Sus matrices G y solucion contienen cada uno 400,000,000 enteros, que es aproximadamente 1,6 GiB cada uno en la mayoría de las máquinas. A menos que tenga suficiente memoria (virtual) para eso (3.2 GiB y conteo), y permiso para usarlo (intente ulimit -d; eso es correcto para bash en MacOS X 10.7.2), su proceso no podrá iniciarse y será asesinado por SIGKILL (que no puede ser atrapado, no es que el proceso realmente esté yendo todavía).