INTRODUZIONE A RTAI-LINUX - LAR-DEIS Home Page · supporto al C++ (anche in kernel space per kernel...

INTRODUZIONE A RTAIINTRODUZIONE A RTAI

SISTEMI DI ELABORAZIONE E CONTROLLO MIngegneria dell'Automazione

Ing. Gianluca PalliDEIS - Università di Bologna

Tel. 051 2093903email: [email protected]

http://www-lar.deis.unibo.it/~gpalli

Gianluca Palli SISTEMI DI ELABORAZIONE E CONTROLLO M A.A. 2010/2011

2Introduzione a RTAIIntroduzione a RTAI

Progetto originale del Politecnico di Milano http://www.aero.polimi.it/~rtai/ http://www.rtai.org/

L'ambiente real time è realizzato tramite moduli kernel: ogni modulo gestisce un particolare servizio; disponibilità di diversi scheduler; possibilità di attivare e disattivare il supporto alle

applicazioni real time; modifica trasparente alle applicazioni non real time.


3Architettura di RTAIArchitettura di RTAI Si introduce un nuovo layer tra il kernel Linux e il

sistema hardware: RTHAL (Real-Time Hardware Abstraction Layer)

Permette di catturare facilmente le funzionalità del kernel (interrupts, system calls, timers) per poterle gestire in accordo a politiche real-time

Sostituisce le operazioni sulle strutture originali con operazioni su puntatori RTHAL

I puntatori RTHAL sono modificabili dinamicamente. Se RTAI non è attivo puntano alle strutture originali di Linux, se RTAI è attivo puntano alle strutture del kernel real-time

Linux non ha più il controllo sull’abilitazione/disabilitazione delle interruzioni.


4Architettura di RTAIArchitettura di RTAI RTHAL non fornisce servizi real-time: ha la sola

funzione di intercettare le chiamate al kernel Linux Le chiamate sono redirette alle strutture puntate da

RTHAL

RTAI può essere attivato e disattivato a dall'utente perchè è realizzato come un normale modulo kernel Permette di estendere dinamicamente le funzionalità del

kernel senza dover essere caricato al boot del sistema.

RTAI non attivo

Funzionamento normale di Linux

RTAI attivo

Solo funzionalità real-timepossono accedere

direttamente all’hardware

Linux è gestito come un processo a bassa priorità


5Architettura di RTAIArchitettura di RTAI

Aggiunge al kernel di Linux le primitive real time Linux (kernel+applicazioni) diventa un processo di RTAI eseguito

quando la CPU non è occupata nell'esecuzioni di processi real time ATTENZIONE!!!: Se i processi real time occupano la CPU al

100%, le applicazioni non real time risulteranno bloccate...

Le primitive originali di Linux (syscall) e gli interrupt vengono filtrati in modo da non disturbare il funzionamento del sistema real time

La programmazione avviene tramite i tools standard di Linux


6Caratteristiche di RTAICaratteristiche di RTAI Infrastruttura hard real time sia in kernel space che in user-

space (LXRT): I processi RTAI nativi eseguono in kernel mode: le API

originarie di RTAI sono utilizzabili solo da moduli kernel LXRT permette di sviluppare processi real-time usando le API

RTAI da spazio utente (si è cercato di mantenere simmetria tra le API in spazio kernel e quelle in spazio utente)

programmazione in user space più semplice; implementazione in kernel space più efficiente ma

potenzialmente più pericolosa per il sistema (in spazio kernel si può accedere liberamente alla memoria)

Funzionalità real time avanzate: supporto al C++ (anche in kernel space per kernel 2.4); supporto al calcolo in virgola mobile in kernel space possibilità di backtrace delle applicazioni real time; disponibilità di una interfaccia grafica; ...


7Tipologie di scheduler in base all'hardwareTipologie di scheduler in base all'hardware

Uniprocessor Scheduler (UP) Utilizzabile nei sistemi monoprocessore

Symmetric Multiprocessor Scheduler (SMP) In un sistema multiprocessore permette una

distribuzione di carico simmetrica. Ogni processo di default può essere assegnato a

qualsiasi processore; per ottimizzare l’esecuzione è possibile imporre l’esecuzione di un processo su una CPU o su un insieme ristretto di CPU

Multi Uniprocessor Scheduler (MUP) In un sistema multiprocessore impone ad ogni processo

l’esecuzione su una CPU stabilita al momento della sua creazione. Meno flessibile ma più efficiente di SMP


8Modalità di esecuzione dello schedulerModalità di esecuzione dello scheduler

Periodic mode Esegue lo scheduler periodicamente al termine di un

periodo prefissato: il timer viene settato una sola volta all’inizio dell’esecuzione

Il periodo dei processi deve essere multiplo esatto del periodo dello scheduler, in caso contrario il periodo dei processi è approssimato al multiplo del periodo dello scheduler più vicino (introduce un jitter di attivazione)

One-shot mode Lo scheduler viene eseguito in maniera non periodica. Il

timer deve essere settato ogni volta in base al processo più prioritario che andrà in esecuzione

Permette una gestione più flessibile delle temporizzazioni di tutti i processi a costo di un maggiore overhead dovuto alla necessità di riprogrammare il timer al termine di ogni periodo


9Politiche di SchedulingPolitiche di Scheduling

FIFO Il processo attivo a priorità più alta ottiene il controllo

della CPU fino a quando la rilascia volontariamente oppure diventa attivo un processo a priorità maggiore

Round-Robin (RR) Il processo attivo a priorità più alta ottiene il controllo

della CPU per un determinato intervallo di tempo, al termine del quale il controllo passa ad un altro processo allo stesso livello di priorità (se presente). Un processo può subire preemption da parte di un processo a priorità maggiore

RTAI integra primitive che associate alla politica FIFO permettono una semplice implementazione degli algoritmi di scheduling Rate Monotonic Priority Order ed Earliest Deadline First.


10RTAI Inter-Process Communication (IPC)RTAI Inter-Process Communication (IPC)

Real-time fifos Meccanismo di base per scambiare dati in modo

asincrono tra processi real-time e processi Linux non real-time

Shared Memory Condivide aree di memoria tra processi RT e processi

Linux Messages

Possibilità di inviare messaggi sia in maniera asincrona che sincrona (RPC) tra processi RT

Mailboxes Permettono di inviare/ricevere messaggi di qualsiasi

dimensione, ordinati per priorità o per istante di arrivo, tra processi RT e processi Linux

Semaphores Permettono di sincronizzare i processi nell’accesso a

risorse condivise evitando inversioni di priorità incontrollate


11

Una semplice applicazione: rt_hello.c

#include <sys/mman.h>

#include <rtai.h>

#include <rtai_sched.h>

#include <rtai_lxrt.h>

#include <rtai_math.h>

int main(void){

RT_TASK *maintask;

RTIME period;

int i;

float sample_time=1.0;

rt_allow_nonroot_hrt();

mlockall(MCL_CURRENT | MCL_FUTURE);

...

Inclusione degli header files

gestione della memoria

definizioni generali di RTAI

RTAI scheduler

supporto user space RT

gestione della FPU

Funzione principale

l'esecuzione del programma inizia dal main()

definizione delle variabili locali

Funzioni di accesso alle risorse

acceso alle primitive real time ad utenti generici (non root)

blocco della memoria per evitare che l'applicazione venga “swappata”

Il primo programma in ambiente RTAI Il primo programma in ambiente RTAI


12Il primo programma in ambiente RTAI Il primo programma in ambiente RTAI ...

if( !(maintask = rt_task_init_schmod( nam2num("MAINTASK"), 50, 0, 0, SCHED_FIFO, 0))) {

printf( "CANNOT INIT MAINTASK\n");

exit( -1);

}

rt_task_use_fpu(maintask,1);

rt_make_hard_real_time();

rt_set_oneshot_mode();

start_rt_timer(0);

...

Parte principale del programma:

rt_task_init... inizializzazione del task e inserimento nello scheduler

deve essere inserita in tutti i processi che accedono alle primitive real time

Alcune funzioni accessorie

accesso del task alla FPU

restrizione dell'ambiente alle sole primitive real time

Inizializzazione del timer per la gestione dello scheduler

impostazione della modalità del timer

attivazione del timer alla massima velocità


13Il primo programma in ambiente RTAI Il primo programma in ambiente RTAI ...

period=nano2count(sample_time*1E9);

rt_task_make_periodic(maintask,rt_get_time()+period, period);

for(i=0;i<10;i++){

rt_task_wait_period();

printf("Hello World at time %llu !!!\n",

rt_get_time_ns());

}

rt_task_delete(maintask);

return 0;

}

Impostazione della periodicità

conversione del periodo di campionamento in intervalli del timer di sistema

il task viene reso periodico

Chiusura dell'applicazione

cancellazione del task

uscita dal main

Ciclo principale

attesa di attivazione da parte dello scheduler

esecuzione del corpo del programma


14Compilazione di rt_hello.cCompilazione di rt_hello.c

In ambiente Linux, il compilatore più diffuso è sicuramente il gcc (GNU Compiler Collection) In realtà non si tratta di un singolo compilatore ma di una

collezione di tool per la creazione degli eseguibili Supporta molti fra i più diffusi linguaggi di programmazione (C, C+

+, Pascal, Java, Fortran, ecc...) Comando per la compilazione:

rtaiuser@rtaibox:~$ gcc rt_hello.c -o rt_hello \

-I/usr/realtime/include -L/usr/realtime/lib \ -llxrt -lpthread -static

l'opzione -I/usr/realtime/include indica al compilatore dove si trovano gli header files di RTAI

l'opzione -L/usr/realtime/lib indica al compilatore dove si trovano le librerie di RTAI

Per approfondimenti sul gcc consultare il manuale (man gcc)


15Uso di Uso di make e Makefilemake e Makefile È possibile utilizzare tool per la gestione della

compilazione quali “make“ Utile per gestire progetti di qualsiasi dimensione Utilizzato per la quasi totalità dei software opensource

(compreso il kernel di Linux!!!)

CCFLAGS = -I/usr/realtime/include

LDFLAGS = -L/usr/realtime/lib -llxrt -lpthread -static

default: rt_hello

rt_hello: rt_hello.c Makefilegcc $(CCFLAGS) $(LDFLAGS) -o rt_hello rt_hello.c

clean:rm -rf *.o rt_hello

Variabili d'ambiente

Direttive del make

Direttiva di default

Compilazione del programma

Pulizia della directory di compilazione

Per la compilazione basta lanciare il comando “make”


16Esecuzione di rt_helloEsecuzione di rt_hello

Caricamento dei moduli per la gestione dei processi realtime (realtime scheduler)root@rtaibox:~$ modprobe rtai_sched

per approfondimenti consultare i manuali (man modprobe)

per eseguire questo comando è necessario possedere i diritti di superutente

Esecuzione del programma:rtaiuser@rtaibox:~$ ./rt_hello

esaminare i messaggi del kernel con il comando dmesg verificare cosa cambia togliendo dal codice l'istruzione rt_task_make_hard_hrt();

Problema: l'istruzione printf()non è studiata per funzionare in modalità real time: il kernel segnala che non è possibile gestire questa istruzione

mantenendo il task in hard real time cambio di modalità forzato


17

Soluzione: si delegano le operazioni non real time ad un secondo processo (non real time) necessari meccanismi di comunicazione fra i due processi

uso di FIFO real time (eseguire modprobe rtai_fifos)

Il programma rt_hello.c viene modificato nel seguente modo: ...

#include <rtai_fifos.h>

#define FIFODIM 128

#define DEBUGFIFO 1

...

char buf[FIFODIM];

...

rtf_create(DEBUGFIFO,sizeof(char)*FIFODIM*10);

for(i=0;i<10;i++){

rt_task_wait_period();

sprintf(buf,”Hello World at time %lld !!!\n",

rt_get_time_ns());

rtf_put(DEBUGFIFO,buf,FIFODIM);

}

...

gestione delle comunicazioni

creazione della fifo real time per lo scambio dei messaggi fra i due processi

scrittura dei messaggi sulla fifo

Stampa di messaggi a videoStampa di messaggi a video


18

Ora tutte le istruzioni vengono eseguite in modalità hard real time la funzione sprintf() non effettua chiamate di sistema percui non

causa problemi alle applicazioni real time Il secondo processo accede alla FIFO per la lettura dei messaggi

int main(void){

char buf[ 128];

int len;

if((fd_debug = open(“/dev/rtf1”, O_RDONLY))==-1) {

printf("Error opening fifo: %i\n",fd_debug);

exit(-1);

}

while(1) {

if( 0 > (len = read( fd_debug, buf, 128))) return 0;

buf[ len] = “\0”;

printf( "%s", buf);

}

close( fd_debug);

return 0;

}

gestione delle comunicazioni

apertura della FIFO in sola lettura

lettura dei messaggi dalla FIFO

scrittura dei messaggi a video

chiusura della FIFO

Stampa di messaggi a videoStampa di messaggi a video


19Stampa di messaggi a videoStampa di messaggi a video Uso dei thread per la cattura dei messaggi di debug...

#include <pthread.h>

...

void *debug_logging(void *p){

...

close( fd_debug);

}

Definizione della funzione di gestione del thread

i parametri e il valore ritornato dalla funzione devono essere necessariamente di questo tipo

Il corpo della funzione rimane inalterato

è stata rimossa l'istruzione return()

Creazione del thread all'interno del main...

int main(void){

...

pthread_t debug_thread;

...

if(pthread_create( &thread1, NULL, debug_logging, (void *) NULL)!=0){

printf(“main: Unable to create debug_thread\n”);

exit(-1);}

...

}

Generazione del thread

definizione della struttura che contiene i parametri del thread

generazione del thread


20RTAI LXRTRTAI LXRT Cosa deve fare un processo LXRT per funzionare

correttamente?

Settare la sua politica di scheduling a FIFO Permette di avere una modalità di funzionamento “soft real-time”

anche mentre lavora come processo Linux standard: migliori performance

È possibile utilizzare le system calls native di Linux

Creare il collegamento con un agente real-time L’agente creato in spazio kernel gestirà le system calls rese

disponibili da RTAI

Prima di entrare in modalità hard real-time occorre disabilitare la paginazione delle memoria RAM Il funzionamento real-time non può essere interrotto da accessi

su disco in maniera non deterministica Codice e dati del processo sono mantenuti in RAM


21RTAI LXRTRTAI LXRT

Attivare la modalità di funzionamento hard real-time Il processo viene tolto dalla running-queue di Linux e viene

schedulato dallo scheduler RTAI I processi Linux vengono eseguiti solo se non c’è nessun

processo schedulato dallo scheduler RTAI in esecuzione

Esecuzione di codice real-time

Ritorno alla modalità soft real-time Il processo è riportato nella coda dei processi pronti dello

scheduler Linux

Prima di terminare l’esecuzione occorre eliminare l’agente RTAI relativo al processo in esecuzione


22RTAI LXRT APIRTAI LXRT API #include <rtai_lxrt.h>

void rt_allow_nonroot_hrt(); Consente di effettuare operazioni normalmente permesse solo ad

utenti con privilegi di root

RT_TASK* rt_task_init(<name>, <priorità>, 0, 0); Crea un agente real-time relativo al processo chiamante. La

priorità definita dalla funzione riguarda l’esecuzione gestita dallo scheduler RTAI

RT_TASK* rt_task_init_schmod(<name>, <priorità>, 0, 0,<policy>,<fpu>); Come rt_task_init ma imposta anche l'algoritmo di scheduling

Linux e l'uso della FPU

int rt_task_delete(RT_TASK*); Elimina un processo RTAI creato con rt_task_init(...)

void* rt_get_adr(<name>); Restituisce l’indirizzo dell’oggetto di nome <name>


23RTAI LXRT APIRTAI LXRT API

int rt_task_make_periodic(RT_TASK*, <start_time>, <period>); Rende un processo periodico ed avvia l'esecuzione all’istante <start_time>

void rt_task_wait_period(); Sospende il processo fino all’inizio del periodo successivo

void rt_set_oneshot_mode(); Imposta lo scheduler in One-shot mode

void rt_set_periodic_mode(); Imposta lo scheduler in Periodic mode

RTIME start_rt_timer(<period>); Fa partire il timer con risoluzione <period>. In modalità one-shot <period>

non ha importanza: la risoluzione del timer è quella del clock di RTAI

void stop_rt_timer();

int rt_thread_create(<func*>,<args*>, <stack_size>);


24RTAI LXRT APIRTAI LXRT API RTIME nano2count(<nanoseconds>);

Converte il tempo da ns a numero di ticks del clock interno

RTIME rt_get_time_ns(); Restituisce il tempo in ns da quando è stato fatto partire il timer

void rt_busy_sleep(<nanoseconds>); Ritarda l’esecuzione del processo senza perdere l’uso della CPU:

simula l’utilizzo della CPU per <nanoseconds> ns

void rt_make_hard_real_time(); Forza l’esecuzione del processo in modalità hard real-time

permettendo full-preemption del sistema

void rt_make_soft_real_time(); Ritorna alla modalità non real-time restituendo il controllo a

scheduler e kernel di Linux

int rtai_print_to_screen(...); Funzione di visualizzazione da utilizzare in modalità hard real-time


25RTAI: modulo kernel rt_hello_km.c RTAI: modulo kernel rt_hello_km.c #include <rtai.h>#include <rtai_sched.h>...RT_TASK task;...void task_routine() { while(1) { /* Codice real-time */ rt_task_wait_period();

rt_printk("Hello World at \\ time %llu !!!\n", rt_get_time_ns());

}}...int init_module(void) {... rt_task_init(&task, task_routine, 0, stack_size, priority, 0, 0); timer_period = start_rt_timer(nano2count(1e9)); task_period = 2*timer_period; rt_task_make_periodic(&task, now, task_period);}void cleanup_module(void) { rt_task_delete(&task); stop_rt_timer();}

