ELE-542 Systèmes ordinés en temps réels. Cours # 3 Langage C et temps réel

Transcription

1 ELE-542 Systèmes ordinés en temps réels Cours # 3 Langage C et temps réel Jean-Marc Beaulieu et Bruno De Kelper Site internet: Systèmes ordinés en temps réel 1 Qu est ce qui influence le temps d exécution Compilateur Matériel Compilateur Optimisation du code Déroulement de boucle Utilisation de registres «Inlining» Instructions spéciales du CPU Algorithmes Programme Matériel Processeur Taille (8, 16, 32 bits) Instructions Pipeline, cache Mémoire Bus système Programme Choix des variables Type des variables Emplacement en mémoire Choix des opérations Algorithmes Algorithmes Systèmes ordinés en temps réel 2 1

2 Le matériel Bus de données Bus d adresse Processeur Mémoire Systèmes ordinés en temps réel 3 Le langage C pour le temps réel Ce qu on veut analyser : En quoi le langage C aide-t-il à la conception temps réel? Quelles sont les caractéristiques désirables pour le T.R? En C, qu est-ce qui influence le temps d exécution? Pourquoi le langage C? Les compilateurs sont très performants; Le temps de développement est beaucoup plus court; Beaucoup de développement déjà existant; Portabilité d une architecture à une autre. Systèmes ordinés en temps réel 4 2

3 Architecture du programme Systèmes ordinés en temps réel 5 Modularité en langage C La modularité permet de décomposer un projet en bloc plus facile à gérer. En C, nous avons la notion de fonction et la notion de bloc de code (code entre { }). Au plus haut niveau, l approche consiste à découper le code en utilisant plusieurs types de fichiers. Identifier les fichiers sources (.c); Identifier les fichiers d en-têtes et d inclusions (.h); Identifier les fichiers de données et les fichiers spéciaux. Systèmes ordinés en temps réel 6 3

4 Sortes de fichiers Sortes de fichiers.c Code source en C. Le module principal doit contenir la définition de la fonction main(). Permet d exploiter la compilation séparée..obj,.o Code objet. Fonction compilée traduite en assembleur mais non localisée en mémoire. (adresse relative) Code orienté selon un processeur cible. Résultant de la compilation d une source.c. Systèmes ordinés en temps réel 7 Sortes de fichiers.h Fichier d inclusion et d en-têtes; Utilisation : #include <math.h> /*répertoire système*/ #include math.h /*répertoires courants*/ Contient les déclarations de fonctions (prototype); Contient les structures de données (typedef STRUCT); Contient les définitions communes (#define PI ); Contient les variables globales. Systèmes ordinés en temps réel 8 4

5 Sortes de fichiers.lib Bibliothèque; Regroupement de fonctions compilées sous format objet (.o); Outil tlib pour construire et générer une bibliothèque..exe (.hex) Exécutable; Contient un code compilé à charger en mémoire; Comprend le code du programme et de tous ces modules, localisés en mémoire; Résultant de l édition des liens (Linker). Systèmes ordinés en temps réel 9 Processus de compilation.h.h.c.c Compilateur.h Compilateur : Traduction en langage machine. Adresse relative. Laisse un espace pour les appels de fonctions. Utilise les prototypes des fonctions appelées pour garder un espace. Étape lente Votre source appelle; fabs(float); /*nécessite l entête dans math.h*/.lib.o.o Linker.exe Linker : Assemble toutes les portions de code compilées. Place des adresses absolues. Le code des fonctions provient de vos.o ou des biblio.lib. Votre source a besoin du code compilé de fabs(), alors il le prendra dans math.lib. Systèmes ordinés en temps réel 10 5

6 Avantages et désavantages de la modularité Avantages : Masquage Fonctionnement interne caché. Permet une description du module en terme d entrée/sortie sans les détails internes. Interface par paramètres La description des paramètres indique sur quelles données la fonction va travailler. Traitement spécifique et restreint Chaque module a une tâche spécifique. Division possible du travail Chaque membre de l équipe s occupe d un module. Systèmes ordinés en temps réel 11 Avantages et désavantages de la modularité Auto-suffisance Un module est complet en lui-même. Il peut être testé séparément en lui fournissant des paramètres de vérification. Compilation séparée On peut recompiler que les sources modifiées avec des utilitaires. (make, project) Réutilisation On peut réutiliser les blocs dans un autre projet ou encore les commercialiser avec seulement (.lib +.h) Les désavantages sont très faibles : Ralentissement causé par les accès mémoire supplémentaires (appel de fonctions) Systèmes ordinés en temps réel 12 6

