Création de drapeaux Qt4 optimisés - "./configure" et de leurs significations

Question

J'ai récemment suivi une discussion sur la liste de diffusion Qt4-intérêt pour savoir s'il est légal ou non de construire une application commerciale/propriétaire et de lier statiquement Qt4. Bien qu'il existe des moyens non éprouvés de le faire (en fournissant des fichiers objet et un Makefile, etc. au client), cela ne semble pas être une bonne idée après tout. L'un de mes projets utilise les bibliothèques Qt4 sous licence LGPL et je les envoie en tant que DLL/Dylibs/so séparées à mon client, en utilisant un programme d'installation simple sur toutes les plates-formes. Bien que cela fonctionne assez bien jusqu'à présent, j'aimerais optimiser a) la taille de l'installateur en réduisant la taille de la bibliothèque Qt en n'incluant que ce dont j'ai besoin, b) augmenter la vitesse de démarrage/chargement de mon application.

Je suis familier avec la compilation de Qt moi-même, mais Qt a beaucoup de drapeaux et de commutateurs.

En ce moment, je construis avec les indicateurs 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/l'impact des drapeaux suivants ont:

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

Y at-il autre chose que je peux faire, par exemple, en fournissant des commutateurs d'optimisation pour le compilateur, ou « stripping » fonctions inutilisées de la bibliothèque Qt construit pour le rendre plus petit (ce qui serait facile avec des constructions statiques). Je n'ai pas beaucoup d'expérience avec ça. Oh, juste comme une petite note, ma taille d'application compilée est d'environ 600 kb (non-dénudée) lors de la liaison dynamique avec Qt. Je l'ai expérimenté et j'ai trouvé que sa taille était d'environ 4 Mo lorsque je lia statiquement; mais de cette façon, je n'aurais plus besoin d'inclure 40 Mo de bibliothèques Qt.

Alors, pour mettre tout ce qui précède dans une question/demande:

Si vous êtes plus avancé que moi sur ce sujet, comment optimiser/Déployez vos propres applications et assurez-vous qu'ils commencent rapidement et ne contiennent que ce qui est necessaire?

Answer 1

Il y a peu de choses que je peux penser:

• utiliser une combinaison compilateur/éditeur de liens qui les optimisations de bonne taille. MSVC est bien meilleur que MinGW par exemple. Toutes les DLL de version Qt construites avec MSVC totalisent environ 21 Mo. Construit avec MinGW, ils totalisent environ 41 Mo. En passant, avez-vous vraiment besoin d'expédier toutes les DLL?
• Utilisez l'indicateur -ltcg (génération de code de liaison-temps) pour optimiser les fichiers objets.
• utiliser des indicateurs de préprocesseur pour exclure des parties de la fonctionnalité Qt. par exemple: QT_NO_STL = -no-stl.
• essayer le MMX/3D/drapeaux SSE2
• supprimer certains des styles (-no-style-)

Answer 2

Lorsque vous avez sauté tous les modules et tel que vous sentez que vous n'avez pas besoin, alors vous pouvez continuer à utiliser l'outil qconfig (sorte de caché dans l'arborescence $ QTDIR/tools /) et supprimer des classes individuelles. Méfiez-vous des dépendances - vous devrez peut-être répéter plusieurs fois pour obtenir Qt (par exemple, QSpinBox dépend de la présence de QValidator).

Lors de la construction de Qt, en particulier plusieurs fois, le drapeau -nomake est un excellent gain de temps. Essayez -nomake exemples -nomake démos.

Answer 3

Une autre optimisation pour la vitesse générale réside dans l'utilisation des optimisations du compilateur lors de la compilation de Qt, mais vous devez éditer certains fichiers. Lorsque vous obtenez Qt de Git, vous vous retrouvez avec un qtbase/dir. D'abord, vous exécutez le script de configuration, qui construit qmake

Note: vous pouvez modifier Makefile.win32 ou Makefile.unix et ajouter des lignes comme:

QMAKE_CXXFLAGS_RELEASE = -CompilerDependentOptimizerSwitches 

si vous voulez qmake être 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 total de compilation pour une application de taille moyenne.

Mais l'optimisation réelle vient lors de l'édition des mkspecs qui sont utilisés pour construire Qt. Par exemple, sous Windows avec VS2012, vous devrez probablement modifier qtbase/mkspecs/win32-msvc2012/qmake.conf.

Ex. : Le défaut Qt5.1, le mkspec de msvc2012 lit:

QMAKE_CFLAGS_RELEASE = -O2 -MD 
QMAKE_CXXFLAGS_RELEASE = $$QMAKE_CFLAGS_RELEASE 

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

QMAKE_CFLAGS_RELEASE = -O1 -MD 

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

Parfois il comprend plus de mkspecs de haut niveau trouvés dans qtbase/mkspecs/common/ dir.

J'ai réussi à compiler Qt5.1 sur Debian/g ++ 4.8.1 avec -O3 -march=native (la valeur par défaut est -O2) s'il sert n'importe qui. Après cela, lancez make sur la racine gt Qt, et allez prendre une bière avec votre équipe, car même sur un bon ordinateur, cela prendra beaucoup de temps (environ 2h sur un i7, sans construire 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 sur Linux