Systmes Programmations Temps Relle Master MSRS kafdelymail com

Systèmes & Programmations Temps Réelle Master MSRS kafdel@ymail. com 1

Programmations temps Réelle Problématique des RTOS Quelqu'un pose des questions concernant la température extérieure actuelle. Laquelle est la meilleure réponse ? • Une réponse correcte de 20 ° C mais livré 12 heures plus tard; • ou Une lecture erronée de 10 ° C livré immédiatement; Dans un système temps réel, une réponse tardive est tout aussi mauvais qu'une réponse fausse Objectifs Dans ce cours, nous allons introduire des méthodes et des modèles pour contrôler le comportement temporel des programmes, en outre leur fonctionnalité 2

Définition • Les systèmes informatiques temps réel se différencient des autres systèmes informatiques par la prise en compte de contraintes temporelles dont le respect est aussi important que l'exactitude du résultat système TR ne doit pas simplement délivrer des résultats exacts, il doit les délivrer dans des délais imposés. 3

4

Domaine d'utilisation • Les systèmes informatiques temps réel sont aujourd'hui présents dans de nombreux secteurs d'activités • Industrie de production par exemple, au travers des systèmes de contrôle de procédé (usines, centrales nucléaires), • Marché Boursier au travers du traitement des données boursières en « temps réel » • Aéronautique au travers des systèmes de pilotage embarqués (avions, satellites), • Médecine -- Robots 5

RTOS • Le développement de systèmes temps réel nécessite donc que chacun des éléments du système soit lui-même temps réel (prendre en compte des contraintes temporelles) • système d'exploitation conçu pour prendre en compte ces contraintes est appelé système d'exploitation temps réel « RTOS » 6

Exemple : Impact du temps réel sur les systèmes Le but de l'expérience est de générer un signal périodique sortant du port parallèle du PC. • Le temps qui sépare deux émissions du signal sera mesuré à l'aide d'un compteur. • Le but est de visualiser l'évolution de ce délai en fonction de la charge du système. • La fréquence initiale du signal est de 25 Hz (Hertz) ce qui donne une demi-période T/2 de 20 ms. 7

Sur un système classique, cette demi-période varie de 17 à 23 ms, ce qui donne une variation de fréquence entre 22 Hz et 29 Hz. La figure cidessous donne la représentation graphique de la mesure sur un système non chargé puis à pleine charge 8

Sur un système temps réel, la demi-période varie entre 19, 990 ms et 20, 015 ms, ce qui donne une variation de fréquence de 24, 98 Hz à 25, 01 Hz. La variation est donc beaucoup plus faible. La figure donne la représentation graphique de la mesure Lorsque la charge est maximale, le système temps réel assure donc une variation de +/- 0, 2 Hz alors que la variation est de +/- 4 Hz dans le cas d'un système classique. 9

CPU sans Charge On remarque l'on n'a pas une période de 100 ms mais de 119, 6 ms dû au temps supplémentaire d'exécution des appels système. 10 CPU avec Charge On stresse le système (écriture répétitive sur disque d'un fichier de 50 Mo), on observe Effet de Jitter(gigue). La gigue maximale sur la durée de l'expérience est de 17, 6 ms. La forme du signal varie maintenant au cours du temps, n'est pas de forme carrée mais rectangulaire. LINUX n'est donc plus capable de générer

Rappel OS 11

• Système d'exploitation se présente donc comme une couche logicielle placée entre la machine matérielle et les applications • OS s'interface avec la couche matérielle, notamment par le biais du mécanisme des interruptions • OS peut être découpé en plusieurs grandes fonctions 12

• Gestion du processeur – algorithme d'ordonnancement qui planifie l'exécution des programmes. • Gestion de la mémoire – Allocation de mémoire • Gestion des entrées/sorties • Gestion de la concurrence – synchroniser l'accès aux données partagées afin de maintenir leur cohérence • Gestion des objets externes – Système de gestion de fichiers (SGF) • Gestion de la protection 13

RTOS 14

RTOS 1 - Task management and scheduling – Gestionnaire des Taches est la tâche principale du système d'exploitation • les tâches doivent être créés et supprimés alors que le système est en cours d'exécution; • les tâches peuvent modifier leurs niveaux de priorité, leurs contraintes de temps, leurs besoins en mémoire; etc 15

