Discussion :

[ame_12]

Bonjour,

Pour les besoins d'une application, je dois afficher et actualiser quelque données que je récupérer depuis un carte.
Le problème que je rencontre est dans l'actualisation des données : j'utilise un thread qui parcours tous les données et demande à la carte leur nouvelle valeur une par une.
Au bout d'un moment, j'ai un dépassement de pile ( Stack overflow at 0xXXXXXXX), qui intervient toujours au même endroit: lors de la récupération d'une valeur.

Quelqu'un peut me dire qu'est ce qui peut cause ce dépassement de pile ?
Merci pour vos réponses.

[Iradrille]

Hello,

Généralement ça vient de fonctions récursives : trop d'appels imbriqués => stack overflow.

Post le bout de code qui pose problème, ça sera plus simple que de jouer aux devinettes pour trouver le vrai problème.

[ame_12]

le code est très long mais voici le bout de code (simplifier) où l’exception est levée:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 // ce qui permet de lancer le thread: 
this->hDataThread = CreateThread ( NULL,             
                                0,      //  Est ce qu'on peut spécifier une taille plus grande pour eviter le depassement?                       
                                &dwThreadStart,    
                                this,                             
                                0,                               
                                &this->dwThreadId );

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 // Le thread 
DWORD WINAPI CMaClass::dwDataThreadStart( void* pvThreadParam )
{
    CMaClass* pThis = (CMaClass*)pvThreadParam;
    return pThis->dwThread(  );
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
DWORD CMaClass::dwThread(  )
{
 
    EError eError;
    do
    {
        for (int iListIndex = 0; iListIndex < this->xmlDataList->GetCount(); iListIndex++)
        {
                AnsiString szValue = L"";
                _di_IXMLStandardTestV1_Field xmlUsage = xmlDataList->Get_Field(iListIndex);
                szValue = szGetValue( xmlUsage );   // <== cette fonction appelle une fonction d'une autre dll ou il y a beacoup d'appels imbriqués 
                mMapValue[ xmlUsage->Id ] = szValue;;
        }
    } while ( ... );
    return 0;
}

Je pense que le problème vient des fonctions récursives, comme tu as dis.
Est ce qu'il y a une solution pour ce problème ?
Ce Thread permet d'actualiser les données une par une.
Je ne sais pas si il y a une autre méthode pour actualiser les données que de faire du polling.
Je développe sous C++ builder.
Merci

[oodini]

Sous Visual, on peut changer la taille qu'on alloue à la pile, mais je ne sais plus comment.

[ame_12]

La fonction CreateThread a un paramètre où on peut spécifier la taille de la pile, s'il est à zéro, une taille par défaut est prise.
le problème est que je ne sais pas si c'est ça le problème ni quelle taille prendre pour ne pas avoir de dépassement.

[Médinoc]

Généralement, il y a deux causes pour des Stack Overflow:

• Des tableaux très volumineux en variable locale
• Un appel récursif infini.

Les débordements de pile suite à un appel récursif "trop profond" mais pas infini, en l'absence gros tableaux, ça n'arrive pratiquement jamais.

Note: il me semble que la pile fait 1MO par défaut sous Windows.

[koala01]

Salut,

Personnellement, je ne suis pas fan de la solution qui consisterait à forcer la taille de la pile pour ton application.

La raison est que ton problème (le stack overfloaw) est le symptôme qu'il y a "quelque chose qui ne va pas".

La seule chose que tu feras en modifiant la pile de ton application, c'est de "planquer la poussière sous le tapis".

Cela marchera maintenant, mais n'aura absolument pas résolu le problème de fond et, tôt ou tarde, il reviendra en force.

De toute évidence, tu manipules un fichier XML. La structure même du fichier xml fait que la "moins mauvaise solution" passe sans doute effectivement par la récursivité.

Le problème de la récursivité, c'est que chaque fonction qui en appelle une autre (même, et surtout si c'est elle que la fonction appelle), elle va placer des données sur la pile, et que, tôt ou tard, la pile va déborder.

Plutôt que de jouer avec la taille de la pile, j'essayerais sans doute de trouver le moyen pour "simplifier" la structure même du xml utilisé, de limiter le besoin de récursivité.

Cela peut entraîner des changements profonds, et remonter sans doute jusqu'aux spécifications. Je comprendrai donc fort bien si tu me disais que l'option n'est pas envisageable.

Mais je reste cependant convaincu que c'est la seule option envisageable sur le long terme, car tes données continueront à s'entasser, quoi que tu fasses