Thread real-time

Ciclo infinito

Periodico

Generazione del thread

definizione dei parametri del thread

generazione del thread

Chiusura del modulo


26Compilazione dei moduli kernel: Linux 2.6Compilazione dei moduli kernel: Linux 2.6 Uso di make e Makefile

#MakefileKERNEL_SOURCE = /usr/src/linux

EXTRA_CFLAGS= -ffast-math -mhard-float -I/usr/realtime/include -I$(KERNEL_SOURCE)/include -I$(KERNEL_SOURCE)/include/asm-i386/mach-default -I/usr/include

EXTRA_LDFLAGS= -L/usr/realtime/lib -lmath -static

obj-m := rt_hello_km.o

default: rt_hello_km

rt_hello_km: rt_hello_km.c Makefilemake -C ${KERNEL_SOURCE} SUBDIRS=`pwd` modules

clean: make -C ${KERNEL_SOURCE} SUBDIRS=`pwd` clean

Variabili d'ambiente

Sono necessari almeno header e configurazione del kernel corrente

Direttive del make

Indicazione del modulo da generare

Direttiva di default

Compilazione del modulo

Pulizia della directory di compilazione


27RTAI APIRTAI API

Diversa chiamata alle funzioni di generazione del task

int rt_task_init(RT_TASK*, <funzione>, <data>, <stack_size>, <priorità>, 0, 0); Crea un processo real-time task di priorità <priorità> <funzione> indica la funzione da cui task inizia l’esecuzione RT_TASK è la struttura dati che identifica un processo RTAI Solo in kernel mode

