Cyclic Scheduling

– Advantages• Simple implementation (no real-time

operating system is required).• Low run-time overhead.• It allows jitter control.

– Disadvantages• It is not robust during overloads.• It is difficult to expand the schedule. • It is not easy to handle non periodic

activities.

Other Schedule Algorithms

– Priority Scheduling• Each task is assigned a priority based on its

timing constraints • We verify the feasibility of the schedule

using analytical techniques • Tasks are executed on a priority-based

kernel

– Example: Rate Monotonic (RM)• Each task is assigned a fixed priority

proportional to its rate

Real Time and Linux

• Linux is a standard time-sharing operating system– Good average performance and highly

sophisticated services– Hardware management layer dealing

with event polling or processor/peripheral interrupts

– Scheduler classes dealing with process activation, priorities, time slice

– Communications between applications.

Real Time and Linux

• Linux suffers from a lack of real time support

• Changes in the kernel sources, i.e. in the interrupt handling and scheduling policies

• Real time platform, with low latency and high predictability requirements– Full non real time Linux environment (access

to TCP/IP, graphical display and windowing systems, file and data base systems, etc.).

Timers PC’s

– Specific chip to solve the problem of generating accurate time delays under software control.

– 8254• Programmable interval timer/counter• 4 I/O ports in the system software• Three are independent 16-bit, one is a control

register• We configures the 8254 to match requirements

(select the mode) and program one of the counters for the desired delay.

• After the delay, the 8254 will interrupt the CPU.

Real Time in Linux, RTAI

• Use low cost general purpose computers and open-free source operating systems

• RTAI means Real Time Application Interface. – Not a real time operating system – Based on the Linux kernel.

• RTAI expands Linux to hard real time

Real Time in Linux, RTAI

• A patch to the Linux kernel which introduces a hardware abstraction layer

• A broad variety of services which make real-time programmers' life easier

• RTAI offers the same services of the Linux kernel core, adding the features of an industrial real time operating system.

Real Time in Linux, RTAI

• Is an interrupt dispatcher• RTAI traps the peripherals interrupts and if

necessary re-routes them to Linux• It uses the concept of HAL (hardware

abstraction layer) to get information from Linux and to trap some fundamental functions.

• HAL provides few dependencies to Linux Kernel.

• RTAI considers Linux as a background task running when no real time activity occurs.

RT Computer Systems RTAI

– Basic task management• time management and conversions• dynamic priority assignment• scheduler policy assignment• scheduling locking/unlocking• counting suspend/resume to avoid trivial

deadlocks

– Memory Management• shared memory for inter tasks• inter-intra user/kernel space data• sharing, dynamic memory allocations

RT Computer Systems RTAI

– Semaphores• Wait• Send• broadcast on

– counting, binary and resources with full priority

• inheritance to avoid priority inversion.

RT Computer Systems RTAI

– Conditional variables• wait, signal, broadcast, equivalent to the

related POSIX APIs, but with an RTAI specific implementation.

– Bits synchronization• Multi events/flags/signals synchronization,

i.e. semaphore like operations with different logical masking/unmasking on a set of bits at call and return time.

RT Computer Systems RTAI

– Mailboxes• send, receive of messages with multi

readers/writers capability• messages queued in either FIFO or priority

order. It is possible to use overwriting and urgent sends, broadcast a single message to all task waiting to receive on a mailbox queue, preview any message before reading it.

RT Computer Systems RTAI

– Direct Inter-task Messages• Asynchronous: send, receive• Synchronous remote procedures calls

(RPC)– rpc, receive, return.

RTAI Modules

– To use RTAI, you have to load the modules that implement whatever RTAI capabilities you need.

– Modules: • Rtai, Main module.• rtai_sched. scheduler module, which is in charge of

distributing the CPU to different tasks– Task functions – Timing functions– Semaphore functions – Mailbox functions – Inter-task communication functions

• rtai_fifos.

RTAI Modules

– Modules• rtai_shm• Lxrt• rtai_pqueue• rtai_pthread• rtai_utils

RTAI Examples

The program simply generates a sine signal and displays the instant values on the screen.

-------------- RT_PROCESS.C -------------------\#include <linux/module.h>\#include <asm/io.h>\#include <math.h>\#include <rtai.h>\#include <rtai_sched.h>\#include <rtai_fifos.h>

\#define TICK_PERIOD 1000000\#define TASK_PRIORITY 1\#define STACK_SIZE 10000\#define FIFO 0

RTAI Examples

static RT_TASK rt_task; static void fun(int t){    int counter = 0;    float sin_value;        while (1) {        sin_value = sin(2*M_PI*1*rt_get_cpu_time_ns()/1E9);        rtf_put(FIFO, &counter, sizeof(counter));        rtf_put(FIFO, &sin_value, sizeof(sin_value));        counter++;        rt_task_wait_period();    }}

RTAI Examples

int init_module(void){    RTIME tick_period;    rt_set_periodic_mode();    rt_task_init(&rt_task, fun, 1, STACK_SIZE, TASK_PRIORITY, 1, 0);    rtf_create(FIFO, 8000);    tick_period = start_rt_timer(nano2count(TICK_PERIOD));    rt_task_make_periodic(&rt_task, rt_get_time() + tick_period,       tick_period);    return 0;}

RTAI Examples

void cleanup_module(void){    stop_rt_timer();    rtf_destroy(FIFO);    rt_task_delete(&rt_task);    return;}

RTAI Examples

Scope: int main (void){    int fifo, counter;    float sin_value;    if ((fifo = open("/dev/rtf0", O_RDONLY)) < 0) {        fprintf(stderr, "Error opening /dev/rtf0\n");        exit(1);    }    signal(SIGINT, endme);    while (!end) {        read(fifo, &counter, sizeof(counter));        read(fifo, &sin_value, sizeof(sin_value));        printf(" Counter : %d Seno : %f \n", counter, sin_value);    }    return 0;}