linux temps reel et embarqu´ e´ -...

Systemes temps reel et Systemes embarquesLinux temps reel et embarque

Loıc Cuvillon

Ecole Nationale Superieure de Physique de Strasbourg

29 novembre 2015

Loıc Cuvillon (ENSPS) Systemes temps reel et Systemes embarques Annee scolaire 2013-2014 1 / 125

Plan

Plan

1 Linux Operating SystemLinux KernelLinux Driver Model

2 Compilation of userland applications and libraryCompilation and libraries

3 Le temps reelOrdonnancement preemptif

4 Programmation Muli-taches (Posix/Xenomai)Les threadsIPC : mutex, semaphore, pipes, signauxLe temps

5 Linux XenomaiLinux n’est pas temps reelArchitecture de Xenomai


Bibliographie

Bibliographie

Le noyau Linux

Understanding the Linux kernel, 3eme Edition, D.P. Bovet et M. Cesati,O’Reilly.Linux Kernel Development, 2eme Edition, Robert Love, Novell Press.Linux Device Drivers, Jonathan Corbet, Alessandro Rubini, and GregKroah-Hartman,O’Reilly

Le temps reel :

Real-time concepts for embedded systems, Q. Li, CMP Books.Xenomai documentation

Documents de cours et Annales :

http ://eavr.u-strasbg.fr/wiki/index.php/ENSPS 3A et master ISTI


Linux Operating System

Plan








Operating System

Operating system

a collection of software that provideservices and abstraction of thehardware to multiple user programs

enable multi-tasking, multi-user

share CPU, memory,... for processes

enable inter-processes communicationHardware

Operating System

User Application



Operating System Features

2. Memory

− memory allocation

− virtual memory

Management

Drivers

1. ProcessManagement

− process creation/

CPU time−sharing− scheduling/

destruction

Device System3. File and

− open / close− read / write

Keyboard Mouse ScreenHard−driveCPU

6. System Call Handling

GCC Internet Browser Shell

libc

system calls

management

− Timers / Alarms− System Time

5. Time

Hardware abstraction

OS

/ker

nel S

pace

Hardware

User Space

OS

Communication4. Inter−Process

− Message queues/ Shared memory

Networking− Socket/

− Synchronization



Process scheduling

scheduler(odonnanceur) select the process to run at one time

CPU time-sharing for multi-tasking

3 states for a process : ready, running, blocked

vlc

gedit

−read()−sleep()−sem_wait()− ...

ssh gcc bash xterm

CPU timeline

CPU

Ready Tasks Pool Blocked Tasks Pool

Running Task

blocking function

return of the

Scheduler :periodically selectthe task to run

If call to a blocking function:



Scheduling

Ordonnancement disponible sous Linux

SCHED OTHER : ordonnanceur equitable (default)

augmentation de la priorite des taches qui ont eu peu de temps CPU niveaude ”nice” pour favoriser des taches

SCHED FIFO : ordonnanceur TR a priorite fixe (need to be root user)

taches utilisant cet ordonnanceur sont prioritaires sur les tachesSCHED OTHERsi priorite identique la premiere dans la file est entierement executee

SCHED RR : equivalent a SCHED FIFO

mais une tache interrompue est remise en bout de sa file de priorite



Linux Process/Task scheduling

Running Task

CPU

The Rule: Task with highest level run first.

99 98 2 1...

T3

T4 T5

RT Tasks (SCHED_FIFO/RR) (SCHED_OTHER)

Priority level

T1

0

T7

T6

T9

T8

T2

scheduler

Ready RT Tasks Pool

Inside Priority level 0 only,

tasks have a nice level.



POSIX system calls

ONLY way to ask the OS a service :open file sys_open, write on screen sys_write, memory allocation..

each OS syscall has its corresponding function in the libc :open(), write()

call notification to the OS through interruption (INT 0X80)

R7 Name Linux Source R0 R1 R2

1 sys exit kernel/exit.c int

2 sys fork kernel/process.c struct pt regs

4 sys write fs/read write.c unsigned int const char * size t

5 sys open fs/open.c const char * int int

11 sys execve kernel/process.c struct pt regs

15 sys chmod fs/open.c const char * mode t

23 sys setuid kernel/sys.c uid t

...

37 sys kill kernel/signal.c int int

39 sys mkdir fs/namei.c const char * int

78 sys gettimeofday kernel/time.c struct timeval * struct timezone *

...



System call

The “Hello World !”

.data

HelloWorldString:

.ascii "Hello World\n"

.text

.globl _start

_start:

# Load all the arguments for write ()

mov r7, #4

mov r0, #1

ldr r1,=HelloWorldString

mov r2, #12

swi #0

# Need to exit the program

mov r7, #1

mov r0, #0

swi #0



System call

The “Hello World !”as hello.S -o hello.o

ls hello.o -o hello

strace ./hello :strace enable to track system call and signals of the process



System Call

R7 5R0 @filenameR1 1

IR SWI 0x00

int fd=

open(filename,

O_RDONLY);

1

libc