Analoga differenza per altre funzioni quali rt_sem_int, rt_mbx_int, and rt_cond_init ...


28Considerazioni su Missed DeadlineConsiderazioni su Missed Deadline

Non si ha nessuna segnalazione di fault(politica As Soon As Possible Execution)

Se il processo continua ad essere prioritario prosegue nell’esecuzione

Politiche di rilevazione e di reazione ad un evento missed deadline sono lasciate al programmatore Skip Next Execution Policy: nei processi periodici viene

annullata l’esecuzione nel periodo successivo a quello in cui è avvenuta la situazione di overrun


29Gestione HW del tempoGestione HW del tempo RTAI supporta tre timer hardware:

Real Time Clock (RTC) Ha una risoluzione bassa (fino a 8192 Hz) e può essere

programmato solo in modalità periodica con frequenze potenze di 2 Hz

Non interferisce con i timer di Linux È disponibile anche nei PC più “datati” ed in molti sistemi

embedded

PIT 8254 e APIC (IA-32) / Decrementer (PowerPC) Hanno una risoluzione più elevata e non hanno il vincolo delle

“potenze di 2Hz” e possono essere programmati sia in modalità periodica che in modalità oneshot

La lettura del PIT è lenta (bus ISA), l’APIC non è presente in tutte le CPU

