[aadl]: Ann. of a new release of Cheddar, a GPL real time scheduling analyzer

[frank singhoff]

We are pleased to announce a new release of Cheddar.
Cheddar is a GPL real time scheduling tool. Cheddar is designed for
checking task temporal constraints and buffer sizes of a real time
application/system.
It can also help you for quick prototyping of real time schedulers.
Finally, it can be used for educational purposes.
Cheddar is developed and maintained by the Lab-STICC Team,
University of Brest.

Since 2008, Ellidiss Technologies also contributes to the development of
Cheddar and provides industrial support.
Cheddar is written in Ada and runs on Linux and win boxes.

Thanks to contributors of this release (see AUTHORS.txt for the list of 
the contributors).

The current release is now 3.2. If you are a regular Cheddar's user, we 
advice you to switch
to the 3.2 release. See "ChangesLog.pdf" and "FIXED_BUGS.pdf" files for 
more information.



1) Summary of the new features for this release
-----------------------------------------------

The new release (aka Cheddar-3.2) provides the following improvements:


1) Fix several bugs (see FIXED_BUG.pdf for details) such as :
     - Cheddar does not work when When_Resource was false
     - XML event table printer was slow ; use streams instead
     - Speed attribute of core units now scale task execution time
     ...

2) New GUI features
   - Scheduling GANTT display now provides a zoom feature and processor 
may have different speed, that may help to display large scheduling 
sequences
   - Model name is now displayed in the main window

3) New features to connect Cheddar with other tools
   - Java binding  of Cheddar ADL : it is now possible to write Java 
programs to generate Cheddar XML model files, in order to call Cheddar 
from any Java program
(e.g. Eclipse plugin or standalone program). This Java binding is fully 
synchronized with CheddarADL updates thanks to Platypus code generators
   - Eclipse Plug-in to analyze AADL models from OSATE2

4) New analysis features:
   - Scheduling simulation feature for SDF
   - New feasibility interval subprograms implementation : should now be 
compliant with most of the task models existing in Cheddar
   - New processor demand function feasibility tests
   - New schedulers : DAG HLFET scheduler, EDH (energy oriented 
scheduler), LLREF
   - Add MILS implementation and partitionning  technics : to model and 
veriy security aspects of MILS architecture combined with Cheddar ARINC 
653 modeling/analysis features
   - Add NoC communication analysis:
      - Provide a new protocol to simulate message exchanges
      - Provide a transformation method to analyze NoC communications
        as a DAG scheduling problem
   - Add Spacewire communication analysis feature : to analyze them as a 
DAG of tasks
   - Add packages to manage Design patterns for multiprocessors/multicores:
         - prolog_printer : prints a prolog representation of Cheddar 
ADL models
         - feasibility test repository : package which describes all 
feasibility tests
           implemented into the Cheddar framework
   - Memory bank interference analysis for DRAM components. A Kalray 
schedulability analysis is under
     development.

5) Cheddar ADL improvements:
   - Extend the concept of network
   - Add concept of battery and memory units
   - Implement a new dependency type : Remote Procedure Call
   - Add various attribute on existing entities in order to implement 
new analysis features

6) Update of the compilation and running environment
   - Docker scripts are now available to compile and run Cheddar kernel
   - Cheddar binaries compilation process has been organized in 3 clear 
set of binaries : ellidiss, open source public distribution and examples 
for research activities
   - Cheddar sourcecode has been updated to be compiled with GNAT 2014 
on windows, linux 64 and linux 32
   - Cheddar kernel sourcecode has been updated to be compiled with GNAT 
2019 on windows 64, linux 64 and linux 32


2) License and web site
-----------------------

Cheddar is distributed under the GNU GPL license.
It's a free software, and you are welcome to  redistribute it under
certain conditions;
See the GNU General Public License for  details.

Source code, binaries and documentations can be freely downloaded from
http://beru.univ-brest.fr/~singhoff/cheddar



3) Main Cheddar features
----------------------------------

Cheddar is composed of two independent parts : an editor used to
describe a real-time system, and an analysis framework.
The analysis framework includes many feasibility tests and simulation 
features (see below).

The editor allows you to describe systems composed of several cores, 
processors, caches, memory and energy units which own tasks, shared 
resources, buffers, address spaces/partitiosn, which may exchange 
messages or communication with buffers.  Cheddar includes its own ADL, 
namely Cheddar ADL, to describe such architecture.
Cheddar is also able to handle AADL models with
a full compliant AADL V2 parsers by the  Ellidiss commercial product 
AADLInspector.
CheddarKernel, the Elllidiss commercial version of Cheddar, is embedded 
into
AADLInspector and maintained by Ellidiss.

