je gagne quelque chose (en particulier en vitesse d'exécution du programme) ou si cela ne change rien ?
À vue de nez, ça doit varier énormément suivant le compilateur et les options de compilation. Mais il y a des chances pour que l'appel de la fonction "FaireQuelqueChose" (s'il y a bien appel, i.e. si le compilo n'a pas inliné "FaireQuelqueChose") prenne nettement plus de temps que tout le reste.
Normalement, on ne se pose pas ce genre de questions, du moins pas a priori : on programme de la façon la plus naturelle possible (ici, je pense que c'est la version à deux boucles, mais ça dépend de ton application), puis, si le besoin s'en fait sentir, on détecte les goulots d'étranglement avec un profiler.
De toutes façons, avec un compilo récent et un processeur de style Pentium, deviner quel sera le code généré et comment il sera exécuté, est quasi impossible. Ce genre d'optimisation (bricolage de boucles) a peut-être un sens en assembleur, pour de l'embarqué (ou un vieux processeur, style 386).
On Sat, 29 Jul 2006 03:15:09 +0200, "ByB" <email@email.com>:
je gagne quelque chose (en particulier en vitesse d'exécution du
programme) ou si cela ne change rien ?
À vue de nez, ça doit varier énormément suivant le compilateur et les
options de compilation. Mais il y a des chances pour que l'appel de la
fonction "FaireQuelqueChose" (s'il y a bien appel, i.e. si le compilo
n'a pas inliné "FaireQuelqueChose") prenne nettement plus de temps que
tout le reste.
Normalement, on ne se pose pas ce genre de questions, du moins pas a
priori : on programme de la façon la plus naturelle possible (ici, je
pense que c'est la version à deux boucles, mais ça dépend de ton
application), puis, si le besoin s'en fait sentir, on détecte les
goulots d'étranglement avec un profiler.
De toutes façons, avec un compilo récent et un processeur de style
Pentium, deviner quel sera le code généré et comment il sera exécuté,
est quasi impossible.
Ce genre d'optimisation (bricolage de boucles) a peut-être un sens en
assembleur, pour de l'embarqué (ou un vieux processeur, style 386).
je gagne quelque chose (en particulier en vitesse d'exécution du programme) ou si cela ne change rien ?
À vue de nez, ça doit varier énormément suivant le compilateur et les options de compilation. Mais il y a des chances pour que l'appel de la fonction "FaireQuelqueChose" (s'il y a bien appel, i.e. si le compilo n'a pas inliné "FaireQuelqueChose") prenne nettement plus de temps que tout le reste.
Normalement, on ne se pose pas ce genre de questions, du moins pas a priori : on programme de la façon la plus naturelle possible (ici, je pense que c'est la version à deux boucles, mais ça dépend de ton application), puis, si le besoin s'en fait sentir, on détecte les goulots d'étranglement avec un profiler.
De toutes façons, avec un compilo récent et un processeur de style Pentium, deviner quel sera le code généré et comment il sera exécuté, est quasi impossible. Ce genre d'optimisation (bricolage de boucles) a peut-être un sens en assembleur, pour de l'embarqué (ou un vieux processeur, style 386).
Fabien LE LEZ
On Sat, 29 Jul 2006 03:15:09 +0200, "ByB" :
Je suis curieux de savoir si en remplaçant deux boucles imbriquées :
Si jamais tu as vraiment besoin de ce genre d'optimisations, je te conseille de jeter un oeil sur le compilateur C++ Intel, réputé assez bon en matière d'optimisation (Ben oui, logiquement, chez Intel, ils savent comment leurs processeurs fonctionnent).
Note que certains logiciels (pour Windows) sont fournis en trois versions : la version "générale", non optimisée ; une version optimisée pour Athlon, et une version optimisée pour Pentium 4.
On Sat, 29 Jul 2006 03:15:09 +0200, "ByB" <email@email.com>:
Je suis curieux de savoir si en remplaçant deux boucles imbriquées :
Si jamais tu as vraiment besoin de ce genre d'optimisations, je te
conseille de jeter un oeil sur le compilateur C++ Intel, réputé assez
bon en matière d'optimisation (Ben oui, logiquement, chez Intel, ils
savent comment leurs processeurs fonctionnent).
Note que certains logiciels (pour Windows) sont fournis en trois
versions : la version "générale", non optimisée ; une version
optimisée pour Athlon, et une version optimisée pour Pentium 4.
Je suis curieux de savoir si en remplaçant deux boucles imbriquées :
Si jamais tu as vraiment besoin de ce genre d'optimisations, je te conseille de jeter un oeil sur le compilateur C++ Intel, réputé assez bon en matière d'optimisation (Ben oui, logiquement, chez Intel, ils savent comment leurs processeurs fonctionnent).
Note que certains logiciels (pour Windows) sont fournis en trois versions : la version "générale", non optimisée ; une version optimisée pour Athlon, et une version optimisée pour Pentium 4.
Sylvain Togni
Je suis curieux de savoir si en remplaçant deux boucles imbriquées :
for (int i = 0;i<8;i++) { for (int j=0;j<8;j++) { FaireQuelqueChose(i,j); } }
par une seule boucle :
int i,j; for (int x = 0;x<64;x++) { i = x % 8; j = x/8; FaireQuelqueChose(i,j); }
je gagne quelque chose (en particulier en vitesse d'exécution du programme) ou si cela ne change rien ?
Ce n'est pas une optimisation courante, à mon avis il y a peu de chance de gagner quelque chose, le calcul des indices va sûrement coûter plus cher qu'une seconde boucle.
Une optimisation plus courante est de dérouler les boucles, par exemple :
for (int i = 0;i<8;i++) { FaireQuelqueChose(i,0); FaireQuelqueChose(i,1); FaireQuelqueChose(i,2); FaireQuelqueChose(i,3); FaireQuelqueChose(i,4); FaireQuelqueChose(i,5); FaireQuelqueChose(i,6); FaireQuelqueChose(i,7); }
À noter que certains compilateurs savent très bien faire par eux même ce genre d'optimisations.
-- Sylvain Togni
Je suis curieux de savoir si en remplaçant deux boucles imbriquées :
for (int i = 0;i<8;i++)
{
for (int j=0;j<8;j++)
{
FaireQuelqueChose(i,j);
}
}
par une seule boucle :
int i,j;
for (int x = 0;x<64;x++)
{
i = x % 8;
j = x/8;
FaireQuelqueChose(i,j);
}
je gagne quelque chose (en particulier en vitesse d'exécution du
programme) ou si cela ne change rien ?
Ce n'est pas une optimisation courante, à mon avis il y a peu de
chance de gagner quelque chose, le calcul des indices va sûrement
coûter plus cher qu'une seconde boucle.
Une optimisation plus courante est de dérouler les boucles, par
exemple :
for (int i = 0;i<8;i++)
{
FaireQuelqueChose(i,0);
FaireQuelqueChose(i,1);
FaireQuelqueChose(i,2);
FaireQuelqueChose(i,3);
FaireQuelqueChose(i,4);
FaireQuelqueChose(i,5);
FaireQuelqueChose(i,6);
FaireQuelqueChose(i,7);
}
À noter que certains compilateurs savent très bien faire par eux
même ce genre d'optimisations.
Je suis curieux de savoir si en remplaçant deux boucles imbriquées :
for (int i = 0;i<8;i++) { for (int j=0;j<8;j++) { FaireQuelqueChose(i,j); } }
par une seule boucle :
int i,j; for (int x = 0;x<64;x++) { i = x % 8; j = x/8; FaireQuelqueChose(i,j); }
je gagne quelque chose (en particulier en vitesse d'exécution du programme) ou si cela ne change rien ?
Ce n'est pas une optimisation courante, à mon avis il y a peu de chance de gagner quelque chose, le calcul des indices va sûrement coûter plus cher qu'une seconde boucle.
Une optimisation plus courante est de dérouler les boucles, par exemple :
for (int i = 0;i<8;i++) { FaireQuelqueChose(i,0); FaireQuelqueChose(i,1); FaireQuelqueChose(i,2); FaireQuelqueChose(i,3); FaireQuelqueChose(i,4); FaireQuelqueChose(i,5); FaireQuelqueChose(i,6); FaireQuelqueChose(i,7); }
À noter que certains compilateurs savent très bien faire par eux même ce genre d'optimisations.
-- Sylvain Togni
ByB
Sylvain Togni a émis l'idée suivante :
Je suis curieux de savoir si en remplaçant deux boucles imbriquées :
for (int i = 0;i<8;i++) { for (int j=0;j<8;j++) { FaireQuelqueChose(i,j); } }
par une seule boucle :
int i,j; for (int x = 0;x<64;x++) { i = x % 8; j = x/8; FaireQuelqueChose(i,j); }
je gagne quelque chose (en particulier en vitesse d'exécution du programme) ou si cela ne change rien ?
Ce n'est pas une optimisation courante, à mon avis il y a peu de chance de gagner quelque chose, le calcul des indices va sûrement coûter plus cher qu'une seconde boucle.
Une optimisation plus courante est de dérouler les boucles, par exemple :
for (int i = 0;i<8;i++) { FaireQuelqueChose(i,0); FaireQuelqueChose(i,1); FaireQuelqueChose(i,2); FaireQuelqueChose(i,3); FaireQuelqueChose(i,4); FaireQuelqueChose(i,5); FaireQuelqueChose(i,6); FaireQuelqueChose(i,7); }
À noter que certains compilateurs savent très bien faire par eux même ce genre d'optimisations.
Merci pour vos conseils. En fait, je suis en train de développer un programme qui joue à l'Othello, et je remarque que l'ordinateur met pas mal de temps à trouver le coup qu'il veut jouer. Mon code est plein de parcours du tableau de jeu (de 8x8 cases) et je cherchais un moyen d'accélérer les choses ...
-- Es de sabios lo comete cualquiera. (Chespirito)
Sylvain Togni a émis l'idée suivante :
Je suis curieux de savoir si en remplaçant deux boucles imbriquées :
for (int i = 0;i<8;i++)
{
for (int j=0;j<8;j++)
{
FaireQuelqueChose(i,j);
}
}
par une seule boucle :
int i,j;
for (int x = 0;x<64;x++)
{
i = x % 8;
j = x/8;
FaireQuelqueChose(i,j);
}
je gagne quelque chose (en particulier en vitesse d'exécution du programme)
ou si cela ne change rien ?
Ce n'est pas une optimisation courante, à mon avis il y a peu de
chance de gagner quelque chose, le calcul des indices va sûrement
coûter plus cher qu'une seconde boucle.
Une optimisation plus courante est de dérouler les boucles, par
exemple :
for (int i = 0;i<8;i++)
{
FaireQuelqueChose(i,0);
FaireQuelqueChose(i,1);
FaireQuelqueChose(i,2);
FaireQuelqueChose(i,3);
FaireQuelqueChose(i,4);
FaireQuelqueChose(i,5);
FaireQuelqueChose(i,6);
FaireQuelqueChose(i,7);
}
À noter que certains compilateurs savent très bien faire par eux
même ce genre d'optimisations.
Merci pour vos conseils.
En fait, je suis en train de développer un programme qui joue à
l'Othello, et je remarque que l'ordinateur met pas mal de temps à
trouver le coup qu'il veut jouer.
Mon code est plein de parcours du tableau de jeu (de 8x8 cases) et je
cherchais un moyen d'accélérer les choses ...
--
Es de sabios lo comete cualquiera. (Chespirito)
Je suis curieux de savoir si en remplaçant deux boucles imbriquées :
for (int i = 0;i<8;i++) { for (int j=0;j<8;j++) { FaireQuelqueChose(i,j); } }
par une seule boucle :
int i,j; for (int x = 0;x<64;x++) { i = x % 8; j = x/8; FaireQuelqueChose(i,j); }
je gagne quelque chose (en particulier en vitesse d'exécution du programme) ou si cela ne change rien ?
Ce n'est pas une optimisation courante, à mon avis il y a peu de chance de gagner quelque chose, le calcul des indices va sûrement coûter plus cher qu'une seconde boucle.
Une optimisation plus courante est de dérouler les boucles, par exemple :
for (int i = 0;i<8;i++) { FaireQuelqueChose(i,0); FaireQuelqueChose(i,1); FaireQuelqueChose(i,2); FaireQuelqueChose(i,3); FaireQuelqueChose(i,4); FaireQuelqueChose(i,5); FaireQuelqueChose(i,6); FaireQuelqueChose(i,7); }
À noter que certains compilateurs savent très bien faire par eux même ce genre d'optimisations.
Merci pour vos conseils. En fait, je suis en train de développer un programme qui joue à l'Othello, et je remarque que l'ordinateur met pas mal de temps à trouver le coup qu'il veut jouer. Mon code est plein de parcours du tableau de jeu (de 8x8 cases) et je cherchais un moyen d'accélérer les choses ...
-- Es de sabios lo comete cualquiera. (Chespirito)
Fabien LE LEZ
On Sat, 29 Jul 2006 15:25:54 +0200, "ByB" :
En fait, je suis en train de développer un programme qui joue à l'Othello, et je remarque que l'ordinateur met pas mal de temps à trouver le coup qu'il veut jouer.
Donc, il te faut un profiler. Si tu programmes avec g++, utilise gprof. Sinon, pour Windows, j'aime assez LtProf <http://www.lw-tech.com> -- basique, mais il rend bien des services.
Mon code est plein de parcours du tableau de jeu (de 8x8 cases) et je cherchais un moyen d'accélérer les choses ...
Ce n'est pas en bricolant sur les boucles que tu arriveras à quelque chose. Assure-toi néanmoins que toutes les options d'optimisation de ton compilo sont activées.
Une fois que tu auras identifié les fonctions qui prennent du temps, tu seras peut-être amené à changer la structure de données, ou de garder des données en "cache" (Par exemple, créer la liste des cases vides une fois pour toutes, au lieu de la calculer plusieurs fois.)
Vérifie aussi que ton algorithme est adéquat -- cf fr.comp.algorithmes.
On Sat, 29 Jul 2006 15:25:54 +0200, "ByB" <email@email.com>:
En fait, je suis en train de développer un programme qui joue à
l'Othello, et je remarque que l'ordinateur met pas mal de temps à
trouver le coup qu'il veut jouer.
Donc, il te faut un profiler.
Si tu programmes avec g++, utilise gprof.
Sinon, pour Windows, j'aime assez LtProf <http://www.lw-tech.com> --
basique, mais il rend bien des services.
Mon code est plein de parcours du tableau de jeu (de 8x8 cases) et je
cherchais un moyen d'accélérer les choses ...
Ce n'est pas en bricolant sur les boucles que tu arriveras à quelque
chose. Assure-toi néanmoins que toutes les options d'optimisation de
ton compilo sont activées.
Une fois que tu auras identifié les fonctions qui prennent du temps,
tu seras peut-être amené à changer la structure de données, ou de
garder des données en "cache" (Par exemple, créer la liste des cases
vides une fois pour toutes, au lieu de la calculer plusieurs fois.)
Vérifie aussi que ton algorithme est adéquat -- cf
fr.comp.algorithmes.
En fait, je suis en train de développer un programme qui joue à l'Othello, et je remarque que l'ordinateur met pas mal de temps à trouver le coup qu'il veut jouer.
Donc, il te faut un profiler. Si tu programmes avec g++, utilise gprof. Sinon, pour Windows, j'aime assez LtProf <http://www.lw-tech.com> -- basique, mais il rend bien des services.
Mon code est plein de parcours du tableau de jeu (de 8x8 cases) et je cherchais un moyen d'accélérer les choses ...
Ce n'est pas en bricolant sur les boucles que tu arriveras à quelque chose. Assure-toi néanmoins que toutes les options d'optimisation de ton compilo sont activées.
Une fois que tu auras identifié les fonctions qui prennent du temps, tu seras peut-être amené à changer la structure de données, ou de garder des données en "cache" (Par exemple, créer la liste des cases vides une fois pour toutes, au lieu de la calculer plusieurs fois.)
Vérifie aussi que ton algorithme est adéquat -- cf fr.comp.algorithmes.
Gabriel Dos Reis
Fabien LE LEZ writes:
| On Sat, 29 Jul 2006 15:25:54 +0200, "ByB" : | | >En fait, je suis en train de développer un programme qui joue à | >l'Othello, et je remarque que l'ordinateur met pas mal de temps à | >trouver le coup qu'il veut jouer. | | Donc, il te faut un profiler. | Si tu programmes avec g++, utilise gprof.
gprof avec C++, c'est pas top -- il faut linker statiquement plein de trucs autrement ça donne rien.
-- Gaby
Fabien LE LEZ <gramster@gramster.com> writes:
| On Sat, 29 Jul 2006 15:25:54 +0200, "ByB" <email@email.com>:
|
| >En fait, je suis en train de développer un programme qui joue à
| >l'Othello, et je remarque que l'ordinateur met pas mal de temps à
| >trouver le coup qu'il veut jouer.
|
| Donc, il te faut un profiler.
| Si tu programmes avec g++, utilise gprof.
gprof avec C++, c'est pas top -- il faut linker statiquement plein de
trucs autrement ça donne rien.
| On Sat, 29 Jul 2006 15:25:54 +0200, "ByB" : | | >En fait, je suis en train de développer un programme qui joue à | >l'Othello, et je remarque que l'ordinateur met pas mal de temps à | >trouver le coup qu'il veut jouer. | | Donc, il te faut un profiler. | Si tu programmes avec g++, utilise gprof.
gprof avec C++, c'est pas top -- il faut linker statiquement plein de trucs autrement ça donne rien.
-- Gaby
ByB
A peine arrivée chez Fabien LE LEZ, l'info suivante nous est retransmise :
On Sat, 29 Jul 2006 03:15:09 +0200, "ByB" :
je gagne quelque chose (en particulier en vitesse d'exécution du programme) ou si cela ne change rien ?
À vue de nez, ça doit varier énormément suivant le compilateur et les options de compilation. Mais il y a des chances pour que l'appel de la fonction "FaireQuelqueChose" (s'il y a bien appel, i.e. si le compilo n'a pas inliné "FaireQuelqueChose") prenne nettement plus de temps que tout le reste.
Normalement, on ne se pose pas ce genre de questions, du moins pas a priori : on programme de la façon la plus naturelle possible (ici, je pense que c'est la version à deux boucles, mais ça dépend de ton application), puis, si le besoin s'en fait sentir, on détecte les goulots d'étranglement avec un profiler.
Où puis je trouver un profiler ? Le logiciel Purify (auquel je peux avoir accès) est il un profiler ou peut-il être utilisé comme tel ?
-- Mas vale solo que mal que por bien no venga. (Chespirito)
A peine arrivée chez Fabien LE LEZ, l'info suivante nous est
retransmise :
On Sat, 29 Jul 2006 03:15:09 +0200, "ByB" <email@email.com>:
je gagne quelque chose (en particulier en vitesse d'exécution du
programme) ou si cela ne change rien ?
À vue de nez, ça doit varier énormément suivant le compilateur et les
options de compilation. Mais il y a des chances pour que l'appel de la
fonction "FaireQuelqueChose" (s'il y a bien appel, i.e. si le compilo
n'a pas inliné "FaireQuelqueChose") prenne nettement plus de temps que
tout le reste.
Normalement, on ne se pose pas ce genre de questions, du moins pas a
priori : on programme de la façon la plus naturelle possible (ici, je
pense que c'est la version à deux boucles, mais ça dépend de ton
application), puis, si le besoin s'en fait sentir, on détecte les
goulots d'étranglement avec un profiler.
Où puis je trouver un profiler ?
Le logiciel Purify (auquel je peux avoir accès) est il un profiler ou
peut-il être utilisé comme tel ?
--
Mas vale solo que mal que por bien no venga. (Chespirito)
A peine arrivée chez Fabien LE LEZ, l'info suivante nous est retransmise :
On Sat, 29 Jul 2006 03:15:09 +0200, "ByB" :
je gagne quelque chose (en particulier en vitesse d'exécution du programme) ou si cela ne change rien ?
À vue de nez, ça doit varier énormément suivant le compilateur et les options de compilation. Mais il y a des chances pour que l'appel de la fonction "FaireQuelqueChose" (s'il y a bien appel, i.e. si le compilo n'a pas inliné "FaireQuelqueChose") prenne nettement plus de temps que tout le reste.
Normalement, on ne se pose pas ce genre de questions, du moins pas a priori : on programme de la façon la plus naturelle possible (ici, je pense que c'est la version à deux boucles, mais ça dépend de ton application), puis, si le besoin s'en fait sentir, on détecte les goulots d'étranglement avec un profiler.
Où puis je trouver un profiler ? Le logiciel Purify (auquel je peux avoir accès) est il un profiler ou peut-il être utilisé comme tel ?
-- Mas vale solo que mal que por bien no venga. (Chespirito)
ByB
Bien que tout le monde le sache déjà, Fabien LE LEZ a décidé de nous écrire que ...
On Sat, 29 Jul 2006 03:15:09 +0200, "ByB" :
je gagne quelque chose (en particulier en vitesse d'exécution du programme) ou si cela ne change rien ?
À vue de nez, ça doit varier énormément suivant le compilateur et les options de compilation. Mais il y a des chances pour que l'appel de la fonction "FaireQuelqueChose" (s'il y a bien appel, i.e. si le compilo n'a pas inliné "FaireQuelqueChose") prenne nettement plus de temps que tout le reste.
Normalement, on ne se pose pas ce genre de questions, du moins pas a priori : on programme de la façon la plus naturelle possible (ici, je pense que c'est la version à deux boucles, mais ça dépend de ton application), puis, si le besoin s'en fait sentir, on détecte les goulots d'étranglement avec un profiler.
Où puis je trouver un profiler ? Rational Rose (auquel je peux avoir accès) est il un profiler ?
-- Tout métier qui ne fait pas oublier le travail est un esclavage. [Henri Jeanson]
Bien que tout le monde le sache déjà, Fabien LE LEZ a décidé de nous
écrire que ...
On Sat, 29 Jul 2006 03:15:09 +0200, "ByB" <email@email.com>:
je gagne quelque chose (en particulier en vitesse d'exécution du
programme) ou si cela ne change rien ?
À vue de nez, ça doit varier énormément suivant le compilateur et les
options de compilation. Mais il y a des chances pour que l'appel de la
fonction "FaireQuelqueChose" (s'il y a bien appel, i.e. si le compilo
n'a pas inliné "FaireQuelqueChose") prenne nettement plus de temps que
tout le reste.
Normalement, on ne se pose pas ce genre de questions, du moins pas a
priori : on programme de la façon la plus naturelle possible (ici, je
pense que c'est la version à deux boucles, mais ça dépend de ton
application), puis, si le besoin s'en fait sentir, on détecte les
goulots d'étranglement avec un profiler.
Où puis je trouver un profiler ?
Rational Rose (auquel je peux avoir accès) est il un profiler ?
--
Tout métier qui ne fait pas oublier le travail est un esclavage. [Henri
Jeanson]
Bien que tout le monde le sache déjà, Fabien LE LEZ a décidé de nous écrire que ...
On Sat, 29 Jul 2006 03:15:09 +0200, "ByB" :
je gagne quelque chose (en particulier en vitesse d'exécution du programme) ou si cela ne change rien ?
À vue de nez, ça doit varier énormément suivant le compilateur et les options de compilation. Mais il y a des chances pour que l'appel de la fonction "FaireQuelqueChose" (s'il y a bien appel, i.e. si le compilo n'a pas inliné "FaireQuelqueChose") prenne nettement plus de temps que tout le reste.
Normalement, on ne se pose pas ce genre de questions, du moins pas a priori : on programme de la façon la plus naturelle possible (ici, je pense que c'est la version à deux boucles, mais ça dépend de ton application), puis, si le besoin s'en fait sentir, on détecte les goulots d'étranglement avec un profiler.
Où puis je trouver un profiler ? Rational Rose (auquel je peux avoir accès) est il un profiler ?
-- Tout métier qui ne fait pas oublier le travail est un esclavage. [Henri Jeanson]
ByB
Fabien LE LEZ avait écrit le 29/07/2006 :
On Sat, 29 Jul 2006 03:15:09 +0200, "ByB" :
je gagne quelque chose (en particulier en vitesse d'exécution du programme) ou si cela ne change rien ?
À vue de nez, ça doit varier énormément suivant le compilateur et les options de compilation. Mais il y a des chances pour que l'appel de la fonction "FaireQuelqueChose" (s'il y a bien appel, i.e. si le compilo n'a pas inliné "FaireQuelqueChose") prenne nettement plus de temps que tout le reste.
Normalement, on ne se pose pas ce genre de questions, du moins pas a priori : on programme de la façon la plus naturelle possible (ici, je pense que c'est la version à deux boucles, mais ça dépend de ton application), puis, si le besoin s'en fait sentir, on détecte les goulots d'étranglement avec un profiler.
Où puis je trouver un progiler ? Le logiciel Purify (auquel je peux avoir accès) est il un profiler ?
-- Les pommes de terre cuites sont plus digestes que les pommes en terre cuite. (Alphonse Allais)
Fabien LE LEZ avait écrit le 29/07/2006 :
On Sat, 29 Jul 2006 03:15:09 +0200, "ByB" <email@email.com>:
je gagne quelque chose (en particulier en vitesse d'exécution du
programme) ou si cela ne change rien ?
À vue de nez, ça doit varier énormément suivant le compilateur et les
options de compilation. Mais il y a des chances pour que l'appel de la
fonction "FaireQuelqueChose" (s'il y a bien appel, i.e. si le compilo
n'a pas inliné "FaireQuelqueChose") prenne nettement plus de temps que
tout le reste.
Normalement, on ne se pose pas ce genre de questions, du moins pas a
priori : on programme de la façon la plus naturelle possible (ici, je
pense que c'est la version à deux boucles, mais ça dépend de ton
application), puis, si le besoin s'en fait sentir, on détecte les
goulots d'étranglement avec un profiler.
Où puis je trouver un progiler ?
Le logiciel Purify (auquel je peux avoir accès) est il un profiler ?
--
Les pommes de terre cuites sont plus digestes que les pommes en terre
cuite. (Alphonse Allais)
je gagne quelque chose (en particulier en vitesse d'exécution du programme) ou si cela ne change rien ?
À vue de nez, ça doit varier énormément suivant le compilateur et les options de compilation. Mais il y a des chances pour que l'appel de la fonction "FaireQuelqueChose" (s'il y a bien appel, i.e. si le compilo n'a pas inliné "FaireQuelqueChose") prenne nettement plus de temps que tout le reste.
Normalement, on ne se pose pas ce genre de questions, du moins pas a priori : on programme de la façon la plus naturelle possible (ici, je pense que c'est la version à deux boucles, mais ça dépend de ton application), puis, si le besoin s'en fait sentir, on détecte les goulots d'étranglement avec un profiler.
Où puis je trouver un progiler ? Le logiciel Purify (auquel je peux avoir accès) est il un profiler ?
-- Les pommes de terre cuites sont plus digestes que les pommes en terre cuite. (Alphonse Allais)
Fabien LE LEZ
On Sat, 29 Jul 2006 16:49:38 +0200, "ByB" :
Où puis je trouver un profiler ?
Cf mon autre message.
Le logiciel Purify (auquel je peux avoir accès) est il un profiler
Non. Purify est un détecteur d'erreurs. Un profiler ne détecte pas les erreurs, il chronomètre chaque instruction.
On Sat, 29 Jul 2006 16:49:38 +0200, "ByB" <email@email.com>:
Où puis je trouver un profiler ?
Cf mon autre message.
Le logiciel Purify (auquel je peux avoir accès) est il un profiler
Non. Purify est un détecteur d'erreurs. Un profiler ne détecte pas les
erreurs, il chronomètre chaque instruction.