7 Note sur la programmation Pour éviter programme confus; difficile à déboguer; difficile à modifier ou à adapter. Règles générales d écriture de programme Indentation des blocs et des boucles Aération du code source En-tête de fonction Description, paramètres E/S, structure, date, auteur) Commentaires Nom de variable significatif Systèmes ordinés en temps réel 13 Réentrance Et Passage de paramètres Systèmes ordinés en temps réel 14 7

8 Réentrance et récursivité Quelques définitions : Réentrance Propriété d une fonction qui peut être interrompue et être appelée de nouveau dans la fonction de traitement de l interruption. Récursivité Propriété d une fonction qui s appelle elle-même. Région critique ou atomique Partie de code qui ne peut pas être interrompue. Systèmes ordinés en temps réel 15 Réentrance et récursivité En C, les conditions pour avoir une fonction réentrante sont : 1) La fonction utilise seulement des variables locales (sur la pile) -- Attention aux pointeurs; 2) La fonction appelle seulement des fonctions réentrantes; 3) La fonction utilise les variables non locales de façon atomique. -- En C, les accès sont protégés par désactivation des interruptions, sémaphores, etc... Systèmes ordinés en temps réel 16 8

9 Passage de paramètres Il existe 2 grandes catégories pour le passage de paramètres à une fonction. Par liste de paramètres Passage par valeur; Passage par référence. Par variables globales Systèmes ordinés en temps réel 17 Passage par liste de paramètres Attention. Souvent les IRQ sont désactivées durant la copie des paramètres sur la pile. a b c d Augmente le temps de latence des interruptions Prenons un exemple de fonction : float moyenne(a, b, c, d); une IRQ pourrait survenir au milieu du transfert des paramètres sur la pile, et cette IRQ pourrait modifier les valeurs a, b, c, d; Alors on aura pour la fonction moyenne( ) des nouvelles valeurs et des anciennes valeurs. Systèmes ordinés en temps réel 18 9

10 Passage par variables globales Variables globales Visibles de tous les modules parce que définies à l extérieur; Possibilité de référer en mode d adressage direct, donc; Plus rapide parce qu elles ne passent pas par la pile; Pas nécessaire de désactiver les interruptions; Seule façon (sauf par registre) de transmettre un paramètre à une routine d interruptions. DANGER n importe quel module peut modifier la valeur; difficile à documenter Systèmes ordinés en temps réel 19 Comparaison Quoi faire si on a plusieurs paramètres à transmettre à une fonction? Rendre toutes les variables globales : peu pratique Transmettre tous les paramètres : lent, beaucoup d accès pile Transmettre un pointeur sur une liste oui, si les valeurs sont placées à la suite en mémoire... En résumé... Si le temps est "moins" important ou crucial Liste de paramètres; Meilleur pour la modularité, encapsulation entretien du code. Si le temps est très, très important Variable globale Si on doit transmettre à une routine d IRQ Variable globale Systèmes ordinés en temps réel 20 10

11 Les données Systèmes ordinés en temps réel 21 Gestion de données Outre les variables GLOBALES et LOCALES Classes d'allocation (Un préfixe à la déclaration ) Permet de spécifier l endroit où sont emmagasinées les données Dans la région mémoire de la pile, le heap, les données, un registre; Register un registre du CPU sera attribué, si possible ; Static une variable globale au fichier seulement.; Auto une variable locale est une auto par défaut... Extern pour partager une variable globale entre fichiers Volatile une variable qui est modifiée par des instructions non apparentes Exemple : variable modifiée dans une interruption Systèmes ordinés en temps réel 22 11

12 Types de données Répertoire Le langage C possède un grand répertoire de types disponibles au programmeur. Plus facile de structurer les données; Plus grand choix d espace d enregistrement; Exemple : La valeur du CAN 8 bits : unsigned char. Le C permet des opérations sur des types différents. Mais la conversion implicite peut entraîner une pénalité dans le temps d'exécution. Systèmes ordinés en temps réel 23 Types de données Systèmes ordinés en temps réel 24 12

13 Opérations sur des données Dépend du processeur Les opérations ont des performances différentes selon le type des données : Dépend du processeur LENT RAPIDE double float long int int char RAPIDE X double float long int int char + double float long int int char - double float long int int char & long int int char Systèmes ordinés en temps réel 25 Opérations sur des données Soit x,y,z : entiers 16 bits Processeur 8 bits 2 opérations d addition z LSB = x LSB + y LSB z MSB = x MSB + y MSB + carry 2 cycles d écriture 2 cycles de lecture z = x + y 1 cycle d écriture 1 cycle de lecture Processeur 16 bits 1 opération d addition z = x + y Systèmes ordinés en temps réel 26 13

