Comment pouvons-nous mesurer avec précision les temps de sortie des fonctions dans le profilage des performances au-delà de l'utilisation de `__gnu_mcount_nc` ?

Détermination du temps de sortie d'une fonction avec __gnu_mcount_nc

Dans une tentative d'effectuer un profilage des performances sur une plate-forme embarquée, il a été noté que le GCC - L'indicateur pg insère des remerciements à __gnu_mcount_nc à l'entrée de chaque fonction. Bien qu'aucune implémentation de __gnu_mcount_nc ne soit facilement disponible, les implémentations personnalisées qui enregistrent le cadre de pile et le nombre de cycles en cours se sont révélées utiles pour collecter des graphiques d'appelants/appelés et identifier les fonctions fréquemment appelées.

Cependant, capturer des informations sur le temps passé dans Les instances fonctionnelles restent un défi uniquement basé sur les points d’entrée. Les approches existantes, telles que le maintien d'une pile d'appels fantôme et la manipulation de l'adresse de retour, introduisent des limitations et des frais généraux.

Pour aborder la question d'une implémentation alternative de __gnu_mcount_nc qui permet de capturer les temps de sortie des fonctions, examinons l'approche réelle utilisée par gprof.

Comment fonctionnent les mesures gprof Time

Contrairement aux hypothèses initiales, gprof n'utilise pas __gnu_mcount_nc pour l'entrée ou la sortie de la fonction de synchronisation. Au lieu de cela, il s'appuie sur le temps personnel recueilli en comptant les échantillons PC dans chaque routine. Ces échantillons sont ensuite utilisés, ainsi que le nombre d'appels de fonction à fonction, pour estimer la part du temps libre qui doit être attribuée aux appelants.

Comptage d'appels vs. Stack-Sampling

Une autre approche est le stack-sampling, qui consiste à capturer un échantillon de la stack à intervalles réguliers. Bien que plus coûteux que l'échantillonnage sur PC, il fournit des mesures plus précises car il ne fait pas de distinction entre les appels courts et longs, et n'est pas non plus affecté par les E/S ou les routines de bibliothèque non instrumentées.

Identification des opérations coûteuses

La clé pour détecter les goulots d'étranglement en matière de performances réside dans l'analyse des échantillons bruts de pile et dans leur relation avec le code source. Au lieu de se concentrer sur les graphiques d'appels ou les points chauds, l'examen d'échantillons de pile individuels peut révéler les raisons spécifiques pour lesquelles certaines opérations prennent beaucoup de temps et suggérer des optimisations possibles.

Au-delà des visualisations fantaisistes

Bien que les visualisations telles que les graphiques de flammes et les cartes arborescentes puissent être visuellement attrayantes, elles ne parviennent souvent pas à mettre en évidence les problèmes de performances résultant de l'appel répété du code à partir d'emplacements différents. L'agrégation et le tri des données par fonction, plutôt que uniquement en fonction du temps, fournissent une vue plus complète de l'exécution du code.

Conclusion

Bien que __gnu_mcount_nc puisse fournir des informations précieuses sur les points d'entrée des fonctions, des méthodes alternatives telles que l'échantillonnage de pile doivent être envisagées pour capturer les temps de sortie des fonctions. En se concentrant sur l'analyse d'échantillons de pile réels et en évitant les distractions causées par des visualisations accrocheuses, les développeurs peuvent identifier efficacement les goulots d'étranglement en matière de performances et mettre en œuvre des optimisations.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!