Sono utilizzati anche da Linux


30Modalità di gestione del tempoModalità di gestione del tempo

Periodic Mode: la temporizzazione dei task è a frequenza fissa La frequenza impostabile (e la risoluzione temporale) dipende dal dispositivo di clock utilizzato Le decisioni di scheduling sono prese (principalmente)

allo scadere del tick Il tick successivo è automaticamente (via hardware)

reimpostato La funzione start_rt_timer() consente di impostare la

frequenza di tick desiderata Se l’unico dispositivo di clock è l’RTC, questa è l’unica

modalità disponibile

Le decisioni di scheduling sono sia clock driven, sia event driven


31Modalità di gestione del tempoModalità di gestione del tempo

Oneshot Mode: la temporizzazione dei task è a frequenza variabile Come nella modalità periodica, la frequenza e la

risoluzione dipendono dal clock device Le decisioni di scheduling vengono prese ad istanti

temporali variabili: Nel momento in cui un task oneshot viene messo in esecuzione,

il tick timer è impostato per scadere a: now() + resume_time resume_time è il primo tempo di risveglio di un task a priorità

maggiore (o uguale) del task corrente

Le decisioni di scheduling sono solo event driven! Il tick è un evento dinamico


32Problemi architetturaliProblemi architetturali

Su architetture x86, la presenza dell’APIC implica lapresenza del Time Stamp Counter (TSC) Il TSC è un contatore monotono ad elevata precisione