14 Types de données Conversion implicite des données En C, les 2 données d une opération sont converties au type le plus exigeant avant d effectuer l opération. Ceci a pour conséquence : Long double double float unsigned long int long int unsigned int char int short Temps d exécution plus long *** en général ***; Mécanisme pas facile à prévoir; Exemple de problématique ( le 2 est pris comme un int, alors) unsigned char resul, n = 5; resul = 2 * n; Solution, la conversion explicite («casting») resul = (unsigned char)2 * n; Un autre exemple plus complexe : *(int *)(0x0074) = (int) codec_interrupt; Systèmes ordinés en temps réel 27 Valeurs logiques versus entiers Le langage C ne possède pas de type booléen, donc les opérations sont faites avec des variables entières (ou char). Pour utiliser efficacement les ressources, on regroupe souvent plusieurs booléens. Zéro = FAUX et non-zéro = VRAI Exemples : 7 RXC Bits Bits 10-5 Bits 4-0 Hours Minutes Seconds 2 6 TXC MS/DOS packed representation of time. 5 UDRE 4 FE 3 DOR 2 PE 1 U2X 0 MPCM Registre UCSRA du UART du ucontrôleur ATMega16 Réf. : Lewis, Chap. 3 Systèmes ordinés en temps réel 28 14

15 Deux types d opérateurs : Booléens et binaires Opérations Opérateur booléen Opérateur binaire AND && & OR XOR non-supporté ^ NOT! ~ Décalage à gauche non-supporté << Décalage à droite non-supporté >> Tester un bit if ((bits if (bits & & 64) (1 <<!= 0) 6)) /* /* Test Test du du bit bit 6 */ 6 */ & b 7 b 6 b 5 b 4 b 3 b 2 b 1 b b Réf. : Lewis, Chap. 3 Systèmes ordinés en temps réel 29 Assigner un bit Opérations sur les bits bits = bits (1 << 7) ; /* sets bit 7 */ b 7 b 6 b 5 b 4 b 3 b 2 b 1 b b 6 b 5 b 4 b 3 b 2 b 1 b 0 Remise à zéro d un bit bits &= ~(1 << 7) ; /* resets bit 7 */ Note : (1 << 7) ~(1 << 7) Réf. : Lewis, Chap. 3 Systèmes ordinés en temps réel 30 15

16 Opérations sur les bits Inverser un bit XOR bits ^= (1 << 6) ; /* inversion du bit 6 */ Attention à la taille par défaut des variables entières (int) selon le compilateur/processeur Si les int sont de 32 bits 0xFFFFFFFFL & ~(1 << 14) 0xFFFFFFFFL & ~(1L << 14) Si les int sont de 16 bits 0xFFFFFFFFL & ~(1 << 15) 0xFFFFFFFFL & ~(1L << 15) FFFFBFFF (ok) FFFFBFFF (ok) 00007FFF (error) FFFF7FFF (ok) Réf. : Lewis, Chap. 3 Systèmes ordinés en temps réel 31 Utilisation des structures pour manipuler les bits Exemple : Bits Bits 10-5 Bits 4-0 Hours Minutes Seconds 2 struct { unsigned seconds :5, minutes :6, hours :5 ; } time ; time.hours = 13 ; time.minutes = 34 ; time.seconds = 18 / 2 ; Réf. : Lewis, Chap. 3 Systèmes ordinés en temps réel 32 16

17 Exemple : Bits réservés mais inutilisés typedef struct { unsigned CF :1, /* Bit 0: Carry Flag */ :1, /* Bit 1: (unused) */ PF :1, /* Bit 2: Parity Flag */ :1, /* Bit 3: (unused) */ AF :1, /* Bit 4: Auxiliary Carry Flag */ :1, /* Bit 5: (unused) */ ZF :1, /* Bit 6: Zero Flag */ SF :1, /* Bit 7: Sign Flag */ TF :1, /* Bit 8: Trap Flag */ IF :1, /* Bit 9: Interrupt Enable Flag */ DF :1, /* Bit 10: Direction Flag */ OF :1, /* Bit 11: Overflow Flag */ :4 ; /* Bits 12-15: (unused) */ } PSW ; Réf. : Lewis, Chap. 3 Systèmes ordinés en temps réel 33 Accès selon différents types UNION Vous voulez accéder aux mêmes cases mémoires mais en utilisant des types différents. union { 31 0 unsigned long dd ; dd unsigned short dw[2] ; dw[1] dw[0] unsigned char db[4] ; db[3] db[2] db[1] db[0] } ; Occupe le même espace en mémoire Réf. : Lewis, Chap. 3 Systèmes ordinés en temps réel 34 17

