STR AN2012

Premiers pas

Les informations d'identification sont:

utilisateur: root passwd: mot de vide

L'image bénéficie également du soutien du réseau en utilisant 'NAT'. Cela signifie que les machines virtuelles peuvent communiquer entre eux et le réseau extérieur. Cependant seules les machines du réseau local, et non à partir du réseau extérieur peuvent se connecter à la machine virtuelle.

Accès à distance

de trouver l'adresse ip de l'OS en cours d'exécution de type VMware:

/sbin/ifconfig

les deux prochains services sont lancés:

1. serveur ssh: ssh root @ <ip-address> Avec ce serveur, vous pouvez vous connecter à un shell distant sur le système d'exploitation s'exécutant dans vmware. Dans ce shell, vous pouvez éditer les fichiers avec les éditeurs de texte tels que joe / nano / vim.

2. serveur samba: Ce serveur exporte le système de fichiers racine que networkshare pour les fenêtres. Sur les ordinateurs Linux et Macintosh, vous pouvez accéder à ce partage en allant à l'emplacement réseau:

smb://<ip-address>/root user: root passwd :<empty password>

Sous Windows, vous pouvez accéder à ce partage en tapant ce qui suit dans la barre d'adresse de l'explorateur:

\\<ip-address>\root user: root passwd :<empty password>

Fixer le temps et la date

Vous pouvez demander l'heure et la date de la machine virtuelle avec la commande suivante:

date

1

STR AN2012

Lorsque vous faites une pause de la machine virtuelle, il peut arriver que, lorsque la machine est reprise beaucoup plus tard, les réglages de la date et l'heure ne sont pas coorectes. Une solution rapide. Vous pouvez synchroniser l'heure facilement avec un serveur de temps avec la commande suivante:

Rdate -s time.nist.gov

ou

ntpdate time.nist.gov

note: pour ntpdate fonctionne, vous devez d'abord faire ce qui suit

apt-get update apt-get install ntpdate tzconfig # set timezone to Europe\Paris instead of America\NewYork

Modifier la langue

Langue par défaut:

dpkg-reconfigure locales

Modification du clavier:

dpkg-reconfigure console-data

Remote access

Pour trouver l’adresse IP :

/sbin/ifconfig

Utiliser le service ssh pour accede au serveur avec des clients comme putty

Serveur samba

1. Linux :

smb://<ip-address>/root user: root passwd :<empty password>

2. windows :

\\<ip-address>\root user: root passwd :<empty password>

Des fichiers sources pour les TP sont sous le repertoire /root/labsUtiliser putty pour une meilleure utilisation

2

STR AN2012

Linux Temps Réel (Xenomai)

TP n ° 1: Les Bases de la Real-Time Linux

Real-Time Linux Introduction

Linux est un système d'exploitation libre de type Unix qui fonctionne sur une variété de plates-formes, y compris les PC. De nombreuses distributions Linux telles que Red Hat, Debian et Mandrake regrouper le système d'exploitation Linux avec des outils, des logiciels de productivité, jeux, etc

L'ordonnanceur de Linux, comme celle de d'autres OS tels que Windows ou MacOS, est conçu pour la meilleure réponse moyenne, de sorte qu'il se sent rapide et interactif, même lors de l'exécution de nombreux programmes.

o Toutefois, elle ne garantit pas que toute tâche particulière soit toujours exécutée dans un délai optimal. Une tâche peut être suspendu pour un temps arbitrairement long.

o L’ordonnancement équitable des tâches est des garanties par les systèmes d'exploitation temps réel (RTOS), tels que QNX, VxWorks ou LynxOS. RTOS sont généralement utilisés pour le contrôle ou les applications de communications, et non pas pour l'informatique à usage général.

Linux a été adapté pour supporter le temps réel. De nombreuses versions de RT Linux sont disponibles, libre ou commercial. Trois

