Discussion :

[Clandestino]

Vous avez sans doute remarqué que lazarus compile des executables de taille assez conséquente.
La raison est la suivante : lazarus compile en incluant les symboles nécessaires au débugguage.
Pour remédier à celà, lazarus est livré avec un utilitaire nommé strip qui vous permet de vous débarasser de ces octets superflus.
L'inconvénient de cet utilitaire, c'est qu'il faut le lancer en ligne de commande.
Heureusement lazarus offre la possibilité d'intégrer ce genre d'utilitaires dans son IDE. Pour celà utilisez le menu :

menu Outils >> Configurer les outils personnalisés

puis appuyez sur le bouton :

+ Ajouter

Remplissez ainsi la fenêtre qui s'ouvre :

Champ Titre >> Stripper mon projet
Champ Fichier du programme (sous windows) >> C:\lazarus\pp\bin\i386-win32\strip.exe
Champ Fichier du programme (sous Linux) >> /usr/bin/strip
Champ Paramètres >> $(TargetFile)
Champ Répertoire de travail >> $(ProjPath)
puis cocher l'option Rechercher les messages de sortie de FPC
puis cocher successivement Ctrl, Alt, Shift
Champ touche choisir 'S'

Validez votre choix deux fois par ok.

Grace à cette petite manipulation, le menu outils vous donne accès à une nouvelle fonction nommée Stripper mon projet qui peux reduire considérablement la taille du fichier généré... (après compilation).
Cette fonction est accessible aussi par le racourci clavier :

Code :

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

CTRL ALT SHIFT S

Dommage pour ceux qui tapent à deux doigts...


PS:
La même manipulation peut-être faite avec le programme UPX. cependant, si celui-ci compresse la taille du fichier sur votre disque, il le décompresse en mémoire au moment de l'utiliser. A vous de voir si vous souhaitez l'utiliser


Bonne programmation

Clandestino

[JoseF]

Merci de l'info. je faisais tout cela en mode console !

Je vais paramétrer l'IDE pour integrer Strip et UPX . car mes executables de 8M.... pas terribles..

Même si UPX decompresse en mémoire ça prend moins de place sur disque et plus facile à proposer en téléchargement

autre point ( j'utilise assez souvent freepascal avec votre outil minipascal et là c'est super pratique quand je teste des petits bouts de code.


JoseF

[Hibou57]

Hello

Je viens justement de faire cette triste découverte également : un simple Hello world (ou plutôt un coucou, chez moi), compilé sur un serveur linux avec FPC 2.0.4, fait quand même 105 KB !

Je connaissais ce problème avec Gnat, un compilateur Ada... et j'espérais secrêtement, ayant de bon souvenir de la taille des exe produit par TurboPascal, que FPC ferait peut-être aussi bien, et serait un bon substitut à Gnat.

Malhreusement non.

J'ai essayé les méthodes que vous donnez ici, et les 105 KB que j'obtiens pour un programme qui ne contient rien d'autres qu'un WriteLn ('Coucou '); sont beaucoup trop.

Comme la solutions donnée ici n'aboutit à rien de bon : est-ce que quelqu'un(e) connais la cause de la grande taille des exe produit par FPC ? Est-ce que c'est la runtime ? Et si oui, existe t-il des runtimes alernatives pour produire des exe plus petits ?

Comprendre et connaître la cause du phénomène aiderait beaucoup, et c'est sûrement cela qui manque.

Bye-bye

[Ultima]

Bonjour,
105KB pour writeln('coucou') ?
Je suis étonné !!
Je viens de faire des testes ;
Quand on compile par la ligne de commande, comme je l'ai toujours fait, il n'y a pas d'information de débogage enregistrés. Donc ton exécutable "coucou" ne prend pas plus de 30KB.
Si tu tiens absolument à utiliser l'IDE, il te suffit d’aller sur options>>debugger
En suite tu coches "Strip all debug symbols from executable".
Le tour est joué.

[Hibou57]

Bonjour Ultima, et merci pour ta réponse.

Je n'utilise pas l'IDE, car j'eccede au serveur via une connextion ssh, et ce genre d'environnement ne permet pas toujours d'executer ce d'application.

Donc je compile en ligne de commande, et mon fichier fpc.cfg indique les options suivante :

• -Og2p1 i.e. Optimise pour le taille (sans les optimisations non-sûres) et pour le i386/486).
• -Xs i.e. Strip tout les symbole de l'executable produit.
• -Mtp i.e. compatibilité Borland TP7
• -Rintel i.e. assembleur Intel (mais je ne pense pas que ça ai une influance sur le code produit)
• -Sgt (sans influance sur la taille du code)
• -l l'option -l n'est pas présente (d'ailleur je n'ai jamais vu de logo texte FPC apparaître au lancement du programme)
• -XD J'ai essayé l'option -XD (smart linking), mais ça ne donne rien. Peut-être que je devrais recompiler la unit system avec cette option... Avec quelles options a été compilé ta unit system chez toi ?

