Création optimisée de Qt4 - Drapeaux «./configurer» et leur signification

Question

J'ai récemment suivi une discussion sur la liste de diffusion Qt4-interest sur la question de savoir s'il est légal ou non de créer une application commerciale / exclusive et d'y associer statiquement Qt4. Bien qu'il existe des moyens non éprouvés de le faire (en fournissant des fichiers objets et un Makefile, etc. au client), cela ne semble pas être une si bonne idée après tout.

Un de mes projets utilise les bibliothèques Qt4 sous licence LGPL et je les envoie sous forme de DLL / Dylibs / so distinctes à mon client, à l'aide d'un simple programme d'installation installé sur toutes les plateformes. Bien que cela fonctionne assez bien jusqu'à présent, j'aimerais optimiser a) la taille du programme d'installation en réduisant la taille de la bibliothèque Qt en incluant uniquement ce dont j'ai besoin, b) augmenter la vitesse de démarrage / chargement de mon application.

Je suis habitué à compiler Qt moi-même, mais Qt a beaucoup d'indicateurs et de commutateurs.

En ce moment, je construis avec les drapeaux suivants:

./configure \
  -fast \
  -opensource \
  -qt-sql-sqlite \
  -nomake demos examples \
  -silent \
  -no-qt3support \
  -no-gif \
  -plugin-sql-mysql \
  -release \
  -no-xmlpatterns \
  -no-multimedia

Je ne suis pas tout à fait sûr de l'effet / de l'impact des indicateurs suivants:

• -no-stl
• -no-javascript-jit
• -no-nis
• -separate-debug-info
• -no-openvg
• -no-mitshm

Y a-t-il autre chose que je puisse faire, par exemple, en fournissant des commutateurs d'optimisation pour le compilateur ou "stripping"? fonctions inutilisées de la bibliothèque Qt construite pour la rendre plus petite (ce qui serait facile avec des versions statiques). Je n'ai pas beaucoup d'expérience avec ça.

Oh, juste à titre de remarque, la taille de mon application compilée est d’environ 600 ko (sans suppression) lors de la liaison dynamique avec Qt. Je l'ai expérimenté et j'ai trouvé qu'il faisait environ 4 Mo de taille lorsque je liais statiquement; mais de cette façon, je n'aurais plus à inclure 40 Mo de bibliothèques Qt.

Donc, pour mettre tout ce qui précède dans une question / requête:

Si vous êtes plus avancé que moi sur ce sujet, comment optimiser / déployer vos propres applications et vous assurer qu'elles démarrent rapidement et ne contiennent que ce qui est nécessaire?

Answer 1

Il y a peu de choses auxquelles je peux penser:

• utilise une combinaison compilateur / éditeur de liens qui optimise bien la taille. MSVC est bien meilleur à cet égard que MinGW par exemple. Toutes les DLL Qt créées avec MSVC totalisent environ 21 Mo. Construit avec MinGW, ils totalisent environ 41 Mo. Au fait, avez-vous vraiment besoin d'expédier toutes les DLL?
• utilisez l'indicateur -ltcg (génération de code de liaison) pour optimiser les fichiers d'objet.
• utilise des indicateurs de préprocesseur pour exclure des parties de la fonctionnalité Qt. Par exemple: QT_NO_STL = -no-stl.
• essayez les drapeaux mmx / 3d now / sse2
• supprimer certains styles (-no-style -)

Answer 2

Lorsque vous avez ignoré tous les modules et que vous pensez ne pas en avoir besoin, vous pouvez continuer à utiliser l'outil qconfig (en quelque sorte caché dans l'arborescence $ QTDIR / tools /) et supprimer des classes individuelles. Méfiez-vous simplement des dépendances - vous devrez peut-être effectuer plusieurs itérations pour que Qt se construise (par exemple, QSpinBox dépend de la présence de QValidator).

Lors de la construction de Qt, en particulier plusieurs fois, le drapeau -nomake vous fait gagner beaucoup de temps. Essayez des exemples -nomake -nomake demos.

Answer 3

Une autre optimisation de la vitesse générale consiste à utiliser les optimisations du compilateur lors de la compilation de Qt, mais vous devez éditer certains fichiers. Quand vous obtenez Qt de Git, vous vous retrouvez avec un qtbase / dir. D'abord, vous exécutez le script de configuration, qui construit qmake

Remarque: vous pouvez modifier Makefile.win32 ou Makefile.unix et ajouter des lignes telles que:

QMAKE_CXXFLAGS_RELEASE = -CompilerDependentOptimizerSwitches 

si vous voulez que qmake soit optimisé, mais je ne pense pas que ce soit vraiment nécessaire, étant donné que le temps d'exécution de qmake pourrait être de 0,0000001% du temps de compilation total d'une application de taille moyenne.

Mais l'optimisation réelle survient lors de la modification des mkspecs utilisés pour construire Qt.

Par exemple, sous Windows avec VS2012, vous modifieriez probablement qtbase / mkspecs / win32-msvc2012 / qmake.conf .

Ex. : sur Qt5.1 par défaut, le mkspec msvc2012 lit:

QMAKE_CFLAGS_RELEASE    = -O2 -MD
QMAKE_CXXFLAGS_RELEASE  = $QMAKE_CFLAGS_RELEASE

Puisque vous souhaitez optimiser la taille, vous pouvez le remplacer par:

QMAKE_CFLAGS_RELEASE    = -O1 -MD

(Selon http://msdn.microsoft.com/en-us /library/8f8h5cxt.aspx )

Parfois, il inclut plus de mkspecs de haut niveau dans le répertoire qtbase / mkspecs / common / .

J'ai compilé Qt5.1 avec succès sur Debian / g ++ 4.8.1 avec -O3 -march = native (la valeur par défaut est -O2 ) s'il sert quelqu'un .

Après cela, lancez simplement make sur la racine Qt git, et allez boire une bière avec votre équipe, car même sur un bon ordinateur, cela prendra du temps (environ 2h sur un i7, sans créer de démos / exemples, mais avec webkit).

Answer 4

sed -i 's@QMAKE_CXXFLAGS_THREAD  += $QMAKE_CFLAGS_THREAD@QMAKE_CXXFLAGS_THREAD  += $QMAKE_CFLAGS_THREAD -march=native@g'  qtbase/mkspecs/common/linux.conf

Optimisera Qt5.8 sous Linux