18 Exemple : Structure et union de bits typedef union { struct { char TXB8 :1, /* Bit 8 : transmission */ RXB8 :1, /* Bit 8 : réception */ UCSZ2 :1, /* MSB de Taille de données */ TXEN :1, /* Activation du transmetteur */ RXEN :1, /* Activation du récepteur */ UDRIE :1, /* Registre de donnée vide */ TXCIE :1, /* Fin de transmission */ RXCIE :1, /* Fin de réception */ } Bits; unsigned char Byte; } USCRB ; Exemple d utilisation : UCSRB.Byte = (char) 0x00; UCSRB.Bits.TXEN = 1; UCSRB.Bits.RXEN = 1; Réf. : Lewis, Chap. 3 Systèmes ordinés en temps réel 35 Accès aux ports d entrées / sorties Accès de type «I/O Mapped» Utilisation d instructions spéciales (IN ou OUT) ou de fonctions C [inportb() ou outportb()]. Certains ports sont accessibles seulement en lecture ou en écriture. Plusieurs registres peuvent avoir la même adresse dans l espace des adresses E/S. Dans ce cas, la procédure d accès est importante (ordre d accès, lecture/écriture, bit de sélection, ). Exemple : // lire contenu du registre de données, port série COM3, 8250 carac_recu = inportb (0x03E8); Systèmes ordinés en temps réel 36 18

19 Compilateur Systèmes ordinés en temps réel 37 Techniques d optimisation utilisées par les compilateurs Utilisation d identités arithmétique Utilise les identités arithmétique pour éliminer des opérations inutiles tels que : z = x + 1*y z = x + y z = 3*x + 0 z = 3*x Réduction de force des opérations Choisit les instructions les plus performantes, tel que z = 8*x z = x << 3 Élimination de sous expressions communes Regroupe des sous expressions communes, tel que t = a*b x = y + a*b x = y + t y = a*b + z y = t + z Systèmes ordinés en temps réel 38 19

20 Techniques d optimisation utilisées par les compilateurs Utilisation de fonctions intrinsèque Remplace des appels de fonctions par des «macro» insérées directement à la place de l appel de fonction. Pliage de constantes Regroupe les constantes ensembles, tel que z = 7*x*2 z = 14*x Optimisation des parties invariantes des boucles Extrait les parties des boucles qui ne changent pas, tel que x = 100; while (x > 0) { x = x y + z; } x = 100; t = y + z; while (x > 0) { x = x + t; } Systèmes ordinés en temps réel 39 Techniques d optimisation utilisées par les compilateurs Élimination des inductions dans les boucles Élimination des calculs de «décalage» inutiles, tel que for (i = 0; i < 10; i++) a[i+2] = 1; for (i = 2; i < 12; i++) a[i] = 1; Utilisation de registres et de mémoire cache Place les variables fréquemment utilisées dans des registres du processeur ou dans la mémoire cache. Élimination de code «mort» ou inatteignable Élimine le code qui ne sera jamais exécuté, tel que debug = 0; if (debug) x = x + t; Systèmes ordinés en temps réel 40 20

21 Techniques d optimisation utilisées par les compilateurs Propagation de constantes Certaines assignations à des variables peuvent être remplacées par des constantes, tel que x = 100; y = x; x = 100; y = 100; Élimination de stockage «mort» ou inutile Certaines variables utilisées pour du stockage temporaire peuvent être éliminées, tel que t = y + z; x = sin(y+z); x = sin(t); Élimination de variables «mortes» Élimine les variables qui semblent inutiles, tel que x = y + z; x = y; x = y; Systèmes ordinés en temps réel 41 Techniques d optimisation utilisées par les compilateurs Équations logiques court-circuitées Transforme une équation logique compliquée en une série de sous-expressions qui seront évalué une à la fois, tel que if (x > 0) && (y > 0) z = 1; Déroulement de boucle Déroule les boucles courtes, tel que for (i = 0; i < 3; i++) a[i] = 7*b[i+2]; if (x > 0) if (y > 0) z = 1; a[0] = 7*b[2]; a[1] = 7*b[3]; a[2] = 7*b[4]; Systèmes ordinés en temps réel 42 21

22 Optimisation du code Systèmes ordinés en temps réel 43 Trucs et conseils pour optimiser le code C Limites et mise en garde Les langages de haut niveau offrent plus ou moins de contrôle sur les instructions générées; Les options du compilateur (en particulier, le niveau d optimisation) ont un impact prépondérant sur la performance; Rien ne peut remplacer la sélection d algorithmes performants. Systèmes ordinés en temps réel 44 22