couramment disponibles en libre accès RT versions de Linux sont o RTLinux, développé par New Mexico Tech et maintenu par Wind River Systems . o RTAI, l'interface d'application en temps réel (RTAI), développé par l'Université

polytechnique de Milan et disponible à https://www.rtai.org/~~V . o Xenomai, une spin-off de RTAI Linux. Alors que RTAI est axé sur les plus bas temps de

latence est techniquement possible, Xenomai considère également une extensibilité propre aux RTOS, la portabilité et la maintenabilité comme des objectifs très importants. Il est disponible à www.xenomai.org .

Ces systèmes Linux RT sont des correctifs apportés au code source du noyau Linux de base. Les instructions pour construire un système Linux RT partir d'un code de la source de Linux sont fournies avec ces systèmes Linux RT. En bref, il s'agit de mettre en place le système de base Linux, obtenir le dernier le code source du noyau Linux à partir www.kernel.org , patcher le code source du noyau, et la compilation du noyau patché.

Objectifs

Ce qui suit sont les principaux objectifs de cet exercice:

Pour apprendre comment Xenomai fonctionne et de construire une tâche temps réel Xenomai.

3

STR AN2012

Comment fonctionne RT Linux travail?

L'idée générale de la RT Linux, c'est que d'un petit noyau temps réel, s’exécute sous Linux, ce qui signifie que le noyau en temps réel a une priorité plus élevée que le noyau Linux. En temps réel les tâches sont exécutées par le noyau temps-réel, et celle de Linux normales sont autorisées à s'exécuter quand les tâches temps réel ne sont pas exécutés. Linux peut être considéré comme la tâche d'inactivité de l'ordonnanceur temps réel. Comme le noyau temps réel a une priorité plus élevée, un processus normal de Linux est préempté quand une tâche temps réel devient prêt à fonctionner et la tâche temps réel est exécuté immédiatement.

Comment est le noyau temps réel a une priorité plus élevée que le noyau Linux?

Fondamentalement, un système d'exploitation est entraîné par interruptions, ce qui peut être considéré comme des battements de cœur d'un ordinateur:

Tous les programmes en cours d'exécution dans un système d'exploitation sont superviser par un ordonnanceur qui leurs alloue des quantums du temps CPU.

Un programme en cours d'exécution peut bloquer ou volontaire abandonner la CPU. Dans ce cas l’ordonnanceur est informé à l'aide d'une interruption logicielle (appel système).

Le matériel peut générer des interruptions pour interrompre le fonctionnement normal du système d'exploitation pour une manipulation rapide du matériel.

RT Linux utilise le flux d'interruptions pour donner le noyau temps réel une priorité plus élevée que le noyau Linux:

Quand une interruption arrive, elle est d'abord donnée au noyau temps réel. Les interruptions destinées à l’OS classique sont stockées et elles ne sont envoyées que si l’RTOS termine ses tâches.

En premier lieu, le noyau temps réel capable d'exécuter ses tâches en temps réel entraînées par ces interruptions.

Ce n'est que lorsque le noyau en temps réel ne fonctionne pas, les interruptions qui ont été stockées sont passées sur le noyau Linux.

En deuxième lieu, Linux peut ordonnancer ses propres processus entraînés par ces interruptions.

Par conséquent, quand un programme normal Linux s'exécute et une interruption arrive :

il est d'abord traité par un gestionnaire d'interruption définie par le noyau temps réel; le code dans le gestionnaire d'interruption réveille une tâche temps réel; immédiatement après le gestionnaire d'interruption, l'ordonnanceur temps réel est appelé; l'ordonnanceur temps réel observe qu'une autre tâche temps réel est prête à s’exécuter, il

met le noyau Linux attente, et se réveille la tâche temps réel.

Ainsi, pour le noyau temps réel et le noyau Linux cohabitent sur une seule machine d'une manière spéciale de passer des interruptions entre noyau temps réel et le noyau Linux est

4

STR AN2012