fopen(filename,FILE *F=

"w"

return fd

User Space

SWI 0x00

−call syscall function

−retrieve syscall number

−rise CPU privilege

sys_open

−retrieve parameters

−check parameters

−retrieve process userID

−browse file system

−return file descriptor *fd* number via R0

−check file permission

−lower CPU privilege

OS (Kernel) Space

user process


Linux Operating System Linux Kernel

Linux Kernel

Linux Kernel

the Kernel :software providing all OS functionality

kernel monolithic, 1 binary file

but parts of kernel can be unload/load :the modules

written in C, open-source

version 0.01 in 1991 by Linus Torvald

Process scheduling

Process communication

Memory management

File Systems

Network stack

Syscalls

DriversModule 1

Module 2

Module 3

Linux Kernel



Kernel compilation

$> cp linux−3.8/arch/x86/boot.bzimage /boot

5. Kernel installation on PC plateform

make installor $> update−grub (update bootloader (amorçage))

linux−3.8.tar.gz

1. Download Kernel source from kernel.org in /usr/src

2. Kernel configuration in linux−3.8/ folder

$> make menuconfig

3. Compilation of kernel and modules

$> make

4. Module installation$> make modules_install

Menu to select kernel core features,optionnal features as static code or module

Create compress kernel image (bzimage) and module objects *.ko

Create /lib/modules/3.8.0 and copy *.ko in it



Kernel compilation

Kernel configuration

save and load in the .config file

features can be set has [] not include , [*] include in kernel imageor [M] compiled as a module

correct configuration not easy(base .config files available at www.kernel-seeds.org)

Modules

kernel object (*.ko) can be load/unload on demand

used for drivers, file system support, optional features

avoid to compile again the kernel if one driver missing

useful for development-debug



Module Manipulation

vga_fb

Linux Kernel1. list of loaded modules

2. load/unload modules

> rmmod vga_fb

soundcore

soundcore

vga_fb

bluetooth

> lsmod

> insmod /lib/.../bluetooth.ko

Exercise : unload and load the Ethernet card driver



Kernel Module Programming

in Kernel Programming

in kernel programming → C language

only kernel API (printk, kalloc) → no libc (user-space) : no printf, fopen

dynamic linking with Kernel procedure at insertion of module

User SpaceUser Space

libc

User API

library function call

system call

Kernel function call

Kernel Task

time

libc

Kernel API

Kernel Space

time

Kernel Space

User task



Kernel Module Programming

API function : printk()

print message in kernel ring buffer (in RAM since kernel can not fopen)

availability of printk() in kernel can be checked in /proc/kallsyms

otherwise error message : Undefined symbol at loading

printk("hello!");

[43.0] ACPI: error[52.6] usb−2: new dev[54.3] hello!

root@pc: dmesg

To visualize ring buffer in terminal:

RAM memory

[43.0] ACPI: error[52.6] usb−2: new dev[54.3] hello!3.

printk("hello!");

1.1.> insmod ./hello.ko

2. Dynamic Linking at insertion

3. Execution printk

drivers

...register_c

kalloc:

printk:

2.

Linux Kernelkernel procedure:

...IPC

Scheduler



Module programming

no main() function

one called at insertion : init_module() or module_init(*func)

one called at removal : cleanup_module() or module_exit(*func)

other functions have to be called through the 2 previous ones

#include <linux/init.h>

#include <linux/module.h>

#include <linux/kernel.h>

MODULE_LICENSE("GPL");

int init_module (void)

{ printk("Hello world!\n"); return 0;

}

void cleanup_module(void)

{ printk("Bye! \n");}



Module compilation

Module Compilation

Kernel source tree is needed (kernel headers and .config)

for hello.c module, this makefile is used and then command make :

obj-M := hello.o

all:

make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

Exercise : compilation and test of the previous hello.c module


Linux Operating System Linux Driver Model

Device drivers

Device files

each device accessed by a specialfile called ’device file’ in /dev

→ open, read, write syscalls can beused to access devices

device file associated with a driver

read Mouse device

open(/dev/input/mice)and read it

or cat /dev/input/mice

Hw

Devices

User Application

system call

/dev/cdrom

Kernel S

pace

Virtual file system

User S

pace

/dev/mice /dev/sda

driver A driver B driver C



Device drivers

Inside the driver

write one function for each fileoperation :

fops={

.open=device_open,

.write=device_write,

.read=device_read

};

int device_open()

{...}

copy_from_user() : to copyin the kernel data from a userside write()

copy_to_user() : to copykernel data to the user side

read (fd, )write(fd, ) close(fd)fd=open("

.openfunction

.writefunction

.readfunction

.releasefunction

Hardware device

User Application

/dev/newdriver

driver functions

Virtual file system

Kernel



Device Files

Create a device filemknod name device_type major minor

Exemple : mknod /dev/newdriver c 60 0

the major number is the unique ID of the associated kernel driver.(numbers list in kernel /Documentation/devices.txt)

crw− r−− −−− 1 root root 13, 63 janv 23 19:42 /dev/input/mice

group’s member rights

owner rights (r=read,w=write,x=execute)

> ls −l /dev/input/mice

Device type:c, for character device (data transmitted one byte at a time) b, for block device (hard disks, data transmitted one block of data at a time)

users groupowner

other users rights

Minor number: to identify devices using same drivers

Major number: ID of associated driver



Char Device driver

Exemple : char device driver with .open operation

#include <linux/kernel.h><linux/module.h><linux/fs.h><asm/uaccess.h><asm/io.h>

static int device_open(struct inode *, struct file *);

static int Major=60;

static struct file_operations fops = {

.open = device_open

};

static int device_open(struct inode *inode, struct file *file)

{

printk("open\n");

return 0;

}

int init_module(void)

{ int Res;

Res = register_chrdev(Major, "newdriver", &fops); /*enregistre le pilote*/

return 0; }

void cleanup_module(void)

{ unregister_chrdev(Major, "newdriver"); }



Char device driver

Char device driverregister_chrdev(Major, "newdriver", &fops) :to register a major number for the driver and its file operation.

driver linked to device files with the same major number

Exercise :

create a special device file with a major number 60.

give all users rights to read/write on the device file :chmod o+rx device name

load previous driver

test opening with a small C program or with the shell command :echo -n 1 > device name



Char device driver

addition of .write operation to the previous driver

char my_data[1];

ssize_t device_write(struct file *filep,const char *buff,size_t count,

loff_t *offp );

static struct file_operations fops = {

.write = device_write,

.open = device_open

};

ssize_t device_write(struct file *filep,const char *buff,size_t count,

loff_t *offp )

{

/*function to copy user space buffer to kernel space*/

if ( copy_from_user(my_data,buff,1) != 0 )

{ printk( "Userspace -> kernel copy failed!\n" );

return 0; }

printk("int: %i",my_data[0]);

return 1;

}


Compilation of userland applications and library

Plan







Compilation of userland applications and library Compilation and libraries

Compilation of userland applications in C

main:ldr r1, abl printfadd r0,#1

EF 0003 1C10 32C4 00

libc.a

libm.a03 92

1C BF libjpeg.a

EF 0003 1C10 32C4 00

84 68

objet

executable (ELF)

gcc −lm −ljpg

ld −lm −ljpg

cpp file.c −o file.i

gcc −E file.c −o file.i

file.s file.o

#include < >int main(){

int a;/*comment*/

int main()

int scanf(, ,)int printf(, ,)

{int a;

file.ifile.c

gcc −S gcc −c

assembly

1-The preprocessor (cpp)

gcc -E file.c -o file.i ou cpp file.c -o file.i

to include files, remove comments, expend #define




EF 0003 1C10 32C4 00

libc.a

libm.a03 92

1C BF libjpeg.a

EF 0003 1C10 32C4 00

84 68

objet

executable (ELF)

gcc −lm −ljpg

ld −lm −ljpg

file.o

gcc −c

file.c

int a;/*comment*/

{int main()#include < >

gcc −E

file.i file.s

int printf(, ,)int scanf(, ,)

int main(){int a;


gcc −S file.i −o file.s

assembly

2-The compilator (gcc or cc)

gcc -S file.i -o file.s

to translate C langage in assembly langage




libc.a

libm.a03 92

1C BF libjpeg.a

EF 0003 1C10 32C4 00

84 68

executable (ELF)

gcc −lm −ljpg

ld −lm −ljpg

file.c

int a;/*comment*/


gcc −E

file.s



int main()

int a;{

file.i

EF 0003 1C10 32C4 00

file.o

gcc −S

gcc −c file.s −o file.oas file.s −o file.o

assembly objet

3-The assembler (as)

gcc -c file.s -o file.o ou as file.s -o file.o

to translate assembly in binary machine langage




gcc −lm −ljpg

file.c

int a;/*comment*/


gcc −E


int main()

int a;{

file.i

EF 0003 1C10 32C4 00

file.o

gcc −S

objet

ld −lm −ljpg


file.s

assembly

as

84 68EF 0003 1C10 32C4 00

03 92

1C BF

libc.a

libm.a

libjpeg.a

executable (ELF)

4-The linker options (ld)

-l[libname] with library name without the ’lib’ prefix of the filename.Exemple : -lm for math library libm.so .

-L[path] to give library location. Ex : -L. for current directory.



le format ELF

ELF (Executable and Linking Format)

conteneur des fichiers objets, executables etbibliotheques.

utilise par Linux, Wii, PS3,...

la table des sections :donne la position dans le fichier ELF des diversessections (.text (code), .data, .symbols, ...)

la table de programme :indique ou charger en memoire les sections avantexecution

ELF Header

Section HeaderTable

(othersections)

.rodata

.text

.data

Programm HeaderTable



le format ELF et relocation

utilitaires du format elfobjdump [-option] [file]

-f : affiche l’entete ELF du fichier

-h : affiche la table des sections-t : affiche la table des symboles

-r : affiche la table de relogement

-d : desassemble le code de la section .text-D : desassemble toute les sections

nm [file]

liste les symboles du fichier et leur etat (Undefined, Text(fonction definie),Data definie)



les differents fichiers objets

Fichier objet relogeable : .o

1 table de symboles : noms des fonctions et variables globalesSi le symbole est defini, l’offset a partir du debut de la section ou setrouve sa definition (code pour une fonction, valeur pour une variable).

1 table de relogement : offsets ou apparaissent chaque symbole nondefini dans le fichier.

un fichier adapte au relogement :

les 2 tables permettent facilement de remplacer les symboles non definiepar leur definition quand celle-ci est connue.



Fichier objet relogeable .o

analyse du fichier objet : objdump -t -r -D hello.o

0000000a0000001a

10=0x0a

OFFSET TYPE VALUE

R_386_PC32R_386_32 a

printf

Disassembly of section .text:extern int a;

00 00 00 00 <main>:

1: ....

e: ....9: a1 00 00 00 00 mov ?, %eax

0: 55 push %epb

Offset

Undefined00000000 *UND* 00000000 00000000 *UND* 00000000

aprintf

00000000 g .text 00000020 main

section name

void main()

{ printf("Hello world %i!",a); }

hello.c hello.o

SYMBOL TABLE:

RELOCATION RECORDS FOR [.text]:

19: e8 fc ff ff ff call 1a <main+0x1a>



Fichier objet relogeable .o

analyse du fichier objet : objdump -t -r -D def.o

Disassembly of section .data:0:aa 00 00 00

00000000g .data 00000000 aSYMBOL TABLE:

RELOCATION RECORDS: empty

def.c def.o

int a=0xaa;



Edition de lien et affectation d’adresse memoire

gcc hello.o def.o -o hello : fusion sectionset affectation d’adresses memoires effectives aux symboles

20 a0 04 08 8048425: a1 mov ,%eax0x804a020

hello.o

def.o

hello

Disassembly of section .text:

8048322: ...

804841c <main>:

804841d: ...

804842a: ...

8048320 <start_>:

804841c: 55 push %ebp

8048320: 31 ed xor %ebp,%ebp

80482f0b6 fe ff ff(@ via un offset)804843a: ...

Disassembly of section .data:

SYMBOL TABLE :

804a020: aa 00 00 00 <a>

(optional, can be removed with cmd strip)

8048435: e8 call <printf@plt>

ELF HEADER:

NO RELOCATION RECORDS

start address 0x08048320Loıc Cuvillon (ENSPS) Systemes temps reel et Systemes embarques Annee scolaire 2013-2014 38 / 125


Les bibliotheques

bibliotheque statique .a

code de la librairie copie dansl’executable

executable sans dependance

lourde empreinte disque etmemoire

bibliotheque dynamique .so

edition de liens a l’execution

pas de duplication de code

empreinte memoire legere

dependance : bibliothequeinstallee ?

Hello world ! avec la lib C

gcc –statichello.c -o hello

ls -l hello : 564 Ko

gcc hello.c -o hello

ls -l hello : 7 Ko

ldd ./hello :(liste dependances)libc.so.6

ld-linux.so.2



Les bibliotheques dynamiques et statiques

bibliotheques statiques .a bibliotheques dynamiques .so

add.o

linker linker

Executables

printf.o

fopen.o...

libc.a

x x

xadd: x

xmain: x

printf: x

main: x x

xprintf: x

source.o source2.o

printf.o

fopen.o...

add.o

printf.o

fopen.o...

libc.so

linker linker

main: xmain: x

add: x x

x

xprintf:−

printf:−libc.so(en mémoire)

dynamic linker (ld−linux.so)loader (execv) loader (execv)

dynamic linker

partially linked executables

full executable in memory

source.o source2.o



Static library creation (.a)

EF 0003 1C

C4 0010 32

EE A003 1CEF 0023 D2

84 68

file2.o

ar −q libmylib.a file1.o file2.o

libmylib.a

file1.o

EE A003 1C

84 68

Static library .a

lib prefix must be added to the library filename.Example : for mylib library, libmylib.a

Compilation

use of link options : -l and -L

Example : gcc [sources.c,.o] -lmylib -L. -o [exe]



Dynamic library creation (.so)

EF 0003 1C

C4 0010 32

EF 0003 1C

C4 0010 32

file2.o

file1.o

EE A003 1CEF 0023 D2

84 68

file2.c

file1.cgcc −shared file1.o file2.o −o libmylib.so

gcc −fPIC −c file2.c −o file2.o

gcc −fPIC −c file1.c −o file1.o

libmylib.so

EE A003 1C

84 68EE A003 1C

84 68

2 steps creation

1 create position independant objects(-fPIC) :gcc -fPIC -c [.c] -o [.o]

2 create the mylib library : gcc -shared -o libmalib.so [.o]



Shared dynamic library installation

/etc/ld.so.conf (/etc/ld.so.conf.d/) has to be updated withthe directory containing the libraryOr

the library file has to be moved in one directory listed by/etc/ld.so.conf

run ldconfig to update the library location database by scanningdirectories listed in /etc/ld.so.conf

Linking with shared library

Example : gcc prog.c -lmylib -o prog

at running time, the ldconfig database is used by the linker to find thelibrary and load it.



Creation d’une librairie dynamique

Utilitaires

ldd : liste les librairies dynamique necessaires a un executable

nm : liste les symboles definis dans le bibliotheque

ldconfig : met a jour la liste des librairies connues en parcourant lesrepertoires definis dans /etc/ld.so.conf

ldconfig -p, affiche la liste des bibliotheques connues.



Exercice11 Creer les fichiers hello.c et def.c precedemment introduit.

2 Faire de def.c une bibliotheque statique. Compiler hello.c en la liantavec votre bibliotheque statique.

3 Faire de meme mais avec une bibliotheque dynamique.On utilisera la commande sudo -s pour passer utilisateur root etinstaller la bibliotheque dans un repertoire adequat.(Attention a ne pas ecraser une bibliotheque existante.)


Le temps reel

Plan







Le temps reel

Systeme temps reel

Systeme temps reel

Def :systeme (materiel et logiciel) qui satisfait aux contraintesfonctionnelles et temporelles qui lui sont imposees.

Temps de reponse d’un systeme :

temps entre l’apparition d’un vecteur d’entree et l’apparition du vecteurde sortie associe.

SystèmeS1

S0E0

E1

E2


Le temps reel

Systeme temps reel mou (soft real-time)

la majorite des systemes informatiques sont temps reel ”mou” :

un lecteur mp3

lecteur video (variation possible du framerate : fps)

Systemes Temps reel mou

Def : systeme devant satisfaire des echeances temporelles mais avec undegre de flexibilite, tolerance sur l’echeance.

une echeance non satisfaite :

pas de destruction du systemea une penalite relative au retard sur l’echeance


Le temps reel

Systeme temps reel dur (hard real-time)

Systeme temps reel dur

Def : systeme devant respecter des echeances avec une tolerance nulle.

utilite nulle des resultats obtenus apres echeance.

penalite elevee : panne complete du systeme + danger pour l’integritephysique du systeme ou des etres humains.

la critere entre un systeme temps reel dur et mou est la penalite en casde non-respect de l’echeance.


Le temps reel

Systeme temps reel dur (hard real-time)

Majoritairement des taches periodiques

Tache de regulation et d’asservissement d’un systeme physique.Tout retard destablise l’asservissement.(Exemple : regulation de l’altitude en mer des misiles rasants Exocet)

Tache de supervision

Applications du temps reel dur

aeronautique/spatial, automobile (ABS, Airbag. . . )

systemes militaires, medicaux (IRM)

process industriel (centrales nucleaires, robotique (evitons lesbutees !),. . . )


Le temps reel Ordonnancement preemptif

Problematique du temps reel

Simple : si 1 tache periodique

Pas de systeme d’exploitation

1 µ-controleur avec 1 tache (code) execute a chaque interruption d’unehorloge

temps reel si : Temps execution < Periode de la tache

Example : ABS, 1978



Problematique du temps reel

Complexe : multitude de taches de periodes differentes

taches de supervision, d’archivage, de l’interface graphique,d’asservissement...

→ Probleme de concurrence pour l’acces au CPU, la memoire...

→ Politique d’ordonnancement necessaire pour assurer les echeances destaches



OS temps reel

Caracteristiques

une politique d’ordonnancement ”temps reel”Resoudre la concurrence des taches pour le CPU

un temps de reponse (latence) assez court pour l’application visee

Usage

n’assure pas le respect des contraintes temps reel d’un programmequelconque !(exemple : inversion de priorite avec pathfinder (NASA))

mais donne les primitives pour y parvenirsi conception et timings valides par experience ou simulation.



Ordonnancement

Ordonnancement

appel a l’ordonnanceur (scheduler)→ choix du process a executer parmi les processus prets

En exécution

BloquéPrêt

Ordonnanceur Appel à unefonction bloquante

Retour de la fonction

bloquante



Ordonnancement preemptif

Objectif de l’ordonnanceur temps reel

faisabilite : assurer l’ordonnancement des taches et leurs echeances

implementable

le plus utilise : ordonnanceur preemptif a priorite fixe

Ordonnanceur preemptif a priorite fixe

preemption : capacite a interrompre une tache au profit d’une autre

priorite fixe : chaque tache a une priorite d’execution invariante

regle : execution de la tache de plus haute priorite non-bloquee achaque appel a l’ordonnanceur



Ordonnancement preemptif a priorite fixe

Ordonnancement RM (rate-monotonic)

etudie dans les annees 70 (Liu&Leyland) et etendu par la suite

generalisation des ordonnanceurs preemptifs a priorite fixe

hypotheses :

taches periodiques et independantes uniquementpriorite P de la tache inverse a sa periode T

A i+T iA i

Ci

t

tache i

Caracterisation d’une tache

Ai : date d’activation de la tache i(prete)

Ti : periode d’activation de latache i

Ci : duree de la tache i

Pi : priorite de la tache i



Ordonnancement RM

Condition suffisante d’ordonnancement

N taches periodiques et independantes sont ordonnancables si :

U =N∑

i=1

Ci

Ti

< N(21N − 1)

︸︷︷︸

cst. de liu & Leyland

(1)

avec

avec Pi =1

Ti

(2)

N Cst. de l&l

1 12 0.823 0.78.. ..∞ 0.69

U : taux de charge du CPU

si {cst de l&l} < U < 1 :on ne peut conclure avec ce test



Ordonnancement RM

Exemple 1

ordonnanceur execute toutes les unites de temps

occupation du CPU 81.5% ( 2550 + 30

95 )→ condition suffisante d’ordonnancabilite verifiee

i Ci Ti Pi

1 25 50 0.022 30 95 0.01

échéanceème2 échéanceème3A 1 échéance ère1A 1 A 1 A 1

A 2

A 2

0 50 150100

t

échéanceère1 échéanceème2fin

fin fin fin

fin

Tâche 2

Tâche 1



Ordonnancement RM

Exemple 2

ordonnanceur execute toutes les unites de temps

occupation du CPU → condition suffisante

poursuite de l’analyse

i Ci Ti Pi

1 25 502 30 75

A 1A 2

0 50 150100

t

Tâche 2

Tâche 1



Ordonnancement RM

Temps d’execution dans le pire cas de la tache i : Wi

soit hp(i), l’ensemble des taches de priorite superieur a la tache i

soit ⌈⌉, l’operateur plafond (entier superieur)

Wi = Ci +

N∑

j∈hp(i)

⌈Wi

Tj

⌉Cj (3)

Methode de calcul de Wi

iterative a partir de k = 0 et avec W 0i = Ci

arret si ∃k ′ tel que W k ′

i > Ti ou W k ′

i = W k ′+1i

W k+1i = Ci +

N∑

j∈hp(i)

⌈W k

i

Tj

⌉Cj (4)



Ordonnancement RM

Retour sur l’exercice 2 :

Tache 1 : (pas de tache plus prioritaire)

W 01 = C1 = 25

W 11 = C1 = W 0

1

Tache 2 : 1 tache prioritaire, hp(j) = {1}

W 02 = C2 = 30

W 12 = C2 + ⌈

W 02

T1⌉C1

= 30 + ⌈30

50⌉C1 = 30 + 1 ∗ 25 = 55

W 22 =

=



Ordonnancement RM

Conclusion

en presence d’un ordonnancement preemptif et de taches periodiquesindependantes :

RM permet d’utiliser des priorites fixes pour les tachesRM donne un critere suffisant d’ordonnancabilite

Remarques

un grand nombre de taches = 69% du CPU utilisable (Cst. de l&l)

31% restant (instants creux) utilisable pour les taches sporadiques,asynchrones

le RME (RM Etendu) peut prendre en compte des taches dependantes

des ordonnancements preemptifs a priorites variables existent : EDF

critere necessaire et suffisant U < 100%mais bien + complexe a implementer (priorites a recalculer dynamiquement)



Le modele preemptif

Piles multiplesd’éxecution

Changementde contexte

Mutex(race condition)

Inter−blocage

Inversion de priorité

Préemption

mais des inconvenients par rapport a un systeme non preemptif

changement de contexte : sauver l’etat d’un processus preempte(pile, registres CPU)

necessite de proteger une ressource par un mutex implique :

blocage possible du systemeinversion de priorite


Programmation Muli-taches (Posix/Xenomai)

Plan







Programmation Muli-taches (Posix/Xenomai) Les threads

Thread : 1 processus leger

Un processus :plusieurs fils d’execution

pour chaque fil (thread) :

1 etat des registres1 compteur ordinal

execution en parralele

legerete

meme espace d’adressage

variables globales (data)partagees entre threads

global var 2

global var1

{ var1, var2

thread1( )

...}

{ var1, var2

thread2( )

...}

Prog. counterCPU Registers

{ thread1( ) thread2( ) ...}

main( )



thread1main main thread2 thread2

Processus

thread1

timeCPU timeline



Thread : Creation et destruction

Creation d’une thread

la fonction main() est la thread initiale

une thread peut creer une nouvelle thread avecpthread_create()/rt_task_create() and rt_task_create()

Fin d’une thread

si fin d’execution de son code

si appel a la fonction pthread_exit()/rt_task_delete()

si une thread la stoppe avec pthread_cancel()/rt_task_delete()

si le processus se termine : le main() retourne.



Thread : Destruction

Attente de la fin d’une threadpthread_join()/rt_task_join() :thread appelante bloque tant que la thread indiquee n’est pas finie

eviter que le main ne se termine et detruise les threads.

thread 1

thread 2

Mainthread

pthread_create() pthread_join()

pthread_exit()



Thread : Example creation de 2 taches paralleles

/* Function as body of the thread */

void* dad_is_having_a_beer( void *ptr )

{

printf("Is my beer in the fridge?");

return NULL; }

...

int main( void )

{

pthread_t thread1, thread2; //thread descriptor

pthread_create( &thread1, NULL, dad_is_having_a_beer,

(void*) NULL );

pthread_create( &thread2, NULL, son_is_having_a_coke,

(void*) NULL );

pthread_join( thread1, NULL);

pthread_join( thread2, NULL);

return 0; }Loıc Cuvillon (ENSPS) Systemes temps reel et Systemes embarques Annee scolaire 2013-2014 68 / 125


Thread : Propriete

Attributs de creation

la politique d’ordonnancement, la taille de la pile,...

API native : en parametre de rt_task_create()

API POSIX : attributs dans une structure de type pthread_attr_t

Politique d’ordonnancement temsp reel

SCHED FIFO et SCHED RR pour du premeptif a priorite fixe (0 (prioritebasse)-99(priorite haute))

seul l’utilisateur root peut choisir un ordonnancement TR (prioritaire surtaches classiques SCHED OTHER)

pthread_setschedparam() et pthread_getschedparam()



Thread : Example ordonnancement

void* dad_is_having_a_beer( void *ptr )

{

int my_policy =SCHED_FIFO;

struct sched_param my_param;

my_param.sched_priority = 90;

if ( pthread_setschedparam( pthread_self( ),

my_policy, &my_param ) )

printf( "Unable to change scheduling parameters.\n" );

if ( !pthread_getschedparam ( pthread_self( ),

&my_policy, &my_param ) )

printf ("Thread_HP : running in mode %d %d \n",

my_policy ,my_param.sched_priority );

...

}


Programmation Muli-taches (Posix/Xenomai) IPC : mutex, semaphore, pipes, signaux

Situation de competition (race condition)

Definition

manipulation conjointe d’une meme ressource ou variable par 2 tachessans synchronisation de l’acces

Consequence : resultat non deterministe, fonction de l’ordonnancementdes processus.

Example : race.c (partage d’une variable refrigerator)



Mutex

Illustration avec une variable partagee entre 2 processus legers (threads)

if (frigo==EMPTY)

frigo=BEER;

else

frigo=EMPTY;

if (frigo == BEER)

printf("who stole my beer!");

{

}

Dad:

preemption

preemption

preemption

EMPTY

COKE

BEER

EMPTY

0.

1.

2.

3.

frigo:Etat variable

if (frigo==EMPTY)

frigo=COKE;

else

frigo=EMPTY;

if (frigo == COKE)

printf("who stole my coke!");

Son:

{

}

0.

2.

3.

1.

> who stole my coke!



Mutex

Illustration avec une variable partagee entre 2 processus legers (threads)

if (frigo==EMPTY)

frigo=BEER;

else

frigo=EMPTY;

if (frigo == BEER)


{

}

Dad:

EMPTY0.

1.

2.

3.

frigo:Etat variable

if (frigo==EMPTY)

frigo=COKE;

else

frigo=EMPTY;

if (frigo == COKE)


Son:

{

}

1.

0.

2.

preemption

BEER

EMPTY

COKE

4.

4.

3.

EMPTY

> (no message display)



l’objet Mutex (Mutual Exception)

Definition

2 etats : ouvert/libre (1), ou ferme (0)

une tache peut acquerir le mutex si il est libre : 1 → 0

si le mutex n’est pas libre, la tache bloque tant qu’il n’est pas libere

la tache ayant acquis le mutex, doit le liberer ensuite : 0 → 1

Fonction Xenomai Fonction Posix Operation

rt mutex create() pthread mutex init() creer un mutex

(toujours heritage de priorite) pthread mutexattr init() definir proprietes du mutex

rt mutex delete() pthread mutex destroy() detruire un mutex

rt mutex aquire() pthread mutex lock() acquerir un mutex

rt mutex release() pthread mutex unlock() liberer un mutex



Mutex

Usage

protection par une section critique : encadree par une acquisition etliberation d’un mutex

pour un meme mutex, seul 1 processus a la fois peut etre dans unesection critique

partagéeRessource

MutexTâche

Tâche

Tache()

{ ...

pthread\_mutex\_lock();

//lecture/ecriture sur la ressource : la section critique

pthread\_mutex\_unlock();

}



Mutex

un mutex pour prevenir l’acces simultane au frigo (race_mutex.c)

if (frigo==EMPTY)

frigo=BEER;

else

frigo=EMPTY;

if (frigo == BEER)


}

pthread_mutex_unlock(&mx);

pthread_mutex_lock(&mx);{Dad:

{

Son:

if (frigo==EMPTY)

frigo=COKE;

else

frigo=EMPTY;

if (frigo == COKE)


pthread_mutex_unlock(&mx);

pthread_mutex_lock(&mx);

}

preemption

preemption(Son bloque,Mutex deja acquis)

preemption

(Mutex libre)



Mutex

Problemes courants avec les mutexes (et semaphores)

famine : privee de la ressource monopolisee par les taches prioritaires

interblocage : taches ayant chacune une ressource voulue par une autre

inversion de priorite : execution de taches non prioritaires car la tacheprioritaire attend une ressource

Solutions possibles

interblocage :

detection du blocage par le RTOSprocedure de deblocage (liberation forcee d’une ressource)

inversion de priorite : algorithme d’heritage de priorite



Mutex

Interblocage (Deadlock)

la ressource est protegee par un mutex (exclusion mutuelle)

une chaıne de 2 taches ou plus, ou chaque tache possede une ressourcevoulue par une autre

A

Tâche Tâche

B

A 1

A 2 mutex_unlockA et B (prévu)

0 50 100

mutex_lockB

mutex_lockA

t

possédépar veut veut

possédépar

mutex_lock

t

mutex_lockBA

Inter−blocage



Mutex

Inversion de priorite

Def : situation ou des taches de basse priorite s’executent avant unetache de haute priorite du a un blocage sur une ressource

situation aggravee par les taches de priorite intermediaire

A 2

A 1

t

Priorité

0 50 100

t

150

mutex_lock

t

mutex_lock

3

mutex_unlock

mutex_lock

section critique de (comportement normal)

∆t

∆t ≤ T1



Mutex

Inversion de priorite

Def : situation ou des taches de basse priorite s’executent avant unetache de haute priorite du a un blocage sur une ressource

situation aggravee par les taches de priorite intermediaire

A 2

A 1

t

Priorité

0 50 100

t

150

mutex_lock

t

t

mutex_lock

A 4

A 3

mutex_unlock

mutex_lock

Inversion de priorité

∆t +C3 + C4



Mutex

Heritage de priorite

algorithme pour resoudre le probleme d’inversion de priorite

le plus frequemment implemente dans les RTOS(rarement implemente dans les GPOS (linux))

Principe :

liberer au plus tot la ressource qui bloque la tache prioritaire

→ si une tache A bloque sur une ressource detenue par une tache B depriorite inferieure :

1 la priorite de la tache B est elevee a celle de A2 des que la ressource est liberee, B retrouve sa priorite initiale



Mutex

Heritage de priorite

algorithme pour resoudre le probleme d’inversion de priorite

le plus frequemment implemente dans les RTOS(rarement implemente dans les GPOS (linux))

A 2

A 1

t

3

t

Priorité

0 50 100

t

150

mutex_lock

t

mutex_lock

A 4

A

mutex_unlock

mutex_lock

héritage:

initial)

∆t

(P1 = P1

P1 = P2



Mars Pathinder : un cas celebre d’inversion de priorite

Mars Pathinder

sonde avec rover (sojourner) pour exploration de la surface de Mars

“faster, better and cheaper” concept (< 150 million $)

le bug : re-initialisation de la sonde annulant les commandes en cours

cause : inversion de priorite retardant assez l’execution d’une tache pourdeclencher le watchdog de reinitilisation de la sonde



Cas d’etude : Robot a cable et tracking visuel

End−effector

IR cameras

Driving cable actuator

Robot

INCA

But: Commander les courants moteurs

pour asservir la position de l’effecteur

via la mesure de sa position par vision.

Windows PC

End−effector pose

RT Linux Xenomai PC

(via Ethernet)

VRPNserver

Trackersoftware

VR

PN

RT

clie

nt

RT

rob

otco

ntro

ller

(1 k

Hz)

(200 Hz)Bonita M3 cameras

PC

Ica

rds

Encodersvalues

currentsMotors



Cas d’etude : Robot a cable et tracking visuel

RobotINCA

rt_mutex_acquire(&mutex_b);position_b=position;rt_mutex_release(&mutex_b);

}

while (1){

position=recvfrom(sockUDP, );

tant qu’aucun paquet UDP n’est présent*/

/*recvfrom est un appel bloquant

rt_mutex_acquire(&mutex_b);bonita=position_b;rt_mutex_release(&mutex_b);

compute_cmd(commande,bonita,encoders);

send_currents(commande);

...

rt_mutex_create(&mutex_b);

int position_b;

rt_task_spawn(&task_loop, , loop, );rt_task_spawn(&task_bonita, , bonita_loop, );

Encodersvalues

End−effector pose

bonita_loop();

Motorscurrents

rt_task_set_periodic(NULL, TM_NOW,

(via Ethernet)

main():

while(1){

rt_task_wait_period(NULL);

..

}

1000000);

1kHz loop():



Semaphore

Definition

un objet partage, assimilable a un compteur, pouvant soit etre disponible(compteur ≥ 1) ou indisponible (0)

1 l’acquisition d’un semaphore decremente son compteur2 la liberation d’un semaphore incremente son compteur3 la tache bloque (passif) si le compteur est a zero lors d’une tentative

d’acquisistion

un semaphore binaire est un semaphore dont le compteur est limite a 1


rt sem create() sem init() creer un semaphorert sem delete() sem destroy() supprimer un semaphore

rt sem p() sem wait() acquerir un semaphorert sem v() sem post() liberer un semaphore

rt sem broadcast() voir objet barrier debloquer toutes les tachesen attente sur le semaphore



Semaphore

Usage

coordination de l’acces a une ressource : un compteur

synchronisation entre taches

rendez-vousbarriere de synchronisation

acces a une ressource multiple (2 canaux, 2 co-processseurs. . . )

Sémaphore(initialisé à 2)

Ressourceidentique 1

Ressource

identique 2

A 1

A 2

Tâche

Tâche

Tâche

0 50 100 150

sem_wait sem_post

sem_wait sem_post

3

A 1 sem_wait sem_post

t

Sémaphore

2 1 0 210

bloque

Priorité



Semaphores : exemple du producteur-consommateur

BufferSize = 3;

pthread_mutex_t mutex ; // access to critical section

sem_t empty, full ;

sem_init(&full,0, 0); // number of full buffer slots

sem_init (&empty, 0,BufferSize); // number of empty slots

Producer() {

int widget;

while (TRUE) { // loop forever

make_new(widget); // create a new widge

sem_wait(&empty); // decrement the empty semaphore

pthread_mutex_lock(&mutex); // enter critical section

put_item(widget); // put widget in buffer

pthread_mutex_unlock(&mutex); // leave critical section

sem_post(&full); // increment the full semaphore

}

} Loıc Cuvillon (ENSPS) Systemes temps reel et Systemes embarques Annee scolaire 2013-2014 86 / 125


Semaphores : exemple du producteur-consommateur

Consumer() {

int widget;

while (TRUE) { // loop forever

sem_wait(&full); // decrement the full semaphore

pthread_mutex_lock(&mutex); // enter critical section

remove_item(widget);// take a widget

pthread_mutex_unlock(&mutex); // leave critical section

sem_post(&empty); // increment the empty semaphore

consume_item(widget);// consume the item

}

}

Interet :

Attente passive (bloque si rien a consommer/produire)

Solution sans semaphore : des compteurs dans la section critique+ attente active



Semaphore

Synchronisation simple de taches

la tache 2 a besoin que 1 ait fait son travail prealablement

si P2 > P1, 2 redemarre des que 1 atteint le point de synchro.

cas mono-CPU

A 1

A 2

Priorité

0 50 100 150

t

sem_wait

sem_post

bloquesem_wait

sem_post

TâcheTâche



Cas d’etude : Camera pilote et traitement temps reel

Un semaphore synchronise la fin d’acquisition et le traitement. Si lecompte du semaphore est superieur a 1, des images sont perdues.

int main(){

}

rt_sem_bind(&sem_vb, "vb_sem1", );

rt_task_spawn(&task, , process_loop, );

void* process_loop()

/* copy image from kernel to user memory */

}

while(1){

rt_sem_p(&sem_vb);

/* waiting for image */

/* process image */

{

return NULL;}

{

RT_SEM sem;

int vb_int_handler(){

return RT_INTR_HANDLED;

}

rt_sem_v(&sem);

rt_intr_create(&isrDesc,"", vb_int,

vb_int_handler );

RT_INTR isrDesc;

signal fin d’acquisition

}

Vertical blank (vb)

image

processing.c

camera.kc

int init_module()

rt_sem_create(&sem,"vb_sem1",0, );

RT_SEM sem_vb;



File de messages (”queue”)

Definition

objet de communication asynchrone entre 2 taches TR

taille de la file definie a la creation (nombre max. de messages contenus)

si file pleine : impossible d’ecrire de nouveaux messages

lecture dans la file est non-bloquante, ou bloquante(tache bloquee tant qu’il n’y a pas un message)

→ synchronisation avec message


rt queue create() mq open() creer une filert queue delete() mq close() supprimer une filert queue write() mq send() envoyer un messagert queue read() mq receive() lire un message



File de messages (”queue”)

un mode message urgent et broadcast souvent disponible

MessageB

MessageB

MessageB

AMessage

MessageA

MessageB par une tâche

Lecture de A

File de message

Ecriture B

par tâche

MessageMessage

MessageA

Ecriture

Message urgent (LastIn First Out)

A

urgente C

C



File de messages

Communication avec accuse de reception

notification de reception du message a l’envoyeur

outil : file + semaphore binaire (ou une 2eme file si message de retour)

cas mono-CPU

A 1

0 50 100 150

t

A 2Tâche

Tâche

mq_receive sem_post

sem_waitmq_sent

Priorité



File de messages (”pipe”)

L’objet pipe

communication entre un processus linux (exemple : GUI) et un processusXenomai

utilise un objet RT_PIPE identifie par son numero de mineur et device


rt pipe create() open() creer une filert pipe delete() close() supprimer une filert pipe write() write envoyer un messagert pipe read() read() lire un message



File de messages (”pipe”)

rt_pipe_create (RT_PIPE*, ,0)

rt_pipe_create (RT_PIPE*, ,1)

rt_pipe_read()

rt_pipe_write()

write()

read()

open("/dev/rtp0",)

open("/dev/rtp1",)

Linux Task(ex: Interface graphique)

Realtime TaskXenomai



Memoire partagee

Definition

une zone memoire partagee par des taches

allocation faite dans un tas memoire de taille fixe reserve au demarrage→ allocation dynamique de memoire temporellement deterministe

utiliser un mutex pour un acces coherent a la memoire(race condition)

communication inter-taches : file de messages preferable (evite le mutex)


rt heap create() shm open() creer une memoire partageert heap delete() close() supprimer une memoire partageert heap alloc() nmap() allouer de la memoirert heap free() unmap() liberer de la memoire



Signaux

Generalites

kill() : delivre signal a un processus ou thread

identifie par un numero (1 a SIGRTMAX (64 sous linux) )

action par defaut a reception : fin du processus (exit())

pas d’equivalent direct sous xenomai

Quelques Signaux Usuels

Numero Sens du signal

SIGINT Interruption interactive (ctr-c au clavier)SIGKILL Signal non deroutableSIGSEGV Violation memoire(MMU)SIGALARM Expiration d’un delai (alarm(),pause)ou timerSIGCHLD Fin processus enfantSIGUSR1 Signal reserve pour les applicationsSIGRTMIN -SIGRTMAX 32 signaux temps reel libres d’utilisation



Delivrance des Signaux

Masquage des signaux

un masque definie un ensemble de signaux a considerer

SIGKILL et SIGTSTP ne peuvent etre masques

Fonctions de definition de masques

sigemptyset(sigset_t* set);

initialise un masque set sans aucun signal

sigfillset(sigset_t* set);

initialise un masque set avec tous les signaux

sigaddset(sigset_t* set, int signal);

ajoute le signal au masque set

sigdelset(sigset_t* set, int signal)

supprime le signal du masque set

int sigsmember(sigset_t* set, int signal)

teste si le signal est contenu dans le masque.




Action associee au signal

sigaction(int signal, struct sigaction *new,

struct sigaction *old);

1 le signal considere2 l’action associee definit par la structure sigaction new3 une structure old pour sauvegarde l’action anterieure ou NULL

struct sigaction { void (*sa_handler)(int) ;

sigset_t sa_mask;

unsigned long sa_flags; }

sa_handler, la fonction a executer lors de l’arrivee du signal

sa_mask, les signaux a bloquer pendant le traitement du sigaction

sa_flags, pour modifier le comportement du signal ou non (NULL)




Attente sur un signal quelconque

pause(void); bloque dans l’attente d’un signal quelconque

Attente d’un signal particulier

int sigwait(sigset_t* set, NULL);

cherche un signal en attente parmi ceux du masque set

et retourne le signal en attente selectionne

si aucun signal en attente : bloque




Exemple Capture de SIGINT (ctrl-c)

void SignalHandler( int signal_num )

{ fprintf( stderr, "Catch ctrl-c\n"); }

void main( void )

{

struct sigaction sa;

sigemptyset(&sa.sa_mask);

sa.sa_handler=SignalHandler;

sigaction ( SIGINT, &sa, NULL);

while(1) sleep(1); //while to prevent end of main

}




Blocage de signaux

bloquer les signaux delivres a un thread

sigprocmask(int methode, sigset_t *new, sigset_t*old);

avec

new, un masque de signauxmethode est :

SIG SETMASK : utiliser new comme nouveau masque pour la threadSIG BLOCK : ajouter les signaux de new au masque actuelSIG UNBLOCK : retirer les signaux de new du masque actuel

old pour y sauvegarder le masque anterieure ou non (NULL)


Programmation Muli-taches (Posix/Xenomai) Le temps

La gestion du temps Linux et skin POSIX

Mesure du temps : horloges

Resolution 1 ns, si option CONFIG_HIGH_RES_TIMERS dans le noyau

le temps (tv_sec,tv_nsec secondes) stocke dans unestruct timespec :

{ time_t tv_sec; /* seconds */

long tv_nsec; /* nanoseconds */ };

Horloges disponibles clkid t :

CLOCK_MONOTONIC, temps depuis la mise sous tension (A UTILISER)

CLOCK_REALTIME, temps depuis l’Epochmodifiable par clock_settime()

CLOCK_PROCESS_CPUTIME_ID, temps CPU consomme par le process



La gestion du temps Linux et skin POSIX

Lecture des horloges

clock_nanosleep(clockid_t,, struct timespec *res,)

thread dort res nanosecondes ou attend un signal quelconque

clock_gettime( , ) obtenir le temps ecoule

clock_getres( , ) obtenir la resolution de l’horloge

Compilation sous Linux

l’utilisation de ces fonctions necessite l’edition de lien avec librt : -librt

et les threads requierent l’inclusion de <pthread.h> et -libpthread



La gestion du temps XENOMAI

Lecture des horloges

RTIME, un long long int qui contient un temps en us

RTIME rt_timer_read ( void ) retourne le temps courant

rt_task_sleep(RTIME time)

fait dormir (bloque) la tache time us.

Voir examples



La gestion du temps

Les timers

API posix avec struct itimerspec

{ struct timespec it_interval; /*Timer period*/

struct timespec it_value; /*Initial expiration time*/};

Signaler l’expiration struct sigevent {

int sigev_notify; /* Notification method */

int sigev_signo; /* Signal d’expiration */

void (*sigev_notify_function) (union sigval); };

ou sigev_notify peut prendre les valeurs :

SIGEV_NONE : ne pas signaler, on se satisfait de timer_gettime()

SIGEV_SIGNAL : generer le signal sigev_signo pour le processusSIGEV_THREAD : cree une thread dont la fonction de depart estsigev_notify_function



La gestion du temps

Les timerstimer_create(clockid_t, struct sigevent *evp,

timer_t);

creer un timer associe a l’action evp

timer_settime(timer_t timerid, int flags,

struct itimerspec *new, NULL);

arme le timer avec les valeur de new

timer_gettime(timer_t timerid,struct itimerspec *cur)

obtenir la valeur courante du timer

timer_delete(timer_t timerid) detruire le timer.



Tache periodique

Tache periodique sous Xenomai

rt_task_set_periodic(,date,period)

/pthread_make_periodic_np()

genere un signal periodique de periode period

le premier signal est envoye a partir de l’instant date+period

rt_task_wait_period(&overrun)/pthred_wait_np()

bloque tant qu’aucun signal n’est en attenteoverrun compte le nombre de signaux (periodes) manques



Thread : tache periodique

while(1){

....}

rt_task_wait_period(&overrun)

rt_task_make_periodic( );

periodic Task A

Task A

Periodic release signal

CPU timeline

rt_task_wait_period()rt_task_wait_period()

rt_task_wait_period(&overrun)

overrun=1, code erreur −ETIMEDOUT1 signal/période perdueEchec ! (plus d’1 signal en attente)



Tache periodique

tache periodique sous Linux

pthread_make_periodic_np() n’existe pas

1 utiliser un timer lie a un descripteur de fichieret lecture bloquante read() sur ce fichier.http://www.2net.co.uk/tutorial/periodic_threads

2 programmer un timer periodiqueet attendre son signal d’expiration avec sigwait()

Voir example


Linux Xenomai

Plan







Linux Xenomai Linux n’est pas temps reel

Latence globale

En reponse a une interruption

Temps de reponse (latence)= latence d’interruption + duree dugestionnaire (ISR) + latence d’ordonnancement + duree del’ordonnanceur

Tâche enexecution

Tâcheprête

Interruption (INT)

temps

Tâchebloquée

d’interruptionLatence

ordonnanceurLatence

Odonnanceur(Scheduler)

Espacenoyau

Espaceutilisateur

d’interruptionGestionnaire

Latence globale ou temps de reponse



Latence du kernel Linux

Linux, un noyau devenu preemptif

noyau premptif : peut repondre a plusieurs appels systeme en parallele

→ creation de sections critiques pour eviter une modification concurrente(non synchronisee) sur les structures internes du noyau

Facteurs de latence d’interruption

interruption masquee dans les sections critiques du noyau Linux

Facteurs de latence d’ordonnancement

preemption (appel ordonnanceur) inactive dans les sectionscritiques du noyau Linux



La preemption dans l’espace noyau

Illustration : latence du noyau linux

reveil d’une tache de haute priorite B par une interruption

alors que l’on est dans la section critique d’un appel systeme (sys unlink)

→ latence importante

Préemption du processus A par B

AppelSystème

tempsINT

Processus A

Espace utilisateur

Espace noyau

Priorité

ISR ordonnanceur

Processus B

latence d ’ INT

Section critique de l’appel systemenon interruptible, non premptible



Motivation pour un Linux temps reel

RTOS dedies et commerciaux

Vxworks (monolithique), QNX (micro-noyau)

developpement sur une machine host par cross-compilation

Pour : performant, petite taille et fonctionnalites (debogage)

Contre : couts importants, sources majoritairement fermes, drivers acreer

GPOS libre avec extension RT

linux xenomai, RTAI

developpement direct sur le systeme possible

Pour : Open sources, gratuit, support communautaireenvironnement linux : X windows, drivers (not RT but open source)

Contre : ”You can put racing stripes on a bulldozer but it won’t go anyfaster” (RTLinux Manifesto)

→ modifications importantes du noyau pour approcher les performances desRTOS commerciaux



Solution pour rendre TR le noyau Linux

1/Modifier le noyau

rendre le noyau le plus preemptible possiblereduire le nombre de sections critiques, ajout heritage de priorite,...

le patch RT PREEMPT fait progressivement ces modifications

2/Ajouter un micro noyau temps reel

concept du ”Dual Kernel” ou co-noyau

adosser un micro-noyau temps reel a Linux

Linux Xenomai et RTAI


Linux Xenomai Architecture de Xenomai

co-noyau Xenomai

Le concept

un micro-noyau Xenomai entre le hardware et Linux

ordonnanceur temps reel specifiqueindependant des sections critiques Linux

Prioritaire sur noyau Linux

Via un tube d’interruption(INT), Xenomai recoit en priorite les INT

or les noyaux sont pilotes par les interruptions :

interuption horloge systeme : appels ordonnanceur, timersinterruptions des peripheriquesappels systeme (interruprion 0x80)



ADEOS (now i-pipe)

Le pipe d’evenement ou ”I-pipe”

disponible sous forme d’un patch du noyau

evenements dispatches successivement aux domaines a travers un tubevirtuel

l’INT capturee par Xenomai peut etre remis dans le tuyau pour Linux

Xenomaikernel kernel

Linux

andInterrupts

exceptions

I−pipe (Interrupt pipe)



Xenomai

Co-noyau Linux-Xenomai

ISR

ISR

Contrôle

masque IRQSources d’interruptions

Virtualisation d’interruptions

Migration espace utilisateurApplications TR

Domaine Linux (noyau standard)

Domaine Xenomai (co−noyau)

ordonnanceur

ordonnanceur TR Application TR

espace kernel



Compilation/Configuration de Xenomai

Patch des source du noyau Linux

patch et source de la suite Xenomai disponible sous forme d’archives(tar xf xenomai-xx.x.tbz)

script interactif pour le patch a executer a partir du repertoire source dukernel linuxsh ../xenomai-2.x.x/scripts/scripts/prepare-kernel.sh

Configuration/compilation identique au kernel linux

configuration (make menuconfig)

compilation du noyau linux-xenomai (make)

Note

les services de gestion d’interruptions ne sont pas compiles par defaut



Compilation de la suite Xenomai

La suite xenomai

a compiler dans le repertoire source de Xenomai (pour un x86) :(cd xenomai-xx.x ; ./configure –enable-x86-sep ;make ;make install)

utilitaires de test de xenomai (latency)entetes et bibliotheques pour l’API xenomai dans l’espace utilisateur(userspace), ainsi que les differents skins (API Native, POSIX, VXWORKS)documentation

installation par defaut dans /usr/xenomai



Xenomai

Tache TR dans l’espace noyau Xenomai

sous forme d’un module noyau

utile pour developper des drivers temps reel (gestion des INT)

sinon deconseille : pas de protection memoire (plantage Linux possible)

Tache TR dans l’espace utilisateur

sous forme d’une application multi-thread classique

executee par le noyau Xenomai

plusieurs API disponibles pour Xenomai (native, POSIX, VXworks...)



Xenomai

Migration des Tache TR dans l’espace utilisateur

→ permettre a une tache xenomai de faire un appel systeme Linux(ouvrir un fichier, utiliser un pilote non-RT)

si migration dans le domaine Linux (secondaire)

le noyau Linux herite de la priorite de la tache Xenomai TR migree ;Linux devient une tache TR Xenomailatence superieure pour la tache ;executee par Linux donc souffre de ses latences

Execution de la tâche Xenomai

Migration

Linux

domaineXenomai

temps

domaine

Appel système Linux

Appel API Xenomai



Xenomai

Perfomance du noyau Xenomai

distribution du temps de reponse a une interuption(Source : How fast is fast enough ? Choosing between Xenomai and Linux for

real-time applications. J H Brown)



Xenomai API

skins pour l’Interface de Programmation (API)

le noyau Xenomai fournit les services d’un RTOS generique

l’API native est une API parmi d’autres utilisant ces services

skins disponibles (POSIX, VxWorks,..) en plus de l’API Native



Xenomai API/Posix

Categories de services

gestion des taches

creer une tache avec une priorite en parametrert task create() / pthread create()

definir une thread comme periodiquert task set periodic() / pthread make periodic np()

gestion du temps et alarmes

definir une thread comme periodiquert timer read() / clock gettime()

synchronisation

creer un semaphorert sem create() / sem init()

gestion d’interruption

creer un gestionnaire d’interruption (noyau)rt intr create() / pthread intr attach np()