23 Truc 1 Réduire l utilisation de la pile Réduire les paramètres et les variables locales. Réduire le nombre de fonctions. Compromis entre performance et clarté du code. Simuler les fonctions Il est possible de «simuler ou mimer» les fonctions avec les directives de pré-compilation. Ex. : #define poly2( a, b, c, x) \ ( (a)*(x)*(x)+ (b)*(x)+(c) ) Systèmes ordinés en temps réel 45 Truc 2 - Pas d allocation dynamique Ne pas utiliser l allocation de mémoire dynamique. L allocation de mémoire fait appel au système d exploitation pour obtenir une portion de la mémoire disponible; C est un processus lent. Solution : Allocation statique, ou; Allocation dynamique SEULEMENT durant l initialisation. Systèmes ordinés en temps réel 46 23

24 Truc 3 Variables de type register Déclarer les variables très utilisées (ex. : les compteurs) comme registres. Mode d'allocation register. Il n est pas sous garantie que le processeur utilisera un registre, mais c est souvent le cas. Systèmes ordinés en temps réel 47 Truc 4 Rendre les conversions explicites Le langage C se convertit toujours au type qui exige le plus de ressources avant de faire des opérations. Exemple : double multiplicateur = 2.0; int x, n; x = ((int) multiplicateur) * n; Comme x et n sont de type int, on évite que l'opération soit effectuée en double. Systèmes ordinés en temps réel 48 24

25 Truc 5 Réduire la complexité mathématique L'objectif est d'utiliser des instructions plus simples pour faire les mêmes calculs (pyramide des instructions). Plus rapide Logiques Bit shift Branchements ADD CMP SUB Multiplication Division Racine carrée Exemple : * 2 n Remplacer par un décalage à gauche de n bits; Division par x * 1/x si x ne change pas ou si votre CPU offre une instruction INVERSION plus performante. Systèmes ordinés en temps réel 49 Truc 6 Éliminer les appels au OS ou au BIOS Les appels au système d'exploitation (ou au BIOS) peuvent être plus lents parce que : Le système effectue des opérations / vérifications afin de protéger le système. Validation des arguments; Vérification des erreurs. Implique généralement une interruption logicielle; Lors des appels au système, celui-ci en profite souvent pour faire des mises à jour internes ("housekeeping") Exemple : mise à jour de l'horloge. Deux problèmes : Solution est beaucoup moins portable; Votre code doit être optimisé plus vite que celui du OS. Systèmes ordinés en temps réel 50 25

26 Truc 7 Ordre dans l'accès au tableau En langage C, les éléments des tableaux sont emmagasinés "par colonnes«. table[5][3] Dans une boucle, optimiser l'accès en "bouclant" d'abord sur le dernier index. Exemple : int somme = 0; for (i=0; i<5;i++) for (j=0;j<3;j++) somme += table[i][j]; Systèmes ordinés en temps réel 51 Truc 8 Réduire et simplifier les équations On a avantage à éliminer la répétition de calculs Factorisation xp[i] = cos(theta) * x[i] + sin(theta) * y [i]; yp[i] = - sin(theta) * x[i] + cos(theta) * y [i]; c_theta = cos(theta); s_theta = sin(theta); xp[i] = c_theta* x [i] + s_theta * y [i]; Éliminer les opérations inutiles *0, *1, +0, -0 a = b x = sqrt ( a 2 b 2 ) Systèmes ordinés en temps réel 52 26

27 Truc 9 Pré-calcul des constantes Exemple : w = 2 * PI * frequence; #define 2PI w = 2PI *frequence; Systèmes ordinés en temps réel 53 Truc 10 Simplifier les boucles Éliminer les expressions constantes ou communes dans les boucles. Exemple : for (i=0; i < 100 ; i++) x[i] = x [i] + 2*w*t; devient z = 2*w * t; for (i=0; i < 100 ; i++) x[i] = x [i] + z; // on sauve 198 multiplications Systèmes ordinés en temps réel 54 27

28 Truc 11 Dérouler les petites boucles Dans les petites boucles, on accepte d'augmenter la taille du programme pour éliminer les tests. for (i=1; i < 4 ; i++) x[i] = x [i] + 1; devient x[1] = x [1] + 1; x[2] = x [2] + 1; x[3] = x [3] + 1; On sauve 9 instructions car le "for" est en fait INC TEST (..) JMP Systèmes ordinés en temps réel 55 Truc 12 Combiner les boucles Il faut regrouper les boucles : for (i=0; i < 100 ; i++) x[i] = y [i] * 8; for (i=0; i < 100 ; i++) z[i] = x [i] * y[i]; devient for (i=0; i < 100 ; i++) { x[i] = y [i] * 8; z[i] = x [i] * y[i]; } On sauve 300 instructions car le "for" est en fait INC TEST (..) JMP Systèmes ordinés en temps réel 56 28

