Module MT13 : Systèmes Temps Réel Embarqués. Linux pour le temps-réel. el et l embarqul. embarqué. Audrey Marchand - Université de Nantes

Audrey Marchand - Université de Nantes Module MT13 : Systèmes Temps Réel Embarqués Linux pour le temps-réel el et l embarqul embarqué

Plan du cours Introduction Caractéristiques des OS Temps Réel Linux pour les OS TRE : stratégies et solutions RTAI Programmation sous RTAI LTT Une introduction aux makefiles TPs Méthodologie de création d un système Linux embarqué Le logiciel libre Dossier de presse sur Linux Temps Réel Conclusion

Introduction But du cours sur Linux Temps Réel Acquérir une connaissance du marché des OS TRE Mieux comprendre l architecture interne du noyau Linux Appréhender l OS temps réel RTAI Approfondir ses connaissances en programmation TR Assimiler le concept de logiciel libre

Introduction Références Portail communautaire général : http://www.realtimelinux.org Portail Linux embarqué : http://www.linuxdevices.com Portail plus jeune : http://www.realtimelinuxfoundation.org RTAI : http://aero.polimi.it/projects/rtai Portail communautaire RTAI : http://www.rtai.org RTLinux : http://www.rtlinux.com Portail communautaire RTLinux : http://www.rtlinux.org Linux Trace Toolkit : http://opersys.com/ltt Logiciel Libre : http://www.openresources.com

Caractéristiques des OS Temps Réel Quelques définitions (1) noyau ou moniteur temps réel : exécutif temps réel : système d exploitation temps réel :

Caractéristiques des OS Temps Réel Quelques définitions (2) celle de Stankovic dans son ouvrage intitulé «Misconceptions about realtime computing», IEEE Computer, octobre 1988 : "En informatique temps réel, le comportement correct d un système dépend, non seulement des résultats logiques des traitements, mais aussi du temps auquel les résultats sont produits." celle de DORSEUIL A. dans «Le temps réel en milieu industriel, concepts, environnements, multitâches». Paris : Bordas, 1991 : "Un système fonctionne en temps réel s il est capable d absorber toutes les informations d entrée sans qu elles soient trop vieilles pour l intérêt qu elles présentent, et par ailleurs de réagir à celles-ci suffisamment vite pour que cette réaction ait un sens."

Caractéristiques des OS Temps Réel Comportement d un système temps réel L interaction avec son environnement : Capteurs Processeur Temps réel Actionneurs 3 caractéristiques fondamentales : prévisibilité, déterminisme, fiabilité

Caractéristiques des OS Temps Réel Fonctionnalités d un système temps réel Deux contraintes sont à vérifier : exactitude logique (logical correctness) : sorties adéquates en fonction des entrées, assurant le comportement désiré pour le système suite à des événements et à des données communiquées, exactitude temporelle (timeliness) : rencontre des contraintes temporelles. Les sorties sont présentées au bon moment.

Caractéristiques des OS Temps Réel Les contraintes temporelles (1) Niveaux de contraintes temporelles : Souple (soft) : la performance du système est dégradée sans engendrer des conséquences dramatiques si les contraintes temporelles ne sont pas rencontrées, Sévère (hard) : l'incapacité du système à rencontrer les contraintes temporelles cause la faute du système, Ferme (firm) : contrainte sévère mais où une faible probabilité de manquer les limites temporelles peut être tolérée.

Caractéristiques des OS Temps Réel Les contraintes temporelles (2) Catégories de contraintes temporelles : Deadline : une tâche doit être achevée avant un instant donné dans le temps, Zero Execution Time : la tâche doit être effectuée dans une période de temps égale à zéro dans le cas idéal, Quality Of Service (QoS) : la tâche doit effectuer une quantité fixée de service par unité de temps.

Caractéristiques des OS Temps Réel Les responsabilités des OS temps réel (1) Le service d interruption le traitement des ISRs événement Sauvegarde du contexte Traitement de l interruption Restauration du contexte Déroulement normal du programme Déroulement normal du programme

Caractéristiques des OS Temps Réel Les responsabilités des OS temps réel (2) La synchronisation la signalisation par événement la signalisation par sémaphore - le sémaphore binaire, - le sémaphore compteur, - l exclusion mutuelle. la synchronisation par messages

Caractéristiques des OS Temps Réel Les responsabilités des OS temps réel (3) La communication le passage de messages - les «pipes», - les FIFOs, - les BALs. la mémoire partagée les RPCs

Caractéristiques des OS Temps Réel Les responsabilités des OS temps réel (4) La gestion de la mémoire La mémoire virtuelle et la pagination

Caractéristiques des OS Temps Réel Les responsabilités des OS temps réel (5) La gestion des tâches Les tâches temps réel sont caractérisées par : - une période T, - une échéance d, - une durée d exécution c, Le facteur de charge se définit comme le rapport de la durée d exécution de la charge sur sa période : L = c/t.

Caractéristiques des OS Temps Réel Les responsabilités des OS temps réel (6) L ordonnancement ORDONNANCEUR PROCESSEUR processus élu DISPATCHER file d attente des processus bloqués file d attente des processus éligibles

