Aperçu des OS Temps Réel Gestion des tâches

Transcription

1 Systèmes d'exploitation Temps Réel Aperçu des OS Temps Réel Gestion des tâches Définition : un programme qui ordonnance l'exécution des tâches de façon ponctuelle, gère les ressources du système et fournit les éléments de base pour développer les applications souvent organisé autour d'un noyau fournissant les algorithmes minimum pour l'ordonnancement et la gestion des ressources éventuellement de services, fournis par exemple par des modules, pour gérer les systèmes de fichier, les accès réseau, ou tout autre service requis par l'application F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année Systèmes d'exploitation Temps Réel les composants de base du noyau d'un OS Temps Réel sont : l'ordonnanceur, contenu dans tous les noyaux et qui va fournir les algorithmes de base pour choisir la tâche qui va accéder au processeur des objets du noyau pour aider les développeurs à créer les applications : tâches sémaphores files de message... des services, qui sont les opérations effectuées par le noyau sur un objet ou plus généralement des opérations comme les mesures de temps, la gestion des interruptions, la gestion des ressources... F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année L'ordonnanceur le coeur du noyau agit sur des entités ordonnançables (tâches) threads processes gère plusieurs tâches à la fois (multi-tâche) doit donner la CPU à la bonne tâche au bon moment (ordonnancement) met en oeuvre les changements de contexte si nécessaire sauvegarde et restauration du bloc de contrôle de tâche (TCB) F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année

2 L'ordonnanceur le répartiteur (dispatcher) : partie de l'ordonnanceur qui exécute les changements de contexte et modifie le cours de l'exécution le cours de l'exécution peut être consacré à : tâche utilisateur ISR noyau passage du cours de l'exécution au noyau dès qu'une tâche ou un ISR fait un appel système ensuite une autre (même?) tâche reprend la main un ISR court-circuite le répartiteur jusqu'à la fin de son exécution Les algorithmes d'ordonnancement Deux politiques d'ordonnancement préemptifs basés sur la priorité round robin Préemptif basés sur la priorité la tâche qui a la plus haute priorité a la CPU si une tâche de plus haute priorité que celle en cours devient éligible, l'exécution est interrompue et le répartiteur effectue un changement de contexte l'attribution de la priorité fait l'objet d'algorithmes plus ou moins complexe (on y reviendra plus tard) Round robin peu ou pas utilisé en environnement Temps Réel F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année Caractéristiques d'un OS Temps Réel 5 propriétés essentielles 1) fiabilité (reliability) faculté de pouvir être utilisé sans intervention extérieure s'exprime en fonction du nombre de 9 de la disponibilité: Caractéristiques d'un OS Temps Réel 5 propriétés essentielles (suite) 2) prédictabilité (predictability) spécifique des systèmes temps réels spécifie le degré de confiance que l'on peut avoir dans la prévision du temps de réponse 3) performances caractérise la vitesse à laquelle le système va fournir sa réponse dépend du hardware autant que du software va dépendre du hardware autant que du software a un coût certain... F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année

3 Caractéristiques d'un OS Temps Réel 5 propriétés essentielles (suite) 4) compacité de l'empreinte (compactness) utilisation optimale des ressources 5) possibilité d'appliquer un facteur d'échelle (scalability) utilisation optimale des ressources en cas de modification de la taille du système optimisation des conditions de développement Nom Editeur Open Quelques OS Temps Réel source Temps Réel URL Remarques VxWorks WindRiver non oui certainement le leader du marché psos WindRiver non oui ancien mais très répandu QNX QNX partiel. oui basé sur UNIX, pas mal de composants open source, assez répandu, bonnes performances µc/os Micriµm non oui pour les micro-contrôleurs Windows CE Microsoft non oui e.net/ LynxOS LynuxWorks non oui Édite également Blue Cat basé sur Linux Nucleus Accelerated Technology oui oui pas de royalties ECOS Red Hat oui oui utilisable pour de très faibles empreintes mémoire, environnement de développement croisé Linux disponible PeeWeeLinux aucun oui non fondé sur RedHat 6.2 (noyau 2.2) RTLinux FSM Labs oui oui existe en version GPL et en version "pro" (breveté), temps réel dur RTAI aucun oui oui proche de RTLinux, mais non commercial TUXIA TUXIA oui non dédié aux applications Internet Red Hat Embedded Red Hat oui non Linux µclinux aucun oui oui pour les micro-contrôleurs sans MMU. Sponsorisé par Lineo. Existe en noyau 2.0 et 2.4 Embedix Lineo oui non utilisé dans le PDA Zaurus de SHARP Montavista Linux (Hard Hat) Monta Vista oui oui fondé sur des patches préemptifs du noyau Linux. Pas de temps réel dur F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année L'interface POSIX Portable Operating System Interface pour aider à produire des codes portables sans trop d'efforts initié par l'ieee et organisé par l'iso à partir d'unix, pour le C ANSI différents standards pour différents problèmes POSIX.4 : extensions temps réel POSIX.4a : extensions pour les threads Linux pour le Temps Réel important : l'interface POSIX.4 ne fournit pas un environnement temps réel, mais uniquement des interfaces qui peuvent être utilisées dans le cadre d'un OS Temps Réel F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année

