matrice 2D Grande dà errore di segmentazione

Question

Sto scrivendo un po 'di codice C++ in Linux dove ho dichiarato alcune matrici 2D in questo modo:

double x[5000][500], y[5000][500], z[5000][500]; 

Durante la compilazione non ci sono errori. Quando eseguo dice "difetto di segmentazione".

Wen I ridurre le dimensioni dell'array da 5000 a 50, il programma funziona correttamente. Come posso proteggermi da questo problema?

Answer 1

La dichiarazione deve essere visualizzata al livello superiore, al di fuori di qualsiasi procedura o metodo.

Di gran lunga il modo più semplice per diagnosticare un segfault in C o C++ di codice è quello di uso valgrind. Se uno dei tuoi array è in errore, valgrind individuerà esattamente dove e come. Se l'errore si trova altrove, lo dirà anche a te.

valgrind può essere utilizzato su qualsiasi binario x86 ma fornirà ulteriori informazioni se si compila con gcc -g.

Answer 2

Questi array sono in pila. Le pile sono di dimensioni abbastanza limitate. Probabilmente esegue in un ... overflow dello stack :)

Se si vuole evitare questo, è necessario metterli sul negozio libera:

double* x =new double[5000*5000]; 

Ma è meglio iniziare la buona abitudine di utilizzare il contenitori standard, che avvolgono tutto questo per voi:

std::vector< std::vector<int> > x(std::vector<int>(500), 5000); 

più: anche se la pila si adatta gli array, è ancora bisogno di spazio per le funzioni di mettere le loro cornici su di esso.

Answer 3

Mi sembra che tu abbia un overflow onesto per Spolsky!

Prova a compilare il programma con l'opzione -fstack-check di gcc. Se i tuoi array sono troppo grandi per essere allocati nello stack, otterrai un'eccezione StorageError.

Penso che sia una buona scommessa, tuttavia, dato che 5000 * 500 * 3 raddoppia (8 byte ciascuno) arriva a circa 60 mega - nessuna piattaforma ha abbastanza stack per quello. Dovrai allocare i tuoi grossi array sul mucchio.

Answer 4

Se il programma si presenta così ...

int main(int, char **) { 
    double x[5000][500],y[5000][500],z[5000][500]; 
    // ... 
    return 0; 
} 

... poi si traboccano lo stack. Il modo più veloce per risolvere questo problema è aggiungere la parola statica.

int main(int, char **) { 
    static double x[5000][500],y[5000][500],z[5000][500]; 
    // ... 
    return 0; 
} 

Il secondo modo più veloce per risolvere questo problema è quello di spostare la dichiarazione dalla funzione:

double x[5000][500],y[5000][500],z[5000][500]; 
int main(int, char **) { 
    // ... 
    return 0; 
} 

Il terzo modo più veloce per risolvere questo problema è quello di allocare la memoria sul mucchio:

int main(int, char **) { 
    double **x = new double*[5000]; 
    double **y = new double*[5000]; 
    double **z = new double*[5000]; 
    for (size_t i = 0; i < 5000; i++) { 
     x[i] = new double[500]; 
     y[i] = new double[500]; 
     z[i] = new double[500]; 
    } 
    // ... 
    for (size_t i = 5000; i > 0;) { 
     delete[] z[--i]; 
     delete[] y[i]; 
     delete[] x[i]; 
    } 
    delete[] z; 
    delete[] y; 
    delete[] x; 

    return 0; 
} 

Il quarto modo più veloce consiste nell'assegnarli all'heap utilizzando std :: vector.Sono presenti meno righe nel tuo file ma più righe nell'unità di compilazione e devi pensare a un nome significativo per i tipi di vettore derivati ​​o inserirli in uno spazio dei nomi anonimo in modo che non inquinino lo spazio dei nomi globale:

#include <vector> 
using std::vector 
namespace { 
    struct Y : public vector<double> { Y() : vector<double>(500) {} }; 
    struct XY : public vector<Y> { XY() : vector<Y>(5000) {} } ; 
} 
int main(int, char **) { 
    XY x, y, z; 
    // ... 
    return 0; 
} 

il modo quinto più veloce è ripartirli sul mucchio, ma utilizzare modelli così le dimensioni non sono così remote dagli oggetti:

include <vector> 
using namespace std; 
namespace { 
    template <size_t N> 
    struct Y : public vector<double> { Y() : vector<double>(N) {} }; 
    template <size_t N1, size_t N2> 
    struct XY : public vector< Y<N2> > { XY() : vector< Y<N2> > (N1) {} } ; 
} 
int main(int, char **) { 
    XY<5000,500> x, y, z; 
    XY<500,50> mini_x, mini_y, mini_z; 
    // ... 
    return 0; 
} 

il modo più performante è allocare le matrici bidimensionali come uno -array dimensionali e quindi utilizzare l'aritmetica dell'indice.

Tutto ciò presuppone che si abbia un motivo, buono o scarso, per voler creare il proprio meccanismo di array multidimensionale. Se non avete ragione, e si aspettano di utilizzare nuovamente gli array multidimensionali, considerare vivamente di installare una libreria:

• A gioca-ben-con-STL modo è quello di utilizzare il Boost Multidimensional Array.

• Un modo rapido è utilizzare Blitz++.

Answer 5

Si consiglia di cercare di utilizzare Boost.Multi_array

typedef boost::multi_array<double, 2> Double2d; 
Double2d x(boost::extents[5000][500]); 
Double2d y(boost::extents[5000][500]); 
Double2d z(boost::extents[5000][500]); 

L'attuale grande pezzo di memoria sarà assegnato sul mucchio e rilascia automaticamente quando necessario.

Answer 6

Un'altra soluzione ai precedenti sarebbe eseguire un

ulimit -s stack_area 

per espandere la pila massima.

Answer 7

Una prenotazione sull'utilizzo sempre del vettore: per quanto ho capito, se si esce dalla fine dell'array si assegna semplicemente un array più grande e si copia tutto ciò che potrebbe creare errori sottili e difficili da trovare quando si è veramente legare per lavorare con una matrice di dimensioni fisse. Almeno con un vero array ti segfault se ti allontani rendendo l'errore più facile da catturare.

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

int main(int argc, char **argv) { 

typedef double (*array5k_t)[5000]; 

array5k_t array5k = calloc(5000, sizeof(double)*5000); 

// should generate segfault error 
array5k[5000][5001] = 10; 

return 0; 
}