Processo ucciso da SIGKILL

Question

Ho un processo che viene ucciso immediatamente dopo l'esecuzione del programma. Questo è il codice dell'eseguibile compilato, ed è un piccolo programma che legge diversi grafici rappresentati da numeri da input standard (un file descrittivo di solito) e trova l'albero spanning minimo per ogni grafico usando l'algoritmo di Prim (non mostra il risultati ancora, trova solo la soluzione).

#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(); 
     } 
    } 
} 

Ho imparato che devo utilizzare strace per trovare ciò che sta succedendo, e questo è ciò che ottengo:

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

sto runing ubuntu e questa è la prima volta che ottengo questo tipo di errori. Il programma dovrebbe fermarsi dopo aver letto due zeri di fila dall'input che posso garantire di avere nel mio file grafico descrittivo. Anche il problema si verifica anche se eseguo il programma senza effettuare un reindirizzamento dell'input al mio file di grafici.

Answer 1

Anche se io non sono sicuro al 100% che questo è il problema, date un'occhiata alle dimensioni del vostro array globali:

const int MAX_NODOS = 20000; 

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

Supponendo int è di 4 byte, è necessario:

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

Per uno, potresti anche non avere molta memoria. In secondo luogo, se si è su 32 bit, è probabile che il sistema operativo non consenta a un singolo processo di avere molta memoria.

Supponendo che tu sia su 64 bit (e supponendo che tu abbia memoria sufficiente), la soluzione sarebbe quella di allocarlo tutto in fase di esecuzione.

Answer 2

I tuoi array G e solucion contengono ciascuno 400.000.000 interi, ovvero circa 1,6 GB ciascuno nella maggior parte delle macchine. A meno che tu non abbia abbastanza memoria (virtuale) per questo (3.2 GiB e conteggio) e il permesso di usarlo (prova , corretto per bash su MacOS X 10.7.2), il tuo processo non verrà avviato e verrà ucciso da SIGKILL (che non può essere intrappolato, non che il processo stia davvero andando avanti).