4 Linux pour le temps réel et l'embarqué Linux pour le temps réel et l'embarqué le monde de l'embarqué est encore dominé par les solutions propriétaires mais l'open source a des avantages prix disponibilité des sources et quelques inconvénients stratégie industrielle vs licence GPL continuité du support points forts de Linux fiabilité du noyau faible coût performances ( portabilité ouvert aux autres systèmes (y compris Windows) points faibles pas vraiment un micro noyau F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année les approches temps réel pour Linux Linux peut être adapté pour une utilisation temps réel ou embarquée mais Linux "natif" n'est pas un OS Temps Réel plusieurs approches possibles modification de l'ordonnanceur (MontaVista) ajout d'un véritable noyau temps réel (RTLinux, RTAI) systèmes minimaux (µclinux) modification de l'ordonnanceur en tirant partie de la possibilité d'utiliser un ordonnancement de type et en modifiant l'ordonnanceur pour avoir davantage de points de préemption où l'on vérifie si une tâche de priorité supérieure demande la CPU patch de modification du noyau kernel-preempt (disponible pour 2.4, intégré dans le noyau 2.6) approche intéressante car ne modifie pas l'interface de programmation des applications qui continuent à tourner en mode utilisateur temps réel mou F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année

5 ajout d'un noyau temps réel RT Linux le noyau Linux n'est pas adapté au temps réel on intercale un noyau temps réel dans le même espace le noyau Linux, et les Processe sutilisateurs mémoire entre le hardware et le noyau "normal" (RTCore) Processe sutilisateurs applications utilisateurs, sont exécutés comme une tâche de fond Processes temps réels Librairies systèmes pilotes Noyau Linux Processes temps réels RT scheduler Interrupts s/w RTCore (Plugin RT Linux) accès direct h/w Interrupts h/w Librairies systèmes pilotes Noyau Linux accès direct h/w RT scheduler Interrupts s/w RTCore (Plugin RT Linux) Interrupts h/w F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année RT Linux RT Linux le noyau Linux, et les Processe sutilisateurs le noyau Linux, et les Processe sutilisateurs applications utilisateurs, sont exécutés comme une tâche de fond le noyau temps réel est préemptif à priorité fixe Processes temps réels RT scheduler accès direct h/w Librairies systèmes pilotes Noyau Linux Interrupts s/w RTCore (Plugin RT Linux) Interrupts h/w applications utilisateurs, sont exécutés comme une tâche de fond le noyau temps réel est préemptif à priorité fixe les tâches temps réel sont Processes temps réels RT scheduler accès direct h/w Librairies systèmes pilotes Noyau Linux Interrupts s/w RTCore (Plugin RT Linux) Interrupts h/w des threads qui s'exécutent dans l'espace noyau (modules) F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année

6 le noyau Linux, et les applications utilisateurs, sont exécutés comme une tâche de fond le noyau temps réel est préemptif à priorité fixe les tâches temps réel sont des threads qui s'exécutent dans l'espace noyau RT Linux Processes temps réels pilotes RT scheduler Processe sutilisateurs Librairies systèmes Noyau Linux Interrupts s/w RTCore (Plugin RT Linux) accès direct h/w Interrupts h/w (modules) la communication entre tâches TR ou utilisateurs peut se faire par la mémoire partagée ou des FIFOs F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année RT Linux principes de fonctionnement de RTCore les interruptions matérielles du noyau Linux sont désactivées le service des interruptions est effectué par une émulation le noyau Linux est exécuté avec la priorité minimale (tâche de fond qui n'est activée que quand le noyau temps réel est inactif) F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année RT Linux émulation des interruptions la désactivation des interruptions à l'intérieur des sections critiques est la manière la plus simple et la plus efficace d'obtenir un comportement «temps réel» mais il ne faut pas perdre des interruptions en les désactivant trop longtemps les interruptions qui ne sont pas destinées aux tâches temps réel sont passées à Linux qui les traite quand il le peut en remplaçant toutes les occurences de sti et cli par un code émulateur les interruptions matérielles sont simplement émulées dans Linux pas besoin de modifier les pilotes de Linux RT Linux traitement des interruptions if (there is an RT-handler for the interrupt) { call the RT-handler } if (there is a GPOS-handler for the interrupt) { call the GPOS handler for this interrupt } else { mark the interrupt as pending } limitations de l'approche la prise en compte par le système de l'occurence d'une interruption est prioritaire sur les tâches temps réel et peut légèrement perturber l'ordonnancement F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année

7 Les tâches dans un environnement TR Gestion des tâches La plupart des applications temps réel exigent une exécution parallèle de plusieurs activités utilisation optimale des ressources gain de temps quand c'est possible mais les exigences en termes de conception sont plus grandes Concepts présentés : définition états d'une tâche et ordonnancement opérations sur une tâche l'interface POSIX F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année Un fil d'exécution indépendant qui peut entrer en compétition avec d'autres fils pour accéder à la CPU définition ''récursive'' utilisée pour optimiser la gestion des entrées/sorties une tâche est ordonnançable et est définie par un ensemble de paramètres contenus dans des structures de données nom identificateur priorité bloc de contrôle pile Définition d'une tâche liste d'instructions (routine) Stack TCB Task Name/ID plus hautes priorités int MyTask() { 130 while (1)... } plus basses priorités F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année Tâches systèmes créées par le noyau à son démarrage des priorités réservées leur sont allouées tâche d'initialisation tâche de fond quand le processeur n'a rien à faire priorité minimale importante car il faut que le registre de compteur de programme pointe à une valeur valide tâches de logging tâches de gestion des exceptions et bien d'autres encore... ensuite le noyau pointe sur un point d'entrée pour les applications de l'utilisateur qui vont à leur tour créer des tâches et des objets du noyau F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année

8 États d'une tâche Tâches dans l'état ''Prêt'' 3 états possibles pour dans l'état Prête quand seul le fait que des tâches de plus la machine à états Prêt haute priorité existent l'empêche d'avoir accès à la CPU finis des tâches la plupart des noyaux acceptent l'existence de plusieurs courant tâches avec le même niveau de priorité prêt à l'intérieur d'un niveau de priorité, l'élection d'une tâche bloqué Bloqué Courant pour le passage dans l'état Courant passe par l'exécution d'un algorithme plus ou moins complexe le noyau gère les états des différentes tâches sous son contrôle l'ordonnanceur provoque les changements d'états et si nécessaire provoque un changement de contexte F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année Tâches dans l'état ''Courant'' une seule tâche dans cet état dans les systèmes monoprocesseurs retourne dans l'état Prêt par préemption par une tâche de plus haute priorité passe dans l'état Bloqué dans l'un des cas suivants : en requérant l'usage d'une ressource indisponible en se mettant en attente d'un événement en décidant de se suspendre pour un temps donné Tâches dans l'état ''Bloqué'' l'éventualité du blocage d'une tâche est la seule possibilité pour une autre tâche de plus basse priorité d'accéder à la CPU le déblocage se produit quand la condition de blocage est levée, par exemple : un sémaphore est libéré un message est arrivé dans la file sur laquelle la tâche était en attente de lecture le délai d'attente a expiré la tâche débloquée passe dans l'état Prêt et entre en F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année compétition avec les autres pour l'accès à la CPU Elle peut éventuellement passer directement dans l'état Courant F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année

9 Processus et Threads processus (process) : entité ordonnançable possédant son propre espace d'adressage les threads existent à l'intérieur d'un process (appartenant au noyau ou à l'utilisateur) et partagent l'espace d'adressage du process hôte. Ils sont ordonnançables indépendemment (le process hôte est un thread comme les autres) chaque thread possède son bloc de contrôle (TCB), ses registres et sa pile (stack) la création d'un process est Primitives pour la gestion des tâches Fonctions à remplir création destruction gestion de l'ordonnancement suspendre reprendre retarder redémarrer modifier la priorité bloquer la préemption plus lente et plus lourde en termes de consommation de ressources que celle d'un thread mais l'espace mémoire est beaucoup mieux protégé F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année fork pid_t fork(void) clonage d'un process Création des processes un appel, mais deux retours... le process qui a appelé fork récupère le PID du nouveau process le process qui a été créé récupère 0 exec Création des processes remplace l'image exécutée par une autre execl(const char *file,const char *arg0,...,null); execv(const char *file,char *const argv[]); execle(const char *file,const char *arg0,...,null,char *const envp[]); execve(const char *file,char *const arg[],char *const envp[]); execlp(const char *file,const char *arg0,...,null); execvp(const char *file,char *const argv[]); execl prend une liste d'arguments terminée par NULL execv prend un vecteur de pointeurs d'arguments la terminaison en e indique qu'il y aura une 2ème liste ou vecteur passé pour préciser l'environnement (sous la forme key=value) la terminaison en p indique qu'il faut utiliser la variable d'environnement PATH pour localiser file le main de file est exécuté avec la liste d'arguments passée F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année

10 exit et _exit Destruction des processes termine le processus void exit(int status); void _exit(int status); la différence entre les deux fonctions tient dans la façon dont elles "nettoient" l'environnement (_exit ne fait pas appel aux fonctions enregistrées par atexit) elles ne retournent rien! wait et waitpid attente de la fin du process fils par le père pid_t wait(int *status); pid_t waitpid(pid_t which,int *status,int options); tant que le parent n'a pas appelé wait, le fils terminé est un "zombie" (occupation de ressources) Ordonnancement des processes POSIX.4 définit 3 algorithmes SCHED_FIFO la priorité est le seul paramètre les tâches sont rangées dans des queues par niveau de priorité la 1 ère tâche de la queue de plus haute priorité obtient la CPU elle la garde jusqu'à sa terminaison ou jusqu'à ce qu'elle soit bloquée quand elle redevient Prête, la tâche est mise en fin de queue SCHED_RR (Round Robin) comme FIFO, mais avec en plus un quantum de temps la tâche rend la CPU à l'expiration du quantum de temps SCHED_OTHER dépend de l'implémentation F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année modifications de l'ordonnancement sched_setscheduler, sched_getscheduler int sched_setscheduler(int pid, int policy, const struct sched_param *param) int sched_getscheduler(int pid, struct sched_param *param) modifie (ou obtient) les paramètres de l'ordonnanceur, y compris la politique sched_setparam, sched_getparam int sched_setparam(int pid, const struct sched_param *param) int sched_getparam(int pid, struct sched_param *param) modifie (ou obtient) les paramètres de l'ordonnanceur struct sched_param {... int sched_priority;... }; modifications de l'ordonnancement sched_get_priority_min, sched_get_priority_max int sched_get_priority_min(int policy); int sched_get_priority_max(int policy); sched_yield int sched_yield(void); relache volontairement le processeur, sans se bloquer attention : ce n'est pas parce que un process de haute priorité relache le processeur que les processes de priorité inférieure vont être exécutés! F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année

11 Création des threads fichier d'include <pthread.h> les caractéristiques des threads (attributs) sont décrites dans une structure spéciale accédée par des fonctions dédiées initialisation aux valeurs par défaut : pthread_attr_init(pthread_attr_t *attr); libération des ressources liées aux attributs : pthread_attr_destroy(pthread_attr_t *attr); Création des threads Modification des valeurs des attributs pthread_attr_setstacksize pthread_attr_setstackaddr pthread_attr_setdetachstate PTHREAD_CREATE_DETACHED PTHREAD_CREATE_JOINABLE pthread_attr_setschedparam pthread_attr_setschedulepolicy SCHED_FIFO SCHED_RR SCHED_OTHER pthread_attr_setinheritsched PTHREAD_EXPLICIT_SCHED PTHREAD_INHERITSCHED pthread_attr_setscope PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_PROCESS F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année Création des threads Lecture des valeurs courantes pthread_attr_getstacksize pthread_attr_getstackaddr pthread_attr_getdetachstate pthread_attr_getschedparam pthread_attr_getschedpolicy pthread_attr_getinheritsched pthread_attr_getscope pthread_create Création des threads crée un thread int pthread_create(pthread_t *tid, const pthread_attr_t *attr, void * (*start_func)(void *), void *arg); pthread_self retourne le tid du thread appelant pthread_t pthread_self(void); F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année

12 pthread_join Création des threads appel bloquant : attend la terminaison d'un thread (attente de synchronisation sur la fin du thread) pthread_join (pthread_t tid,void **status); récupère le status de terminaison retourne immédiatement si le thread est déjà terminé pthread_exit Destruction des threads auto-destruction void pthread_exit(void *status); passe éventuellement le status de retour au thread en attente de synchronisation sur la fin le thread doit avoir été créé en mode joignable pthread_detach transforme un thread joignable en thread détaché int pthread_detach(pthread_t tid); F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année Destruction des threads pthread_cancel demande de destruction d'un autre thread int pthread_cancel(pthread_t tid); L'effet de l'appel dépend de la politique adoptée par le thread visé : int pthread_setcancelstate(int state, int *ostate) int pthread_setcanceltype(int type, int *otype) état PTHREAD_CANCEL_DISABLE PTHREAD_CANCEL_ENABLE type PTHREAD_CANCEL_ASYNCHRONOUS destruction immédiate PTHEAD_CANCEL_DEFERRED destruction quand le thread atteint un point d'annulation : (appel à pthread_testcancel ou appel à une fonction bloquante) Destruction des threads Handlers de terminaison exécutés à l'appel de pthread_exit ou sur une annulation stockés dans une pile manipulée par void pthread_cleanup_push(void (*handler)(void *), void *arg); void pthread_cleanup_pop(int execute); exécutés en mode LIFO lors de la terminaison du thread (pthread_exit) si on retire un handler de la pile (pthread_cleanup_pop), il est exécuté seulement si l'argument passé par pthread_cleanup_pop vaut 1 F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année

13 threads et fork quand un thread exécute un fork il va créer un nouveau process même image mémoire que le père mêmes ressources (descripteurs de fichiers, mutexes, etc...) mais le process fils n'a qu'un seul thread, qui est la réplique du thread du père qui a appelé le fork Attention à des situations parfois inextricables! le process fils peut hériter de locks qui ont été pris par des threads du père n'existant pas dans le process fils l'espace mémoire du fils peut comporter des zones du heap qui ont été alloués à des threads n'existant pas dans le process fils utilisation de la fonctionpthread_atfork pour aider à gérer ces difficultés F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année threads et fork int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void)); installe dans 3 stacks différents des handlers qui seront exécutés au moment de l'appel à fork prepare sera exécuté par le père avant l'exécution du fork parent sera exécuté par le père au retour du fork child sera exécuté par le fils au retour du fork peut être applé plusieurs fois les handlers seront appelés en mode LIFO si on fait un appel à exec dans un process multithreadé, alors on détruit tous les autres threads et on démarre la nouvelle image dans son main F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année Politiques d'ordonnancement des threads défini à la création par un attribut priorité politique (FIFO, Round Robin) visibilité "système" (seule visibilité supportée par Linux. La seule "utile" pour les applications de type temps réel) "process" dépend beaucoup de l'implémentation et de la configuration hardware (mono ou multi-processeur) pour l'élection d'un thread activable ou bloqué "priorité à la priorité" pour l'élection du thread Politiques d'ordonnancement des threads pthread_setschedparam, pthread_getschedparam modification des paramètres de l'ordonnancement int pthread_setschedparam(pthread_t tid, int policy, const struct sched_param *param); int pthread_getschedparam(pthread_t tid, int *policy, struct sched_param *param); sched_xxx setinheritsched la politique va déterminer la façon de rendre la CPU F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année

14 Politiques d'ordonnancement des threads Ordonnancement des mutex mécanismes de changement des priorités en donnant au mutex une priorité que le thread courant récupérera (priority ceiling) ou en donnant au thread possédant le mutex la plus haute priorité des threads en attente du mutex (priority inheritance) l'api de RTCore compatible POSIX avec des extensions (_np) en suivant le profil POSIX PSE 51 l'appel à une fonction POSIX signifie par défaut que l'on va travailler dans un environnement temps réel F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année l'api de RTCore l'api de RTCore #include <stdio.h> #include <pthread.h> #include <unistd.h> pthread_t thread; void *thread_code(void *t) { struct timespec next; int count = 0; clock_gettime(clock_realtime, &next); while (1) { timespec_add_ns(&next, 1000*1000); clock_nanosleep(clock_realtime, TIMER_ABSTIME, &next, NULL); count++; if (!(count % 1000)) printf("woke %d times\n",count); } return NULL; } int main(void) { pthread_create(&thread, NULL, thread_code, (void *)0) rtl_main_wait(); pthread_cancel(thread);pthread_join(thread, NULL); return 0; } compatible POSIX avec des extensions (_np) en suivant le profil POSIX PSE 51 l'appel à une fonction POSIX signifie par défaut que l'on va travailler dans un environnement temps réel avant de pouvoir lancer l'application temps réel, il faut avoir lancé le noyau RTCore /opt/rtldk-x.y/rtlinuxpro/modules/rtcore (on peut vérifier sa présence avec la commande lsmod) F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année F. Touchard Cours Temps Réel ESIL Département d'informatique 2ème année