(BusFreq) La modalità oneshot in RTAI fa uso sia del TSC sia

dell’APIC: Lettura veloce del TSC, risoluzione temporale elevata Programmazione veloce della prossima scadenza mediante

timer APIC È necessario prestare attenzione in ambiente MP in quanto il

TSC è un registro per-CPU

L’utilizzo del PIT 8254 in modalità oneshot introduce un jitter più elevato (e la lettura è più lenta)


33Punti di attivazione dello schedulerPunti di attivazione dello scheduler Lo scheduler di RTAI sia è clock driven che event driven

Il meccanismo di scheduling viene attivato: alla ricezione di un timer interrupt (clock tick, periodico o

oneshot) all’uscita di una routine di gestione interrupt (ISR) alla sospensione spontanea di un task

Le principali operazioni effettuate sono: Aggiornamento degli slice temporali (politica Round-Robin) Risveglio dei task scaduti od in scadenza (timing oneshot) Selezione del task READY di priorità massima (O(1), è il

task successivo la testa della lista) Eventuale task switching (potrebbe non essere necessario

se il task corrente è quello di massima priorità) Regolazione del timer per il clock tick successivo (timing

oneshot)


34Scheduling RM in RTAIScheduling RM in RTAI Rate Monotonic

È di facile realizzazione a partire dallo scheduling FIFO

