Le cache disque QML

Pour obtenir des performances optimales, les documents QML sont soit précompilés à l’avance lors du processus de construction, soit mis en cache après compilation lors de l’exécution. Cette page décrit ces deux stratégies et explique comment configurer le comportement de mise en cache.

Compilation anticipée

Vous devez définir vos modules QML à l’aide de ` qt_add_qml_module `, qui garantit que le Qt Quick Compiler traite vos fichiers QML et JavaScript à l’avance. Cela garantit des performances optimales lors de l’exécution.

Le Qt Quick Compiler génère du bytecode pour chaque fonction et chaque liaison. Ce bytecode peut être utilisé par l’interpréteur QML et le compilateur Just-in-Time (JIT) du moteur QML. De plus, le Qt Quick Compiler génère du code natif pour certaines fonctions et liaisons. Le code natif est exécuté directement, ce qui se traduit par de meilleures performances que l'interprétation ou la compilation « just-in-time » du bytecode. Le bytecode et le code natif sont ensuite tous deux intégrés dans le binaire de votre application.

L’un des avantages de la compilation anticipée est que les erreurs de syntaxe dans vos documents QML sont détectées lors de la compilation de l’application, et non lors de l’exécution, au moment du chargement du fichier.

Avec CMake

Lorsque vous utilisez CMake avec `qt_add_qml_module`, les fichiers QML sont automatiquement compilés à l’avance. Vous devez charger vos documents QML à partir du système de fichiers de ressources dans la mesure du possible. Cela garantit que le moteur QML peut trouver le code compilé à l’avance.

Avec qmake

Lorsque vous utilisez qmake, vous pouvez activer la compilation anticipée en spécifiant ` CONFIG += qtquickcompiler ` dans votre fichier de projet. Qt Creator dispose d’un paramètre permettant de transmettre cette directive à la ligne de commande de qmake. Par défaut, cette option est activée pour les versions de production et les builds de profilage.

Lorsque vous utilisez qmake, vous devez organiser votre projet d’une manière spécifique :

• Tous les documents Qml (y compris les fichiers JavaScript) doivent être inclus en tant que ressources via le système de ressources de Qt.
• Votre application doit charger les documents QML via le schéma d'URL qrc:///.

Notez que qmake ne peut pas transmettre autant d’informations à Qt Quick Compiler que CMake. Par conséquent, la compilation contiendra moins de code natif.

Mise en cache sur disque à l'exécution

Si aucun code précompilé n’est trouvé au moment de l’exécution, ou si le code ne peut pas être utilisé, le moteur QML compile les documents QML en une représentation en bytecode à la volée. Au lieu de recompiler le même document à chaque fois qu’il est chargé, le moteur QML met en cache le bytecode compilé. Le processus de mise en cache est automatique : chaque fois que vous chargez un document QML modifié, le cache est automatiquement recréé.

Format et emplacement des fichiers de cache

Les fichiers de cache utilisent les extensions suivantes :

• .qmlc pour les documents QML compilés
• .jsc pour les fichiers JavaScript importés
• .mjsc pour les modules ECMAScript

Les fichiers de cache se trouvent dans un sous-répertoire nommé « qmlcache » du répertoire de cache du système, comme indiqué par QStandardPaths::CacheLocation.

Efficacité mémoire

Les fichiers de cache sont chargés via l’appel système ` mmap() ` sur les systèmes d’exploitation conformes à POSIX ou via ` CreateFileMapping() ` sous Windows. Cette approche de mappage mémoire permet de réaliser d’importantes économies de mémoire. De plus, lorsque plusieurs applications utilisent le même document QML, la mémoire nécessaire au code est partagée entre les processus des applications, ce qui réduit encore davantage la surcharge mémoire.

Validation du cache

Les fichiers de cache et le code compilé à l’avance ne sont chargés que si toutes les conditions suivantes sont remplies :

• La version de Qt n’a pas changé
• Le code source du fichier d'origine n'a pas changé
• Le débogueur QML n'est pas en cours d'exécution
• La validation du code AOT aboutit

Notez que la variable d'environnement ` QML_FORCE_DISK_CACHE ` (voir ci-dessous) peut passer outre la condition relative au débogueur QML. Les autres variables d'environnement n'ont aucune incidence sur ces conditions de validation.

Validation du code natif généré à l'avance

Le code natif généré par le Qt Quick Compiler repose sur certaines hypothèses. Si les conditions d’exécution du code diffèrent de celles dans lesquelles il a été compilé, son utilisation peut présenter un risque. Par conséquent, le code natif est validé lors de l’exécution à l’aide des métadonnées stockées avec lui. Si cette validation aboutit, le code est exécuté normalement. En cas d’échec, l’exécution bascule silencieusement vers l’interprétation du bytecode. Cette validation a lieu une fois par fichier, lors du premier chargement du code, et approuve ou rejette l’ensemble des fonctions et des liaisons contenues dans ce fichier QML.

Vous pouvez personnaliser la validation du code AOT :

• Pour désactiver la validation lors de l’exécution, définissez la variable d’environnement ` QV4_SKIP_AOT_VALIDATION `. Cela vous permet d’éviter la légère surcharge liée à l’exécution de la validation.

  QV4_SKIP_AOT_VALIDATION=1 ./myQmlApp

• Pour garantir la réussite de la validation lors de l’exécution, définissez la variable d’environnement ` QV4_FAIL_ON_INVALID_AOT `. Si la validation échoue, le programme est interrompu. Cela vous permet de vous assurer, par exemple, que les fonctions compilées sont bien exécutées en tant que code natif.

  QV4_FAIL_ON_INVALID_AOT=1 ./myQmlApp

• Pour désactiver complètement cette fonctionnalité et empêcher Qt Quick Compiler de générer les métadonnées et la logique de validation, passez NO_GENERATE_AOT_VALIDATION à qt_add_qml_module.

  qt_add_qml_module(... NO_GENERATE_AOT_VALIDATION)

Configuration

Vous pouvez affiner le comportement de la mise en cache à l’aide de la variable d’environnement QML_DISK_CACHE, qui accepte une liste d’options séparées par des virgules. Par exemple :

QML_DISK_CACHE=aot,qmlc-read

Les options disponibles sont les suivantes :

De plus, vous pouvez utiliser les variables d’environnement suivantes :