Caractéristiques des OS Temps Réel Les responsabilités des OS temps réel (7) Les politiques d ordonnancement Fixed Priority Preemptive Scheduling (FPPS) Dynamic Priority Preemptive Scheduling (DPPS) Rate-Monotic Scheduling (RMS) Deadline Monotonic Scheduling (DMS) Earliest Deadline-First Scheduling (EDFS) Highest Priority First Scheduling (HPFS) Least Laxity First Scheduling (LLFS)

Linux pour les OS TRE Mécanismes critiques de l architecture du noyau (1) La gestion des interruptions externes Masquage des interruptions («interrupt-off» processor mode) - assurance d un noyau non réentrant, - traitement des sections critiques. Interruptions imbriquées (nest interrupts)

Linux pour les OS TRE Mécanismes critiques de l architecture du noyau (2) Le mécanisme de préemption Un noyau préemptible doit protéger les sections critiques de toute réentrance : - masquage des interruptions, - utilisation de sémaphores. Introduction de «points de préemption» (preemption points) dans le cas d un noyau non préemptible Changements de contexte interdits dans les sections critiques

Linux pour les OS TRE Mécanismes critiques de l architecture du noyau (3) L ordonnancement L ordonnanceur est une procédure de service du système d exploitation qui a pour rôle d allouer le processeur aux différentes tâches L ordonnanceur doit sélectionner et activer les tâches «prêtes» selon une politique spécifique basée sur la priorité (ex : RMS) et ce, dans une fenêtre de temps fixée (déterministe) Ordonnancement en ligne ou hors ligne Minimisation du temps overhead = simplicité de l ordonnanceur

Linux pour les OS TRE Le contrôle temps réel avec Linux : stratégies Les différentes alternatives : Éviter le masquage systématique des interruptions au niveau des sections critiques : - protection par mécanismes à état, - protection par sémaphores. Rendre le noyau Linux préemptible Ne pas utiliser un algorithme mixte de sélection des tâches assurant d une part un flux global de sortie et d autre part une progression de l ensemble de tous les processus

Linux pour les OS TRE Le contrôle temps réel avec Linux : solutions Le noyau Linux standard : Il ne peut garantir l'exécution d'une tâche dans un délai donné Les variantes actuelles pour le TRE : Elles utilisent toutes le même principe : un noyau temps réel prédictif qui laisse fonctionner sur son temps libre le noyau Linux et ses applications. Elles diffèrent dans leur implémentation et les architectures supportées

Linux pour les OS TRE RTLinux : Les variantes de Linux pour le temps réel (1) RTLinux est un «patch» pour le noyau Linux RTLinux est noyau temps réel multi-threads, dans lequel le Linux standard est le thread de plus basse priorité. RTLinux fonctionne sur toutes les plates-formes de la famille x86, plus les systèmes PowerPC et Alpha. RTLinux/Pro supporte également les processeurs MIPS. RTLinux est distribué par la compagnie Finite State Machine Labs (FSMLabs) sous licence GPL, en accord avec le brevet d invention 5995745 du 30 novembre 1999.

Linux pour les OS TRE Les variantes de Linux pour le temps réel (2) RTAI (Real-Time Application Interface) : RTAI est un «patch» pour le noyau Linux RTAI considère Linux comme une tâche de fond s exécutant lorsque aucune activité temps réel n est présente. RTAI utilise le concept de RTHAL (Real-Time Hardware Abstraction Layer) pour récupérer de l information depuis Linux. RTAI est distribué par la compagnie Lineo (formellement Zentropix). On peut citer le développeur principal : Paolo Mantegazza.

Linux pour les OS TRE Les variantes de Linux pour le temps réel (3) minirtl : minirtl est une minuscule implémentation de RTLinux qui tient sur une seule disquette 1.44MB Il s agit donc d un système Linux autonome, bootable, de taille minimale, et supportant le réseau. Il fonctionne sur les machines i486 et vise tout particulièrement les cartes PC-104 standards de l industrie

Linux pour les OS TRE Les variantes de Linux pour le temps réel (4) AtomicRTAI : AtomicRTAI est une installation sur une seule disquette pour Linux temps réel Il inclut des possibilités de mesure de base qui évaluent les paramètres clés d un système d exploitation temps réel Il comprend plusieurs programmes de démonstration relatifs au temps réel dur AtomicRTAI est un «Open Source» et est distribué gratuitement sous la Licence Publique GNU

Linux pour les OS TRE Les variantes de Linux pour le temps réel (5) LynxOS (Lynx Real-time Systems) : LynxOS est un système d exploitation temps réel propriétaire type UNIX Il a été développé avec des objectifs de haute performance et des réponses temps réel dur déterministes. LynxOS est conforme à la norme POSIX 1003.1. Le système d exploitation est une entière réimplémentation d UNIX à partir de perspectives temps réel.

Linux pour les OS TRE Linux comme système embarqué Avantages : Fiabilité Faible coût Performances Portabilité et adaptabilité Ouverture Inconvénients : Crédibilité de l open-source Méconnaissance des licences Support technique