RTOS Gestion des tâche est plus dangereuse que pour un usage général OS Exemple : Si une tâche temps réel est créée, il doit obtenir la mémoire dont il a besoin sans délai, et que la mémoire doit être verrouillée pour éviter: 1. les temps d'accès en raison de permutation, 2. l'évolution des priorités d'exécution influe sur le comportement à l'exécution de l'ensemble du système la prévisibilité qui est très important pour RTOS 16

2 - Services des Interruptions • Un système d'exploitation ne doit pas seulement être en mesure de planifier des tâches selon un algorithme déterministe, mais elle a aussi la tache de servir le matériel périphérique via interruption 17

3 - Communication & synchronisation • IPC (Inter-Process Communication )recueille un grand nombre de primitives de programmation que l’OS met à la disposition des tâches qui ont besoin d'échanger des informations avec d'autres tâches, ou de synchroniser leurs actions; • RTOS doit s'assurer que cette communication et la synchronisation se déroulent de manière déterministe; • Cette communication peut être effectuer avec d'autres ordinateurs, ou avec le matériel périphérique. 18

4 - Gestion mémoire • Donner à chacun la tâche de la mémoire dont il a besoin (allocation de mémoire) • Prendre les « mesures appropriées » lorsqu'une tâche utilise la mémoire qu’elle ne lui a pas été attribué. – Exemple : pointeurs non connecté et d'indexation de tableau au-delà des limites du tableau "mesures appropriées « : dépend de l'application, souvent cela se résume à la solution la plus simple: tuer la tâche et avertir l'utilisateur 19

Trade-offs (compromis) Espace noyau vis-à-vis espace utilisateur noyau monolithique 20 micro-noyau

• Un noyau monolithique possède tous les services de l'OS (y compris les pilotes de périphérique, piles de réseau, les systèmes de fichiers, etc) en cours d'exécution en mode privilégié du processeur. • Un micro-noyau, d'autre part, utilise le mode privilégié uniquement pour les services vraiment de base (gestion des tâches et ordonnancement, communication inter-processus, la gestion des interruptions, et de la mémoire gestion), et possède la plupart des pilotes de périphériques et de services de l'OS en tant que des tâches «normales» 21

Noyau préemptif ou non • Linux a été initialement un noyau non-préemptif – une tâche "espace noyau" ne peut pas être interrompu par d'autres tâches de ne peut pas être interrompu "l'espace noyau", ou par des tâches de « l'espace utilisateur » • Le noyau est "verrouillé " tant qu’il est en exécution. • Utilisation de serrures permet la conception de la plus simple du noyau Inconvénient : il introduit des latences déterministes qui ne sont pas tolérables dans latences déterministes un RTOS. 22

Contrainte de temps • " Un système d'exploitation temps réel est capable d'exécuter toutes ses tâches sans violer les contraintes de temps spécifié « spécifié • « Temps au cours de laquelle les tâches exécutera peut être prédit de façon déterministe sur la base des connaissances sur le coté matériel et logiciel du système « système • On distingue le temps réel strict ou strict dur (de l'anglais hard real-time) et le dur temps réel souple ou souple mou (soft real-time) suivant l'importance accordée aux mou contraintes temporelles. • Le temps réel strict ne tolère aucun dépassement de ces contraintes, – tels dépassements peuvent conduire à des situations critiques, voire catastrophiques : • Exemple : pilote automatique d'avion, système de surveillance de centrale nucléaire, etc. • 23 À l'inverse le temps réel souple s'accommode de dépassements des contraintes temporelles dans certaines limites au-delà desquelles le système devient inutilisable : visioconférence, jeux en réseau, etc.

Le temps de latence • Le temps de latence (ou retard) d'une tâche = différence entre l'instant de temps sur laquelle la tâche doit commencer (ou terminer) et l'instant à laquelle il est effectivement en exécution – le temps écoulé entre la génération d'un événement, et sa perception r : date de réveil c'est le moment du déclenchement de la 1 ere requête d'exécution C : durée d'exécution maximale (capacité) D : délai critique c'est le délai maximum acceptable pour son exécution P : période si la tâche est périodique 24

