Quels sont les principaux frappeurs de performance dans AS3 en dehors des vecteurs de rendu?
Dans ActionScript 3, l'utilisation de graphiques vectoriels est un moyen garanti de causer des dommages considérables aux performances de votre projet.
L'utilisation d'un seul Bitmap pour tous les graphiques en utilisant .copyPixels() via son objet BitmapData à la place de tous les graphiques vectoriels produira une augmentation ridicule des performances et est essentiel pour des gens comme moi qui développent des jeux dans Flash.
Au-delà de cela, je ne suis pas vraiment sûr des prochaines grandes choses que je devrais viser et tenter d'optimiser. J'utilise beaucoup de fonctions de trigonométrie intégrées, mais elles ne semblent pas l'affecter autant. Je sais qu'il existe des bibliothèques qui optimisent les mathématiques avec des méthodes d'approximation et similaires, mais jusqu'à présent, je n'ai pas trouvé celles-ci nécessaires.
Y a-t-il d'autres points connus massifs que je devrais examiner? Je fais plus référence aux choses intégrées que je dois faire attention (comme éviter le rendu vectoriel) plutôt qu'à la façon d'améliorer mon propre style de codage.
Les documents que j'ai trouvés utiles sont:
- Optimisation des performances pour la plate-forme Adobe Flash
- Optimisation des performances ActionScript 3.0 et AVM2 par Gary Grossman
- Création d'applications iPhone haute performance par Mike Chambers
Quelques faits saillants:
Choisissez les objets d'affichage appropriés
L'un des conseils d'optimisation les plus simples pour limiter l'utilisation de la mémoire consiste à utiliser le type approprié de objet d'affichage . Pour les formes simples qui ne sont pas interactives, utilisez les objets Shape . Pour objets interactifs qui n'ont pas besoin de chronologie, utilisez Sprite objets. Pour une animation qui utilise une chronologie, utilisez MovieClip objets.
tilisez getSize() pour comparer le code
getSize()renvoie la taille en mémoire d'un objet spécifié.
Choisissez les types primitifs appropriés pour conserver la mémoire
Tous les types primitifs sauf String utilisent 4 à 8 octets en mémoire. Un Number , qui représente une valeur 64 bits, se voit allouer 8 octets par la machine virtuelle ActionScript (AVM), si aucune valeur ne lui est affectée. Le comportement diffère pour le type String. Benchmarkez le code et déterminez l'objet le plus efficace pour la tâche.
Réutiliser les objets
Optimisez la mémoire en réutilisant des objets et évitez de les recréer autant que possible.
tiliser le regroupement d'objets
La réutilisation d'objets réduit le besoin d'instancier des objets, ce qui peut être coûteux. Cela réduit également les chances de fonctionnement du ramasse-miettes, ce qui peut ralentir votre application.
Mémoire libre
Pour vous assurer qu'un objet est ordures récupérées , supprimez toutes les références à l'objet. L'allocation de mémoire, plutôt que la suppression d'objet, déclenche la récupération de place. Essayez de limiter les passes de récupération de place en réutilisant autant que possible les objets. En outre, définissez les références sur null, lorsque cela est possible, afin que le garbage collector passe moins de temps de traitement à rechercher les objets. Considérez la collecte des ordures comme une assurance et gérez toujours la durée de vie des objets de manière explicite, lorsque cela est possible.
La définition d'une référence à un objet d'affichage sur null ne garantit pas que l'objet est figé. L'objet continue de consommer des cycles CPU jusqu'à ce qu'il soit récupéré.
BitmapData La classe comprend une méthode
dispose(), bien que la méthode dispose supprime les pixels de la mémoire, la référence doit toujours être définie sur null pour la libérer complètement.
tiliser des bitmaps
L'utilisation de vecteurs, en particulier en grand nombre, augmente considérablement le besoin de ressources CPU ou GPU. L'utilisation de bitmaps est un bon moyen d'optimiser le rendu, car le runtime a besoin de moins de ressources de traitement pour dessiner des pixels à l'écran que pour rendre du contenu vectoriel.
Évitez les filtres, y compris les filtres traités via Pixel Bender
Lorsqu'un filtre est appliqué à un objet d'affichage, le runtime crée deux bitmaps en mémoire. L'utilisation de bitmaps créés en externe aide le runtime à réduire la charge CPU ou GPU.
tilisez le mipmapping pour mettre à l'échelle de grandes images
Utilisez le mipmapping avec parcimonie. Bien qu'il améliore la qualité des bitmaps à échelle réduite, il a un impact sur la bande passante, la mémoire et la vitesse.
tiliser le moteur de texte pour le texte en lecture seule, TextField pour le texte d'entrée
Pour le texte en lecture seule, il est préférable d'utiliser Flash Text Engine , qui offre une faible utilisation de la mémoire et un meilleur rendu. Pour le texte d'entrée, les objets TextField sont un meilleur choix, car moins de code ActionScript est nécessaire pour créer des comportements typiques, tels que la gestion des entrées et le retour à la ligne.
tilisez des rappels au lieu d'événements
L'utilisation du modèle d'événement natif peut être plus lente et consommer plus de mémoire que l'utilisation d'une fonction de rappel traditionnelle. Les objets d'événement doivent être créés et alloués en mémoire, ce qui crée un ralentissement des performances. Par exemple, lors de l'écoute de l'événement
Event.ENTER_FRAME, un nouvel objet événement est créé sur chaque trame pour le gestionnaire d'événements. Les performances peuvent être particulièrement lentes pour les objets d'affichage, en raison des phases de capture et de propagation, qui peuvent être coûteuses si la liste d'affichage est complexe.
Gel et dégel des objets ajoutés/supprimés de la scène
Même si les objets d'affichage ne figurent plus dans la liste d'affichage et attendent d'être récupérés, ils peuvent toujours utiliser du code gourmand en ressources processeur.
Le concept de gel est également important lors du chargement de contenu distant avec la classe Loader.
unloadAndStop()La méthode vous permet de décharger un fichier SWF, de geler automatiquement chaque objet du fichier SWF chargé et de forcer l'exécution du garbage collector.
tilisez les événements Event.ACTIVATE Et Event.DEACTIVATE Pour détecter l'inactivité en arrière-plan
Event.ACTIVATEetEvent.DEACTIVATEles événements vous permettent de détecter quand le runtime gagne ou perd le focus. Par conséquent, le code peut être optimisé pour réagir aux changements de contexte.Les événements d'activation et de désactivation vous permettent de mettre en œuvre un mécanisme similaire à la fonction "Pause et reprise" que l'on trouve parfois sur les appareils mobiles et les Netbooks.
Désactivez l'interaction avec la souris si possible
La détection de l'interaction avec la souris peut être gourmande en ressources CPU lorsque de nombreux objets interactifs sont affichés à l'écran, surtout s'ils se chevauchent. Lorsque cela est possible, envisagez de désactiver l'interaction avec la souris, ce qui aide votre application à utiliser moins de traitement CPU et, par conséquent, à réduire l'utilisation de la batterie sur les appareils mobiles.
tilisez des minuteries pour le contenu non animé
Les minuteries sont préférées aux événements
Event.ENTER_FRAMEPour le contenu non animé qui s'exécute pendant longtemps.Un temporisateur peut se comporter de la même manière qu'un événement
Event.ENTER_FRAME, Mais un événement peut être distribué sans être lié à la fréquence d'images. Ce comportement peut offrir une optimisation importante. Prenons l'exemple d'une application de lecteur vidéo. Dans ce cas, vous n'avez pas besoin d'utiliser une fréquence d'images élevée, car seuls les contrôles d'application se déplacent.
Limiter l'interpolation
Limitez l'utilisation de l'interpolation, ce qui économise le traitement du processeur, la mémoire et la durée de vie de la batterie, ce qui accélère le contenu sur les appareils de bas niveau.
tilisez Vector contre Array
La classe Vector permet un accès en lecture et en écriture plus rapide que la classe Array .
L'accès aux éléments de tableau et l'itération sont beaucoup plus rapides lors de l'utilisation d'une instance de Vector que lors de l'utilisation d'un tableau.
En mode strict, le compilateur peut identifier les erreurs de type de données.
La vérification de la plage d'exécution (ou la vérification de longueur fixe) augmente considérablement la fiabilité des baies.
tilisez l'API de dessin pour une exécution plus rapide du code
Réduisez la quantité d'exécution de code en utilisant
drawPath(),drawGraphicsData(),drawTriangles()Moins de lignes de code peuvent fournir de meilleures performances d'exécution ActionScript.
tilisez la capture d'événements et le bullage pour minimiser les gestionnaires d'événements
Tirer parti du bouillonnement d'un événement peut vous aider à optimiser le temps d'exécution du code ActionScript. Vous pouvez enregistrer un gestionnaire d'événements sur un objet, au lieu de plusieurs objets, pour améliorer les performances.
Peindre les pixels en utilisant la méthode setVector()
Lors de la peinture de pixels, certaines optimisations simples peuvent être effectuées simplement en utilisant les méthodes appropriées de la classe BitmapData. Un moyen rapide de peindre des pixels consiste à utiliser la méthode
setVector().
lock() et unlock()BitmapData lors de l'utilisation de méthodes lentes comme setPixel() ou setPixel32()
L'appel
lock()etunlock()empêche l'écran d'être mis à jour inutilement. Méthodes qui itèrent sur les pixels, telles quegetPixel(),getPixel32(),setPixel()etsetPixel32(), sont susceptibles d'être lents, en particulier sur les appareils mobiles. Si possible, utilisez des méthodes qui récupèrent tous les pixels en un seul appel. Pour lire les pixels, utilisez la méthodegetVector(), qui est plus rapide que la méthodegetPixels(). N'oubliez pas non plus d'utiliser des API qui reposent sur des objets vectoriels, dans la mesure du possible, car elles sont susceptibles de s'exécuter plus rapidement.
tilisez des méthodes de classe String au lieu d'expressions régulières
Lorsqu'une méthode de classe String est disponible, elle s'exécute plus rapidement que l'expression régulière équivalente et ne nécessite pas la création d'un autre objet.
Pour TextFields, utilisez apendText() au lieu de l'opérateur +=
L'utilisation de la méthode
appendText()permet d'améliorer les performances.
L'opérateur entre crochets [] Peut ralentir les performances - stocker une référence dans une variable locale
L'utilisation de l'opérateur de crochet carré peut ralentir les performances. Vous pouvez éviter de l'utiliser en stockant votre référence dans une variable locale.
Réduisez le nombre d'appels de fonction en déplaçant le code en ligne
Les fonctions d'appel peuvent coûter cher. Essayez de réduire le nombre d'appels de fonction en déplaçant le code en ligne.
Le déplacement de l'appel de fonction en ligne entraîne un code plus de quatre fois plus rapide.
Évitez de placer le contenu hors scène
Même si les éléments hors scène ne sont pas affichés à l'écran et ne sont pas rendus, ils existent toujours dans la liste d'affichage. Le runtime continue d'exécuter des tests internes sur ces éléments pour s'assurer qu'ils sont toujours hors scène et que l'utilisateur n'interagit pas avec eux.
Évitez d'utiliser la propriété alpha
Lorsqu'un objet d'affichage utilise la fusion alpha , le runtime doit combiner les valeurs de couleur de chaque objet d'affichage empilé et la couleur d'arrière-plan pour déterminer la couleur finale. Ainsi, le mélange alpha peut nécessiter plus de processeur que le dessin d'une couleur opaque. Ce calcul supplémentaire peut nuire aux performances sur les appareils lents.
tiliser la fréquence d'images la plus basse possible
Une fréquence d'images plus élevée dépense plus de cycles CPU et d'énergie de la batterie qu'une fréquence inférieure.
tilisez la mise en cache bitmap pour le contenu vectoriel complexe
Cette fonctionnalité met en cache un objet vectoriel, le rend en tant que bitmap en interne et utilise ce bitmap pour le rendu. La mise en cache bitmap améliore le rendu si le contenu mis en cache n'est pas pivoté, mis à l'échelle ou modifié sur chaque image. Toute transformation autre que la traduction sur les axes x et y, le rendu n'est pas amélioré.
Définir la propriété cacheAsBitmapMatrix lors de l'utilisation de bitmaps mis en cache dans les applications AIR mobiles
cacheAsBitmapMatrixdans le profil mobile AIR, vous pouvez appliquer n'importe quelle transformation bidimensionnelle à l'objet sans régénérer le bitmap mis en cache. Vous pouvez également modifier la propriété alpha sans régénérer le bitmap mis en cache.
tilisez la classe BitmapData pour créer un comportement de mise en cache bitmap personnalisé
L'utilisation d'un seul bitmap mis en cache est utilisée en mémoire et partagée par toutes les instances.
Isoler des événements tels que Event.ENTER_FRAME Dans un seul gestionnaire
Cette technique économise les ressources du processeur.
tilisez la fonction de mise en cache bitmap et la propriété opaqueBackground pour améliorer les performances de rendu du texte
La fonction de mise en cache des bitmaps vous permet de mettre en cache le contenu vectoriel sous forme de bitmaps pour améliorer les performances de rendu. Cette fonctionnalité est utile pour le contenu vectoriel complexe et également lorsqu'elle est utilisée avec du contenu texte nécessitant un traitement.
La transparence alpha impose une charge supplémentaire à l'exécution lors du dessin d'images bitmap transparentes. Vous pouvez utiliser la propriété
opaqueBackgroundpour contourner cela, en spécifiant une couleur comme arrière-plan.
Activer l'accélération graphique matérielle du GP
Afin de tirer parti de l'accélération GPU du contenu Flash avec AIR pour les plates-formes mobiles, Adobe vous recommande d'utiliser renderMode = "direct" (c'est-à-dire Stage3D) plutôt que renderMode = "gpu". Adobe prend officiellement en charge et recommande les cadres basés sur Stage3D : Starling (2D) et Away3D (3D) .
Évitez d'utiliser wmode = transparent ou wmode = opaque dans les paramètres d'intégration HTML. Ces modes peuvent entraîner une baisse des performances. Ils peuvent également entraîner une petite perte de synchronisation audio-vidéo dans le rendu logiciel et matériel. De plus, de nombreuses plateformes ne prennent pas en charge le rendu GPU lorsque ces modes sont en vigueur, ce qui nuit considérablement aux performances.
Favoriser l'utilisation de versions asynchrones des opérations
Le code d'application dans le thread d'exécution en cours continue de s'exécuter.
Les opérations asynchrones sont planifiées et divisées pour éviter les problèmes de rendu. Par conséquent, il est beaucoup plus facile d'avoir une application réactive utilisant des versions asynchrones d'opérations. Voir Performances perçues versus performances réelles pour plus d'informations.
Formes lisses pour améliorer le rend
Contrairement aux bitmaps, le rendu du contenu vectoriel nécessite de nombreux calculs, en particulier pour les dégradés et les chemins complexes qui contiennent de nombreux points de contrôle. En tant que concepteur ou développeur, assurez-vous que les formes sont suffisamment optimisées.
Mettre en cache les actifs localement après les avoir chargés, au lieu de les charger depuis le réseau chaque fois qu'ils sont nécessaires
Si votre application charge des actifs tels que des supports ou des données, mettez les actifs en cache en les enregistrant sur le périphérique local. Pour les actifs qui changent rarement, envisagez de mettre à jour le cache à intervalles.
tilisez la classe StageVideo pour profiter de l'accélération matérielle
Utilisez la classe StageVideo pour profiter de l'accélération matérielle pour présenter la vidéo.
Cette approche tire pleinement parti du matériel vidéo sous-jacent. Le résultat est une charge beaucoup plus faible sur le CPU, ce qui se traduit par des fréquences d'images plus élevées sur des appareils moins puissants et également une utilisation moindre de la mémoire.
Le format audio AAC offre une meilleure qualité et une taille de fichier plus petite que le format mp3 à un débit binaire équivalent
Semblable au décodage vidéo, le décodage audio nécessite des cycles CPU élevés et peut être optimisé en exploitant le matériel disponible sur l'appareil.
Le format AAC offre une meilleure qualité et une taille de fichier plus petite que le format mp3 à un débit binaire équivalent.
Réduire le code dans les constructeurs
Les fonctions d'initialisation telles que constructeurs sont interprétées, tout le reste est JIT.