Linux pour les OS TRE Les variantes de Linux pour l embarqué (1) MontaVista Linux (Hard Hat Linux) : MontaVista Linux est la plate-forme de développement leader de Linux embarqué Il a été conçu pour les solutions embarqués utilisant les architectures processeurs x86/ia-32, PowerPC, StrongARM, Xscale, MIPS, SH, ARM et autres. MontaVista Linux fournit un «patch» qui rend le noyau Linux globalement préemptible Il possède des timers POSIX haute résolution précis à la microseconde.

Linux pour les OS TRE Les variantes de Linux pour l embarqué (2) PeeWee Linux : PeeWee Linux est basé sur la distribution Red Hat 6.2 Il s appuie sur la version standard du noyau 2.2 Il supporte les mémoires flash du type DiskOnChip et les périphériques IDE, SCSI, USB, PCMCIA. Il est distribué sous licence GPL.

Linux pour les OS TRE µclinux : Les variantes de Linux pour l embarqué (3) µclinux, dérivé du noyau Linux 2.0 est destiné aux µcontrôleurs dépourvus de MMUs (Memory Management Units). Le noyau seul occupe moins de 512ko d espace disque et si l on veut y ajouter les outils, on atteint les 900ko. Les systèmes de fichiers supportés sont les suivants : NFS, ext2, MS-DOS, FAT16/32.

Linux pour les OS TRE EtLinux : Les variantes de Linux pour l embarqué (4) Etlinux est un système complet basé sur Linux, conçu pour fonctionner sur de très petits ordinateurs industriels Etlinux nécessite 2Mo de Ram et 2Mo d espace disque et peut fonctionner sur la plupart des PC standards d industrie basés sur la famille Intel 80x86. Il bénéficie des fonctionnalités avancées de Linux : multitâche préemptif, multithreading, gestion rapide des entrées-sorties, etc. Le développement d Etlinux a été sponsorisé par la société EuroTech Spa qui souhaitait elle-même un système d exploitation fiable pour ses systèmes embarqués PC/104. Le code source est disponible sous licence GPL

Linux pour les OS TRE L ordonnancement du noyau Linux standard 3 modes de fonctionnement POSIX : SCHED_RR : algorithme type tourniquet (round robin) SCHED_FIFO : mode basé sur la politique du premier arrivé, premier servi (FIFO) SCHED_OTHER : l objectif est de trouver un compromis entre un débit maximum et une bonne interactivité utilisateur

Linux pour les OS TRE KURT Linux : Les «patches» d ordonnancement (1) KURT (Kansas University Real-Time) fournit trois modes système : -le mode normal dans lequel le système fonctionne en temps partagé, -le mode focalisé dans lequel seuls les processus temps réel sont autorisés à s exécuter, -le mode mixte dans lequel tous les processus sont autorisés à s exécuter et où les processus non temps réel sont servis seulement comme l ordonnancement temps réel l autorise.

Linux pour les OS TRE Les «patches» d ordonnancement (2) Linux-SRT : L utilisateur peut spécifier une QoS pour des applications temps réel Il est ainsi possible d assigner un certain pourcentage de CPU à chaque tâche L ordonnanceur de Linux-SRT est donc plus précis et flexible qu un ordonnanceur standard (qui ne garantit rien)

Linux pour les OS TRE Les «patches» d ordonnancement (3) Qlinux : Qlinux est un noyau Linux qui peut fournir des garanties de QoS Il a les caractéristiques suivantes : - un ordonnanceur H-SFQ (Hierarchical Start Time Fair Queuing) CPU - un ordonnanceur de paquets de réseau H-SFQ (Hierarchical Start Time Fair Queuing)

Linux pour les OS TRE Les «patches» d ordonnancement (4) Fairshed : Fairshed est un ordonnanceur QoS hiérarchique Linux DWCS (Dynamic Window-Constrained Scheduling) : Un processus a des attributs en termes de : - période de demande (request period) : la deadline courante d'un processus se situe à la fin de sa période courante de demande. - fenêtre de contraintes (window-constraint) : fraction x/y, telle qu'un processus peut ne pas être servi au plus sur x périodes de demande vis à vis de toutes les y périodes de demande.

Linux pour les OS TRE Les «patches» d ordonnancement (5) TimeSys Linux/RT : TimeSys Linux / RT rend le noyau standard de Linux préemptible Il permet de construire un ordonnancement QoS pour les tâches utilisateur Tous les mutex de Linux on été changés pour supporter : - l héritage de priorité (POSIX PRIO_INHERIT), - le protocole de plafond de priorité (POSIX PRIO_PROTECT).

RTAI RTAI (Real-Time Application Interface) La solution RTAI : RTAI présente les spécifications d un OS temps réel industriel. RTAI est un patch pour le noyau Linux qui permet de rendre ce dernier totalement préemptible. RTAI considère Linux comme une tâche de fond s exécutant lorsqu aucune activité temps réel n est présente RTAI repose sur le concept RTHAL.