Occorre determinare le priorità dei processi in funzione della loro frequenza di attivazione

Se non si vuole implementare l’intero meccanismo manualmente RTAI mette a disposizione una primitiva che determina la priorità dei processi real-time presenti nel sistema in funzione del periodo impostato con rt_task_make_periodic(...)

void rt_spv_RMS(<cpu>); Setta la priorità dei processi RTAI che eseguono sul processore

<cpu> in maniera inversamente proporzionale al loro periodo di attivazione


35Scheduling RM in RTAIScheduling RM in RTAI

Creare un processo figlio fork();

Creare i processi real-time definendone le priorità (anche se saranno sovrascritte) rt_task_init(nam2num(“TaskHF”), LOW_PR, 0, 0); rt_task_init(nam2num(“TaskLF”), HIGH_PR, 0, 0);

Entrare in modalità real-time rt_make_hard_real_time();

Rendere i processi periodici rt_task_make_periodic(taskHighFrequency, now + ...,

SHORT_PERIOD_COUNT); rt_task_make_periodic(taskLowFrequency, now + ...,

LONG_PERIOD_COUNT);

Settare le priorità in modo inversamente proporzionale alla durata del periodo rt_spv_RMS(0);


36Scheduling RM in RTAIScheduling RM in RTAI


37Scheduling EDF in RTAIScheduling EDF in RTAI Earliest Deadline First

