Costruire Qt4 ottimizzato - flag “./configure” e loro significato

StackOverflow https://stackoverflow.com/questions/1807203

Domanda

Di recente ho seguito una discussione sulla mailing list di interesse Qt4 sulla legittimità o meno della creazione di un'applicazione commerciale / proprietaria e il collegamento statico di Qt4 al suo interno. Mentre ci sono alcuni modi non comprovati per farlo (fornendo file oggetto e un Makefile, ecc. Al cliente), dopo tutto non sembra una buona idea.

Uno dei miei progetti sta usando le librerie Qt4 con licenza LGPL e le spedisco come DLL / Dylibs / così separate al mio cliente, usando un semplice installer su tutte le piattaforme. Anche se finora funziona abbastanza bene, vorrei ottimizzare a) le dimensioni dell'installer riducendo le dimensioni della libreria Qt includendo solo ciò di cui ho bisogno, b) aumentando la velocità di avvio / caricamento della mia applicazione.

Ho familiarità con la compilazione di Qt da solo, ma Qt ha ottenuto un sacco di flag e switch.

In questo momento sto costruendo con le seguenti bandiere: 

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

Non sono del tutto sicuro di quale effetto / impatto abbiano i seguenti flag:

  • -no-stl
  • -no-javascript-JIT
  • -no-nis
  • -separate-debug-info
  • -no-OpenVG
  • -no-mitshm

C'è qualcos'altro che posso fare, ad esempio, fornendo opzioni di ottimizzazione per il compilatore o "stripping" funzioni inutilizzate dalla libreria Qt integrata per renderla più piccola (il che sarebbe facile con build statiche). Non ho molta esperienza con questo.

Oh, proprio come una nota a margine, la mia dimensione di applicazione compilata è di circa 600 kb (senza stripping) quando si collega dinamicamente a Qt. L'ho provato e ho scoperto che era di circa 4 MB di dimensione quando collego staticamente; ma in questo modo non dovrei più includere 40 MB di librerie Qt.

Quindi, per mettere tutto quanto sopra in una domanda / richiesta:

Se sei più avanzato di me su questo argomento, come puoi ottimizzare / distribuire le tue applicazioni e assicurarti che si avviino rapidamente e contengano solo ciò che è necessario?

È stato utile?

Soluzione

Ci sono alcune cose che mi vengono in mente:

  • utilizza una combinazione compilatore / linker che ottimizza le dimensioni. MSVC è molto meglio, ad esempio, di MinGW. Tutte le DLL di rilascio Qt costruite con un totale di MSVC a ~ 21 MB. Costruito con MinGW hanno un totale di ~ 41 MB. A proposito, davvero devi spedire tutte le DLL?
  • usa il flag -ltcg (Link-time code generation) per ottimizzare tra i file oggetto.
  • usa i flag del preprocessore per escludere parti della funzionalità Qt. ad esempio: QT_NO_STL = -no-stl.
  • prova i flag mmx / 3d now / sse2
  • rimuove alcuni degli stili (-no-style-)

Altri suggerimenti

Una volta saltati tutti i moduli e tali da farti sentire di non aver bisogno, puoi continuare a usare lo strumento qconfig (nascosto in $ QTDIR / tools / tree) e rimuovere le singole classi. Fai attenzione alle dipendenze: potresti dover ripetere alcune volte per far costruire Qt (ad esempio, QSpinBox dipende dalla presenza di QValidator).

Quando si costruisce Qt, specialmente più volte, il flag -nomake è un grande risparmio di tempo. Prova -nomake esempi -nomake demo.

Un'altra ottimizzazione per la velocità generale sta nell'utilizzo delle ottimizzazioni del compilatore durante la compilazione di Qt, ma è necessario modificare alcuni file. Quando ottieni Qt da Git, finisci con un qtbase / dir. Per prima cosa esegui lo script di configurazione, che crea qmake

Nota: puoi modificare Makefile.win32 o Makefile.unix e aggiungere righe come: 

QMAKE_CXXFLAGS_RELEASE = -CompilerDependentOptimizerSwitches

se vuoi che qmake sia ottimizzato, ma non credo sia davvero necessario, considerando che il tempo di esecuzione di qmake potrebbe essere 0,0000001% dell'intero tempo di compilazione per un'app di medie dimensioni.

Ma l'ottimizzazione reale arriva quando si modificano i mkspec usati per costruire Qt.

Ad esempio, in Windows con VS2012, è probabile che tu modifichi qtbase / mkspecs / win32-msvc2012 / qmake.conf .

Ex. : su Qt5.1 predefinito, il mkspec msvc2012 recita: 

QMAKE_CFLAGS_RELEASE    = -O2 -MD
QMAKE_CXXFLAGS_RELEASE  = $QMAKE_CFLAGS_RELEASE

Poiché desideri ottimizzare le dimensioni, puoi sostituirlo con: 

QMAKE_CFLAGS_RELEASE    = -O1 -MD

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

A volte include più mkspec di alto livello presenti nella directory qtbase / mkspecs / common / .

Ho compilato correttamente Qt5.1 su Debian / g ++ 4.8.1 con -O3 -march = native (il valore predefinito è -O2 ) se serve a qualcuno .

Dopo aver fatto questo, basta eseguire make sulla radice Qt git e andare a bere una birra con il tuo team perché anche su un buon computer ci vorranno anni (circa 2h su un i7, senza creare demo / esempi, ma con webkit). 

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

Ottimizzerà Qt5.8 su Linux

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top