RTAI RTAI (Real-Time Application Interface) Origine et historique : Concept d une couche d abstraction temps réel (RTHAL) née en 1996 à Milan au sein d une équipe du DIAPM dirigée par Paolo Mantegazza Concept implanté en 1998 (noyau Linux 2.2) Depuis son introduction, RTAI a acquis le soutien d une multitude de passionnés, scientifiques, personnels de l industrie. RTAI bénéficie du support d un revendeur commercial de Linux temps réel : Zentropix. - R2D2, - RTDesigner.

RTAI Architecture : RTAI (Real-Time Application Interface)

RTAI Implémentation : RTAI (Real-Time Application Interface)

RTAI RTAI (Real-Time Application Interface) La structure RTHAL :

RTAI RTAI (Real-Time Application Interface) Avantages du concept RTHAL : Les changements apportés au noyau Linux standard sont minimaux : - faible intrusion, - amélioration de la maintenance du code, - rapide adaptation aux nouvelles versions du noyau Linux. Les extensions temps réel peuvent aisément être supprimées en reroutant les pointeurs des fonctions d interruption vers les routines Linux d origine. Inconvénients du concept RTHAL : Le noyau Linux souffre un peu de pertes de performances du fait des détournements à travers les pointeurs, vers les fonctions de masquage et démasquage des interruptions.

RTAI RTAI (Real-Time Application Interface) L ordonnanceur RTAI : UP : - environnements monoprocesseur exclusivement, - basé sur le chip 8254, - ordonnancement one-shot ou périodique, - compatible 486. SMP : - environnements multiprocesseurs, - basé sur le chip 8254 ou bien sur un timer LOCAL APIC, - ordonnancement single one-shot ou périodique, - les tâches peuvent s exécuter de façon symétrique sur un ou plusieurs clusters de CPUs ou se confiner sur un seul CPU. MUP :- environnements multiprocesseurs exclusivement, - basé sur timer LOCAL APIC (ordonnancement hétérogène possible) - une tâche doit être confinée à un seul CPU,

RTAI RTAI (Real-Time Application Interface) La modularité du concept : rtai : rtai_sched : rtai_fifos : rtai_shm : lxrt : rtai_trace : tracer :

RTAI RTAI (Real-Time Application Interface) Les performances : Temps de changement de contexte (SCT) : 4 µs Temps de réponse à une interruption : 20 µs Positionnement sur le marché : VxWorks (SCT) : entre 2 µs et 4 µs QNX (SCT) : garanti 2 µs WinCE (SCT) : 32 µs

Programmation sous RTAI Organisation structurelle d un programme (1) Squelette d un programme sous RTAI : Inclusions de librairies Définitions générales Déclarations des identificateurs de tâches Code des fonctions des différentes tâches Fonction de lancement du processus temps réel Fonction d arrêt du processus temps réel

Programmation sous RTAI Organisation structurelle d un programme (2) Inclusions de librairies (exemple) : include <linux/module.h> include <asm/io.h> include <rtai.h> include <rtai_fifos.h> include <rtai_sched.h>...

Programmation sous RTAI Organisation structurelle d un programme (3) Définitions générales (exemple) : #define RT_STACK_SIZE 2000 #define RT_PRIORITY 0 #define NO_FPU 0 #define FPU 1 #define TIMERTICKS 500000 #define ONE_SHOT...

Programmation sous RTAI Organisation structurelle d un programme (4) Déclarations des identificateurs de tâches (exemple) : static RT_TASK tidhorloge static RT_TASK tidcapteur static RT_TASK tidactionneur static RT_TASK tidcontrole static RT_TASK tidcommande...

Programmation sous RTAI Organisation structurelle d un programme (5) Code des fonctions des différentes tâches (exemple) : static void CodeCapteur(int t) { float erreur; while(1) { if (erreur>2.50) outb(reg_canal,baseport);... } }

Programmation sous RTAI Organisation structurelle d un programme (6) Fonction de lancement du processus temps réel (exemple) : int init_module(void) { rt_task_init(&tidhorloge, CodeHorloge, 0, RT_STACK_SIZE, RT_PRIORITY, NO_FPU, 0);... rt_task_resume(&tidhorloge);... return 0 }

Programmation sous RTAI Organisation structurelle d un programme (7) Fonction d arrêt du processus temps réel (exemple) : void cleanup_module(void) { rt_task_delete(&tidhorloge); rt_task_delete(&tidcontrole); rt_task_delete(&tidcommande); rt_task_delete(&tidcapteur);... }

Programmation sous RTAI Programmation de tâches temps réel (1) La priorité des tâches RT_HIGHEST_PRIORITY = WATCHDOG_PRIORITY RT_LOWEST_PRIORITY RT_LINUX_PRIORITY rt_change_prio : change la priorité initiale de la tâche temps réel rt_get_prio : retourne la priorité initiale de la tâche temps réel rt_get_inher_prio : retourne la priorité de la tâche temps réel héritée d autres tâches bloquées sur une ressource possédée par cette tâche

Programmation sous RTAI Programmation de tâches temps réel (2) Programmation de tâches apériodiques et/ou sporadiques : rt_task_init : crée et initialise une nouvelle tâche temps réel rt_task_suspend : suspend une tâche temps réel rt_task_yield : cède la main à l ordonnanceur rt_task_resume : réveille une tâche temps réel rt_task_delete : détruit une tâche temps réel