Si ottiene a partire dall’algoritmo di scheduling FIFO

Occorre eseguire il processo pronto che deve terminare prima RTAI semplifica l’uso di questa politica di scheduling rendendo

disponibile una funzione che rende possibile l’esecuzione del processo con deadline più imminente

void rt_task_set_resume_end_times(<resume>, <end>); Imposta gli istanti assoluti di resume e deadline di un processo.

Esso viene deschedulato ed al risveglio è inserito nella coda dello scheduler in posizione dipendente dall’istante assoluto entro cui deve terminare

Non è specificata alcuna periodicità, ma è possibile definire un istante di resume relativo a quello precedente e deadline relativa al resume ottenuto indicando valori negativi di <resume> e <end>


38Scheduling EDF in RTAIScheduling EDF in RTAI Creare un processo figlio

fork(); Creare un agente real-time per ogni processo

rt_task_init(nam2num(“Task1”), LOW_PR, 0, 0); rt_task_init(nam2num(“Task2”), HIGH_PR, 0, 0);

Entrare in modalità real-time rt_make_hard_real_time();

Rendere i processi periodici rt_task_make_periodic(task1, now + ..., PERIOD_1); rt_task_make_periodic(task2, now + ..., PERIOD_2);

Settare gli istanti di attivazione e di deadline per ogni processo rt_task_set_resume_end_times(now + ..., -REL_DEADL_1); rt_task_set_resume_end_times(now + ..., -REL_DEADL_2);

Un processo al termine di ogni suo job deve risettare i propri istanti di attivazione e di deadline rt_task_set_resume_end_times(-PERIOD_n,-REL_DEADL_n);


39Scheduling EDF in RTAIScheduling EDF in RTAI

INTRODUZIONE A RTAIINTRODUZIONE A RTAIFINEFINE

SISTEMI DI ELABORAZIONE E CONTROLLO MIngegneria dell'Automazione

Ing. Gianluca PalliDEIS - Università di Bologna

Tel. 051 2093903email: [email protected]

http://www-lar.deis.unibo.it/~gpalli

INTRODUZIONE A RTAI-LINUX - LAR-DEIS Home Page · supporto al C++ (anche in kernel space per kernel...

Documents

Transcript of INTRODUZIONE A RTAI-LINUX - LAR-DEIS Home Page · supporto al C++ (anche in kernel space per kernel...