Aide en ligne - Girollet Info

Transcription

o
Documentation HookTrack
(version 1.3)
1 HookTrack en une page
HookTrack est un outil (pour les clients NatStar version 2.60 à 5.00 sous Windows (XP / Seven).
o
o
o
o
d'aide au débogage
d'analyse des temps d'exécution
d'anticipation/analyse des erreurs d'exécution
d'amélioration de la productivité pour les développements NatStar™
Les principales fonctionnalités :
o
o
o
o
o
o
o
o
o
o
débogueur 'client' multithread (pas à pas, points d'arrêt, pile des appels)
browser de code
interception des traces NatStar (activable/désactivable/filtrables en cours d'exécution)
interception des appels de fonction/instruction/méthodes
traces des requêtes SQL, des allocations mémoire, des buffers tuxedo
détection d'erreurs tuxedo sur TpCall, SQL, NatStar (Things_Set_Error), Windows (Kernel32.SetError)
détection des fuites mémoire (segments, objets, séquences, buffers, curseurs DB)
détection des échecs de chargement de dll
détection des écrasements mémoire (écrasement de 'pile')
(En savoir plus )
Installation
o Si le framework Microsoft Net 2.0 n'est pas installé sur votre PC, téléchargez ce framework depuis le site
Microsoft.
o Il vous faudra peut être mettre à jour Windows Installer (version 3.1 ou plus : à télécharger ici).
o Puis lancez setup.exe
o (En savoir plus)
Prise en main : 1re utilisation
o Renseignez, le chemin vers le dictionnaire NatStar™ dans la première IHM lors du 1er lancement.
o Vérifiez que le nom d'exécutable ('sample' par défaut) est bien le nom de votre exécutable NatStar à
'HookTracker' : si tel n'est pas le cas, changez-le, faites 'OK'
o Vous lancez votre application (compilée en mode 'Debug'* c'est mieux) : elle sera alors automatiquement
détectée par HookTrack (sous Windows 7 : lisez ceci) qui affichera une petite bulle d'information au niveau
de la barre des tâches.
o (En savoir plus)
En cas de problèmes
o Si HookTrack se ferme (!), il faudra fermer votre application NatStar (vérifiez dans le gestionnaire des
tâches que le process est bien absent), avant de le relancer.
o L'arrêt 'inopiné' de HookTrack peut provoquer un plantage de votre application (pas forcément
immédiatement) : il vaut alors mieux la relancer.
o Merci de faire remonter tout problème à : [email protected]
Le site des utilisateurs d'HookTrack :
http://hooktrack.girollet.com
*
Case à cocher 'Debug' dans la fenêtre de génération NatStar™.
© 2007, Girollet Info-Conseils
1/55
Sommaire
1
HookTrack en une page................................................................................................................................ 1
2
Fonctionnalités clefs ...................................................................................................................................... 3
2.1 Les traces .................................................................................................................................................. 4
2.2 Le débogueur ............................................................................................................................................ 5
2.3 Le 'browser' de code ................................................................................................................................. 6
2.4 La visualisation de variables .................................................................................................................... 7
2.5 L'analyse des temps de réponse................................................................................................................ 8
2.6 La détection de bugs au plus tôt ............................................................................................................... 9
2.7 Principe de fonctionnement .................................................................................................................... 11
3
Installation ................................................................................................................................................... 12
3.1 Premier lancement .................................................................................................................................. 13
3.2 La vérification de licence ....................................................................................................................... 14
4
Utilisation ..................................................................................................................................................... 16
4.1 Quand lancer HookTrack, comment détecter l'application à déboguer ................................................. 16
4.2 Le paramétrage de HookTrack ............................................................................................................... 18
4.2.1
Paramètres généraux ....................................................................................................................... 19
4.2.2
Paramètres spécifiques à l'application à déboguer 'Trace & Debug settings' ................................. 20
4.3 L'IHM principale de HookTrack (après détection d'une application) .................................................... 30
4.3.1
Détail des menus ............................................................................................................................. 31
4.3.2
Zone de visualisation du source ...................................................................................................... 33
4.3.3
Zone de visualisation des variables................................................................................................. 35
4.3.4
Zone de visualisation des traces ...................................................................................................... 37
4.4 Les outils de HookTrack ........................................................................................................................ 39
4.4.1
Le 'browser' de code ........................................................................................................................ 39
4.4.2
Le 'dump' d'objets en mémoire ....................................................................................................... 41
4.4.3
Le suivi des fuites mémoire ............................................................................................................ 43
4.4.4
La pile des appels ............................................................................................................................ 46
4.4.5
L'analyse des temps de réponse ...................................................................................................... 47
4.4.6
Les messages de débogage et alertes dans HookTrack ................................................................... 49
4.5 Comment détecter des écrasements mémoire ........................................................................................ 51
4.6 Comment lire la trace ............................................................................................................................. 52
4.7 Annexe : syntaxe des expressions régulières ......................................................................................... 54
2/55
2 Fonctionnalités clefs
HookTrack est le fruit de 13 ans d'expériences de débogage d'applications NatStar™.
Il a pour objectif de vous faire gagner du temps... beaucoup de temps. Il s'utilise directement sur vos
applications clientes NatStar™ sous Windows™, sans modifier vos lanceurs.
HookTrack est un outil de développeur à développeur : l'ergonomie a été particulièrement soignée :
ergonomie = productivité !
o
o
o
o
o
o
o
Les traces
Le débogueur
Le 'browser' de code
La visualisation de variables
L'analyse des temps de réponse
La détection de bugs au plus tôt
Principe de fonctionnement
3/55
2.1
Les traces
Le temps perdu à écrire des traces est divisé par un facteur 20 en utilisant HookTrack. De plus,
plus en les voyant
défiler à l'écran, vous pouvez avoir – même sans lancer l'outil d'analyse (profiler) – une petite idée du
d temps
perdu dans un appel.
Vous avez enn plus le choix entre différents types de trace :
o aucune
o la trace classique (Things_Trace)
o la trace des appels de méthodes,, de 'ressources'
o les traces des paramètres d'appels
o les buffers Tuxedo
o les requêtes SQL
o ...
Tout cela étant activable/désactivable à la volée, sans arrêter votre application cliente et sans polluer votre
application avec une nième variable d'environnement.
Dans la zone de trace, un simple clic droit vous fera gagner du temps :
o Aller sur la trace d'appel / de sortie
o Afficher le source correspondant
o Rechercher dans la trace (avec comme résultat une liste 'cliquable' des lignes trouvées)
(Voir aussi : Le paramétrage des traces)).
(Voir aussi : Comment lire la trace).
4/55
2.2
Le débogueur
L'ergonomie du débogueur a été travaillée
travaillé tout particulièrement pour vous permettre d'analyser le plus
efficacement possible le comportement du code, la visualisation du code vous permet d'avoir des bulles d'aide
sur tous les éléments significatifs du code, et des liens hypertextes sur toutes les ressources/méthodes.
o Sur un point d'arrêt,, par un clic sur le bouton 'Break' ou lors d'un problème détecté : HookTrack affiche le
code source et surligne le code sur le point d'être exécuté.
exécuté
o Vous avez accès aux valeurs des variables locales/paramètres/objets par simple survol avec la souris,
souris mais
vous pouvez aussi les afficher dans une liste : leurs valeurs seront alors
alors mises à jour à chaque arrêt.
o Les ressources et les méthodes sont accessibles par simple clic droit.
droit
o Vous pouvez aussi afficher la pile des appels et pour chaque appel, voir le source correspondant, les
paramètres et les variables locales.
o Si votre client plante (Dr Watson), vous pouvez voir où, et encore accéder aux valeurs des variables.
variables
o Les pointeurs non valides (ne correspondant pas à une zone mémoire allouée) sont signalés comme tel dans
les bulles d'aide.
o Le débogueur est 'multithread' : il gère de manière transparente les différents threads que vous auriez pu
démarrer au sein de votre application.
application
o Le mode debug est désactivable en cours d'exécution.
d'exécution
5/55
2.3
C'est un des composants de base de HookTrack,
HookTrack il permet de naviguer dans le code du dictionnaire 'NatStar' de
manière très intuitive, son ergonomie est le fruit des retours des développeurs qui l'utilisent.
o
o
o
o
o
o
Browser de code vous permettant de 'naviguer'
'
dans votre code comme vous le feriez sur un site internet
Affichage de toutes les entités et de tous les liens du dictionnaire
Bulles d'aide descriptives sur
ur les ressources, méthodes ...
Liens hypertextess dans le code source
Affichage pertinent des TypeDefs
Positionnement/Suppression
Suppression des points d'arrêts
(Pour plus de détails : Utilisation : Le browser de code).
code
6/55
2.4
La visualisation de variables
HookTrack intègre un système de visualisation qui s'adapte de manière transparente à la catégorie de la variable
(locale, globale, variable de classe, paramètre) et à son type (types de bases, tableaux, segments, objets).
Affichage des types complexes (segments, typedefs, objets, tableaux) sous forme
forme arborescente
Détection et affichage des pointeurss vers des zones de mémoire non allouées
Interprétation automatique des handles d'objets en tant qu'objets
Interprétation des index 'littéraux'
éraux' (par exemple 'monTableau[i%]',
'monTableau[i%]' et pas seulement 'monTableau[0]')
Interprétation du caractères NCL '@' (par exemple '@monTableau[1]' correspond à l'adresse du 2e élément
de la variable 'monTableau[1]')
o Possibilité de 'caster' (trans-typer)
typer) une variable comme vous le feriez
fe
en NCL (par
par exemple
'S_Segment(hd_segment%)') pour n'importe quel type de segment
o Possibilité de 'caster' avec des typess simples (ou tableaux) (par
par exemple CSTRING(10)[5](hd_segment%),
CSTRING(10)[5](hd_segment%)
affichera un tableau de 5 chaînes
nes de 10 caractères dont l'adresse sera la valeur de hd_segment%)
o
o
o
o
o
(Pour plus de détails : Utilisation : Zone de visualisation de variables).
variables
7/55
2.5
HookTrack intègre également un profileur de code, il permet d'afficher les statistiques des temps d'exécution de
votre application et ainsi de déterminer très aisément les parties du code sur lesquels doivent porter vos efforts
d'optimisation des temps de réponse.
o Affichage du nombre d'appels pour une ressource/méthode/service tuxedo/requête SQL
o Du temps total et moyen par appel
o Du temps total et moyen 'propre' par appel (i.e. le temps hors appels internes vers d'autres
ressources/méthodes…)
(Pour plus de détails : Outils : L'analyse des temps de réponse).
8/55
2.6
La détection de bugs au plus tôt
HookTrack intègre un mécanisme d'alertes,
d'alertes sous forme de boîte 'pop-up'
up' qui vous signale les bugs potentiels
avant que ceux-ci n'aient eu de conséquences.
conséquence
Par exemple sur une erreur SQL :
o l'erreur a été interceptée.
Un descriptif de l'erreur est affichée, ainsi que l'état de la pile des appels au moment où
Le bouton 'Debug' permet de basculer directement en mode débogage à la ligne où a eu lieu le problème.
(Pour plus de détails : Outils : Les messages de débogage et d'alertes).
9/55
Le tableau qui suit donne, par catégorie de bug, la réponse de HookTrack
Catégorie de bug
Problème de chargement de dll
Alerte HookTrack
Pop-up
Procédure à suivre
Utilisez un logiciel comme
'Depends', pour connaître la raison
précise du non chargement de la dll
Handle d'objet nul ou invalide
Erreur Tuxedo™
Débordement d'une chaîne de
caractère
Pop-up
Pop-up
Message en rouge 'Cstring not
terminated by 0' lors de la
visualisation de la variable
Index en dehors des limites d'un
Message en rouge 'invalid index'
tableau
lors de la visualisation de la
variable
Pointeur/Handle invalide
Message en rouge 'Invalid
pointer' lors de la visualisation
de la variable
Un écrasement de 'pile' mémoire
Pop-up en sortie de fonction 1
Erreur NatStar™ (things_set_error) Pop-up ou Warning (au choix)
Erreur Windows™
Pop-up ou Warning (au choix)
(Kernel32.SetError)
Fuites mémoire (segment, objets,
non
séquences) ou de curseurs de base
de données
Problème de performance
non
Boucle infinie
non
Appel récursif infini
non
Autres plantages (dans la mesure
où vous avez une alerte de l'OS du
genre de la boîte de dialogue avec
croix blanche sur fond rouge)
non (mais message windows)
1
Utilisez les IHM HookTrack de
suivi des fuites mémoire
Utilisez l'IHM d'analyse des temps
de réponse de HookTrack
Utilisez l'IHM de pile des appels de
HookTrack pour voir où votre
programme est bloqué
Consultez le buffer de trace de
HookTrack pour repérer les
indentations d'appels auxquelles ne
correspondent pas de retours
Gardez la boîte de message de
plantage ouverte.
HookTrack, sur le dernier appel
faites 'clic droit' [View Source],
vous pourrez, dans la plupart des
cas, consulter la valeurs des
variables au moment du plantage,
et la dernière ligne exécutée
Si compilation avec Microsoft VC++8.0 : voir Détection des écrasements mémoire
10/55
2.7
Principe de fonctionnement
Au lancement de HookTrack (ou lorsqu'on utilise le menu Global Action>Force New application detection),
l'outil recherche et démarre en leur sein un thread (un 'sous-process') qui a pour but d'intercepter certains appels
d'API et de transmettre les informations ainsi récupérées à HookTrack.
Détection du démarrage de
l'application cible
HookTrack
1 fenêtre fille
par
application
détectée
NatStar Application
Thread créé par HookTrack
Canal de communication
Interception d'appels
Threads applicatifs
(votre code et autres dll)
Application cible
11/55
3 Installation
Pré-requis
Internet Explorer en version 6 ou 7
Windows Installer 3.1
Le Framework .NET 2.0 pour une architecture
32bits
Le Framework .NET 2.0 pour une architecture
64bits
Les Dll de l'IDE NatStartm
Un accès internet
Un accès aux fichiers de votre dictionnaire NatStar™
Télécharger Windows Installer 3.1
Télécharger le Framework .NET 2.0 (x86)
Télécharger
arger le Framework .Net2.0 (x64)
Celles qu'utilise votre application
Pour accéder à la validation de licence
Pour pouvoir afficher le code source
Lancer "Setup.exe"
Faire "Suivant", cochez "J'accepte" le cas échéant la boîte de dialogue de la licence, puis "Suivant" et
"Terminer".
Un raccourci "HookTrack"
rack" est créé sur votre bureau,
bureau voir également 'Premier lancement' :
12/55
3.1
Premier lancement
Lors du premier lancement une IHM vous invite à renseigner les paramètres essentiels au bon fonctionnement
de HookTrack :
Renseignez le chemin vers le répertoire 'dict' de votre dictionnaire NatStar™ (N.B.:: 'dict' n'est pas à inclure dans
le nom du répertoire, voir ci-dessus).
Renseignez également le nom de l'exécutable de votre application NatStar (sans spécifier l'extension .exe), dans
l'exemple il s'agit de l'exécutablee 'sample.exe', donc 'sample' dans le champ de saisie.
Puis cliquez sur 'Ok'.
13/55
3.2
La vérification de licence
Une vérification de licence a lieu automatiquement au démarrage de HookTrack, et nécessite une connexion
Internet, une fois la licence vérifiée une nouvelle vérification via Internet se fera à nouveau après 30 jours.
En cas d'échec de celle-ci
ci vous disposerez encore de 15j supplémentaires d'utilisation (et HookTrack essayera
alors à chaque lancement de valider
er sa licence).
Ceci permet aux PC ne pouvant accéder
er à Internet qu'avec des paramètres réseaux incompatibles avec le test
d'application NatStar (configuration VPN spécifiques …) de n'avoir à valider leur licence qu'une fois tous les
30 jours.
Lors de cette vérification, les adresses ip et identifiants
identifiant Windows™ sont transmis (cryptés) au serveur : ces
données sont conservées de manière confidentielle et ne sont utilisées que lors de la vérification de licence
proprement dite.
1. En cas d'échec injustifié de la vérification de licence, merci de contacter [email protected]
Si votre PC est placé derrière un proxy et/ou un pare-feux
pare feux nécessitant une authentification,
authentification HookTrack va
essayer de s'authentifier
hentifier suivant toutes les procédures
procédure connues ... il vous sera alors peut-être
peut
demandé de
ressaisir votre login et 'mot de passe' (password) window : votre 'mot de passe' n'est pas conservé,
conservé ni transmis à
l'extérieur : il faudra donc le ressaisir à chaque
chaqu validation de licence.
Écrans d'authentification à un proxy :
internet vous désirez être averti avant que
2. Si, pour des raisons dues à la configuration de votre connexion internet,
HookTrack ne tente
te de se connecter à internet,
internet allez dans le menu 'Application
Application detection/Define Settings..'
Settings..
Et cocher 'Inform me before HookTrack connection to the licence server'
Avant une tentative de vérification de licence le message suivant apparaîtra :
14/55
15/55
4 Utilisation
o
o
o
o
o
o
o
o
4.1
Quand lancer HookTrack, comment détecter l'application à déboguer
Le paramétrage de HookTrack
L'IHM principale de HookTrack
Points de trace et points d’arrêt
Les outils de HookTrack
Comment détecter les écrasements mémoire
Comment lire la trace
Annexe : syntaxe des expressions régulières
Quand lancer HookTrack, comment détecter l'application à déboguer
• (1) HookTrack détecte les applications dont le nom d'exécutable est renseigné dans ses paramètres (voir :
paramètres généraux), cette application est en principe une application compilée avec NatStar (… bien que cela
ne soit pas requis).
• (2) Idéalement vous pouvez lancer HookTrack avant de lancer votre application (d'ailleurs vous pouvez
laisser HookTrack tourner en permanence).
• (3) Sous XP la détection de toute nouvelle application sera immédiate et automatique, si le menu
'Application detection>Automatic application start detection' est coché.
•
(4) Sous Windows 7 , modifier votre lanceur : lancez votre application avec l’utilitaire hookstart.exe
Par exemple votre ancien lanceur (.bat) était :
Set PATH=…
MonappliNatStar.exe x y z
Modifiez le en :
Set PATH=…
HookStart MonappliNatStar.exe x y z
..n’oubliez pas de copier HookStart.exe qui est dans le répertoire d’installation de HookTrack (par défaut
C:\Program Files\GIC\HookTrack ) dans le répertoire qui contient votre exécutable d’application NatStar
(MonappliNatStar.exe dans l’exemple)
HookStart.exe signalera à HookTrack qu’une nouvelle application est sur le point d’être lancée, elle sera alors
détectée immédiatement par HookTrack, sous réserve que son nom est dans les paramètres comme au (1) et que
la détection automatique est activé comme au (3).
• Il n'est pas possible d'utiliser plusieurs instances de HookTrack en même temps : si vous relancez
HookTrack une seconde fois un message vous le signalera. Cependant HookTrack peut détecter plusieurs
instances d'application ayant le même nom d'exécutable : chacune sera alors gérée dans une fenêtre fille de
HookTrack.
•
Si votre application tournait déjà lorsqu' HookTrack est lancé, il la détectera automatiquement.
16/55
Si vous venez de modifier le nom de l'application à détecter dans les paramètres et que celle-ci est déjà
démarrée, il suffit alors d'utiliser le menu 'Force application detection' :
HookTrack apparaît également dans la barre des tâches sous la forme d'un petit icône
menu contextuel, qui permet aussi d'avoir accès à 'Force application detection' :
auquel est associé un
Après quelques fractions de secondes HookTrack aura fini sa phase de détection et affichera une bulle :
Le nom de l'exécutable est affiché ainsi que le numéro de process : ces informations seront reprises dans la
barre de titre de HookTrack (PiD = process Id dans le Gestionnaire de tâches) :
Ces process sont affichés dans des fenêtres filles, tant qu'ils sont présents. Une fois le process fermé, il reste
toujours dans une fenêtre fille de HookTrack (heureusement car cela est bien utile quand un process a planté).
Le fait de fermer une fenêtre fille correspondant à un process actif, ne fait que la masquer : elle réapparaîtra
quand vous ferez 'Force application detection', ou quand vous la rappellerez via le menu 'Windows'(ce menu
liste toutes les fenêtres filles correspondants aux process qui ont été détectés).
• Pour ne plus voir de process qui correspond à une application terminée, fermez la fenêtre fille concernée
dans HookTrack et faites simplement 'Force application detection' (cf. ci-dessus).
17/55
4.2 Le paramétrage de HookTrack
HookTrack permet un paramétrage relativement poussé de son fonctionnement. Une telle souplesse ne va pas
sans une certaine complexité.
Pour cette raison le paramétrage se fait en utilisant des 'profils' de paramétrage. Certains sont prédéfinis pour les
différents
fférents 'modes' d'utilisation de l'outil.
On accède à l'écran de définition du paramétrage et des profils par le menu :
La fenêtre de définition des paramètres ainsi ouverte concerne les paramètres qui seront utilisés
utilisé initialement
lors de la détection d'une nouvelle application,
application elle comporte 2 onglets :
- 'General Settings' pour les paramètres généraux de HookTrack ;
- 'Trace & Debug settings' pour
ur les définitions
définition du profil à utiliser au lancement, ainsi que la définition de tous
les profils utilisables.
• Une fois une application détectée,, ses paramètres initiaux sont copiés. Ill existe donc une copie de
paramètres par application détectée.
• Chaque copie peut être modifiée indépendamment : il est donc possible d'avoir plusieurs instances
instance
d'application détectéess utilisant des paramétrages différents à un moment donné.
donné
18/55
4.2.1
Paramètres généraux
Il y a deux paramètres essentiels à définir pour utiliser HookTrack :
o
Le nom de l'exécutable à déboguer
oguer (= le nom de l'exécutable de votre application NatStar™), sans
l'extension .exe : si vous devez tester des exécutables de noms
nom différents, vous pouvez les saisir en les
séparant par une virgule.
o Le chemin vers le répertoire de votre glob NatStar – c'est-à-dire – le chemin vers le répertoire 'dict'
contenant le fichier NsThings.dat (ou double-cliquer
double
dans le champ pour naviguer vers ce répertoire).
Par exemple, si le fichier du dictionnaire est c:\glob\dict\NsTings.dat il faudra renseigner c:\glob.
HookTrack pourra ainsi accéder à votre
otre code source référencé dans le dictionnaire NatStar™ 1
o
Sur cet onglet d'autres
autres paramètres concernent
concerne la police ett la couleur de la trace, ainsi que l'exécutable
utilisé pour éditer la trace de manière externe (notepad.exe, uedit32.exe, ...).
...)
o
Vous pouvez également demander à être averti, avant la tentative de connexion via internet, lors de la
vérification de licence (voir : la vérification de licence).
licence
1
La dll utilisée pour charger le dictionnaire est nsw2ldct.dll est celle qui se trouvera dans le chemin (variable PATH) de chargement
cha
des DLL de
l'application cliente : il est donc impératif que cette DLL soit accessible (en principe elle doit se trouver au même endroit que les DLL NatSystem™
utilisées par votre application, et cela est 'transparent' pour vous).
19/55
4.2.2
o
o
o
o
o
Paramètres spécifiques à l'application à déboguer 'Trace & Debug settings'
Les profils de paramétrage
Le paramétrage des traces
Le paramétrage du débogueur
Le paramétrage de la détection de bug
Les paramétrages avancés
4.2.2.1 Les profils de paramétrage
La définition des profils de paramétrage est stockée dans le répertoire d'installation de HookTrack (fichier
'settingsProfiles.ini', qui n'a pas vocation à être édité manuellement,, mais pourra être copié d'un PC à un autre)
autre :
pour revenir à une configuration
uration par défaut des profils,
profil il est possible de supprimer ce fichier ; en relançant
HookTrack il sera recréé avec des valeurs par défaut.
Par défaut un profil 'Personal Settings' est
e créé et est modifiable :
Les autres profils (non modifiables, ils sont précédés d'un ':' dans la liste) correspondent à différents
différent modes
d'utilisation prédéfinis : comme leurs paramétrages ne sont pas modifiables les onglets correspondants
corre
sont
grisés.
Il est possible de créer de nouveaux profils
profil (bouton 'New'), de créer de nouveaux profils
profil par copie (bouton
'Copy') et bien sûr, de supprimer les profils créés (bouton 'Delete').
Sur la fenêtre principale de HookTrack il est possible de choisir un profil de paramétrage à tout moment en le
sélectionnant dans la combo-box des profils
profil (voir : 'IHM principale de HookTrack' pour localiser cette combocombo
box).
4.2.2.1.1 Profil prédéfini:Unactivate spying
Ce profil permet la désactivation
ésactivation de tous les paramètres : pas de trace, pas de débogage,
déb age, pas de détection de bug
(autres que la détection de bug entraînant un plantage assuré). Il est utile pour revenir à un fonctionnement le
plus proche possible de l'application sans HookTrack, ou pour limiter au maximum le temps perdu dans les
interceptions d'appel d'API.
20/55
• On l'utilise classiquement pour arriver rapidement à la procédure que l'on souhaite déboguer (on repassera
alors dans un autre mode de fonctionnement, en sélectionnant un autre profil, juste avant de commencer ladite
procédure).
4.2.2.1.2 Profil prédéfini : Client Trace
Ce profil permet de récupérer les traces NatStar™ (Things_Trace et traces du moteur NatStar™), les appels de
méthodes, de fonction/instruction/événements, de tracer les paramètres d'appels, les buffers Tuxedo, les appels
tuxedo (TpCall), les chargements de DLL.
Il permet également de détecter les erreurs Tuxedo™ suite à un appel TpCall, d'intercepter les messages de
debug Microsoft™, les erreurs de type 'sever' émises par le moteur NatStar.
• On l'utilise classiquement pour produire des traces, la détection de bug est limitée à des problèmes graves. Il
n'ouvre pas accès aux fonctions de 'debug', sauf cas particulier, on utilisera de préférence 'Client Debug trace'.
4.2.2.1.3 Profil prédéfini : Client Debug trace
Ce profil rajoute aux fonctionnalités activées par 'Client Trace', toutes les fonctionnalités de débogage (à
l'exception de l'interception des erreurs Windows™, souvent trop 'bavardes' et ne correspondant que rarement à
de véritables problèmes).
•
C'est en principe un paramétrage basé sur ce profil qui est à utiliser lorsqu'il y a un bug avéré.
4.2.2.1.4 Profil prédéfini : Bug Auto Detect
Ce profil permet de détecter des bugs et de déboguer mais il n'utilise pas la trace (et ne perd donc pas de temps à
'tracer').
•
On l'utilise classiquement en phase de test d'intégration pour vérifier le bon comportement de l'application.
21/55
4.2.2.2 Le paramétrage des traces
Trace & Debug settings'
settings :
Ce paramétrage peut être défini en accédant au sous-onglet 'Traces' de 'Trace
Un ensemble de cases à cocher permet de définir les types
type de traces que l'on désire récupérer :
Ceci permet
ermet d'activer ou de désactiver de manière globale
global l'ensemble des traces ci-après.
après.
(Cette case à cocher est également rappelée sur l'IHM principale de HookTrack).
Ceci permet de tracer les appels de méthodes,
méthode sous la forme :
Call
NomDeClasse.NomDeMéthode(Handle De L'Objet)
…
EndCall NomDeClasse.NomDeMéthode(Handle
NomDeMéthode(Handle De L'Objet)
'Call' est tracé avant l'appel
'EndCall' est tracé après être ressorti de l'appel.
l'appel
(Ce qui est différent de 'Enter'/'Leave' : cf. ci-dessous).
'Trace Enter/Leave' permet de tracer les appels dans les librairies et les classes, mais ceci ne fonctionne que si la
ressource en question a été compilée en cochant l'option 'Debug' dans la fenêtre du générateur de NatStar™.
Les appels seront alors tracés sous laa forme :
Enter Type.[Conteneur.]Ressource
]Ressource
…
Leave Type.[Conteneur.]Ressource
]Ressource
Avec :
Type
Conteneur
Ressource
= M (méthode), I (instruction),
struction), F (fonction), W (événement
(événement de fenêtre)
= la classe si Type='M',
le nom de fenêtre suivi du nom de control si Type='W',
Type=
sinon rien
= le nom de la méthode ou ressource appelée
(méthode,
hode, fonction, instruction, événement)
évé
Attention : il y a une différence entre Call et Enter,
Enter EndCall et Leave :
'Enter' est tracé (depuis le code appelé) avant l'exécution de la première
première ligne de code de la méthode/ressource ;
'Leave' est tracé (toujours depuis le code appelé) juste avant de quitter la méthode/ressource appelée.
(Voir aussi : ‘Comment lire la trace’).
Si 'Trace Enter/Leave' est activé et que la dll concernée est compilée en ayant coché 'Debug' dans le générateur
NatStar™, alors 'Trace
Trace Input/Output params'
params permettra de tracer les valeurs de paramètres d'appel.
Ceci peut être très utile mais rend la trace évidemment
évidem
plus 'verbeuse' et plus lente.
Permet de tracer les allocations/désallocation
désallocations de segments/buffers NCL (instruction New et Dispose).
22/55
Avant l'allocation on trace le type et la taille du segment demandé, puis juste après l'allocation
l'allocatio le pointeur (en
base 10 et en hexadécimal) obtenu.
Avant la désallocation on trace également le pointeur concerné.
concerné
Exemple de trace :
New segment kind=0 size=15187 Name=
->Allocated
>Allocated pointer = 276240146 (0x10771712)
(
…
Dispose segment 276240146 (0x10771712
10771712)
Permet de tracer les allocations/désallocations/'Lock'
allocations/désallocation
d'objets NatStar™.
Exemple de trace :
New Instance LIST 274353682(0x105a4e12)
105a4e12)
…
Dispose object LIST 274353682(0x
0x105a4e12),lock=0 allocated in
M.CT1A_GEST_IHM.GERER_USER10_WCCT1(line=10)
…
Lock object CT1C_GEST_CTT 275821906(0x1070b552)
275821906( 1070b552) lock=1 , allocated in
M.CONTRAT.DISPLAY_VIEW(line=5)
Permet de tracer tous les ordres SQL issus de la partie cliente de l'application.
l'application
Comme HookTrack permet d'évaluer les temps de traitements, il sera aussi possible d'obtenir des statistiques sur
les temps dee traitement des requêtes SQL.
SQL (Pour plus de détails : 'L'analyse des temps de réponse').
réponse'
Exemple de trace :
SQL_OpenCursor% cursor opened=2
SQL_EXEC (cursor=2) select A.ROO_IMA_REF,A.POBJ_CLASS,A.POBJ_EXTRACT from LANGUES A
where A.POBJ_CLASS = 'LANGUE' and A.CC_LNG = : and A.ROO_IMA_REF > : order by
A.ROO_IMA_REF
var0="DE"
var1="00000000000000000000000"
SQL_EXEC (cursor=2) fetch into : ,: ,:
var0="0000000AAA0000000404000"
var1="LANGUE"
var2="Allemandde"
SQL Warning=100 ,NSSQLW100 ** NO ROW WAS FOUND OR LAST ROW REACHED
SQL_EXEC (cursor=2) fetch into : ,: ,:
var0="0000000AAA0000000404000"
0="0000000AAA0000000404000"
var1="LANGUE"
var2="Allemandde"
SQL_CloseCursor cursor closed=2 (opened in source M.LANGUE.CHERCHER_OBJET@line10)
23/55
Permet de tracer les appels tuxedo (TpCall) et les buffers d'entrée et de sortie (fml, fml32, Carray,
Carray view,
view32).
Une trace Call TpCall est générée avant l'appel.
Une autre EndCall TpCall est générée après l'appel.
l'appel
Si vous utilisez Tuxedo pour véhiculer vos appels 'remote' NatStar™, vous verrez alors les paramètres d'appel
tels que 'plié/déplié' par le moteur NatStar™. De plus la fonction/méthode remote appelée sera identifiée et
pourra faire l'objet d'une analyse de temps de traitement (…très intéressant pour détecter vos appels remote trop
lent !).
Comme HookTrack permet d'évaluer
aluer les temps de traitements, il sera aussi possible d'obtenir des statistiques sur
les temps d'appel des services tuxedo. (Pour
(
plus de détails : 'L'analyse des temps de réponse').
réponse'
Format de la trace :
Call Tuxedo.TpCall NomDuServiceTuxedo[:LibrairieRemote.Ressource]
NomDuServiceTuxedo
**Begin Tuxedo Input Buffer**
Service=NomDuServiceTuxedo information sur le buffer
[Trace du buffer (par champ pour FML , dump mémoire pour les autres]
**End Tuxedo Input Buffer**
EndCall Tuxedo.TpCall NomDuServiceTuxedo[:LibrairieRemote.Ressource]
NomDuServiceTuxedo
]
**Begin Tracing Output Buffer**
Service=NomDuServiceTuxedo information sur le buffer
[Trace du buffer (par champ pour FML , dump mémoire pour les autres]
**End Tuxedo Output Buffer**
Exemple :
Call Tuxedo.TpCall
TpCall GCC_DEV_TMA_NXA:LKIT_CASTOR.SEARCH_BAEN7C@line=9
**Begin Tuxedo Input Buffer**
Service=GCC_DEV_TMA_NXA BufferAddress=0305B260 type=FML stype= len=61440 Fields(Sizeof=61440 Number=180
MemoryUsed=1156 MemoryUnused=58844 IndexMemoryUsed=1440)
-------------------------------------|?(Occ.)|Id
|N° |Name |Kind/length|Value ...
-------------------------------------|ok(0) |218 |218|(null)|short/2
|=50
|ok(0) |8295 |103|(null)|long/4
|=170
|ok(0) |41061|101|(null)|string/4
|='1.0'
|ok(0) |41153|193|(null)|string/12 |='LKIT_CASTOR'
|ok(0) |41154|194|(null)|string/14 |='SEARCH_BAEN7C'
|ok(0) |41167|207|(null)|string/11 |='I_INT_NAME'
|ok(0) |41168|208|(null)|string/28 |='DELEGATION POLICE ESPAGNOLE'
-------------------------------------**End Tuxedo Input Buffer**
EndCall tuxedo.TpCall
TpCall GCC_DEV_TMA_NXA:LKIT_CASTOR.SEARCH_BAEN7C@line=9 ¹15
**Begin Tracing Output Buffer**
Service=GCC_DEV_TMA_NXA BufferAddress=0306D970 type=FML stype=
stype= len=4096 Fields(Sizeof=4096 Number=167
MemoryUsed=1088 MemoryUnused=1672 IndexMemoryUsed=1336)
-------------------------------------|?(Occ.)|Id
|N° |Name |Kind/length|Value ...
-------------------------------------|ok(0) |204 |204|(null)|short/2
|=0
|ok(0) |207 |207|(null)|short/2
|=1
|ok(0) |360 |360|(null)|short/2
|=0
|ok(0) |8295 |103|(null)|long/4
|=161
|ok(0) |41170|210|(null)|string/24 |='0000000CTM0064621355000'
|ok(0) |41220|260|(null)|string/28 |='DELEGATION POLICE ESPAGNOLE'
|ok(0) |41270|310|(null)|string/11 |='BAENU_TYPE'
|ok(0) |49352|200|(null)|carray/1
|=03 '
'
-------------------------------------**End Tuxedo Output Buffer**
24/55
Cette option vous permettra d'enrichir la trace d'informations sur les temps de traitement avec un maximum de
précision. Ceci est indépendant de la notion de "chronométrage" et d'analyse, proprement dite, des temps de
réponse.
En fait vous pouvez utiliser le "chronométrage" et/ou les traces des temps de réponse … selon ce qui vous
convient le mieux.
Le "chronométrage" est utilisé –classiquement
classiquement– sans les traces pour optimiser les temps de traitement.
L'option de trace des temps de réponse, elle, est
e utilisée –classiquement– pour surveiller les temps d'exécution.
Si cette option est activée vous pourrez voir apparaître dans les traces de sortie un complément sous la forme :
…
exec:[tempsExecution]
] own:[tempsExecutionPropre]
own:[
lost:[tempsPerdu
tempsPerdu]
[tempsExecution] : le temps total d'exécution de l'appel (hors temps perdu dans hooktrack)
[tempsExecutionPropre] : le temps total d'exécution de l'appel hors temps d'exécution des appels internes
[tempsPerdu] : le temps perdu dans hooktrack : ceci est fournit
fournit à titre d'indication : il a déjà été retranché des
temps ci-dessus.
Les valeurs nulles ne sont pas tracées
Exemple:
a5c:Enter I.BT_TEST_SQL
a5c: Enter I.DB
a5c: Leave I.DB exec.:336(ms) own:336(ms)
own:
lost:1(ms)
a5c:Leave I.BT_TEST_SQL exec.:337(ms)
337(ms) own:1(ms)
on a ici 337 =336+1
c'est-à-dire 'temps total I.BT_TEST_SQL
BT_TEST_SQL'='temps
'='temps des appelés (I.DB)'+'temps propre I.BT_TEST_SQL'
I.
(remarquons que les temps sont ici arrondis
arrondi à la milli-seconde)
Ceci permet la récupération des traces du moteur NatStar™ et la récupération des traces produites par
l'instruction 'Things_Trace' : c'est ce que vous obtenez dans le fichier de trace classique NatStar™, lorsque vous
n'utilisez pas HookTrack.
Ces traces sont encadrées par des 'pipes
pipes' (voir aussi : 'Comment lire la trace').
Dans le lanceur de votre application si vous ne positionnez pas la variable d'environnement 'NSTRACE' vous
n'aurez pas les traces du moteur NatStar™,
NatStar™ par contre – dans tous les cas – en cochant 'NatStar™ trace
(Things_Trace)' vous pourrez récupérer les traces produites par vos propres appels à l'instruction Things_Trace.
Il est possible grâce au champ de saisie situé sous la case à cocher
coch de saisir une expression régulière, qui
permettra d'exclure les traces correspondantes : elles ne seront alors pas récupérées par HookTrack.
(Voir aussi : 'Syntaxe des expressions
ns régulières').
régulières
25/55
4.2.2.3 Le paramétrage du débogueur
eur
Ce paramétrage peut être défini en accédant au sous-onglet
sous
'Debugger' de 'Trace
Trace & Debug settings'
settings :
Cette option permet de fonctionner en mode débogueur
déb
(point d'arrêt, visualisation de variables, de paramètres,
pas à pas).
Mais elle aussi très importante pour qu'en cas de bug/fuite mémoire vous puissiez avoir un maximum
d'informations sur le code source concerné.
Le fait de cocher cette option dégrade légèrement les performances,
performances, mais vous constaterez probablement que
cela est négligeable par rapport au service rendu : en dehors de cas spécifiques et de gros problèmes
problème de
performance, il est conseillé de garder cette option active.
Rappelons une fois de plus que le mode débogueur ne fonctionne qu'avec les dll compilées en mode 'Debug'
sous NatStar™ : rien n'empêche d'avoir des dll non compilées en mode 'Debug' parmi vos dll,
dll simplement
aucune information concernantt leur source ne pourra être affiché.
Ce tableau représente la liste des points d'arrêts actifs pour votre application.
En cochant 'Activate
Activate Below Break Points'
Points vous autorisez HookTrack à arrêter l'application sur les points d'arrêt
du tableau qui sont cochés 'IsActive'.
'Line' : lee numéro de ligne est le numéro dans le source NatStar™ (au moment où
o vous avez compilé la
ressource concernée).
'Scope' : est une identification du source concerné de la forme :
Type
= M (méthode), I (instruction),
nstruction), F (fonction), W (événement
(év nement de fenêtre)
Conteneur
le nom de fenêtre suivi du nom de 'control' si Type='W',
sinon rien
Ressource
= le nom de la méthode ou ressource appelée
(méthode,
hode, fonction, instruction, événement)
évé
Vous pouvez facilement supprimer des lignes en les sélectionnant et en appuyant sur 'Suppr'.
En pratique, il est plus facile de positionner les point d'arrêt en affichant le source (clic
(cli droit 'view source' dans
la plupart des IHM ou via le menu 'Debug>Co
Debug>Code Browser') en positionnantt la souris sur la ligne concernée et
en appuyant sur F9 (voir : 'Le browser de code').
code'
4.2.2.4 Le paramétrage de la détection de bug
Ce paramétrage peut être défini en accédant au sous-onglet
sous
'Bug auto. detection' de 'Trace
'
& Debug settings' :
26/55
Cette option permet d'activer ou de désactiver de manière générale
général la détection automatique de bug (c'est-à-dire
(c'est
les fonctionnalités ci-après).
Rappelons
elons que la localisation d'un bug sera d'autant plus précise que la dll concernée sera compilée en mode
'Debug' sous NatStar™ et vraiment effective
effec
pour la détection de problèmes
mes mémoire en utilisant les options
option
/RTC du compilateur Microsoft™ VC++ 8.0.
8.0
(Pour plus de détails voir : 'Comment détecter des écrasements
écrasement mémoire').
L'option 'Activate
Activate below memory leaking detection'
detection permet l'activation/désactivation des fonctionnalités
fonction
de
détection de fuite mémoire.
o 'Track NCL segment memory leak' : l'allocation de segment NCL ou de buffer mémoire par l'instruction
New sera mémorisée par HookTrack.
o 'Track Object memory leak' : l'allocation
'allocation d'objet par l'instruction !New (ou Things_New) sera mémorisée
mémorisé
par HookTrack.
o 'Track
Track Things_Alloc segment memory leak'
leak : l'allocation
'allocation de buffer par l'instruction Things_Alloc sera
mémorisée par HookTrack.
o 'Track Things_Sequence_Allocmemory
memory leak'
leak : l'allocation
'allocation de séquences par l'instruction
Things_Sequence_Alloc sera mémorisée
mémorisé par HookTrack.
Les séquences ramenées depuis le serveur seront également détectéess (dans la mesure où
o une instruction de
manipulation de séquence Things_*Sequence* est utilisée).
Pour chacune dee ces options (dans la mesure où la dll à l'origine de l'allocation est compilée
compilé en mode 'Debug') la
ligne du source à l'origine de l'allocation.
De plus, un warning sera affiché si une désallocation ne correspond pas à une allocation précédemment
mémorisée.
(Pour plus de détails : 'Le suivi des fuites mémoire').
27/55
Activation de la détection d'erreur Tuxedo™ après un appel TpCall.
En cas d'erreur, une alerte HookTrack sera affichée.
affiché
Activation de la détection d'erreur après l'utilisation d'une des fonction/instruction
fonction/in uction SQL :
o Sql_Exec, Sql_ExecLongStr
o Sql_InitMultiple, Sql_StopMultiple
o Sql_Create, Sql_Delete
o Sql_Open, Sql_Close
o Sql_OpenCursor, Sql_CloseCursor
o Sql_OpenTheCursor, Sql_CloseTheCursor
En cas d'erreur, une alerte HookTrack sera affichée.
Cette option permettra d'intercepter les messages de débogage MicroSoft
Soft (les fameux messages
Retry/Ignore/Continue) et de les faire afficher ou tracer par HookTrack.
Suivant l'option choisie :
o 'Display a debug message' sera affiché par HookTrack (qui pourra alors vous donner la ligne du source
concerné).
o 'Display
Display a debug message, except for error on cast to smaller var'
var idem ci-dessus,
dessus, mais dans le cas d'une
conversion en un type de taille inférieure,
inférieur seul un 'warning' sera tracé.
o 'Trace the message' une ligne de 'warning
warning' sera simplement écrite dans la trace et l'exécution
l'
ne sera pas
interrompue.
Ces options sont surtout utiles pour détecter les écrasements mémoire,
mémoire ce qui nécessite une compilation avec
MicroSoft VC++2005 et des options de compilation de type /RTC*.
/RTC*
(Pour plus de détails : 'Comment détecter les écrasements
écrasement mémoire').
Ces options permettent d'intercepter immédiatement un appel à l'instruction de positionnement d'erreur du
moteur NatStar™ Things_Set_Error.
o 'Intercept NatStar™ Things_Set_Error in case of an error, and display a debug message'
message permet d'afficher
une alerte HookTrack, si Things_Set_Error est
e appelé, sans que cela soit pour un 'Warning' (voir
documentation NatStar™).
o 'Intercept NatStar™ Things_Set_Error in case of a warning, and trace it'
it permet de tracer les appels de type
'Warning' à Things_Set_Error.
28/55
Ces options permettent d'intercepter les appels à l'instruction
l'instructi windows 'SetError()',, il est probable que votre
code n'y fasse pas appel directement, mais les API windows appelées par les dll NatStar™ l'utilisent.
Ces appels peuvent rendre compte de problèmes de connexion,
conne ion, de fichier inexistant, de clef de registre absente,
de variables d'environnement absentes …
Cependant, dans la plupart des cas, cela ne correspond probablement pas pour votre application à de véritables
problèmes.
Si par exemple pour tester l'existence d'un fichier vous essayez
essay de l'ouvrir, SetError() sera appelée (message
'fichier inexistant'), ce n'est pas a priori un bug, simplement le fichier est absent.
À l'utilisation, cette option peut donc générer beaucoup de warning ou de message de debug : ce 'bruit' la rend
peu pertinente.
Il n'en demeure pas moins qu'elle peut s'avérer extrêmement intéressante dans certains cas particuliers
particulier de
problèmes remontés par les API Windows™.
Windo
o 'Display a debug message' affichera un message de debug dans HookTrack.
o 'Trace the message' affichera simplement un warning dans la trace.
4.2.2.5 Les paramétrages avancés
Dans le champ de saisie il est possible de saisir une valeur (en secondes) qui forcera la valeur du timeout
Tuxedo™ pour les appels TpCall depuis le client (i.e. : les appels remote si vous utilisez Tuxedo™).
Tuxedo™
Si vous laissez cette valeur à 0, aucune modification
modification ne sera apportée par HookTrack.
29/55
4.3
L'IHM principale de HookTrack (après détection d'une application)
Voir aussi : [Détail des menus] [Zone de visualisation du source] [Zone de visualisation des variables] [Zone de visualisation des traces]
30/55
4.3.1
Détail des menus
Menu 'Application detection'
Voir aussi : [Comment détecter une application]
[Paramétrage]
Menu 'Windows'
Liste les fenêtres filles de HookTrack correspondant aux différentes applications détectées.
31/55
Menu 'Debug'
Voir aussi : [La pile des appels]
Menu 'Trace Buffer'
Voir aussi : [La zone de visualisation des traces]
32/55
Menu 'Tools'
Voir aussi : [Le 'browser' de code]
4.3.2
[L'analyse des temps de réponse]
[Le suivi des fuites mémoire]
Zone de visualisation du source
La partie supérieure d'une fenêtre fille permet d'afficher le code source, soit parce qu'on est en mode debug ou
'pas à pas', soit parce qu'à partir d'une autre IHM (trace, pile des appels, analyse des temps d'exécution, listing
d'allocation) on a utilisé le menu contextuel (clic droit) 'View Source'.
Les différentes pages de code sont affichées sous forme d'onglet, un survol de l'onglet avec la souris affiche le
nom complet du source.
Le glyphe
permet d'afficher la liste des sources ouvertes, le glyphe
permet de fermer le source courant.
33/55
o Le code source est colorisé, un survol avec la souris d'une variable locale
local ou d'un paramètre ou d'une
expression de type segment séléctionée, permet d'afficher son type, son origine (locale,
(local globale ou
paramètre) et sa valeur (cadre sur fond blanc).
o L'indentation est marquée par une ligne grisée à droite et correspond à du code masquable/affichable en
cliquant sur les icônes [-] et [+], ceci
ci permet une lecture aisée que le code soit indenté correctement ou non.
o Les différents commentaires de source et d'interface sont systématiquement rappelé dans l'entête.
o Le menu contextuel permet de :
o rechercher dans la source
o positionner/supprimer un point d'arrêt
o développer/réduire les indentations
o d'ajouter une variable à la liste des variables
surveillées
o d'ouvrir le code source dans une IHM de type
code 'browser'
o copier dans le presse papier le code indenté
(ce menu n'est actif que si la souris est sur une ligne
: c'est-à-dire
dire si le pointeur est de type 'curseur').
o Un point d'arrêt est représenté par un point rouge à gauche du source.
o Le numéro de ligne survolé par la souris est indiqué
ind
en bas à droite.
Les différentes significations de surlignage dans le code source :
34/55
Si vous accédez au source grâce à un menu contextuel 'View Source', la ligne concernée sera surlignée en vert
clair (sans encadrement).
Si vous êtes en mode 'débogueur', la ligne sur le point d'être exécutée sera surlignée en jaune foncé avec
encadrement noir.
Si vous êtes en mode 'débogueur' et si à l'exécution on s'apprête à sortir du source (ici à cause du 'Return' qui est
sur le point d'être exécuté), alors la ligne sera surlignée en jaune clair avec encadrement noir.
Ceci permet de vous rendre compte 'visuellement' que vous quittez ce code et vous laisse une dernière occasion
de jeter un œil aux variables, mais surtout aux paramètres de sortie !!!
Enfin, toujours en mode 'débogueur', une fois sortie du source, la dernière ligne exécutée reste surlignée en
jaune clair (sans encadrement).
Signalons enfin que si le source est sur fond gris, c'est qu'il ne correspond pas à du source qui n'a pas été
compilé en mode 'debug' dans NatStar™ : c'est le cas par exemple si, dans la fenêtre de trace, vous faites clic
droit/'View source' sur une ligne de type Call/EndCall.
4.3.3
Zone de visualisation des variables
La zone centrale de HookTrack permet de visualiser des variables locales, des paramètres, des variables
globales, des objets ou des expressions (adresses, 'cast', éléments de tableaux).
Les intitulés des colonnes de la liste des variables surveillées sont :
Name : nom ou expression de la variable
Scope : source dans lequel la variable à un sens (rappel : vos dll doivent être compilées en mode 'debug' dans la
fenêtre de génération NatStar™), si le source en question n'est pas dans la pile des appels (= son code n'est pas
en cours d'exécution) alors la variable sera grisée et sa valeur sera '<out of scope>'.
Value : valeur de la variable (ou message d'erreur)
35/55
o Il est possible d'afficher l'adresse d'une variable en la faisant précèder
préc
d'un @ (comme dans
da le code NCL).
Exemple : @racineLocale.Feuille_basses[i%]
o Il est aussi possible d'utiliser des variables pour représenter des index dans les tableaux.
Exemple : S_FEUILLE(P_feuille).CHAINE_3D[i%][j%][k%]
36/55
o Il est possible de 'caster' un pointeur dans un segment en utilisant la syntaxe classique NCL :
nom_segment(nom_pointeur) ;
Exemple : S_FEUILLE(P_feuille)
ou en utilisant en lieu et place de 'nom_segment',
'nom_segment' un type simple ou un tableau de type simple :
Exemple : CHAR[5](2)(P_feuille)
o Il est possible de 'caster' directement en
e utilisant une adresse mémoire.
Exemple : S_FEUILLE(123456).CHAINE_3D
o Il est possible d'extraire d'un arbre (segment/tableau) des champs par glisser/déposer
glisser/déposer.
o Le menu contextuel (clic droit) permet de sauvegarder/charger/effacer/rafraîchir des variables visualisées.
o Les erreurs de valorisation sont signalées en rouge.
Exemple : <Cstring not terminated by 0>
o Les valeurs nouvelles ou modifiées sont signalées en bleu.
o Les valeurs non accessibles (i.e. dont la portée n'est plus dans la pile des appels) sont grisées.
o Les handles d'objet sont détectés automatiquement et les variables d'objets sont présentées
présenté sous forme
arborescente (avec gestion des extraits pour les variables 'store extract' non encore chargées).
c
4.3.4
Zone de visualisation des traces
La partie inférieure de HookTrack présente en temps réel les traces telles que choisies dans le paramétrage.
Dans la zone de trace, un clic droit vous permettra :
o de copier le texte sélectionné (Ctrl+C)
o d'aller
ller sur la trace d'appel / de sortie (Ctrl+E/Ctrl+L)
o de rechercher
echercher dans la trace (avec comme résultat une liste 'cliquable' des lignes trouvées) (Ctrl+F)
o d'afficher le source correspondant (Ctrl+V)
(Voir aussi : Le paramétrage des traces)).
(Voir aussi : Comment lire la trace).
37/55
4.4
Points de trace et points d’arrêt
Vous pouvez positionner des points de trace ou point d’arrêt dans le code affiché (sur l’écran principal ou dans
le code affiché dans le browser de code) de différentes manières :
-
Donner le focus à la zone de code, positionner la souris sur la ligne désirée, et faite un clic droit ‘Toggle
Break Point (F9)’.
Cliquez sur la zone vide la plus a droite de la ligne : une IHM s’ouvre pour renseigner les paramètres du
point.
Les points d’arrêt/trace sont listés dans l’onglet ‘Breakpoints’ de la partie central de l’IHM principale.
Vous pouvez éditer les points en cliquant sur le bouton
de la ligne correspondante via l’IHM ci-dessous :
Un point (arrêt et/ou trace) peut
être conditionné à la valeur
d’une expression (à mettre entre
{}).
Ici le point n’est actif que si
i%=1.
La zone de saisie du texte de
trace peut également inclure une
expression entre {}.
Une expression est un nom de
variable, de paramètre , un
champ de segment, une variable
d’objet (même syntaxe que dans
l’onglet watch) ou {#hits} qui
représente le nombre de fois ou
le point a été atteint.
38/55
4.5
Les outils de HookTrack
Le 'dump' d'objets en mémoire
Le suivi des fuites mémoire
La pile des appels
Les messages de débogage et alertes dans HookTrack
4.5.1
HookTrack intègre un outil de parcours et de visualisation du code source de vos dictionnaires NatStar™, un
peu comme vous le feriez avec un navigateur ('browser') internet.
Vous pouvez afficher le 'browser' avec le menu 'Tools/Code Browser (Ctrl+B)' de l'IHM principale.
Le code source affiché est enrichi de différentes manières :
o Interface rappelée in extenso dans le code affiché
o Liens hypertexte pour naviguer vers les ressources
o Code colorisé (mots clefs, variables locales, paramètres, chaînes de caractères, ressources)
o Structures de contrôle (boucles, if/endif, …) indentées automatiquement et pouvant être masquées
o Bulle d'aide sur les ressources, variables et paramètres
Un historique de votre navigation est conservé et il est possible de le parcourir simplement.
39/55
40/55
4.5.2
Le 'dump' d'objets en mémoire
HookTrack vous permet d'afficher une IHM qui liste les objets en mémoire, vous permet de visualiser les
variables d'un objet sélectionné dans cette liste et également de lister les objets qui le référencent.
Cette IHM peut être affichée à tout moment, même si du code est en train d'être exécuté.
Vous pouvez afficher des fenêtres 'dump' avec le menu 'Tools/Objects Dump (Ctrl+D)' de l'IHM principale.
Il peut être intéressant d'afficher plusieurs fenêtres 'dump' chacune donnant une sorte de photographie à un
instant précis de la liste des objets en mémoire.
Sur les lignes représentant un objet, il est possible grâce à un clic droit d'afficher l'objet dans une IHM
indépendante du dump ou de visualiser le source qui est à l'origine de l'allocation de l'objet (le source à l'origine
de l'allocation de l'objet ne sera disponible que si la détection des fuites mémoire pour les objets a été activée,
(voir : 'Track Object memory leak').
41/55
42/55
4.5.3
Le suivi des fuites mémoire
HookTrack permet d'afficher une liste de ressources système correspondant à des réservations (allocations) de
ressources qui n'ont pas encore fait l'objet de libération (désallocation).
Par 'fuite', on entend la non 'libération' d'une ressource système
syst
qui ne sera plus utilisée par la suite.
Classiquement, une fuite mémoire est avérée lorsque la valeur du pointeur sur la zone mémoire allouée est
perdue sans que l'instruction de désallocation n'ait été utilisée
ut lisée pour libérer cette zone mémoire.
Dans les exemples qui suivent, nous ne traitons que du cas de segment/buffer NCL (instruction New/Dispose).
Les autres cas :
- allocation/désallocation
llocation/désallocation d'objet (!New/!Dispose)
llocation/désallocation de sequence
sequen (Things_Sequence_Alloc/Things_Sequence_Free)
/Things_Sequence_Free)
llocation/désallocation de buffer (Things_Alloc/Things_Free)
(Things_Alloc
- ouverture/fermeture de curseur de base de donnée (Sql_OpenCursor/Sql_CloseCursor)
(Sql_OpenCursor/Sql_CloseCursor)
sont gérés sur le même principe.
HookTrack permet d'aider à la détection de ces fuites, pour ce faire,
faire il faut
ut activer dans le paramétrage les
options de suivi des fuites mémoire :
(Pour plus de détails sur le paramétrage voir : 'Activate
Activate below memory leaking detection').
detection
Il sera alors possible à tout moment d'utiliser le menu Tools/Leaks/Show NCL New&DisposeMemory leaks.
43/55
Ce menu affiche la liste des allocations 'New'
'
effectuées qui n'ont pas fait l'objet de 'Dispose
Dispose' et qui n'ont pas été
marquées explicitement par vous (dans l'IHM ci-dessous)
ci dessous) comme n'étant pas des 'fuites'.
44/55
Dans la colonne 'Ressource', les lignes notées <not tracked> (non pistées) correspondent à des allocations ayant
eu lieu avant que vous n'ayez activé la détection de fuite mémoire, ou ayant eu lieu dans du code pour lequel la
pile des appels était vide (ce qui peut arriver si vos dll ne sont pas compilées en mode 'debug').
Pour avoir une détection précise du source étant à l'origine de l'allocation, il est important de compiler vos dll
NatStar en cochant l'option 'Debug' dans la fenêtre de génération. Vous pourrez alors via un clic droit activer le
menu 'View Source' qui vous amènera directement sur la ligne de source considérée.
Dans la mesure du possible, HookTrack donne le fichier source à l'origine de l'allocation :
- Si vous avez compilé en mode 'Debug' dans NatStar : vous aurez alors le nom de la
ressource et le numéro de ligne de code où a eu lieu l'allocation.
- Si vous avez compilé en vous liant (link) à memdbg.lib et en utilisant l'option de compilation
/DNSMEMTRACE (cf. doc NatStar) : vous aurez alors le nom du source C (ceci uniquement pour les
segments NCL).
- Sinon, soit aucune information complémentaire ne pourra être donnée (<not tracked>), soit la ligne de
source donnée est la dernière connue par HookTrack dans la pile des appels (voir aussi : La pile des
appels).
Pour être certain de détecter les fuites mémoire au sein d'une procédure de votre application il est conseillé de
procéder comme suit :
-
Assurez vous que la détection de fuite mémoire est activée dans le paramétrage.
Effectuez une première fois la procédure dans votre application.
Utilisez le menu Tools/Leaks/Clear NCL New&Dispose Memory leaks (qui marque les allocations comme
n'étant pas des fuites).
Effectuez une nouvelle fois la procédure dans votre application.
Utilisez le menu Tools/Leaks/Show NCL New&Dispose Memory leaks.
À la deuxième exécution de votre procédure, il ne devrait (sauf cas de fuite) y avoir de ligne dans la liste.
Notons également que 'Total size in memory' est un indicateur de la quantité de mémoire allouée et considérée a
priori comme correspondant à des fuites : si elle ne fait qu'augmenter alors que vous exécutez votre procédure
c'est qu'il y a une fuite mémoire avérée.
45/55
multithread
4.5.4
La pile des appels
HookTrack vous permet d'afficher la pile des appels (i.e. la liste des fonctions/instructions/méthodes en cours
d'exécution) : menu Debug/Show CallStack(F12).
Dans cette IHM vous aurez également accès (en dépliant les nœuds [+] de l'arbre) aux variables locales et aux
paramètres correspondant à du code de dll compilées avec l'option 'Debug' cochée dans la fenêtre de génération
NatStar™.
Les appels de méthodes sont toujours affichés, les appels de ressources en librairies ne sont 'vus' par HookTrack
que si vous avez coché l'option 'Debug' dans la fenêtre de génération NatStar™.
Le nom identifiant le source est construit ainsi : <Type>.<Conteneur>.<Ressource>
Type
= M (méthode), I (instruction), F (fonction), W (événement de fenêtre)
Conteneur
le nom de fenêtre suivi du nom de 'control' si Type='W',sinon rien
Ressource
= le nom de la méthode ou ressource appelée (méthode, fonction, instruction, événement)
Ou C.<Nom de classe>.<Nom de méthode> si le code en question est dans une dll qui n'a pas été compilée en
mode 'Debug' dans la fenêtre de génération NatStar™.
46/55
4.5.5
L'enregistrement des temps d'exécution n'est effectif qu'une
une fois que vous avez activé le "chronomètre" en
cliquant sur le bouton "Chrono" de l'IHM principale :
le chronomètre n'est pas activé ( vert = déclenchement
décl
possible )
le chronomètre est actif ( rouge = chronométrage en cours) : il est possible de l'arréter.
l'arr
Si votre objectif est simplement d'obtenir des temps de réponse il n'est pas utile d'activer la trace*.
A l'arrêt du chronomètre (i.e. il passe du 'rouge' au 'vert' ) un compte rendu des temps de traitement est
affiché.
Les valeurs du tableau sont affichables en millisecondes ou en pourcentage du temps total,
total ces valeurs sont les
valeurs réelles de temps d'exécution (les temps perdus pour tracer,
tracer ou dans les 'points d'arrêts' ont été
retranchés). Les lignes peuvent être triées en cliquant sur le titre des colonnes.
Total execution time : temps total d'exécution : inclue le temps passé dans les appels internes.
Average execution time : temps moyen d'exécution = (Total execution time)/(Call count).
Own execution time : temps total d'exécution hors temps passé dans les appels internes
Average own execution time : temps moyen propre = (Own execution time)/(Call count).
Call count : nombre d'appels.
Name
me : nom de la ressource/méthode/service Tuxedo/requête SQL.
Pour déterminer facilement le code à l'origine d'une dégradation de perfomance,
perfomance triez suivant la colonne 'Own
Execution Time'' : temps d'exécution propre (hors appels
app internes). Le code apparaissant avec le temps
maximum estt très probablement celui qui pose problème.
Vous pouvez visualiser facilement le code en question via un clic droit sur le nom du source.
47/55
La cellule en bas du compte rendu affiche la somme des valeurs des cellules sélectionées, si vous avez besoin de
plus de fonctionalités de type 'calcul' le mieux est de faire un copier/coller du tableau dans Excel.
(dans l'exemple on voit que la somme des appels propre est égal au temps d'exécution total de l'appel principal :
0.4113=0.0698+0.2002+0.1412 )
Un conseil pour finir :
n'essayez pas d'optimiser du code a priori (= sans savoir si c'est vraiment ce code qui est responsable de
mauvaise performance) : ce n'est jamais rentable.
*
Le chronométrage des temps de réponse est désormais indépendant de la trace : ce n'était pas le cas dans les versions précédentes.
48/55
4.5.6 Les messages de débogage et alertes dans HookTrack
Les alertes et les messages de débogage
age de HookTrack sont systématiquement affichés sous la forme d'une
fenêtre de type :
Si le message n'est qu'un 'Warning', l'icône change et seul un bouton 'OK' peut être disponible.
bug la réponse de HookTrack
Le tableau qui suit donne, par catégorie de bug,
49/55
Catégorie de bug
Problème de chargement de dll
Alerte HookTrack
Pop-up
Procédure à suivre
Utilisez un logiciel comme
'Depends', pour connaître la raison
précise du non chargement de la dll
Handle d'objet nul ou invalide
Erreur Tuxedo™
Débordement d'une chaîne de
caractère
Pop-up
Pop-up
Message en rouge 'Cstring not
terminated by 0' lors de la
visualisation de la variable
Index en dehors des limites d'un
Message en rouge 'invalid index'
tableau
lors de la visualisation de la
variable
Pointeur/Handle invalide
Message en rouge 'Invalid
pointer' lors de la visualisation
de la variable
Un écrasement de 'pile' mémoire
Pop-up en sortie de fonction 1
Erreur NatStar™ (things_set_error) Pop-up ou Warning (au choix)
Erreur Windows™
Pop-up ou Warning (au choix)
(Kernel32.SetError)
Fuites mémoire (segment, objets,
non
séquences) ou de curseurs de base
de données
Problème de performance
non
Boucle infinie
non
Appel récursif infini
non
Autres plantages (dans la mesure
où vous avez une alerte de l'OS du
genre de la boîte de dialogue avec
croix blanche sur fond rouge)
non (mais message windows)
1
Utilisez les IHM HookTrack de
suivi des fuites mémoire
Utilisez l'IHM d'analyse des temps
de réponse de HookTrack
HookTrack pour voir où votre
programme est bloqué
Consultez le buffer de trace de
HookTrack pour repérer les
indentations d'appels auxquelles ne
correspondent pas de retours
Gardez la boîte de message de
plantage ouverte.
HookTrack, sur le dernier appel
faites 'clic droit' [View Source],
vous pourrez, dans la plupart des
cas, consulter la valeurs des
variables au moment du plantage,
et la dernière ligne exécutée
Si compilation avec Microsoft VC++8.0 : voir Détection des écrasements mémoire
50/55
4.6
Comment détecter des écrasements mémoire
Ce qui est décrit ci-après ne fonctionnera que si vous avez compilé avec le compilateur MicroSoft™ C++
de Visual C++2005 (inclu dans VisualStudio 2005™) … ou pour une version superieure à VC++2005
Il vous faudra modifier les options de compilation dans la 'Configuration' de génération NatStar™.
Il est recommandé d'utiliser une nouvelle configuration de compilation en mode debug, pour VC++2005.
Vous pouvez partir de votre configuration de compilation Cliente et rajouter les options suivantes pour le
compilateur CL.EXE :
/Gs /Gy /RTC1 /RTCc /MDd /Od /errorReport:prompt
En enlevant :
/G* (par exemple /GD et /G5)
/O* (/O1 /O2 …)
Exemple :
Anciennes options de compilation :
/c /Gs /GD /G5 /MD /O2 /W3 /Zp1 /DWIN32 /DNSMEMTRACE
Nouvelles :
/c /Gs /Gy /RTC1 /RTCc /MDd /Od /W3 /Zp1 /DWIN32 /DNSMEMTRACE /errorReport:prompt
IHM NatStar™ correspondante :
Il faudra recompiler votre exécutable et les dll pour lesquelles vous suspectez un écrasement mémoire (dans le
doute, recompilez tout !), en mode 'Debug' dans la fenêtre de génération NatStar™.
Dans HookTrack, n'oubliez pas d'activer les paramètres :
51/55
4.7
Comment lire la trace
-
Les traces issues de NatStar sont toujours encadrées par des caractères 'pipe' |
-
Le texte @line=x donne (pour les dll compilées en mode 'Debug') le numéro de ligne
concernée dans le source : le source en question est celui correspondant au premier 'Enter'
de niveau superieur.
-
Le code hexadécimal en début de ligne donne l'identifiant de thread.
- Les appels de méthodes sont tracés comme suit :
Call Nom_de_classe.Nom_Méthode handle_objet (handle_objet_hexadécimal)
Cette trace est affichée avant que la méthode ne soit réellement appelée.
- Les sorties de méthodes sont tracées comme suit :
EndCall Nom_de_classe.Nom_Méthode handle_objet (handle_objet_hexadécimal)
Cette trace est affichée après que la méthode ait été exécutée.
- Les appels d'instruction/fonction/événement sont tracées comme suit :
Enter type.Nom_de_librairie.Nom_de_ressource
Cette trace est affichée juste après l'entrée dans l'instruction/fonction/événement,et ce, uniquement si la dll
concernée a été compilée avec l'option 'Debug' cochée dans la fenêtre de génération NatStar.
- Les sorties d'instruction/fonction/événement sont tracées comme suit :
Leave type.Nom_de_librairie.Nom_de_ressource
Cette trace est affichée juste avant la sortie (return) de l'instruction/fonction/événement et ce, uniquement si
la dll concernée a été compilée avec l'option 'Debug' cochée dans la fenêtre de génération NatStar.
-
Les traces d'Erreur/Warning/Allocation ou Désalocation sont auto-explicites.
-
À la fin d'une ligne de trace ,si vous avez activé la trace des temps d'exécution, vous aurez les
infromations : … exec:[tempsExecution] own:[tempsExecutionPropre] lost:[tempsPerdu] .
-
Les requêtes SQL sont tracées entre 'SQL_EXEC …' et 'SQL_EXEC end', les valeurs des variables passées
en paramètres sont également tracées (voir : activation des traces SQL).
-
Les appels tuxedo , et les buffers tuxedo d'entrée et de sortie sont tracés suivant le format décrit dans la
partie concernant l'activation des traces tuxedo.
52/55
Exemple :
53/55
4.8
Annexe : syntaxe des expressions régulières
Metacharacter
Meaning
.
Matches any single character.
[]
Indicates a character class. Matches any character inside the brackets (for
example, [abc] matches 'a', 'b', and 'c').
^
If this metacharacter occurs at the start of a character class, it negates the
character class. A negated character class matches any character except
those inside the brackets (for example, [^abc] matches all characters except
'a', 'b', and 'c').
If ^ is at the beginning of the regular expression, it matches the beginning of
the input (for example, ^[abc] will only match input that begins with 'a', 'b',
or 'c').
-
In a character class, indicates a range of characters (for example, [0-9]
matches any of the digits '0' through '9').
?
Indicates that the preceding expression is optional: it matches once or not at
all (for example, [0-9][0-9]? matches '2' and '12').
+
Indicates that the preceding expression matches one or more times (for
example, [0-9]+ matches '1', '13', '456', and so on).
*
Indicates that the preceding expression matches zero or more times.
??, +?, *?
Non-greedy versions of ?, +, and *. These match as little as possible, unlike
the greedy versions that match as much as possible (for example, given the
input '<abc><def>', <.*?> matches '<abc>' while <.*> matches
'<abc><def>').
()
Grouping operator. Example: (\d+,)*\d+ matches a list of numbers
separated by commas (for example, '1' or '1,23,456').
{}
Indicates a match group.
Escape character: interpret the next character literally (for example, [0-9]+
matches one or more digits, but [0-9]\+ matches a digit followed by a plus
character). Also used for abbreviations (such as \a for any alphanumeric
character; see the following table).
\
If \ is followed by a number n, it matches the nth match group (starting
from 0). Example: <{.*?}>.*?</\0> matches '<head>Contents</head>'.
Note that, in C++ string literals, two backslashes must be used: '\\+',
'\\a', '<{.*?}>.*?</\\0>'.
$
At the end of a regular expression, this character matches the end of the
input (for example,[0-9]$ matches a digit at the end of the input).
|
Alternation operator: separates two expressions, exactly one of which
matches (for example, T|the matches 'The' or 'the').
!
Negation operator: the expression following ! does not match the input (for
example, a!b matches 'a' not followed by 'b').
54/55
Abréviations
Abbreviation
Matches
\a
Any alphanumeric character: ([a-zA-Z0-9])
\b
White space (blank): ([ \\t])
\c
Any alphabetic character: ([a-zA-Z])
\d
Any decimal digit: ([0-9])
\h
Any hexadecimal digit: ([0-9a-fA-F])
\n
Newline: (\r|(\r?\n))
\q
A quoted string: (\'[^\']*\')|(\'[^\']*\')
\w
A simple word: ([a-zA-Z]+)
\z
An integer: ([0-9]+)
Example 1 : regular expression {[0-9]?[0-9]}:{[0-9][0-9]} : format hh:mm or h:mm
testing with '1:57' : successful match
testing with '01/03': no match
Exemple 2 : regular expression {\*\*KIT}|{MAC}
will match any string with **KIT or with MAC substring
55/55

Aide en ligne - Girollet Info

Transcription

Documents pareils

Anti aspiration d`un site Web

A quoi sert le carnet de bord?

Des cadeaux pour tous (même les boutches !)

TRACE TV

TRACE renouvelle sa confiance en OpenHeadend Après ses

Eval diagnostique CE2

COMMUNIQUÉ DE PRESSE FORt DE FRaNCE, LE 26 jUILLEt 2012

www.ibpindex.com IBP = 43 HKG - Sport

Télécharger

Husseren