Programmation sous RTAI Programmation de tâches temps réel (3) Programmation de tâches périodiques : rt_task_init : crée et initialise une nouvelle tâche temps réel rt_task_make_periodic : rend une tâche périodique rt_task_wait_period : rend la main jusqu à la période suivante rt_task_delete : détruit une tâche temps réel

Programmation sous RTAI Programmation de tâches temps réel (4) Le démarrage d une tâche apériodique et/ou sporadique : int rt_task_init ( RT_TASK *task, void (*rt_thread) (int), int data, int stack_size, int priority, int uses_fpu, void (*signal) (void) ); int rt_task_resume (RT_TASK *task);

Programmation sous RTAI Programmation de tâches temps réel (5) Le démarrage d une tâche périodique : int rt_task_init ( RT_TASK *task, void (*rt_thread) (int), int data,... ); int rt_task_make_periodic ( RT_TASK *task, RTIME start_time, RTIME period );

Programmation sous RTAI Programmation de tâches temps réel (6) La gestion du timer start_rt_timer() : démarre le timer stop_rt_timer() : stoppe le timer rt_get_time() : renvoie le temps courant rt_sleep() : endort la tâche pendant un temps t (attente passive) rt_busy_sleep() : endort la tâche pendant un temps t (attente active) Note: nécessité d utiliser de la fonction nano2count() pour démarrer le timer!

Programmation sous RTAI Programmation de tâches temps réel (7) Le choix de l ordonnanceur : UP : Uni-Processor SMP : Symetrical Multi-Processor MUP : Multi Uni-Processor rt_set_oneshot_mode() : sélectionne le mode «one-shot» rt_set_periodic_mode() : sélectionne le mode «périodique»

Programmation sous RTAI Programmation de tâches temps réel (8) Le choix de la politique d ordonnancement : RT_SCHED_FIFO : politique par défaut RT_SCHED_RR : Round Robin RMS : Rate Monotonic Scheduling Note: informations détaillées dans le fichier rtai/readme.sched_policy

Programmation sous RTAI Communication entre tâches et processus (1) Mécanismes natifs à RTAI : Les sémaphores Les boîtes aux lettres (BALs) Les FIFOs temps réel La mémoire partagée

Programmation sous RTAI Communication entre tâches et processus (2) Les sémaphores : rt_sem_init : initialise un sémaphore compteur rt_sem_delete : détruit un sémaphore rt_sem_signal : envoie un sémaphore rt_sem_wait : attend un sémaphore rt_sem_wait_if : la tâche appelée ne doit pas être bloquée rt_sem_wait_until, rt_sem_wait_timed : versions temporisées

Programmation sous RTAI Communication entre tâches et processus (3) Les boîtes aux lettres (BALs) : rt_mbx_init : initialise une boîte aux lettres rt_mbx_delete : détruit une boîte aux lettres rt_mbx_send : envoie un message sans conditions (bloquant) rt_mbx_receive : reçoit un message sans conditions rt_mbx_send_wp, rt_mbx_receive_wp rt_mbx_send_if, rt_mbx_receive_if rt_mbx_send_until/timed, rt_mbx_receive_until/timed

Programmation sous RTAI Communication entre tâches et processus (5) Les FIFOs temps réel : Communication entre les tâches RTAI et les processus Linux rtf_create : crée une FIFO temps réel rtf_destroy : ferme une FIFO temps réel rtf_put : écrit des données dans une FIFO temps réel rtf_get : lit des données dans une FIFO temps réel rtf_resize : redéfinit la taille d une FIFO temps réel rtf_create_handler : installe un pointeur sur une fonction qui sera exécutée lors de l accès à la FIFO temps réel (lecture/écriture)

Programmation sous RTAI Communication entre tâches et processus (6) Les FIFOs temps réel : synchronisation avec sémaphores rtf_sem_init rtf_sem_wait rtf_sem_trywait rtf_sem_timed_wait rtf_sem_post rtf_sem_destroy

Programmation sous RTAI Communication entre tâches et processus (7) Les FIFOs temps réel : multiples écrivains et lecteurs rtf_read_all_at_once rtf_read_timed rtf_write_timed rtf_suspend_timed

Programmation sous RTAI Communication entre tâches et processus (8) Les FIFOs temps réel : fonctions auxiliaires Des versions de printk sécurisées pour le temps réel : - rt_printk : écrit une donnée dans un tampon lisible par la commande Linux dmesg - rt_print_to_screen : affiche une donnée à l écran

Programmation sous RTAI Communication entre tâches et processus (9) La mémoire partagée : Mécanisme plus complexe à utiliser que les FIFOs Exclusion mutuelle entre Linux et les tâches RTAI non garantie 2 implantations différentes : - shmem : version propre à RTAI, développée par Paolo Mantegazza - mbuff : version développée par Tomasz Motlewski (version indépendante de RTAI)

Programmation sous RTAI Communication entre tâches et processus (10) La mémoire partagée : Utilisation dans l espace utilisateur (user space) : - adr = rtai_malloc(name, size); - adr = rtai_malloc_adr(start_address, name, size); - rtai_free(name, adr); Utilisation dans l espace noyau (kernel space) : - adr = rtai_kmalloc(name, size); - rtai_kfree(name);