29 Truc 13 Choisir un type de variable plus simple Lorsqu'on utilise que "certaines propriétés" d'un type on peut essayer de prendre un type plus simple. Exemple : Simuler les variables réelles (float) par une variable entière multipliée par la précision voulue Si la précision sur un calcul est limitée (ex.: par le capteur), alors nous pouvons utiliser des entiers. Float int Plus rapide de faire les calculs avec des opérations entières Systèmes ordinés en temps réel 57 Truc 14 Table de correspondance Si vous utilisez souvent une fonction mathématique complexe, il peut être avantageux d'échantillonner la fonction et de calculer ses valeurs par interpolation. Exemple : sin (x) = x x 3 /3! + x 5 /5! x 7 /7! + x 9 /9! - x sin(x) 0 Note : Possible de perdre de la précision sur la valeur obtenue. Taille du tableau augmente rapidement avec le nombre de variables. Systèmes ordinés en temps réel 58 29

30 (Truc 15) Écrire le code en assembleur En principe, il est possible d'écrire le code en assembleur afin d'obtenir la meilleure performance possible. En pratique, Difficile (coûteux) de produire du code assembleur; Difficile (coûteux) de produire du code "plus optimisé" que les compilateurs; Difficile à maintenir et non portable. En pratique, on optimise que des petites portions très critiques du code. Pas en examen Systèmes ordinés en temps réel 59 Mesure de performance Systèmes ordinés en temps réel 60 30

31 3.9 Mesure de la performance Objectif : Améliorer l exécution des portions critiques de notre code en langage C. Mesure : Chronométrage des fonctions Nous allons voir 3 façons d estimer le temps d exécution d une section de code : Mesure directe Boucle sur plusieurs itérations; Chronométrage de haute précision. Décompte d instructions Décompte des entrées / sorties Trucs possibles Systèmes ordinés en temps réel Mesure directe de la performance Mesure du temps d exécution dans une boucle mesure_du_temps_avant; // ex: gettime() ou clock() for (i=0, i < Nb_itération ; i++) ma_fonction ( ); mesure_du_temps_après; Avantages : Pas besoin d une mesure très précise de l horloge; Moyenne sur les plusieurs exécutions. Inconvénients : Attention à l impact du compilateur (i.e. optimisation); Vérifier la linéarité pour Nb_itération assez grand. Systèmes ordinés en temps réel 62 31

32 3.9 Mesure du temps Horloge vs minuterie Deux concepts interreliés Horloge («Clock») Fournie un mesure du temps Définition : 1 seconde = 1/ de la journée solaire moyenne; 1 seconde = 1/ année 1900 au tropique; 1 seconde = vibration Cesium 133. Mesure du temps intervalle entre deux évènements. Minuterie («Timer») Génère un événement après un intervalle de temps spécifié. Systèmes ordinés en temps réel ANSI C Fonction date & time time_t time( time_t *timer ); // timer.h Get current system time as type time_t Résultat : struct tm { int tm_sec; /* seconds after the minute - [0,59] */ int tm_min; /* minutes after the hour - [0,59] */ int tm_hour; /* hours since midnight - [0,23] */ int tm_mday; /* day of the month - [1,31] */ int tm_mon; /* months since January - [0,11] */ int tm_year; /* years since 1900 */ int tm_wday; /* days since Sunday - [0,6] */ int tm_yday; /* days since January 1 - [0,365] */ int tm_isdst; /* daylight savings time flag */ }; Résolution : ± 1 seconde Systèmes ordinés en temps réel 64 32

33 3.9 ANSI C Fonction clock clock_t clock( void ); Retourne le nombre de ticks de l horloge Notes : typedef long clock_t; Temps en secondes = clock_t/clocks_per_sec; Sous Windows2000, CLOCKS_PER_SEC = 1 000; Sous DOS (TurboC), CLOCKS_PER_SEC = Résolution : ± 1 milliseconde Systèmes ordinés en temps réel Test Clock on Windows2000 Programme de test : start = clock(); Sleep (1); // sleep time in milliseconds finish = clock(); duration = (double)(finish - start) / CLOCKS_PER_SEC; Résultat : (finish - start) = 15 et duration = s Avec Sleep(0) ou sans Sleep(); (finish - start) = 0 et duration = 0 Systèmes ordinés en temps réel 66 33