Le temps de latence est du à plusieurs facteurs: (i) les propriétés de synchronisation du processeur, bus, la mémoire (mémoire cache, RAM hors puce et ROM) et périphérique dispositifs; (ii) les propriétés de la programmation du système d'exploitation; (iii) le caractère préemptif ou non du noyau; (iv) la charge sur le système ( le nombre de tâches qui veulent être programmées en même temps); (v) le temps du au changement de contexte. Ce dernier est le temps nécessaire que le processeur a besoin pour sauvegarder les données de la tâche en cours d'exécution (par exemple, les registres, la pile et pointeur d'instruction), et de le remplacer par les données locales de la tâche nouvellement prévue. Conséquence: – Ces facteurs ne sont pas constants au fil du temps et introduisent l'indéterminisme dans le comportement temporel du système 25

Ordonnancement temps-réel Problème – Calculs à exécuter + contraintes de temps = dans quel ordre exécuter? Définition Ensemble des règles définissant l’ordre d’exécution des calculs sur le processeur Pourquoi ordonnancer? ordonnancer Parce que ça a un impact sur le respect des contraintes de temps Exemple • Tâche T 1 : arrivée en r=0, durée C=4, échéance D=7 • Tâche T 2 : arrivée en r=2, durée C=2, échéance D=5 • Ordonnancement O 1: O 1 premier arrivé, premier servi, on n’interrompt jamais une tâche • Ordonnancement O 2: O 2 priorité, T 2 plus prioritaire que T 1 26

C’est quoi une Thread ? • Une thread peut être vue comme étant la plus petite unité d'exécution. • Chaque thread a : • sa pile, • son pointeur de programme • ses registres. • Processus définit le contexte dans lequel les threads s'exécuteront. ü Le contexte contient üles threads, ü le code exécutable, les données, üles descripteurs de fichiers, üles outils de synchronisation, etc. Processus = conteneur de threads(processus est décomposé en tâches ). • tâche est une sorte de processus léger plus ou moins indépendamment des autres 27

28

Classification des ordonnancements • Instant ou l’ordre d’exécution est décidé : hors -ligne /en-ligne • Possibilité d’interruption d’une tâche par une autre: préemptif / non préemptif • Optimalité : quel est le « meilleur » ordonnancement 29

Buts de l'ordonnancement Piloter l'application avec 2 objectifs majeurs : ➢ en fonctionnement nominal : respect des contraintes temporelles ➢ en fonctionnement anormal (par exemple pannes matérielles) : atténuer les effets des surcharges et maintenir un état cohérent et sécuritaire ordonnancer = planifier l'exécution des requêtes de façon à respecter les contraintes de temps ➢ de toutes les requêtes en fonctionnement nominal ➢ d'au moins les requêtes les plus importantes (c'est-a-dire celles nécessaires a la sécurité du procède) en fonctionnement anormal (RT dure) 30

Ordonnancement « hors-ligne » / « enligne" Ordonnancements "en-ligne " – Les décisions d’ordonnancement sont prise au cours de l’exécution – A l’exécution, l’ordonnanceur implante un algorithme d’ordonnancement permettant de savoir à tout instant quel tâche exécuter : besoin d’un exécutif multitâche – Généralement, ordonnancements conduits par la priorité 31

Ordonnancement non préemptif / préeemptif • Non préemptif: On n’interrompt jamais l’exécution d’une tâche en cours au profit d’une autre tâche • Préemptif: La tâche en cours peut perdre involontairement le processeur au profit d’une autre tâche (jugée plus urgente) Remarques : orthogonal par rapport à la classification en-ligne / hors-ligne 32

Exemple d’ordonnancement préemptif : conduit par la priorité • Algorithme d’ordonnancement : sélectionner la tâche la plus prioritaire • priorité(T 3) > priorité(T 2) > priorité(T 1) (ici, priorités fixes(T 1, T 2 et T 3 arrivent respectivement aux dates 1, 2, et 3 33

Caractéristiques des tâches • • • r : date de réveil c'est le moment du déclenchement de la 1 ere requête d'exécution C : durée d'exécution maximale (capacité) D : délai critique c'est le délai maximum acceptable pour son exécution P : période si la tâche est périodique d = r+D : échéance (si tâche a contraintes strictes) Pour les tâches périodiques : rk = r 0 + k*P – 34 Si D = P, tâche est une tâche à échéance sur requête

paramètres statiques ➢ Ui = Ci/Pi : facteur d'utilisation du processeur c-à-d pourcentage de l’activité du processeur dédiée à la tâche Ti ➢ CH = C/D : facteur de charge du processeur paramètres dynamiques ➢ s : date du début de l'exécution ➢ e : date de la fin de l'exécution ➢ D(t) = d-t : délai critique résiduel a la date t (0 ≤ D(t) ≤ D) ➢ C(t) : durée d'exécution résiduelle a la date t (0 ≤ C(t) ≤ C) ➢ L = D-C : laxité nominale de la tâche • ✔ Retard maximum pour son début d'exécution s (si elle est seule) • ➢ L(t) = D(t) - C(t) : laxité nominale résiduelle • ✔ Retard maximum pour reprendre l'exécution • ➢ TR = e - r : temps de réponse de la tâche • ➢ CH(t) = C(t)/D(t) : charge résiduelle (0 ≤ CH(t) ≤ C/P) 35

Etat d'une tâche Les diverses états d’une tâche: – Prêtes (ready) : la tâche n'a pas encore commencé à s'exécuter ou à être interrompue par préemption – en cours d'exécution (running) : la tâche est en cours d'exécution et utilise le processeur – bloquées (blocked) : de manière générale, la tâche est en attente de la ressource – endormie (sleeping) : la tâche n'est pas encore terminée et est en attente d'un réveil. 36

Définition configuration : ensemble de n taches mises en jeu par l'application ➢ Facteur d'utilisation du processeur ➢ Facteur de charge Pour tout système de n tâches, la condition suivante est nécessaire mais pas suffisante à sa faisabilité : U<1 Avec Ci le temps de calcul de la tâche n° i et Pi sa période. Une valeur supérieure à 1 signifierait que le système nécessite plus de temps d'exécution que le processeur ne peut en fournir. Intervalle d'etude : intervalle de temps minimum pour prouver l'ordonnançabilite Intervalle d'etude d'une configuration ➢ Le PPCM des périodes dans le cas d'une configuration de tâches périodiques laxité du processeur LP(t) = intervalle de temps pendant lequel le processeur peut laxité du processeur LP(t) rester inactif tout en respectant les échéances • ✔ laxité conditionnelle: (somme sur les taches déclenchées a la date t et qui sont devant i du point de vue de l'ordonnancement) • ✔ LP(t) = min(LCi(t)) 37

Ordonnancement des tâches independents tâches périodiques 1. A priorités statiques • Rate monotonic : fondé sur les périodes • Deadline monotonic : fondé sur les délais critiques 2 A priorités dynamiques • Earliest deadline : fondé sur les échéances • Least laxity : fondé sur la marge de manœuvre restante 38

Rate Monotonic Analysis (RMA) • • • Algorithme a priorité constante Condition d’ordonnançabilité (pour Pi = Di) se base sur la période (taches à échéance sur requête) : la tâche de plus petite période est la plus prioritaire • test d'acceptabilités (condition suffisante) : théoriquement, le concepteur d'un système temps réel prétendu strict devrait être capable de prouver que les limites temporelles ne seront jamais dépassées quelle que soit la situation. Cette vérification est appelée "test d'acceptabilité", "analyse de faisabilité" ou encore "contrôle d'admission. – Elle dépend de l'ordonnanceur utilisé et des caractéristiques des tâches du système. quand n est très grand : n (21/n – 1) ~ ln 2 = 0, 69 39

Exemple : T 1 (r 0=0, C=3, P=20), T 2 (r 0=0, C=2, P=5), T 3 (r 0=0, C=2, P=10) ΣCi/Pi = 3/20+2/5+2/10 = 0, 75 n(21/n− 1) =3(21/2− 1)= 0, 77 Le test d'acceptabilités est validé Priorité 2 > Priorité 3 > Priorité 1 (le classement s'effectue sur la période la plus petite) 40

Deadline Monotonic Analysis (DMA) • • Algorithme a priorité constante base sur le délai critique D: ➢ La tâche de plus petit délai critique est la plus prioritaire test d'acceptabilités (condition suffisante) • Équivalent à RMA dans le cas des taches à échéance sur requête, meilleur dans les autres cas 41

Exemple: T 1(r 0 = 0, C=3, D=7, P=20), T 2 (r 0 = 0, C=2, D=4, P=5), T 3 (r 0 = 0, C=2, D=9, P=10) ΣCi/Pi= 3/7+ 2/4+ 2/9 = 1, 14 ≥ n(21/n− 1) = 0, 77 Priorité 2 > Priorité 1 > Priorité 3 (le classement s'effectue sur le plus petit délai critique D) 42

Tâches apériodiques : elles correspondent aux événements; elles se réveillent de manière aléatoire. – Apériodiques strictes : contraintes temporelles dures à respecter absolument. – Apériodiques relatives : contraintes temporelles molles qui peuvent être ou non respectées de temps à autre (sans échéance). 43

Model Tâche apériodique Stricte r: date aléatoire de réveil de la tâche C: durée d ’exécution maximale D : délai critique dk : échéance = rk + R R(t): délai critique dynamique (temps restant à t jusqu’à d) Tap( r, C, R) Tap (t, C(t), R(t)) Diagramme temporel d ’exécution Modèle canonique d'une tâche apériodique temps réel Tap (t, C(t), Dt)) C(t): temps d’exécution restant à t 44

Traitement d'arrière-plan • taches apériodiques ordonnancées quand le processeur est oisif • ➢ les tâches périodiques restent les plus prioritaires • ordonnancement relatif des taches apériodiques en mode FIFO • traitement le plus simple, mais le moins performant 45

• • 46 exemple Tp 1 (r 0=0, C=2, P=5), Tp 2 (r 0=0, C=2, P=10) Ta 3 (r=3, C=2), Ta 4 (r=10, C=1), Ta 5 (r=11, C=2) ➢ ordonnancement RMA des taches periodiques

Serveur des Tâches apériodique • Serveur de scrutation : • A chacun de ses réveils, le serveur sert les tâches apériodiques en attente depuis son réveil précédent - jusqu’à épuisement des tâches apériodiques - jusqu’à épuisement de sa capacité • L’ordre de service des tâches apériodiques est quelconque • La capacité non utilisée est perdue 47

48

Exemple de tâche Serveur Scrutation 49

Thread POSIX : Pthread Qu'est ce qu'est un thread? – Techniquement, un thread est défini comme un flux d'instructions indépendant qui peut être programmé pour s'exécuter en tant que tels par le système d'exploitation. Mais qu'est-ce que cela signifie? • Pour le développeur du logiciel, le concept d'une «procédure» qui s'exécute indépendamment de son programme principal peut le mieux décrire un thread. 50

Analogie Pour aller plus loin, imaginez un programme principal (a. out) qui contient un certain nombre de procédures. Alors imaginez toutes ces procédures pouvant être programmé pour s'exécuter simultanément et / ou de façon indépendante par le système d'exploitation. ça serait de décrire un programme «multithread» . 51

Avant de pouvoir comprendre le fonctionnent d’un thread, il faut d'abord comprendre le fonctionnent d’un processus UNIX. Un processus est créé par le système d'exploitation, et exigeant « Overhead » en terme d'exploitation de ressources en particulier des informations sur les ressources du programme et l'état d'exécution du programme, notamment: – – – 52 Process ID, process group ID, user ID, and group ID Registers Stack Heap File descriptors Inter-process communication tools (such as message queues, pipes, semaphores, or shared memory)… etc.

Threads utilisent et existent au sein même des ressources de processus; Threads fonctionnent en grande partie comme des entités indépendantes parce qu'ils reproduire uniquement les ressources dont ils auraient besoin et qui leur permettraient d'exister en tant que code exécutable. Thread gère ses propres ressources(indépendance) : – – – 53 Stack pointer Registers Scheduling properties (such as policy or priority) Set of pending and blocked signals Thread specific data.

54

En résumé, dans l'environnement UNIX un thread: En résumé, dans l'environnement UNIX un thread – Existe au sein d'un processus et utilise les ressources de processus – A son propre flux de contrôle est indépendant aussi longtemps que son processus parent existe et le système d'exploitation qu'il supporte – Duplique seulement les ressources essentielles dont il a besoin d'être ordonnancés indépendamment – Peuvent partager les ressources de processus avec les autres threads qui agissent aussi de façon indépendante (et dépendante) – Détruit si le processus parent meurt - ou quelque chose de semblable – Thread est"léger" car la plupart des coûts d'exploitation a déjà été accompli par la création de son processus. – Comparé au coût de création et de gestion d'un processus, un thread peut être créé avec des « Overhead » du système d'exploitation beaucoup moins élevé. 55

56

Applications multitâches offrent des gains de performance potentiels et des avantages pratiques par rapport aux applications n'utilisant pas les threads par exemple : • Le chevauchement de travail CPU avec les opérations d' E/S: Par exemple, un thread peut effectuer des traitements des données reçus de la dernière opération E / S alors qu'un autre thread est en attente d'une nouvelle opération d'E/S et ne pas bloquer l'opération de E/S jusqu'a la fin de traitement. • Priorité / ordonnancement temps-réel: les tâches qui sont plus importantes peuvent être prévues pour remplacer ou interrompre des tâches de moindre priorité. • La gestion des événements asynchrones: Par exemple, un serveur web peut à la fois le transfert de données de demandes précédentes et à gérer l'arrivée de nouvelles demandes. 57

Thread-safe • Si la routine n'emploie pas une sorte de synchronisation des actions pour empêcher la corruption de données, alors il n'est pas thread-safe. 58

Pthreads API Création de thread int pthread_create(pthread_t *tid, const pthread_attr_t *tattr, void*(*start_routine)(void *), void *arg); – Id du thread – Les attributs du thread – La fonction à executer – Le premier argument de la function à executer #include <pthread. h> //fonction effectuant un traitement void *thr_f (void* param) { int * t = (int *) param; printf ("parametre : %d", *t); } int main () { pthread_t thr 1; pthread_create(&thr 1, NULL, thr_f, arg); return 0; } 59

Les attributs d’un thread : – – – – le type d'ordonnancement la priorité la taille de la pile Par défaut SCHED OTHER : toutes les threads se partagent le processeur en fonction de leur priorité. Hérite de la priorité des parents (priorité=12, héritage=0) Taille de la pile par défaut : 61440 Modifier les attributs d'un thread – Modifier l'ordonnancement : • int pthread_attr_setsched(pthread_attr_t *attr_pt, int scheduler); – Modifier la priorité : • int pthread_attr_setprio(pthread_attr_t *attr_pt, int prio); – Modifier la taille de la pile : • int pthread_attr_setstacksize(pthread_attr_t *attr_pt, long size); 60

Valeur du thread • pthread_t pthread_self(void); Renvoie la valeur du thread appelant. Attendre qu'un thread se termine • int pthread_join(thread_t tid, void **status); Suspend l'activité de la thread appelante tant que la thread tid n'est pas terminée. status contient la valeur de retour du thread tid lors de sa terminaison. Rendre la main • int sched_yield(void); Demander explicitement au cours de son ex_ecution de render la main Terminer une thread • void pthread_exit(void *status); Termine l'exécution la thread courante avec une valeur de retour particulière 61

Pthread condition variable • Une thread mutex permet de synchroniser le contrôle des accès aux données critiques(section critique) • Une thread variable de condition permet de synchroniser la valeur de ces données. Autrement dit “Faire coopérer les threads et attendre que les données atteingnent un état particulier ou jusqu'à ce qu'un certain événement se produise. Exemple : le thread du magasin doit attendre que le stock ne suffise plus aux clients pour le renflouer 62

Créer une condition repose sur le même principe que les mutex à savoir, la création et initialisation d'une variable de type pthread_cond_t soit par exemple: static pthread_cond_t cond_stock = PTHREAD_COND_INITIALIZER; Les conditions reposent essentiellement sur deux fonctions : 1. Une permet de mettre en attente un thread 2. La seconde permet de signaler que la condition est remplie ce qui réveille alors le thread qui est en attente de cette condition. pthread_cond_wait int pthread_cond_wait (pthread_cond_t * cond, pthread_mutex_t * mutex); • L'adresse de la variable condition de type pthread_cond_t. • L'adresse d'un mutex. Une condition est en effet, toujours associée à un mutex. pthread_cond_signal int pthread_cond_signal (pthread_cond_t * cond); • pthread_cond_signal : la fonction qui permet de signaler la condition au thread qui l'attend. Elle prend en paramètre l'adresse de la variable-condition surveillée. Cette fonction ne permet de réveiller qu'un seul thread. Pour en réveiller d'avantage, il faut utiliser la fonction: int pthread_cond_broadcast (pthread_cond_t * cond); 63

Exercices : Pthread Condition Variable Considérons deux variables globales partagées x et y=30, protégées par le mutex mt, et une variable condition cd pour signaler que x devient plus grand que y. Soient deux threads : le thread Alarme qui se déclenche lorsque x > y et le thread X_inc qui incremente x. 1. Proposez le code du thread Alarme 2. Proposez le code du thread X_inc 3. Implémentez ce programme 64

#include <stdlib. h> #include <stdio. h> #include <pthread. h> void* ma. Fonction(void* data); int main() { int i; // On crée un thread pthread_t thread; // Permet d'exécuter le fonction ma. Fonction en parallèle pthread_create(&thread, NULL, ma. Fonction, NULL); // Affiche 50 fois 1 for(i=0 ; i<50 ; i++) printf("1"); // Attend la fin du thread créé pthread_join(thread, NULL); return 0; } void* ma. Fonction(void* data) { int i; // Affiche 50 fois 2 for(i=0 ; i<50 ; i++) printf("2"); return NULL ; } 65