Programmation sous RTAI Fonctions avancées (1) La gestion globale des interruptions : rt_global_cli : masque les interruptions rt_global_sti : démasque les interruptions rt_global_save_flags : sauvegarde les registres CPU rt_global_restore_flags : restaure les registres CPU rt_request_global_irq : installe une routine de service d interruption rt_free_global_irq : désinstalle une routine de service d interruption

Programmation sous RTAI Fonctions avancées (2) LXRT (LinuX Real-Time) : LXRT permet d exécuter des tâches temps réel depuis l espace utilisateur Ces tâches s exécutent avec les mécanismes de protection mémoire de Linux Les tâches peuvent être débuggées en mode Linux puis transférées dans l espace noyau Les utilisateurs NON root peuvent créer des tâches temps réel include "rtai_lxrt.h"... # insmod lxrt

Programmation sous RTAI Programmation temps réel dans une API standard Les extensions POSIX : Fonctionnalités implémentées sous RTAI

LTT Comprendre le comportement d un système temps réel Les besoins des développeurs de systèmes temps réel : 3 niveaux de détails sont nécessaires pour comprendre le comportement et les dynamiques associées à un système temps réel embarqué : - le niveau matériel, - le niveau système, - le niveau application. L outil de visualisation doit pouvoir : - décrire la séquence des événements clés qui se sont produits sur une période précise du temps, - présenter des statistiques relatives au système.

LTT Linux Trace Toolkit (1) Présentation : LTT est un outil de visualisation développée par la société Opersys LTT permet d effectuer des mesures de performances temporelles (pourcentage de temps CPU, durée d exécution, etc.). Les événements capturés par LTT peuvent être des changements de contexte, des interruptions matérielles ou logicielles ou bien des accès disques. LTT réalise une trace en-ligne et une reconstruction hors-ligne du comportement dynamique du noyau Linux/RTAI.

LTT Linux Trace Toolkit (2) Architecture combinée à RTAI :

LTT Linux Trace Toolkit (3) Traçage des événements RTAI :

LTT Linux Trace Toolkit (4) Présentation de l interface logicielle :

LTT Linux Trace Toolkit (5) Analyse détaillée des données (1/2) :

LTT Linux Trace Toolkit (6) Analyse détaillée des données (2/2) :

LTT Linux Trace Toolkit (7) Utilisation : Capture d une trace - utilisation du script trace : #/!bin/sh TraceDaemon/TraceDaemon ts$1 /dev/tracer $2.trace $2.proc Lecture d une trace - utilisation du script traceview : #/!bin/sh TraceToolkit/TraceToolkit g /dev/tracer $1.trace $1.proc &

Une introduction aux makefiles Les Makefiles : généralités (1) Règles de compilation : Une règle de compilation lie un fichier source, un fichier cible et une méthode compilation. Cette liaison s écrit de la manière suivante : FichierCible : FichierSource1 FichierSource2 (TABULATION) gcc [paramètres] o $@ $< Définition d une règle globale : all : FichierCible1 FichierCible2 Définition d une règle clean : clean : (TABULATION) rm f *.o

Une introduction aux makefiles Les Makefiles : généralités (2) L utilisation de variables : Une déclaration de variable se fait par une ligne du type : NomVariable = ValeurVariable L accès à la valeur d une variable s effectue comme suit : $(NomVariable) L inclusion de fichiers : Ceci permet de partager des variables à plusieurs Makefiles : include NomFichier

Une introduction aux makefiles Les Makefiles : cas d une application RTAI (1) Fichier rules.make : INCLUDE = -I/usr/src/rtai/include -I/usr/src/linux/include PARAM = -O2 -c DEFINE = -DMODULE -D KERNEL -DCONFIG_DYN_MM -DCPU=686 Note: on se place dans le cas d une application non-lxrt sur un CPU 686

Une introduction aux makefiles Les Makefiles : cas d une application RTAI (2) Fichier Makefile : include./rules.make all: NomFichierCible1.o NomFichierCible2.o NomFichierCible1.o : NomFichierSource1 NomFichierSource2 gcc $(PARAM) $(INCLUDE) $(DEFINE) -o $@ $< NomFichierCible2.o : NomFichierSource1 NomFichierSource2 gcc $(PARAM) $(INCLUDE) $(DEFINE) -o $@ $< clean : rm -f *.o

Une introduction aux makefiles Exécution et traçage par script (1) Lancement de l application (fichier run ) : #!/bin/sh sync insmod /usr/src/rtai/modules/rtai_trace insmod /usr/src/rtai/rtai insmod /usr/src/rtai/modules/rtai_fifos insmod /usr/src/rtai/modules/rtai_sched insmod tracer insmod monappli if![[ $1 == "" ]]; then./trace $1 file fi

Une introduction aux makefiles Exécution et traçage par script (2) Arrêt de l application (fichier rem ) : rmmod monappli rmmod rtai_sched rmmod rtai_fifos rmmod rtai rmmod tracer rmmod rtai_trace