(EDIT 20 apr 2007 17:13 GMT+2 - le SmartLinking se commande avec l'option -XX, et non pas l'option -XD comme je l'ai cru par erreur - la solution se trouve finalement là - voir deux post plus bas pour tout les détails)

Quel est le contenu de ton fichier fpc.cfg ? Est-ce que tu pourrais me le transmettre ?

Ensuite je restrip en ligne de commande (ce qui ne réduit pas la taille de l'exe).

Je n'utilise aucun framework (évidement), et donc le problème ne vient pas de là.

Etant donné que c'est pour du CGI, le temps de chargement est important pour moi.

Par contre j'ai appris, et j'ai vérifié, que les exe produit sont en liaison statiques... et pour le coup, un exe en liaison statique qui fait cette taille, c'est déjà un peu plus raisonnable (peut-être la RTL est implémenté avec les syscalls du kernel) et cela améliore certainement le temps de chargement.

Mais malgré tout, c'est étrange.

J'ai appris que si la RTL de Freepascal prend de la place, c'est à cause du texte des messages d'erreur qu'elle contient et des fonctions d'internationalisation. Mais pour des CGI, je ne veux pas que si me reposer sur le traitement standard des erreurs... et on comprend bien qu'un CGI qui plante, a mieux a faire que de renvoyer un message de runtime error sur le flux de sorti Alors si je pouvais l'éliminer, ce n'en serait que mieux pour deux raisons (raison de taille et raison de logique). Idem pour les fonctions d'internationalisation qui ne concerne pas un CGI (les CGI, même s'ils sont concernés par cet aspect, le gère autrement : il internationalise pour le visiteur d'un site, et non pas pour l'utilisateur d'un OS).

Peut-être qu'en allant dans le code de System.pas je pourrais retirer ces quelques fonctionalité qui ne sont pas les bienvenues pour un CGI (surtout la partie de code de traitement par défaut des erreurs.. qui ne convient pas du tout pour un CGI).

Note :

J'ai quand même put installer FPC sur mon serveur, en ayant aucun droit root ni autre chose. Il m'a suffit de copier les fichier dans un repertoire, d'ajouter une variable PPC_CONFIG_PATH qui est initilisé dans mon .bash_login, d'écrire le fichier de configuration avec les chemin vers les fichiers nécéssaire au bon fonctionnement de FPC, et ça marche parfaitement (sauf l'IDE qui ne fonctionne pas, mais ça fait bien longtemps que je n'en utilise plus... parce gdb, c'est pas mon truc... le debugger de Borland TP était bien meilleur).

Pour le coté facilité d'installation, FreePascal est une merveille : il n'a aucune dépendence, et produit des executable qui n'ont pas non-plus de dépedance. Comparé au compilateur Ada, Gnat, que je me suis arraché les cheveux pendant plusieurs semaines à essayer de l'installer... FreePascal est vraiment une crème, et je suis bien content d'avoir trouvé une alternative (Pascal n'est pas aussi formel que Ada... mais c'est suffisement pour les CGI que je prévois de programmer).

Alors malgré le problème de la taille des exe : vive FreePascal

P.S. Il semble que ce topic soit lié à celui-ci également
http://www.developpez.net/forums/sho...d.php?t=201095
j'y ai trouvé un lien interessant :
http://wiki.freepascal.org/index.php/Size_Matters
... mais qui est quand même un peu naïf sur certain point (je suis désolé de contredire l'auteur de cette page, mais la taille des programme n'est pas faire pour augmenter indéfiniment... et il y a un ras-le-bol général sur la notion de toujours-plus qui nous pollu la vie... alors je ne pense pas que cette exigence soit une maladie mentale, comme il semble le dire à mi-mot)

[Ultima]

Bonjour,
Je crains de ne pouvoir t’aider ;
Mais voici mon fichier fp.cfg (je crois que le fichier fpc.cfg est le mm pour tt le monde):

# Automaticly created file, don't edit.
#IFDEF NORMAL
-TWin32
-Sg
-Mfpc
-O1
-OG
-Op3
-Ratt
-FuC:\FPC\2.0.4\units\i386-Win32
-FuC:\FPC\2.0.4\units\i386-Win32\*
-FuC:\FPC\2.0.4\units\i386-Win32\rtl
-g-
-p-
-b-
#ENDIF

#IFDEF DEBUG
-TWin32
-Sg
-Mfpc
-Cr
-Ci
-Co
-OG
-Op3
-Ratt
-FuC:\FPC\2.0.4\units\i386-Win32
-FuC:\FPC\2.0.4\units\i386-Win32\*
-FuC:\FPC\2.0.4\units\i386-Win32\rtl
-Xs
-g-
-p-
-b-
#ENDIF

#IFDEF RELEASE
-TWin32
-Sg
-Mfpc
-O1
-O2
-OG
-Op3
-Ratt
-FuC:\FPC\2.0.4\units\i386-Win32
-FuC:\FPC\2.0.4\units\i386-Win32\*
-FuC:\FPC\2.0.4\units\i386-Win32\rtl
-g-
-p-
-b-
#ENDIF

[Hibou57]

Une réponse si vite

Entre temps, j'ai trouvé LA solution, qui va peut-être interesser beaucoup de monde, ouais

Il faut utiliser l'option -XX, car c'est l'option -XX qui commande le SmartLinking, et non pas l'option -XD, comme je l'ai cru par erreur.

J'ai compilé avec l'option -XX, et sans même avoir recompilé les unités standard, mon application de teste est déscendu à 21 KB Rien à redire, c'est parfait... (je ferais quand même une version nettoyé de system.pas, pour les CGI).

Info : Qu'est-ce le SmartLinking ? C'est une idée formidable, et dont il étonnant que seul TurboPascal et FreePascal la connaisse. L'idée est simplement qu'un fichier objet contient beaucoup de chose, et qu'une application liée à tel ou tel fichier objet, n'a pas toujours besoin de lier tout le contenu du fichier objet. TurboPascal avait un format spécial, les TPU, qui permettait de ne lier que ce qui était effectivement référancé par une application.

Je me souviens que je trouvais cette propriété tout à fait appréciable est logique (TurboPascal n'appelait pas ça SmartLinking, et n'avait en fait pas donné de nom spécial à ce concept). J'y était tellement habitué que quand je suis passé à Borland C++, et que j'ai découvert la médiocrité du format obj, j'ai été déçu. Pour obtenir le même effet de liaison intelligente qu'avec les TPU de TurboPascal, je devais compiler des multitude de petits fichiers. C'est à dire que je découpais mes fichier source, en source-1, source-2, etc, etc... chacun contenant seulement une fonction, ou seulement une variable globale. Il va sans dire qu'avec TurboPascal et FreePascal, les choses sont beaucoup plus simple est plus logique. Et c'est étonnant que ces deux compilateurs soient les deux seuls à implémenté cette logique pourtant évidente (comme quoi, il y a beaucoup de gens qui ne se posent pas assez de question).

Une petite différence entre TurboPascal et FreePascal : sous TurboPascal, ce comportement était un comportement par défaut, tandis que sous FreePascal, il faut activer une option pour obtenir le même résultat.

Ainsi donc, je conseille à chacun(e) d'ajouter l'option -XX au fichier de configuration fpc.cfg

Grâce à cette caractéristique ingénieuse, TurboPascal et FreePascal sont de tous les compilateurs, ceux qui produisent les binaires les plus économes. Et pensez donc : ils sont même en liaison statiques en plus! Un Must.

Mais je vais quand-même étudier ta configuration, ça peut être interessant... parce que je découvre le nouveau FPC depuis aujourd'hui... je le connaissais il y a « trés » longtemps (en 1997 je crois), mais il était bugé à l'époque (je l'avais patché, mais comme je n'avais pas d'accès à internet, je n'avais pas put participer à son dévelloppement). En plus, j'étais sous Windows3.1 à l'époque, et il ne permettait pas de programmer pour Windows3.1, mais seulement pour DOS ou Windows95... alors je l'avais abandonné.

Je suis heureux de voir que ce projet commencé il y a longtemps, soit toujours vivant, et qu'il ait bien avancé. Et comparé à d'autres environnement, il est même assez léger (l'installation de base sous Windows fait 20 Méga chez moi, contre 50 Méga pour l'installation de base de Gnat-315p, le compilateur Ada). Le seul défaut de FreePascal à mon avis, c'est gdb... il manque un vrai débuger intégré à l'IDE... mais à vrai dire, on developpe très bien sans débugger aussi... et je ne pense pas que beaucoup de gens en utilise, en dehors des phases d'apprentissage.

Bon, bon, j'ai été très long encore, mais c'était pour apporté une bonne nouvelle, quelques infos utils, et chanter quelques bonne louanges bien méritées... alors j'espère qu'on me pardonnera

A bientôt tout le monde, et portez vous bien

[paulatreides]

Voici quelques solutions personnelles pour utiliser les outils externes.
J'ai utilisé lazarus snapshot version win32.

1. D'abord pour obtenir du code assembleur
   J'ai essayé d'utiliser des macros pour permettre une utilisation la plus générale possible. (Pour savoir si ça marche sur d'autre OS il faut tester et corriger si nécessaire !).J'ai juste opté pour un processeur cible PENTIUM4
   
   

   Champ Titre >> Code Assembleur
   Champ Fichier du programme (sous windows) >> C:\lazarus\fpc\2.2.5\bin\i386-win32\ppc386.exe
   Champ Fichier du programme (sous Linux) >> ???
   Champ Paramètres >>-MObjFPC -Scgi -CX -O3 -OoUNCERTAIN -OoREGVAR -OpPENTIUM4 -T$TargetOS() -P$TargetCPU() -gl -Xs -XX -WG -vewnhi -l -Fu$ProjUnitPath() -FE$ProjPath() -o$(TargetFile) -al -dLCL -dLCL$LCLWidgetType() $ProjFile()
   Champ Répertoire de travail >>
   puis cocher l'option Rechercher les messages de sortie de FPC
   puis cocher successivement Ctrl, Shift
   Champ touche choisir 'A'

   Les fichiers en assembleur portent l'extension .s (ouvrez le avec un éditeur de texte), pour obtenir ce fichier l'option indispensable de compilation était
   -al (list sourcecode lines in assembler file)
2. Faire un strip de l'exécutable du projet
   Le but est de réduire la taille de l'exécutable(explications dans le 1er post donc je développe pas)
   
   

   Champ Titre >> strip sur mon projet
   Champ Fichier du programme (sous windows) >> C:\lazarus\fpc\2.2.5\bin\i386-win32\strip.exe
   Champ Fichier du programme (sous Linux) >> ???
   Champ Paramètres >>--strip-all $(TargetFile)
   Champ Répertoire de travail >> $(ProjPath)
   puis cocher l'option Rechercher les messages de sortie de FPC
   puis cocher successivement Ctrl
   Champ touche choisir 'S'

   La fenêtre message de Lazarus affiche
   

   "strip sur mon projet" terminé

3. Action d'UPX sur l'exécutable du projet
   Le but est de réduire la taille de l'exécutable(explications dans le 1er post donc je développe pas)
   
   

   Champ Titre >> UPX sur mon projet
   Champ Fichier du programme (sous windows) >> C:\lazarus\fpc\2.2.5\bin\i386-win32\upx.exe
   Champ Fichier du programme (sous Linux) >> ???
   Champ Paramètres >>--best $(TargetFile)
   Champ Répertoire de travail >> $(ProjPath)
   puis cocher l'option Rechercher les messages de sortie de FPC
   puis cocher successivement Ctrl
   Champ touche choisir 'U'

   La fenêtre message de Lazarus affiche
   

   Note: Switching assembler to default source writing assembler
   "Code Assembleur" terminé