lorsque je fais un "hello word" basique (avec printf) et que je le compile
avec gcc, il fait 24 Ko, lorsque je le compile avec lcc-win32, il fait 4 Ko.
Bon alors je me pose des questions. Oui je sais la taille d'un executable
c'est la dernière chose à regarder, mais bon, quand même, c'est pas une
petite différence (20 Ko).
Alors d'une part je voudrais savoir si vous connaissez des logiciels
permettant de mesurer la temps d'execution (genre combien de temps mettent
hello-lcc.exe et hello-gcc.exe pour s'executer).
D'autre part, puisque mon code est destiné à win32, lequel des deux
compilateurs il vaut mieux que j'utilise ? Remarque, en compilateur gratuit,
il y aurait bien également le borland 5, et le visual, mais ce dernier ne
donne pas les meme possibilités d'optimisation que celui (payant) de la
version pro (le gratuit = celui de la version standard). Bref quel
compilateur choisir pour win ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Gabriel Dos Reis
Richard Delorme writes:
| | > Bonjour, | > | > lorsque je fais un "hello word" basique (avec printf) et que je le compile | > avec gcc, il fait 24 Ko, lorsque je le compile avec lcc-win32, il fait 4 | > Ko. Bon alors je me pose des questions. Oui je sais la taille d'un | > executable c'est la dernière chose à regarder, mais bon, quand même, c'est | > pas une petite différence (20 Ko). | | Non, ça ne veut rien dire, car les programmes exécutable peuvent utiliser | des bibliothèques partagées qui sont potentiellement énormes, sans compter | qu'il peuvent demander des ressources (mémoire ou autre) sans rapport avec | leur taille.
Il est aussi à noter que printf() entraine une grosse bibliothèque derrière -- si le système implémente les exigences de POSIX et le support pour l'i18n. Ce qui n'est pas le cas de puts().
-- Gaby
Richard Delorme <abulmo@nospam.fr> writes:
|
| > Bonjour,
| >
| > lorsque je fais un "hello word" basique (avec printf) et que je le compile
| > avec gcc, il fait 24 Ko, lorsque je le compile avec lcc-win32, il fait 4
| > Ko. Bon alors je me pose des questions. Oui je sais la taille d'un
| > executable c'est la dernière chose à regarder, mais bon, quand même, c'est
| > pas une petite différence (20 Ko).
|
| Non, ça ne veut rien dire, car les programmes exécutable peuvent utiliser
| des bibliothèques partagées qui sont potentiellement énormes, sans compter
| qu'il peuvent demander des ressources (mémoire ou autre) sans rapport avec
| leur taille.
Il est aussi à noter que printf() entraine une grosse bibliothèque
derrière -- si le système implémente les exigences de POSIX et le
support pour l'i18n. Ce qui n'est pas le cas de puts().
| | > Bonjour, | > | > lorsque je fais un "hello word" basique (avec printf) et que je le compile | > avec gcc, il fait 24 Ko, lorsque je le compile avec lcc-win32, il fait 4 | > Ko. Bon alors je me pose des questions. Oui je sais la taille d'un | > executable c'est la dernière chose à regarder, mais bon, quand même, c'est | > pas une petite différence (20 Ko). | | Non, ça ne veut rien dire, car les programmes exécutable peuvent utiliser | des bibliothèques partagées qui sont potentiellement énormes, sans compter | qu'il peuvent demander des ressources (mémoire ou autre) sans rapport avec | leur taille.
Il est aussi à noter que printf() entraine une grosse bibliothèque derrière -- si le système implémente les exigences de POSIX et le support pour l'i18n. Ce qui n'est pas le cas de puts().
-- Gaby
Antoine Leca
TheBouba écrivit:
lorsque je fais un "hello word" basique (avec printf) et que je le compile avec gcc, il fait 24 Ko,
Je ne sais pas quelle version, quelles options de compilation, ni quel environnement tu utilises. Avec MingW32 (comparable à lcc-win32, puisqu'ils utilisent la même bibliothèque), v.3.0rc3, donc gcc 3.2.3, j'obtiens 5120 octets. Sachant que la granularité est de 1024 octets, je considère qu'il n'y a aucune différence.
Le plus probable, c'est que tu aies oublié l'option -s (par défaut, gcc génère les options de débogage ; c'est logique, puisque tu compiles le plus souvent pour le mise au point, seules les toutes dernières compilations sont "pour production").
lorsque je le compile avec lcc-win32, il fait 4 Ko. Bon alors je me pose des questions.
Arrête. Tu oublies dans ton calcul MSVCRT.DLL. Qui fait sur ma machine 278.581 octets (et c'est une version petite). Autrement dit, tes 20 kilos de différence, c'est rien.
Alors d'une part je voudrais savoir si vous connaissez des logiciels permettant de mesurer la temps d'execution (genre combien de temps mettent hello-lcc.exe et hello-gcc.exe pour s'executer).
Soyons clair: ces programmes écrivent (à l'écran) ; donc ce que tu vas tester, c'est la vitesse d'affichage à l'écran (en supposant que tu neutralises les effets d'être ou pas dans la cache). Le code objet doit être le même (l'initialisation de la DLL, un CALL à _printf, un RET et le code de finalisation de la DLL), il ne devrait donc y avoir aucune différence palpable de temps d'éxécution; et s'il y en a, elle est à mettre en relief en face de a) la raison pour laquelle les codes d'initialisation font ou pas telle ou telle action (par exemple, les vieilles versions des environnments Mingw32 ou lcc-win32 n'initialisaient peut-être pas correctement MSVCRT sur un OS comme XP...) b) le temps que mets Windows à lancer le programme (créer le processus, etc.) est de plusieurs ordres de grandeur supérieur au temps d'exécution c) si tu compares avec Cygwin ou DJGPP, (donc des bibliothèques différentes), tu vas constater des performances nettement inférieurs sur ton exemple particulier, parce que l'initialisation de ces environnements (pseudo Posix ou la machine virtuelle DOS) est beaucoup plus long ; si par contre tu utilises PW32, ou la bibliothèque POSIX de Microsoft (PSXDLL), cela ira plus vite. Et tout cela, avec le même compilateur (gcc), et le même code objet...
D'autre part, puisque mon code est destiné à win32, lequel des deux compilateurs il vaut mieux que j'utilise ?
Pour quoi faire (quel projet) ? Pour compiler Hello_world, n'importe lequel fait l'affaire ;-)
Pour recompiler, j'aime bien celui de Borland, parce qu'il compile un poil plus vite (lcc aussi est bien pour cela). Pour l'optimisation, celui d'Intel reçoit en général de grands éloges. Le mieux, àmha, et en restant en C, c'est de développer du code qui compile sur tous (c'est pas sorcier, juste prendre le temps de lire les descriptions des routines de bibliothèques dans _plusieurs_ aides en ligne ensuite tu prends le dénominateur commun, et fuire comme la peste les extensions).
Antoine
TheBouba écrivit:
lorsque je fais un "hello word" basique (avec printf) et que je le
compile avec gcc, il fait 24 Ko,
Je ne sais pas quelle version, quelles options de compilation,
ni quel environnement tu utilises.
Avec MingW32 (comparable à lcc-win32, puisqu'ils utilisent la
même bibliothèque), v.3.0rc3, donc gcc 3.2.3, j'obtiens
5120 octets. Sachant que la granularité est de 1024 octets,
je considère qu'il n'y a aucune différence.
Le plus probable, c'est que tu aies oublié l'option -s (par défaut,
gcc génère les options de débogage ; c'est logique, puisque tu
compiles le plus souvent pour le mise au point, seules les
toutes dernières compilations sont "pour production").
lorsque je le compile avec lcc-win32, il fait 4 Ko.
Bon alors je me pose des questions.
Arrête. Tu oublies dans ton calcul MSVCRT.DLL. Qui fait
sur ma machine 278.581 octets (et c'est une version petite).
Autrement dit, tes 20 kilos de différence, c'est rien.
Alors d'une part je voudrais savoir si vous connaissez des logiciels
permettant de mesurer la temps d'execution (genre combien de temps
mettent hello-lcc.exe et hello-gcc.exe pour s'executer).
Soyons clair: ces programmes écrivent (à l'écran) ; donc ce que
tu vas tester, c'est la vitesse d'affichage à l'écran (en supposant
que tu neutralises les effets d'être ou pas dans la cache).
Le code objet doit être le même (l'initialisation de la DLL, un
CALL à _printf, un RET et le code de finalisation de la DLL),
il ne devrait donc y avoir aucune différence palpable de temps
d'éxécution; et s'il y en a, elle est à mettre en relief en face de
a) la raison pour laquelle les codes d'initialisation font ou pas
telle ou telle action (par exemple, les vieilles versions des
environnments Mingw32 ou lcc-win32 n'initialisaient peut-être
pas correctement MSVCRT sur un OS comme XP...)
b) le temps que mets Windows à lancer le programme (créer
le processus, etc.) est de plusieurs ordres de grandeur
supérieur au temps d'exécution
c) si tu compares avec Cygwin ou DJGPP, (donc des
bibliothèques différentes), tu vas constater des performances
nettement inférieurs sur ton exemple particulier, parce que
l'initialisation de ces environnements (pseudo Posix ou la
machine virtuelle DOS) est beaucoup plus long ; si par
contre tu utilises PW32, ou la bibliothèque POSIX de
Microsoft (PSXDLL), cela ira plus vite. Et tout cela, avec
le même compilateur (gcc), et le même code objet...
D'autre part, puisque mon code est destiné à win32, lequel des deux
compilateurs il vaut mieux que j'utilise ?
Pour quoi faire (quel projet) ?
Pour compiler Hello_world, n'importe lequel fait l'affaire ;-)
Pour recompiler, j'aime bien celui de Borland, parce qu'il
compile un poil plus vite (lcc aussi est bien pour cela).
Pour l'optimisation, celui d'Intel reçoit en général de grands
éloges. Le mieux, àmha, et en restant en C, c'est de
développer du code qui compile sur tous (c'est pas sorcier,
juste prendre le temps de lire les descriptions des routines
de bibliothèques dans _plusieurs_ aides en ligne ensuite tu
prends le dénominateur commun, et fuire comme la peste
les extensions).
lorsque je fais un "hello word" basique (avec printf) et que je le compile avec gcc, il fait 24 Ko,
Je ne sais pas quelle version, quelles options de compilation, ni quel environnement tu utilises. Avec MingW32 (comparable à lcc-win32, puisqu'ils utilisent la même bibliothèque), v.3.0rc3, donc gcc 3.2.3, j'obtiens 5120 octets. Sachant que la granularité est de 1024 octets, je considère qu'il n'y a aucune différence.
Le plus probable, c'est que tu aies oublié l'option -s (par défaut, gcc génère les options de débogage ; c'est logique, puisque tu compiles le plus souvent pour le mise au point, seules les toutes dernières compilations sont "pour production").
lorsque je le compile avec lcc-win32, il fait 4 Ko. Bon alors je me pose des questions.
Arrête. Tu oublies dans ton calcul MSVCRT.DLL. Qui fait sur ma machine 278.581 octets (et c'est une version petite). Autrement dit, tes 20 kilos de différence, c'est rien.
Alors d'une part je voudrais savoir si vous connaissez des logiciels permettant de mesurer la temps d'execution (genre combien de temps mettent hello-lcc.exe et hello-gcc.exe pour s'executer).
Soyons clair: ces programmes écrivent (à l'écran) ; donc ce que tu vas tester, c'est la vitesse d'affichage à l'écran (en supposant que tu neutralises les effets d'être ou pas dans la cache). Le code objet doit être le même (l'initialisation de la DLL, un CALL à _printf, un RET et le code de finalisation de la DLL), il ne devrait donc y avoir aucune différence palpable de temps d'éxécution; et s'il y en a, elle est à mettre en relief en face de a) la raison pour laquelle les codes d'initialisation font ou pas telle ou telle action (par exemple, les vieilles versions des environnments Mingw32 ou lcc-win32 n'initialisaient peut-être pas correctement MSVCRT sur un OS comme XP...) b) le temps que mets Windows à lancer le programme (créer le processus, etc.) est de plusieurs ordres de grandeur supérieur au temps d'exécution c) si tu compares avec Cygwin ou DJGPP, (donc des bibliothèques différentes), tu vas constater des performances nettement inférieurs sur ton exemple particulier, parce que l'initialisation de ces environnements (pseudo Posix ou la machine virtuelle DOS) est beaucoup plus long ; si par contre tu utilises PW32, ou la bibliothèque POSIX de Microsoft (PSXDLL), cela ira plus vite. Et tout cela, avec le même compilateur (gcc), et le même code objet...
D'autre part, puisque mon code est destiné à win32, lequel des deux compilateurs il vaut mieux que j'utilise ?
Pour quoi faire (quel projet) ? Pour compiler Hello_world, n'importe lequel fait l'affaire ;-)
Pour recompiler, j'aime bien celui de Borland, parce qu'il compile un poil plus vite (lcc aussi est bien pour cela). Pour l'optimisation, celui d'Intel reçoit en général de grands éloges. Le mieux, àmha, et en restant en C, c'est de développer du code qui compile sur tous (c'est pas sorcier, juste prendre le temps de lire les descriptions des routines de bibliothèques dans _plusieurs_ aides en ligne ensuite tu prends le dénominateur commun, et fuire comme la peste les extensions).