nécessaire. Chaque distribution de Linux RT implémente ce mécanisme à sa manière propre. Xenomai utilise un pipeline d'interruption de l’Adeos projet.

RT Linux Tâches ne sont pas des programmes Linux

Une tâche temps réel peut être exécutée dans l'espace noyau à l'aide d'un module du noyau, mais aussi elle peut également être exécutée dans l'espace utilisateur à l'aide d'un programme C.

L’exécution dans l'espace utilisateur au lieu de dans l'espace noyau donne un peu de surcharge supplémentaire, mais avec les avantages suivants:

o Un bug dans un module du noyau peut faire planter tout le système, mais d'un bug dans un programme de l'espace utilisateur ne peut faire planter le programme.

o Dans un modèle à noyau, on ne peut utiliser les API temps réel et les API limitées du noyau. Mais dans un programme temps réel de l'espace utilisateur temps réel peut utiliser l'ensemble de Linux API. Cependant lors de l'utilisation des API Linux dans l'espace utilisateur, le programme ne peut pas être géré par l'ordonnanceur temps réel (HARD en temps réel), mais doit être géré par l'ordonnanceur de Linux ( SOFT en temps réel).

Xenomai

Le projet Xenomai a été lancé en Août 2001. Xenomai est basé sur un noyau abstrait RTOS, utilisable pour construire tout type de

interfaces temps réel, sur un noyau qui exporte un ensemble de RTOS générique services. Xenomai permet d'exécuter en temps réel des threads soit strictement dans l'espace noyau,

ou dans l'espace d'adressage d'un processus Linux. Une tâche temps réel dans l'espace utilisateur bénéfice de la protection de la mémoire, mais elle est ordonnancée par Xenomai directement, et non plus par le noyau Linux. Le temps de latence d'ordonnancement le plus lent des cas de ce type de tâche est toujours à proximité des limites matérielles et prévisibles, car Xenomai n'est pas lié à la synchronisation avec l'activité du noyau Linux dans un tel contexte, et peut anticiper toute activité régulière Linux sans retard. Par conséquent, l’environnement préférable d'exécution pour les applications Xenomai est l'espace utilisateur.

Xenomai API

Dans le tp, nous allons exécuter des tâches temps réel dans l'espace utilisateur, car travailler avec eux est plus facile.

Les API Natives Xenomai sont flexibles et bien documentées. Les caractéristiques les plus importantes des API Xenomai sont:

o Indépendance du contexte

Les API Natives Xenomai fournissent les mêmes services temps réel d'une manière transparente pour l'application, indépendamment de leur mode d'exécution qui est le mode utilisateur ou le mode noyau.

o Topologie transparente

5

STR AN2012

Les objets Xenomai (p. ex. Un sémaphore, tâches, etc ..) sont toujours joignables, même lorsque l'emplacement de l'objet est un autre espace.

À cette fin, chaque catégorie de service de l’API natif Xenomai définit un type de descripteur uniforme pour représenter les objets qu'elle gère. Par exemple, une tâche sera toujours représenté par un descripteur de RT_TASK, une file de messages par un descripteur RT_QUEUE, et un sémaphore par un RT_ SEM Descripteur, indépendamment de l'espace d'exécution à partir de laquelle ils sont utilisés. Xenomai utilise un registre unifié, à l'index de chaque descripteur d'objet sous un nom symbolique donné par l'utilisateur. En faisant cela, Xenomai vous permet de récupérer n'importe quel descripteur associé à un objet enregistré dans n'importe quel endroit de votre demande.

Voir Native API Tour pour plus d'informations sur les API native Xenomai.

C : le langage de programmation

Linux est écrit dans le langage de programmation C, de même pour Xenomai. C est le langage préféré pour l'écriture des programmes RT Linux.

Autres langage (par exemple, C + +) peuvent être utilisés. Les programmes C sont compilés en programmes exécutables complet. En C, le point d'entré d'un programme est une fonction appelée main () . Chaque tâche en temps réel est associée à une fonction C qui est appelée lorsque la tâche est

