S.Ha.R.K. Modules

Models and Modules

One of the goals of the S.Ha.R.K. Kernel is to allow the user to easily implement and test novel scheduling algorithms. These requirements are useful if a comparison between similar algorithms has to be done; in fact, this independence allows the user to configure and test applications without recompile them, only relinking them.

Independence between applications and scheduling algorithms is achieved by introducing the concept of model. Each task asks the system to be scheduled according to a given Quality of Service (QoS) specified by a model. In other words, a model is the entity used by Lego to separate the scheduling parameters from the QoS parameters required by each task. In this way, the kernel provides a common interface to isolate the task QoS requirements from the real scheduler implementation.

Models are required to make the generic kernel independent from the implemented scheduling algorithms: since the kernel does not implement any algorithm, it does not know how to serve a task but invokes a service request to scheduling entities realized as external modules. Hence, the generic kernel does not interpret the models, but just passes them to the modules; each module, reading the common part of the model, can understand whether the task can be served or not.

In this way an application, that uses models, remain indipendent from the modules used into the system, that implements the scheduling algorithms and give the requested QoS.

There are two types of Modules in the S.Ha.R.K. Kernel:

• Scheduling Modules, that implements Scheduling Algorithms and Aperiodic Servers;
• Resource Modules, that implements Shared Resource Access protocols.

The current distribution of the Kernel includes a set of scheduling and resource Modules. In the next paragraphs the implemented Modules are listed:

Scheduling Modules

Scheduling Algorithms

• POSIX - The POSIX priority scheduler
• RM - Rate Monotonic implementation for periodic and sporadic tasks with guarantee based on the used bandwidth
• EDF - Earliest Deadline First implementation for periodic and sporadic tasks with guarantee based on the used bandwidth
• EDFACT - EDF with pending activations and less exception raising (available in the demos/edfact directory)
• RR - The classic Round Robin scheduler
• RRSOFT - A Round Robin for Soft and Hard Task (useful for Scheduling Algorithms comparison)
• RR2 - Round Robin with Pending Activations
• SLSH - The Slot Shifting Algorithm (Module written by Tomas Lennvall)
• DUMMY - A simple dummy task
• STATIC - static scheduling (available in the demos/static directory)
• Hyerarchical Scheduling - available in the demos/first directory, with documentation.

Aperiodic Servers

• PS - Polling Server implementation
• DS - Deferrable Server implementation
• SS - Sporadic Server implementation (Module written by Marco Gigante)
• CBS - Constant Bandwidth Server implementation
• CASH - CASH Server implementation (Module written by Marco Caccamo)
• CBS_FT - Fault Tolerant CBS implementation (Module written by Marco Caccamo; it can be found in the Module Repository section of the Download Page)

Resource Modules

Mutex and Semaphores Modules

• NOP - No Protocol Mutex Handling (this protocol simply works as a classic semaphore)
• NOPM - No Protocol Mutex Handling with multiple locks (similar to the NOP Module, it allows multiple locks/unlock on the same mutex) (Module written by Massimiliano Giorgi)
• PI - Priority Inheritance Protocol
• PC - Priority Ceiling Protocol
• SRP - Stack Resource Protocol
• NPP - Non Preemptive Protocol (when a mutex is locked the task become non-preemptable)
• SEM - Classical Counting Semaphores

The S.Ha.R.K. Tracer Modules

The File System Scheduling Modules

• TRACE - The S.Ha.R.K. Kernel Tracer
• BD_EDF - The EDF algorithm
• BD_PSCAN - The Priority SCAN algorithm
• ... and other algorithms (FCFS, SSTF, LOOK, CLOOK) implemented directly into the file system without Kernel Modules

Other Resource Modules

• HARTPORT - Old hartik Communication Ports (POSIX Message queues also available)
• CABS - Cyclic Asynchronous Buffers