Discussion :

[_error404]

Bonjour à tous

J'aimerais savoir si lorsque l'on utilise le mécanisme des exceptions en c++, celui-ci engendre t'il des baisses de performance.
exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
int _tmain(int argc, _TCHAR* argv[])
{
	try
	{
		main_thread(argc,argv);
	}
	catch(...)
	{
		//exception inconnue attrapée
	}
}

Supposons que je n'avais pas utilisé de try-catch, le code contenu dans main_thread fonctionnerait il de la même manière que le cas ci-dessus?
Je n'arrive pas comprendre comment le mécnisme est implanté :
Le code est-il en permanence surveillé par le système pour générer l'exception?
Ou sinon lorsqu'une erreur se produit, le système effectue une appel vers une section spéciale en mémoire pour gérer l'exception et faire appel au catch par la suite?
Je cherche à comprendre quels sont les impacts qui sont engendrés par l'utilisation d'un try-catch en terme de performances et de robustesses et si la gestion des exceptions est propre à chaque compilateur, propre au système d'exploitation, ou compètement indépendante.
Je vous remercie d'avance pour vos réponses.

[LittleWhite]

Bonjour,

Je vais tenter une explication, mais je doute qu'elle soit complète.

Lorsqu'une une exception est lancée (throw), le programme va dépiler la pile d'appels (soit, remonter les fonctions une par une). À chaque remontée, le programme va vérifier s'il y a un réceptacle pour cette exception (soit, un bloc try / catch avec le catch correspondant à l'exceptions actuelle). Si il y a, le programme exécute la partie se trouvant dans la catch correspondant et continuer son chemin à partir de là. Sinon, il remonte un niveau au dessus.
Si au dessus du main, l'exception n'est pas (r)attrapée, alors le programme plante (car une exception n'est pas gérée).

Maintenant, quel est le terme en cout de performance. Alors, j'ai appris, je crois, dans la version G++ 4.6, que le cout, lorsque rien ne se passe (pas d'exceptions), était nul.
Bonne nouvelle donc .

Par contre, par expérience personnelle (c'était surtout une erreur), si on utilise les exceptions pour remonter des erreurs courantes (à la place d'un code d'erreur), cela pouvait avoir de grosses conséquences sur les performances ( J'en parle ici: http://www.developpez.net/forums/d96...e/#post6168071 )

Mais sincèrement, si exception il y a, elle ne doit être là, quand cas d'erreurs. Et c'est l'unique cas où elle doit avoir lieu. Bien souvent après une erreur on tente de sauver les meubles avant de fermer l'application (proprement). Donc le cout en performances des exceptions est totalement négligeable, car la perte de perf n'arrive que dans un cas où de toute façon, nous fermons l'application.

[Emmanuel Deloget]

La bonne réponse à la question est : il faut que tu mesures l'impact des exceptions dans ton cas précis.

De toute façon, elles sont activées par défaut, la librairie standard lève des exceptions dans certains cas particuliers, et je suis à peu près sur que tu programmes avec des exceptions sans t'en rendre compte (à moins que tu ne t'amuses à faire des new(std::nothrow) un peu partout ).

Ce qu'il faut comparer en termes de performances pures, c'est ce qu'on appelle le "stack unwinding" - ce qu'à expliqué LittleWhite - avec une remontée d'erreur classique (donc dépiler les fonctions une a une jusqu'à trouver un traitement pour l'erreur remontée). J'ai traité de ce problème dans cet article :

http://blog.emmanueldeloget.com/inde...xceptionnelles

Bonne lecture !

[Luc Hermitte]

Il faut savoir avec quoi comparer.
La vraie question est : quel est le coût des exceptions face à un programme robuste, c'est à dire, un programme qui va tester les sorties de toutes les fonctions pouvant échouer.
Aujourd'hui, la réponse est généralement : les exceptions sont plus rapides pour le cas nominal. Et plus lentes pour les cas exceptionnels.
Donc, bien utilisées, elles devraient aboutir à de meilleures perfs.

(autres) Lectures non triées:
- http://lazarenko.me/tips-and-tricks/...nd-performance
- http://www.codeproject.com/KB/cpp/cp...oetcontra.aspx
- http://www.developpez.net/forums/d36...n-performance/
- http://stackoverflow.com/questions/3...es-in-c#307716
- http://ra3s.com/wordpress/dysfunctio...tion-handling/
- http://www.gamedev.net/page/resource...-handling-r953

[_error404]

Merci pour toutes vous réponses.
Pour appronfondir sur le sujet, il faut se placer dans un contexte où l'exception ne se produit pas, et evaluer les performances du programme avec et sans l'exception.
J'ai actuellement un projet de quelques milliers de lignes, je place l'ensemble de ce code dans un try-catch(...), de manière à récupérer toutes les erreurs possibles qui pourraient survenir à n'importe quel endroit de mon projet. je travaille avec Microsoft visual c++ et vous l'aurez compris de manière trivial sous le système d'exploitation Windows. La question que je me suis posé, Si j'encadre autant de lignes dans un try, les performances sont elles conservées?
d'après les liens que tu m'as donné Luc, j'ai pu tomber sur un autre lien que tu avais foruni sur un autre forum concernant les exceptions:

http://gamearchitect.net/Articles/Ex...rrorCodes.html

d'après le lien il semblerait que les performances soit maintenu.

Windows propose de "catcher" par exemple l'affectation des pointeur non valide, etc... en utilisant "_set_se_translator", qui permet d'obtenir des information sur l'endroit ou l'exception c'est produite.Je peux connaitre où l'erreur c'est produite, logger les informations dans un fichier, la corriger.
On doit par conséquent compiler avec l'option /EHa, dont je ne connais pas l'influence au sein des performances.

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
17
18
19
20
21
22
23
24
25
 
#include <windows.h>
#include <eh.h>
 
void trans_func(unsigned int u, EXCEPTION_POINTERS* pExp)
{
    //cette fonction est automatiquement appelée quand l'exception est 
   //levée avant d'atteindre le catch. On peut avoir des informations sur
   //l'exception grâce aux paramètres ci-dessus.
}
 
int _tmain(int argc, _TCHAR* argv[])
 
{
    _set_se_translator( trans_func );
    try
    {
           main_thread(argc,argv);   //les milliers de ligne sont incluse dans
                                              //cette fonction.
    }
    catch(...)
    {
        //une fois passé dans trans_func on arrive ici
    }
}

Une fois que l'exception est levée mon programme va forcément se terminer, donc le lancement de l'exception n'a pas d'importance pour les performances de mon projet, d'où ma question sur le comportement du programme en fonctionnement normal.
Donner moi votre avis sur la question, toute suggestion sur le sujet sera la bienvenue.

[Luc Hermitte]

Mesure contre un programme qui teste les codes de retour si tu veux des mesures qui veulent dire quelque chose.