planifiée pour s'exécuter.

Création d'une tâche

Lorsque vous créez une tâche temps réel Xenomai, la structure RT_TASK est utilisé comme descripteur de référer pour cette tâche.

Une structure de données RT_TASK est utilisé pour contenir toutes les informations sur une tâche:

o la fonction à exécuter par la tâche temps réel, o argument, o la taille de la pile alloué pour ses variables, o sa priorité, o si elle utilise des calculs en virgule flottante, o et un «gestionnaire de signal" qui sera appelée lorsque la tâche devient actif.

La tâche est créée en appelant

int rt_task_create (RT_TASK *task, const char *name, int stack_size, int priority, int mode)

o « task » est un pointeur vers une structure de type RT_TASK qui doit avoir été déclarée avant et dont la structure est remplie.

o « name » est une chaîne de caractères ASCII pour le nom symbolique de la tâche. Ce nom symbolique, peut être utilisé pour récupérer la structure des tâches n'importe où dans le code en appelant rt_task_ bind( ) la fonction.

o « stack_size » est la taille de la pile pour être utilisé par la nouvelle tâche.

6

STR AN2012

o «priority» est la priorité de la tâche. La priorité la plus élevée est de 99, tandis que la plus basse est de 1.

o «mode» est un ensemble de flag qui affectent la tâche: T_ FPU permet à la tâche d'utiliser le FPU (Floating Point Unit) à chaque fois

disponible sur la plate-forme. Ce drapeau est forcé pour les tâches de l'espace utilisateur.

T_SUSP provoque la tâche de démarrer en mode suspendu. Dans un tel cas, le thread doit être explicitement repris à la rt_task_ resume( ).

T_ CPU (CPUID) précise la nouvelle tâche à exécuter avec l’id cpuid. L’identifiants varie de 0 à RTHAL_NR_CPUS - 1 (inclus).

T_JOINABLE (espace utilisateur seulement) permet à une autre tâche d'attendre à la fin de la nouvelle tâche. Cela implique que rt_task_ join () est appelé pour cette tâche pour libérer les ressources allouées de l'espace utilisateur.

Démarrage d'une tâche

Une tâche peut être démarrée en appelant:

int rt_task_start (RT_TASK *task, void(*task_func)(void *arg), void *arg)

o « task » est un pointeur sur une structure de type RT_TASK qui doit être déjà initialisé par un appel à rt_task_create () .

o « task_function » est la fonction de la tâche à exécuter. o « arg » est un argument pointeur de type void donnée à la fonction de tâche.

Si vous avez déjà défini T_SUSP comme un flag de mode rt_task_ create () , la tâche sera lancée dans un mode suspendu. Dans ce cas, vous devez explicitement de reprendre la tâche avec rt_task_resume (). Sinon, la tâche temps réel est prêt à exécuter immédiatement.

Bonjour tout le monde

Le code C « ex01.c » illustre la création et le début d'une tâche demo qui écrit un message.

#include <stdio.h>

#include <signal.h>

#include <unistd.h>

#include <sys/mman.h>

#include <native/task.h>

#include <native/timer.h>

7

STR AN2012

#include <rtdk.h>

RT_TASK demo_task;

void demo(void *arg)

{

RT_TASK *curtask;

RT_TASK_INFO curtaskinfo;

// hello world

rt_printf("Hello World!\n");

// inquire current task

curtask=rt_task_self();

rt_task_inquire(curtask,&curtaskinfo);

// print task name

rt_printf("Task name : %s \n", curtaskinfo.name);

}

int main(int argc, char* argv[])

{

char str[10] ;

// Perform auto-init of rt_print buffers if the task doesn't do so

rt_print_auto_init(1);

// Lock memory : avoid memory swapping for this program

mlockall(MCL_CURRENT|MCL_FUTURE);

rt_printf("start task\n");

8

STR AN2012

/*

* Arguments: &task,

* name,

* stack size (0=default),

* priority,

* mode (FPU, start suspended, ...)

*/

sprintf(str,"hello");

rt_task_create(&demo_task, str, 0, 50, 0);

/*

* Arguments: &task,

* task function,

* function argument

*/

rt_task_start(&demo_task, &demo, 0);

}