Plan du cours Introduction Caractéristiques des OS Temps Réel Linux pour les OS TRE : stratégies et solutions RTAI Programmation sous RTAI LTT Une introduction aux makefiles TPs Méthodologie de création d un système Linux embarqué Le logiciel libre* Dossier de presse sur Linux Temps Réel Conclusion * d après le «Rapport du groupe de travail RNTL sur le Logiciel Libre» du 14 novembre 2001

Création d un Linux embarqué Différentes méthodes de construction Distribution standard Utilisation d une distribution GNU/Linux du commerce Pb : espace disque conséquent (minimum 100Mo) LFS : Linux From Scratch Construction du système GNU/Linux en se basant uniquement sur les sources des programmes Investissement important LFS à base de distribution standard Construction du système en se basant sur les applications d une distribution standard

Création d un Linux embarqué Structure de Linux (1) Généralités Un système Linux est composé de 3 parties : -le noyau (kernel) -la libc, bibliothèque principale pour les applications -les applications (ou commandes) Séquence de démarrage Elle est toujours la même : - chargement du système par LILO - chargement du noyau Linux - lancement du programme d initialisation /sbin/init - exploration du fichier /etc/inittab contenant le chemin d accès au script de démarrage final du système

Création d un Linux embarqué Structure de Linux (2) Répertoires principaux /bin : principales commandes utilisateur /boot : noyaux et chargeurs du système /dev : pseudo-fichiers des pilotes (devices) /etc : fichiers de configuration /lib : bibliothèques partagées et modules /mnt : points de montages /opt : applications externes /sbin : principales commandes système /tmp : fichiers temporaires /usr : hiérarchie secondaire /var : données variables

Création d un Linux embarqué Construction du système de base Formatage de la partition Création des répertoires Création des nœuds sur /dev Remplissage de /bin et /sbin Création des bibliothèques sur /lib Remplissage du répertoire /etc Configuration du noyau Compilation du noyau Installation du noyau

Plan du cours Introduction Caractéristiques des OS Temps Réel Linux pour les OS TRE : stratégies et solutions RTAI Programmation sous RTAI LTT Une introduction aux makefiles TPs Méthodologie de création d un système Linux embarqué Le logiciel libre* Dossier de presse sur Linux Temps Réel Conclusion * d après le «Rapport du groupe de travail RNTL sur le Logiciel Libre» du 14 novembre 2001

Le logiciel libre Origine du concept : Le concept de logiciel libre (1) Le concept du Logiciel Libre (LL) est né il y a une vingtaine d années dans les centres de recherche académiques En Septembre 2001, le nombre de LL était estimé à 11 000 par une enquête IDC («Les différents Modèles économiques du Logiciel Libre» : étude réalisée sur l initiative du secrétaire d Etat à l industrie) De son côté, le RNTL mène une politique de soutien aux Logiciels Libres

Le logiciel libre Le concept de logiciel libre (2) Définition du concept (1/2) : L expression «logiciel libre» fait référence à 4 types de libertés : 1) la liberté d exécuter le programme, sans restriction de temps, de lieu, de motif et de personne, 2) la liberté d étudier le fonctionnement du programme et de l adapter à ses besoins, 3) la liberté de redistribuer des copies, 4) la liberté d améliorer le programme et de diffuser les améliorations. Note: les libertés 2 et 4 supposent la disponibilité du code source

Le logiciel libre Définition du concept (2/2) : Le concept de logiciel libre (3) Les logiciels libres sont des logiciels gratuits mais attention, tous les logiciels gratuits ne sont pas libres - logiciel gratuit : logiciel dont le contrat de licence ne prévoit pas de contrepartie financière de l utilisateur. La gratuité peut être définitive, ou valable pour une période donnée, ou assortie de limitations de fonctions (logiciels de démonstration, par exemple) Les logiciels libres peuvent être intégrés à une offre payante de service (ex : assistance) ou de produit (ex: CD-ROM)

Le logiciel libre Les différentes communautés (1) La communauté académique : Point de vue de la communauté académique: - le programme est écrit pour prouver une théorie ou démontrer une faisabilité. Difficultés rencontrées : - la diffusion du programme au sein même de l équipe de chercheurs, - la maintenance des programmes (objets de recherche) et des logiciels (objets de transfert).

Le logiciel libre Les différentes communautés (2) La communauté industrielle : Point de vue de la communauté industrielle : - les industriels doivent tirer un avantage compétitif de leur engagement dans le développement d un logiciel libre. Apports du LL pour l entreprise : - raccourcissement du délai de transfert du logiciel du monde de la recherche vers celui de l industrie (= transfert rapide d innovations), - le fait d investir en «amont» sur certains logiciels, peut permettre de diminuer les coûts en «aval».

Le logiciel libre Les différentes communautés (3) La communauté des développeurs : La motivation première d un développeur bénévole est que le logiciel réponde à ses besoins. Les bénéfices de contribution : - le développeur prend plaisir aux tâches de développement ainsi qu à la compréhension des codes sources, - le fait de publier des sources (de haute qualité) lui permet de se faire reconnaître par ses pairs.

