Segmentation fault (core dumped) avec de grands tableaux

Question

Je suis nouveau à la programmation C++ et avait écrit ce code C++:

//colpitts high freq 1 GHz working with delay 
#include <iostream> 
#include <cmath> 
#include <string> 
#include <cstring> 
using namespace std; 

const double pi = 3.1415926; 

int main(){ 
    double c0, dx, dt,C1,C2,L,fs,Ceq, freq, tau, Rload, gload, Re, ge,gm,gc1,gc2,ic1,ic2,il,gl ; 
    c0=20000000000; 
    dx=0.01; 
    dt=dx/(2 * c0); 
    cout<<dt<<"\n"; 
    double V1 [1000000]={}; 
    double V2 [1000000]={}; 
    V1[0]=1e-3; 
    C1=1e-12; 
    C2=5e-12; 
    L=30.4e-9; 
    fs=4e12; 
    Ceq=(C1 * C2)/(C1+C2); 
    cout<<Ceq<<"\n"; 
    freq=1/(2 * pi * (sqrt(L*Ceq))); 
    cout<<freq<<"\n"; 
    tau=1/freq; 
    cout<<tau<<"\n"; 
    Rload=50; 
    Re=1e6; 
    ge=1/Re; 
    cout<<ge<<"\n"; 
    gm=0; 
    gc1=(C1)/dt; 
    cout<<gc1<<"\n"; 
    ic1=-((C1)/dt) * V1[0]; 
    cout<<ic1<<"\n"; 
    gc2=(C2)/dt; 
    cout<<gc2<<"\n"; 
    ic2=-((C2)/dt) * V2[0]; 
    cout<<ic2<<"\n"; 
    gl=dt/(L); 
    cout<<gl<<"\n"; 
    il=gl * (V2[0]-V1[0]); 
    cout<<il<<"\n"; 
    gload=1/Rload; 
    cout<<gload<<"\n"; 
    return (0); 
} 

quand je le lance sur une machine Linux, il génère une erreur de segmentation fault (core exporté), mais quand je change le tableau à 100000, aucune erreur n'est levée et le programme s'exécute comme prévu. Je sais que le problème est lié à la mémoire physique qui m'a été allouée, mais y aurait-il un moyen de contourner le problème? Quelqu'un peut-il me guider gentiment quant aux modifications que je dois apporter?

Answer 1

C'est la pile. Vous utilisez environ 16 Mo de pile pour stocker ces deux tableaux de doubles (8 octets par double * 2 tableaux * 1 000 000).

Définition d'une pile beaucoup plus comme ceci:

ulimit -s 32000 

Est-ce que résoudre le problème. Mais mettre des blocs de données de 16 Mo sur la pile n'est pas une bonne idée.

Si vous les sortez de la pile comme ceci (et utilisez des lignes vides pour rendre le code plus facile à lire :)) alors cela fonctionne bien. Cependant je recommande également, comme mentionné ci-dessus, que vous regardez vecteur plutôt que d'utiliser le style C des tableaux bruts:

http://www.codeguru.com/cpp/cpp/cpp_mfc/stl/article.php/c4027/C-Tutorial-A-Beginners-Guide-to-stdvector-Part-1.htm

#include <iostream> 
#include <cmath> 
#include <string> 
#include <cstring> 

using namespace std; 

const double pi = 3.1415926; 


double V1 [1000000]={}; 
double V2 [1000000]={}; 


int main(){ 

    double c0, dx, dt,C1,C2,L,fs,Ceq; 
    double freq, tau, Rload, gload; 
    double Re, ge,gm,gc1,gc2,ic1,ic2,il,gl ; 
    c0=20000000000; 
    dx=0.01; 
    dt=dx/(2 * c0); 
    cout<<dt<<"\n"; 

    V1[0]=1e-3; 
    C1=1e-12; 
    C2=5e-12; 
    L=30.4e-9; 
    fs=4e12; 

    Ceq=(C1 * C2)/(C1+C2); 
    cout<<Ceq<<"\n"; 
    freq=1/(2 * pi * (sqrt(L*Ceq))); 
    cout<<freq<<"\n"; 

    tau=1/freq; 
    cout<<tau<<"\n"; 

    Rload=50; 
    Re=1e6; 
    ge=1/Re; 
    cout<<ge<<"\n"; 

    gm=0; 
    gc1=(C1)/dt; 
    cout<<gc1<<"\n"; 

    ic1=-((C1)/dt) * V1[0]; 
    cout<<ic1<<"\n"; 

    gc2=(C2)/dt; 
    cout<<gc2<<"\n"; 

    ic2=-((C2)/dt) * V2[0]; 
    cout<<ic2<<"\n"; 

    gl=dt/(L); 
    cout<<gl<<"\n"; 

    il=gl * (V2[0]-V1[0]); 
    cout<<il<<"\n"; 

    gload=1/Rload; 
    cout<<gload<<"\n"; 

    return (0); 
} 

Answer 2

Paul R est juste. Les variables déclarées dans une fonction utilisent "la pile". Il y a une limite à l'espace que vous pouvez utiliser pour les variables locales. Ses suggestions pour rendre ces déclarations de tableaux locaux globales, statiques et allouées dynamiquement signifient que ces variables n'utiliseront pas l'espace de pile. L'utilisation du vecteur de la STL fonctionnera également.

Ce lien peut vous donner une idée de la taille de l'espace de pile.

https://stackoverflow.com/a/1825996/3813353

Une solution rapide et sale est d'utiliser limite/ulimit. L'inconvénient est que vous devez utiliser cette commande avant d'exécuter votre programme. Simplifier simplement les tableaux globalement ...

Habituellement, lorsque vous rencontrez des problèmes avec la taille de la pile, vous avez une récursivité ou une récursion infinie. Chaque appel à la fonction récursive peut ne pas utiliser beaucoup de données de la pile, mais si la fonction continue de s'appeler, vous finirez par manquer d'espace de pile.

Answer 3

En effet, vous avez trop de données sur la pile.

Vous pouvez utiliser la classe de modèle standard std::vector (même si vous allouez un vecteur sur une pile, ses données sont dans le tas). Alors ajoutez #include <vector> aux en-têtes inclus, alors les choses de code comme

std::vector<double> v1, v2; 
    v1.push_back(2.512); 
    v1.push_back(3.17); 
    v2.resize(37); 
    v2[0] = v1[0] + v1[1]; 
    v2[17] = sqrt(10.0) + 11.0; 

Lire une STL tutorial; BTW, utiliser et apprendre C++ 11 (pas une norme C++ plus tôt). Utilisez donc un compilateur récent (par exemple GCC 4.9, compilez-le en utilisant g++ -std=c++11 -Wall -g ....) et utilisez le débogueur gdb.