Dans le programme ci-dessus, la mémoire est verrouillée en appelant

mlockall ( MCL _CURRENT | MCL _FUTURE);

de sorte qu'il ne peut pas être échangé sur le disque. Prévenir échange est indispensable quand les performances d’un RTOS doivent être atteintes. Par conséquent, Xenomai génère un avertissement lorsque cela est oublié quand son API est appelée.

La bibliothèque rdtk impression temps réel

Notez que dans le code ci-dessus, nous avons utilisé rt_ printf () au lieu de la commande printf (). Nous n'avons pas utilisé printf (), car il utilise les appels système Linux et par conséquent ralentit terriblement le thread temps réel. Au lieu de cela, nous utilisons rt_printf à partir de la bibliothèque impression temps réel rdtk. elle est intégrée dans la partie espace utilisateur Xenomai, mais elle ne

9

STR AN2012

dépend pas des services Xenomai. Elle utilise uniquement l’API POSIX. Le librtprint API ressemble beaucoup à printf:

rt_vfprintf rt_vprintf rt_fprintf rt_printf

Pour démarrer le thread de sortie non-RT il faut appeler le code suivant au début d'un programme Xenomai:

rt_print_auto_ init (1);

Cette auto-init initialise le buffer de rt_print et de démarrer le thread de sortie non-RT.

Compiler un programme de Xenomai

Pour compiler le programme ci-dessus, il faut d'abord obtenir les CFLAGS et LDFLAGS en exécutant

> xeno-config --xeno-cflags

et

> xeno-config --xeno-ldflags

Pour définir ces flags, utilisez

> export CFLAGS=`xeno-config --xeno-cflags`

et

> export LDFLAGS=`xeno-config --xeno-ldflags`

Enfin, compiler le programme ex01.c avec la bibliothèque native implémentant l’API Xenomai et la bibliothèque 'rtdk' print library

> gcc $CFLAGS $LDFLAGS -lnative -lrtdk ex01.c -o ex01

Par défaut 'ex01' est lié avec les bibliothèques dynamiques dans /usr/xenomai/lib. Nous devons d'abord indiquer à Linux où les trouver à l’aide de la variable d'environnement LD_LIBRARY_PATH :

> export LD_LIBRARY_PATH=/usr/xenomai/lib

Puis exécuter le programme:

>. / Ex01

10

STR AN2012

Exercices

Exercice 1a.

Compilez et exécutez le programme ex01.c pour se familiariser avec la manipulation des tâches Xenomai.

Tout d'abord, essayer un build manuel en compilant avec les commandes ci-dessus.

Ensuite, essayez un Makefile (en utilisant les commandes "make" et ". / ex01").

Exercice 1b.

Introduire une erreur en commentant la cession à la tâche en cours comme suit:

/ / curtask = rt_task_self ();

Enregistrez le programme qui en résulte que ex01b.c Construire et exécuter ce programme, observez le résultat.

Ensuite introduire une valeur de retour pour le « rt_task_inquire » appeler et afficher le code.

err = rt_task_start(&task,&task_body,NULL);

if (err)

{

fprintf(stderr,"failed to start task, code %d\n",err);

return 0;

}

Construire et exécuter la nouvelle version du programme.

11

STR AN2012

Linux Temps Réel (Xenomai)

TP n ° 2: Ordonnancement et communication inter-processus (IPC)

1 Mesure de la performance d’un système temps réel : la gigue