34 3.9 Mesure du temps INTEL Mesure du temps d exécution avec instruction RDTSC : read time-stamp counter Registre de 64 bit incrémenté à chaque cycle du CPU RDTSC 32 bits dans EDX et 32 bits dans EAX Avantages : Permet une mesure de sections très petites. Inconvénients : Disponible seulement sur les processeurs Pentiums; Besoin de «sérialiser» l exécution; Pentium support l exécution hors ordre (out-of-order); Les instructions en assembleur ne sont pas nécessairement exécutées dans l ordre où elles apparaissent dans le code; Attention à l impact du compilateur (ex. : optimisation); Vérifier la linéarité. Chrono.pdf Ref: Systèmes ordinés en temps réel Mesure directe de la performance INTEL Exemple : (Mode DEBUG Pas d optimisation) float z,q,x,y,result; result=0.0f; x=2.0f; y=100.0f; z=12.0f; q=5.0f; // CODE DANS LA BOUCLE de mesure du temps d'execution z += y; q *= x; result = z/q; Moyenne (5 itérations) Average cycles per loop : Average cycles per loop : Average seconds per loop: (incluant la mesure) (excluant la mesure) secondes Moyenne (5 000 itérations) Average cycles per loop : (incluant la mesure) Average cycles per loop : (excluant la mesure) Average seconds per loop: secondes Pourquoi? Systèmes ordinés en temps réel 68 34

35 3.9 Mesure directe de la performance INTEL Exemple : (Mode DEBUG Pas d optimisation) float z,q,x,y,result; result=0.0f; x=2.0f; y=100.0f; z=12.0f; q=5.0f; // CODE DANS LA BOUCLE de mesure du temps d'execution x=2.0f; y=100.0f; z=12.0f; q=5.0f; z += y; q *= x; result = z/q; Temps d éxécution dépend des données Moyenne (5 itérations) Average cycles per loop : Average cycles per loop : Average seconds per loop: (incluant la mesure) (excluant la mesure) secondes Moyenne (5 000 itérations) Average cycles per loop : (incluant la mesure) Average cycles per loop : (excluant la mesure) Average seconds per loop: secondes Optimisation sur plusieurs itérations? Systèmes ordinés en temps réel Mesure directe de la performance INTEL Exemple : (Mode RELEASE optimisation temps d exécution) float z,q,x,y,result; result=0.0f; x=2.0f; y=100.0f; z=12.0f; q=5.0f; // CODE DANS LA BOUCLE de mesure du temps d'execution x=2.0f; y=100.0f; z=12.0f; q=5.0f; z += y; q *= x; result = z/q; Moyenne (5 itérations) Average cycles per loop : Average cycles per loop : Average seconds per loop: (incluant la mesure) (excluant la mesure) secondes Moyenne (5 000 itérations) Average cycles per loop : (incluant la mesure) Average cycles per loop : (excluant la mesure) Average seconds per loop: secondes Compilation AVR Systèmes ordinés en temps réel 70 35

36 3.9 Décompte des instructions Analyse du code assembleur Évaluation du temps d exécution de chaque instruction. Difficultés et limites Pas facile / impossible d estimer le temps d exécution d une séquence d instructions sur les architectures complexes; Souvent le temps d exécution varie; Travail laborieux. Exemple : Entrée / sortie par interrogation BYTE8 Serial_Input(void) { /* Attendre l arrivée d une nouvelle donnée */ while ((inportb(status_port) & READY) == 0) {} return inportb(data_port) ; } void Serial_Output(BYTE8 ch) { /* Attendre que le périphérique soit prêt */ while ((inportb(status_port) & READY) == 0){} outportb(data_port, ch) ; } Réf. : Lewis, Chap. 6 Systèmes ordinés en temps réel Décompte des instructions _Serial_Input: MOV DX,02FDh ; DX Status Port Address SI1: IN AL,DX ; Read Input Status Port TEST AL, B ; Check the Ready Bit JZ SI1 ; Continue to wait if not ready MOV DX,02F8h ; Else load DX with Data Port Address XOR EAX,EAX ; Pre-clear most significant bits of EAX IN AL,DX ; Read Data Port RET ; return to caller with data in EAX Réf: Lewis Chap 6. Systèmes ordinés en temps réel 72 36