The analysis framework is embedded in the following tool set:

- STOOD and AADLInspector (Ellidiss Tech)

- TASTE (European Space Agency)

- OSATE2 (SEI/CMU)

- RAMSES (Télécom Paris Tech)

- PPOOA (ETS Ingenieros Industriales)

- MOSART (LIAS/ENSMA) and Polarsys Time4sys framework



The main provided analysis tools are:

- Do scheduling simulations
     - With preemptive and non preemptive scheduling policies
     - With uniprocessor, Multiprocessor and hierarchical scheduling 
policies
     - With usual uniprocessor : RM, DM, LLF, EDF, POSIX queue policies 
(SCHED_RR/FIFO/OTHER),
           EDH, MUF, Round-Robin, D-over, time sharing policies, HLFET/DAG
     - With hierachical scheduling policies: ARINC 653, aperiodic 
servers (sporadic, deferable, polling,
           priority exchange), Round robin
     - With multiprocessor policies: global RM/DM/EDF/LLF/MUF, 
Proportionate Fair, EDZL, RUN, LLREF
     - With instruction cache entities
     - With different type of tasks : aperiodic, periodic, task 
activated with a poisson process, ...
     - With shared resources (and with FIFO, PCP, PIP, IPCP 
synchronization protocols)
     - Several hierarchical schedulers (such as ARINC 653 scheduling).
     - With task jitters and offsets
     - With various task precedencies
     - With an energy consumption model

- Extract information from scheduling simulation, such as
     - Worst/best/average task response times, task missed deadlines
     - Number of preemption, number of context switch
     - Worst/best/average shared resource blocking time
     - Deadlock and priority inversion
     - Worst/average buffer utilization factor, message worst/average 
waiting time

- Apply feasibility tests on tasks and buffers
      - Compute worst case task response time on periodic task set
      - Several methods to compute worst case response time with linear 
and tree transaction
      - Apply processor utilization feasibility tests.
      - Compute bound on buffer size (when buffers are shared by 
periodic tasks)
      - Worst case shared resource blocking time
      - Memory footprint of software entities
      - Apply feasibility tests based on demand function.

- Schedulability with models of hardware components
         - NoC and spacewire communication delays analysis
         - Memory interferences (DRAM)
         - CRPD analysis, L1 instruction cache interference

- Algorithms to assign priorities
         - Classical Rate Monotonic and Deadline Monotonic
         - Audsley algorithms
         - Priority assigned according to CRPD
         - Ceiling priority for shared resources

- Shared resources support (both scheduling simulation and
          blocking time analysis).  Supported protocols : PIP, PCP, IPCP

- Tools to express and perform analysis with task dependencies :
          - Model task transaction (linear or tree) and compute worst 
case response time
          - Scheduling simulation tasks according to task precedencies
          - Compute Tindell Holistic end to end response time.
          - Apply Chetto and Blazewicz algorithms.

- Cheddar provides a way to quickly define user-defined schedulers to 
model specific scheduling of ad-hoc applications/systems (ex : ARINC 653)
     - User-defined scheduling policies (based on pipeline models or 
automaton models)
     - User-defined task model policies, to express and handle specific 
task activation policies
     - User-defined analysis on scheduling simulation, to look for 
specific properties on
       scheduling simulation result

- Partitionning tools for periodic task set
         - Provide basic policies such as : Best fit, General Task fit, 
Fist fit, Small fit and Next fit.
         - Implementation of the PAES meta-heuristic to allow Cheddar 
users to compute Pareto Front. Such
           a Meta-Heuristic has been used to 1) compute partitionning of 
MILS architecture with objective
           functions to minimize missed deadlines and maximize security 
properties 2) assign a set of functions
           to a set of tasks with objective function to minimize the 
number of preemptions and minimiz missed
           deadlines.





Best Regards

Stéphane Rubini (Lab-STICC, University of Brest)
Jerome Legrand (Ellidiss Technologies)
Nam Tran Hai (Lab-STICC, University of Brest)
Alain Plantec (Lab-STICC, University of Brest)
Laurent Lemarchand (Lab-STICC, University of Brest)
Valérie Anne Nicolas (Lab-STICC, University of Brest)
Pierre Dissaux (Ellidiss Technologies)
Frank Singhoff (Lab-STICC, University of Brest)