Un système temps réel doit être temporellement déterministe. La gigue (jitter en anglais) est la fluctuation de ce temps de réaction. Idéalement, celle-ci est nulle. Dans la pratique, un système temps réel performant présente une gigue dont la valeur est faible (<100 us) et surtout bornée (pour le éterminisme). On se propose de mesurer la gigue sur la période d’une tâche définie périodique sous Linux (temps réel mou) et Xenomai (temps réel dur).1.1 Gigue sous Xenomai1. Dans le répertoire gigue_xenomai, étudier le code du fichier periodic.c avec la documentation POSIX skin/Clocks et Thread management.2. Compiler avec make et exécuter le programme avec ./periodic. Quelle est la résolution de l’horloge MONOTONIC dans Xenomai ?

On notera que le temps système est renvoyé sous la forme de 2 champs dans une structure timespec : tv_sec pour la partie en secondes et tv_nsec< 109 pour la partie en nanosecondes du temps courant.3. Constater que la tache (thread) périodique n’a pas le temps de s’exécuter. Pourquoi, sachant que le fin du main implique la fermeture du processus ?4. Décommenter alors la ligne \\pthread_join(). Rechercher l’utilité de cette fonction. Pourquoi l’exécution du programme ne se finit alors jamais ?Utiliser la combinaison de touche ctrl-c (envoie du signal SIG INT à la tâche) pour demander au système l’INTerruption/fermeture du programme.5. Commenter la ligne mlockall(...); dans le main. Recompiler avec make et exécuter. Est-il cohérent que Xenomai contrairement à Linux refuse l’exécution sans l’instruction mlockall ?6. On veut mesurer précisément la borne inférieure (avance maximale > 0) et la borne supérieure (retard maximale > 0) de la gigue : l’écart entre la période de la tâche et la période demandée.Utiliser les 2 variables max_advance et max_delay pour stocker l’écart maximal rencontré au cours de l’exécution. On affichera à chaque période de l’exécution la valeur actuelle de ces 2 variables.7. Tester et stresser le système pour observer l’évolution de la gigue : ouvrir Firefox, passer de l’interface graphqiue (ctl-alt-F7) `a la console (ctr-alt-F2), ...Conclure sur la gigue de Xenomai.

1.2 Gigue sous Linux1. Dans le répertoire gigue_linux, ouvrir le fichier periodic.c. Constater qu’il est très semblable au fichier précédent. Exécuter et noter la résolution de l’horloge MONOTONIC sous Linux.

12

STR AN2012

2. Ajouter dans le code le calcul de la gigue.Exécuter et stresser le système d’exploitation.3. Entre le noyau Linux utilisé (temps réel mou et faible latence) et le Noyau Xenomai (temps réel dur) lequel est le plus déterministe temporellement ?

2 IPC : Synchronisation entre tâches

L’exécution parallèle de plusieurs tâches (en temps partagé, ou simultané si plusieurs CPUs) pose des problèmes de synchronisation pour l’accès concurrent à un périphérique ou un emplacement mémoire.

2.1 Analyse d’un problème d’accès concurrent1. Dans le répertoire synchro_frigo1, examiner, compiler et exécuter le programme pthread_race.Quel problème survient avec le partage de la variable commune refrigerator ? Est-ce dû a la présence de 2 tâches ? Commenter la création d’une des deux tâches pour vérification.

2. L’erreur survient de manière sporadique. On cherche l’enchaînement spécifique de commutation de tâches à la source du problème par l’ajout :(a) d’instructions du type fprintf(stderr,"1"); , fprintf(stderr,"2"); , ... avant et après chaque instruction contenue dans les boucles while(1) pour suivre via l’affichage la séquence d’exécution des instructions des 2 tâches.(b) d’une instruction fprintf(stderr,"\n"); comme dernière instruction de la boucle while(1) pour la lisibilité.(c) de l’instruction exit(0); après l’affichage de “Dad : damned who stole my candy !” pour quitter le programme dès l’apparition de l’erreur. On inclura <stdlib.h> si nécessaire.

3. Exécuter et interpréter la séquence d’exécutions responsable du problème d’accès concurrent.

13