37 3.9 Décompte des entrées / sorties Modèle approximatif basé sur l observation que la performance est souvent limitée par le temps nécessaire aux accès mémoire. On doit inclure : La lecture des instruction; Les accès aux registres des périphériques. On néglige : Les facteurs d accélération dus à la mémoire cache, à la présence d un pipeline et de plusieurs ALU; L estimation est donc pessimiste. ET TRÈS IMPRÉCISE Réf: Lewis Chap 6. Systèmes ordinés en temps réel Décompte des entrées / sorties ; Opcode Immediate Stack I/O _Serial_Input: ; Bytes Bytes Bytes Transfers MOV DX,02FDh ; 1 2 SI1: IN AL,DX ; 1 1 TEST AL, B ; 1 1 JZ SI1 ; 1 1 MOV DX,02F8h ; 1 2 XOR EAX,EAX ; 1 IN AL,DX ; 1 1 RET ; octets pour les instructions, 4 octets pour la pile, 2 octets pour les entrées / sorties Réf. : Lewis, Chap. 6 Systèmes ordinés en temps réel 74 37

38 3.9 Décompte des entrées / sorties Exemple : Architecture considérée ( c.f. lewis) Accès en mémoire 60 ns; Bus PCI 33 MHz 30 ns par accès. En général, les transferts demandent plusieurs cycles d accès. Décompte: (14 octets / (4 octets par cycle)) * 60 ns = 240 ns (instructions) (4 octets / (4 octets par cycle)) * 60 ns = 60 ns (pile) 2 octets * 30 ns = 60 ns (Entrée / sortie) Total = 360 ns Taux de transfert maximum = 1/360 ns = 2.78 Moctets/s Réf. : Lewis, Chap. 6 Systèmes ordinés en temps réel Décompte des entrées / sorties Autre exemple : Entrées / sorties par interruption Temps de réponse : R = L + C + L + A + C IRQV L i = temps de la plus longue instruction PUSHA sauvegarde des registres 1 cycle d accès mémoire pour l instruction 8 cycles d accès mémoire pour écrire les 8 registres 9 * 60 ns = 540 ns L IRQV = temps de traitement de l interruption (niveau matériel) 12 octets sur la pile (3 cycles) 180 ns 1 octet E/S (lecture du vecteur) 30 ns 16 octets pour chargement PC (4 cycles) 240 ns Total = 450 ns i s i r Réf. : Lewis, Chap. 6 Systèmes ordinés en temps réel 76 38

39 3.9 Interruptions Intel x86 (mode protégé) Réponse aux interruptions Action 1. Push EFlags register. 2. Disable interrupts. Detailed description ESP ESP - 4; MEM 32 [ESP] EFlags IF Flag 0 (Also clears TF Flag) Bytes Transferred 4 (stack write) 3. Push CS ESP ESP - 4; MEM 32 [ESP] CS 4 (stack write) 3. Push EIP ESP ESP - 4; MEM 32 [ESP] EIP 4 (stack write) n/a 4. Identify interrupt. 5. Load CS and EIP Read interrupt type code from data bus. CS visible,eip IDT 64 [8 int. type code] CS hidden GDT 64 [CS visible ] 1 (I/O read) 8 (IDT read) + 8 (GDT read) Réf. : Lewis, Chap. 6 Systèmes ordinés en temps réel Décompte des entrées / sorties Instr. Data Stack I/O _Serial_Input_ISR: Bytes Bytes Bytes Transfers STI ; Enable high prior. Ints. 1 PUSH EAX ; Preserve contents 1 4 PUSH EDX ; of EAX and EDX. 1 4 MOV DX,02FDh ; Retrieve the data and 3 IN AL,DX ; clear the request. 1 1 MOV [_serial_data],al ; Save the data away. 5 1 MOV AL, b ; Send EOI command to 2 OUT 20h,AL ; Prog. Interrupt Ctlr. 2 1 POP EDX ; Restore orig. contents 1 4 POP EAX ; of the registers. 1 4 IRET ; Restore EIP and EFlags octets pour les instructions, 1 octet pour la donnée 28 octets pour la pile, 2 octets pour les entrées / sorties Réf. : Lewis, Chap. 6 Systèmes ordinés en temps réel 78 39

40 3.9 Décompte des entrées / sorties Décompte : (19 octets / (4 octets par cycle)) * 60 ns = 300 ns (instructions) (28 octets / (4 octets par cycle)) * 60 ns = 420 ns (pile) ( 1 octet / (4 octets par cycle)) * 60 ns = 60 ns (donnée) 2 octets * 30 ns = 60 ns (Entrées / sorties) Total = 840 ns Taux de transfert maximum = 1/1.95 µs = Moctets/s Finir l instruction Réponse matérielle Temps d exécution PUSHA: 0.54 µs 0.45 µs 0.84 µs Total = 1.95 µs Réf: Lewis Chap 6. Systèmes ordinés en temps réel 79 40