Le logiciel libre Les différentes communautés (4) La communauté des utilisateurs : Les bénéfices d utilisation d un LL : - le logiciel est gratuit (sauf offres intégrées), - le logiciel est adaptable aux besoins d utilisation, - le logiciel possède une qualité intrinsèque de part son statut de LL, - le modèle d assistance est rapide et gratuit, - la réponse aux problèmes rencontrés est fiable.

Le logiciel libre Le modèle économique du logiciel libre Un logiciel produit de haute qualité : Le logiciel doit être de qualité technique suffisante pour répondre, même partiellement, à un réel besoin partagé par d autres utilisateurs. Les bugs sont sans cesse «traqués» et corrigés. De cette façon, le délai entre 2 versions d un logiciel libre (open-source) est nettement réduit comparé à celui d un logiciel exclusif (proprietary software). Le logiciel dispose d un modèle d assistance qui ne cesse de s enrichir. La durabilité du modèle : La pérennité des logiciels libres repose sur leur associations avec des organisations dans lesquelles des entreprises jouent un rôle important.

Le logiciel libre Le modèle d assistance (1) Les «FAQs»: Ce sont des pages Web qui recensent les questions les plus fréquemment posées ainsi que leurs réponses. Ces pages sont gérées par une personne ou par un groupe de contributeurs identifiés. La fréquence de mise à jour des pages varie selon le logiciel libre considéré (en moyenne quelques fois par an).

Le logiciel libre Le modèle d assistance (2) Les «Tips&Tricks» : Ils reposent sur le même principe que les «FAQs», Ils listent, en plus, des conseils relatifs à l installation et à l utilisation du logiciel. Les «Newsgroups» : Ce sont des forums sur le Web, Ils constituent une version dynamiques de «FAQs». Avant d envoyer son message, il convient de vérifier dans les «FAQs», que le problème n a pas été traité auparavant.

Le logiciel libre Les différentes associations (1) La FSF (Free Software Foundation) : Association sans but lucratif fondée aux Etats-Unis en 1985 pour promouvoir le développement et l usage du logiciel libre. La FSF a développé 2 licences de LL : - la licence GPL, - la licence LGPL. http://www.fsf.org

Le logiciel libre Les différentes associations (2) L OSI (Open Source Initiative) : Association sans but lucratif créée en 1998, qui se consacre à préciser la définition du logiciel libre (qu elle désigne sous le nom d open source), et à promouvoir le développement des LL conformes à sa définition. Elle évalue les licences, détermine leur caractère libre et leur accorde ou non un label de certification (OSI Certified). A ce jour, 26 licences ont obtenu ce label : GPL, LGPL, BSD, MIT, Artistic, MPL,QPL, IBM PL, Ricoh SCPL, Python, zlib/libpng, Apache, Vovida, SISSL, Intel OSL, Jabber OSL, Nokia OSL, Sleepycat, Nethack GPL, Common Public Licence, Apple PSL.

Le logiciel libre Quelques exemples de succès de LL (1) Le serveur Apache : Apache a été développé en 1995 par un collectif d ingénieurs système. Apache est un serveur http configurable et performant en matière d hébergement Web Apache est aujourd hui le serveur web le plus utilisé http://www.apache.org

Le logiciel libre Quelques exemples de succès de LL (2) ecos (embedded Configurable operating system) : ecos est un système d exploitation temps réel embarqué «open-source» Il a été développé avec le soutien de grands producteurs de microélectronique américains et japonais. Les architectures supportées sont les suivantes : ARM, NEC V8xx, SuperH, PowerPC, Intel x86, MIPS, Matsushita AM3x. Ses droits sont couverts par la Red Hat ecos Public License v1.1 (RHEPL).

Le logiciel libre Quelques exemples de succès de LL (3) Linux : promotion individuelle Linus Torvald, étudiant, recherchait pour son PC un système d exploitation performant de type Unix, sans pouvoir se payer la version commerciale ; il décide alors de l écrire lui-même en partant de Minix. Quelques mois après la parution du projet, ce sont déjà plusieurs centaines d utilisateurs de par le monde qui contribuent au projet. Linux a permis à Linus Torvald d obtenir un poste particulièrement intéressant dans la société Transmeta.

Le logiciel libre Mandrake : Quelques exemples de succès de LL (4) Mandrake est l une des 4 grandes distributions Linux dans le monde. Une caractéristique forte de Mandrake est d être entièrement libre. Mandrake possède sa propre marque et gère de façon exclusive l ensemble des bases de données liées à sa communauté. L accès à l information, à la fois en termes de services, de produits dérivés, d assistance et de formation reste contrôlé par Mandrake

Plan du cours Introduction Caractéristiques des OS Temps Réel Linux pour les OS TRE : stratégies et solutions RTAI Programmation sous RTAI LTT Une introduction aux makefiles TPs Le logiciel libre Dossier de presse sur Linux Temps Réel TDs Conclusion

Conclusion Conclusion Entrevoir le futur Quelles seront les solutions temps réel embarquées de demain? Quel avenir pour ce nouveau modèle économique basé sur l approche «open-source» de Linux? La réponse est dans l expression du marché de demain