Conference PaperPDF Available

MeSViz: Visualizing Scenario-based Meta-Schedules for Adaptive Time-Triggered Systems


Abstract and Figures

A time-triggered Multi-Processor System-on-a-Chip (MPSoC) satisfies essential requirements of safety-critical embedded systems such as determinism and fault containment. Scenario-based meta-scheduling improves the flexibility in such a system by pre-computing different schedules at design time and allowing mode changes between schedules at run-time. Therefore, scheduling algorithms are required for solving the scenario-based temporal/spatial mapping of jobs to cores and messages to the Network-on-a-Chip (NoC). The meta-scheduling is highly relevant for automotive electronics. Safety-relevant automotive functions are based on time-triggered networks and can benefit from the meta-scheduling for improved energy-efficiency, flexibility, and dependability. To understand the complexity of developing these algorithms; developers need a global, abstract graphical visualization of their schedules. Engineers also need effective debugging and validation methods for scheduling algorithms to trace and view their output, thus saving time and cost. In this paper, we introduce MeSViz a tool dedicated to visualizing scenario-based meta-schedules as GANTT charts and tree-based graph.
Content may be subject to copyright.
MeSViz: Visualizing Scenario-based Meta-
Schedules for Adaptive Time-Triggered
Babak Sorkhpour
Department of Electrical Engineering and
Computer Science, University of Siegen
Siegen, Germany
Roman Obermaisser
Department of Electrical Engineering and
Computer Science, University of Siegen
Siegen, Germany
Abstract- A time-triggered Multi-Processor System-on-a-Chip
(MPSoC) satisfies essential requirements of safety-critical
embedded systems such as determinism and fault containment.
Scenario-based meta-scheduling improves the flexibility in such a
system by pre-computing different schedules at design time and
allowing mode changes between schedules at run-time. Therefore,
scheduling algorithms are required for solving the scenario-based
temporal/spatial mapping of jobs to cores and messages to the
Network-on-a-Chip (NoC). The meta-scheduling is highly relevant
for automotive electronics. Safety-relevant automotive functions
are based on time-triggered networks and can benefit from the
meta-scheduling for improved energy-efficiency, flexibility, and
dependability. To understand the complexity of developing these
algorithms; developers need a global, abstract graphical
visualization of their schedules. Engineers also need effective
debugging and validation methods for scheduling algorithms to
trace and view their output, thus saving time and cost. In this paper,
we introduce MeSViz a tool dedicated to visualizing scenario-
based meta-schedules as GANTT charts and tree-based graph.
I. Introduction
Many embedded systems are based on Time-
Triggered (TT) networks and used in safety-critical
applications (e.g., healthcare, space, military, nuclear
stations, and aircraft). Efficient scheduling algorithms are
required for such systems (e.g., mathematical programming,
artificial intelligence, scheduling heuristics, neighborhood
search [1]), where a failure would lead to severe
consequences [2]. Scheduling limited resources among
requesting entities is one of the most challenging problems
in computer science [3]. In many articles, scheduling
algorithms are explained by showing abstract tables of the
essential information and data (e.g., tasks, messages,
deadlines, times). However, it is hardly possible for humans
to get an understanding and view of the entire schedules by
only looking at the log files [3].
A visualization of a schedule enables the engineers to do
sanity checks easily, e.g., checking and tracing the jobs,
messages, nodes, and in scenario-based systems, the
behavior for each scenario after an event. Although
scheduling is an important issue in computer science, only a
few visualization tools exist which help scientists to extend
scheduling algorithms and models [3][4]. In scenario-based
scheduling systems, the meta-scheduler (MeS) generates
specific schedules for each situation triggered by relevant
events. To evaluate schedules, engineers need to compare,
understand and debug schedules and this is a challenging
matter in the MeS era. The output of most schedulers is in
text format. It is a hard way to find problems especially when
a huge number of schedules are generated and needed to
debug or compare. This challenge is intangible when using
text logs with big data or abstract graphics that cause wasting
the engineer’s mental resources. The majority of the
schedule visualizers are designed to illustrate a single
schedule and cannot cover multiple schedules in one scope.
However, the generation of schedules via scenario-based
scheduling solutions and algorithms for real-time
multiprocessor systems is gaining increasing importance [6].
The approach of MeS is to add dynamic actions by
computing several valid schedules, which will be
dynamically chosen based on the system status [7]. Previous
visualization tools show abstract schedules as graphical
output in which they do not contain detailed explanations of
the events and the schedules, differences or changes [2].
This paper introduces a scenario-based tool named the Meta-
Schedule Visualizer (MeSViz). It can visualize single-
schedules, meta-schedules and generate graphical data trees
of schedules and their elements (e.g., nodes, IDs, events).
MeSViz is designed to help developers to evaluate
scheduling algorithms, models, and methods for adaptive TT
systems. MeSViz is a tool to cover the gap of visualization
in MeS for adaptive TT systems with scenario-based and
event-based behaviors. This tool can display event locations,
detail schedule changes and dependencies due to events. It
focuses on visualizing schedules at three layers; the first
layer presents individual schedules for each scenario, the
second and third layers display multiple schedules for multi-
scenario events. The rest of the paper is organized as follows:
The basic concepts, related work, and meta-
scheduling are described in section II. In section III the
visualization of schedules is described. The implementation
of the algorithms for the tool MeSViz and its features are
explained in section IV. The case study and experimental
results are given in section V. Finally; section VI concludes
the paper with future research plans.
II. Basic Concepts and Related Work
A. Time-Triggered Systems
In time-triggered architectures, activities are
triggered by the progression of global time. In such systems,
time-triggered messages must be sent over the network at
predefined instants and take precedence over all other
message types [8][9]. For example, FlexRay [22] protocol is
using TT pattern which Time is divided into communication
cycles [15] and other in-vehicle network protocols including
Local Interconnect Network (LIN), Media Oriented System
Transport (MOST), Controller Area Network (CAN) [21]
[16]. Time-triggered systems require development tools for
computing offline schedules with temporal and spatial
resource allocations that satisfy the application requirements
such as precedence constraints and timing constraints. At
runtime, dispatchers perform all activities controlled by
these schedules.
B. Meta-Scheduling
Many research articles have been written about
how to schedule a set of jobs in a system with limited
resources [9]. However, few articles are focused on scenario-
based MeS [7]. A real-time system has to execute concurrent
tasks in such a way that all time-critical tasks meet their
specified deadlines. Every task needs computational and
communication resources to proceed, and the scheduling
problem is concerned with the allocation of all resources to
satisfy all timing requirements [9].
For example, some techniques for message scheduling of
FlexRay do not generate reliable or flexible schedules which
they do not prepare any efficiency obligations in the fault
event era [17]. In MeS to design easy, fast and accurate
scheduling data structure, four models are using and defined:
1. Platform Model (PM): The first model is a physical model
of the platform describing the on-chip resources including
the cores, the switches, and their connectivity via the NoC.
2. Application Model (AM): The second model is the
application model that defines jobs and their dependencies
based on exchanged messages and their timing (e.g., worst-
case execution times (WCETs) and deadlines).
3. Context Model (CM): The third model is the context
model, in which system designers define all events and faults
with implications on the application and the platform (e.g.,
jobs, switches, cores). These elements will be used as input
conditions in the MeS to generate new schedules. This model
is an important part of MeS which needs to control safety
and helps facilitates fault-isolation and complexity
management in smart and future vehicles generations [23]
(e.g., car, flight controls, flying multicopters, self-flying taxi
4. Schedule Model (SM): The Forth model is the scheduling
model, in which MeS store all generated schedule
information (e.g., jobs run time and allocation, messages
injection time and path) on a tree that each node is containing
an SM. These elements will be used as input data in the
MeSViz to visualization.
C. Meta-Scheduler
MeS works with events as an essential prerequisite.
For each relevant event, MeS creates a new schedule with
edges and nodes of a graph tree. MeS is designed to generate
schedules for anticipated changes of scenarios. When an
event such as a fault (e.g., failed link or switch) or slack
happens, the system can react by switching to precomputed
schedules for these events [3]. In static or pre-run-time
scheduling, a feasible schedule of a set of tasks is calculated
offline [9].
D. Visualization of Schedules
An overview of existing tools and a short view of
related work is shown in Table 1. These tools and their
properties demonstrate that most of them are focused on
simulation for generating the visualization [2].
Some tools such as Ghost, FORTISSIMO,
ARTIST, and RTSSim, do not support either shared
resources or multiple cores, which both are necessary
features in adaptive TT multi-core systems [2]. RTSIM
supports these features but focuses mainly on distributed
systems [2]. MeSVis is designed for NoCs, multi-route
messages according to TT control and real-time
Table 1. Overview of existing real-time scheduling tools [2]
E. Requirements for Visualization
A visualizer is needed to show the contents of MeS
including AM, PM, CM, and SM. To visualize multiple
schedules, the visualizer needs to access the data tree of
schedules to calculate and compare the difference of
schedules. A basic schedule visualizer is capable of
displaying the following items:
1. Present job and message location, timing, and allocated
2. Message routes and dependencies between the sender
(job) and receiver(s).
3. Display textual description of message properties (e.g.,
duration, location).
4. Present textual description of job properties (e.g.,
runtime, WCET).
5. Current schedule node ID.
6. Flexibility to generate text and image output formats.
A meta-visualizer to visualize multi-schedules, at first
needs to access the basic data which is generated via the
basic visualizer and then use the CM contents to combine,
analyze and generate extra details to display following items:
1. Display parent and child schedule nodes in one scope.
2. Report detailed event information in textual and graphical
3. Calculate and report the difference between parent and
child nodes.
4. Display job and message location and duration changes in
textual and graphical forms.
5. Display messages are routing changes.
6. Show total and removed schedules (e.g., invalid or pruned
F. Gantt mapping
For presenting schedules, a tool is needed that
helps to understand schedules in one clear picture easily. The
gantt chart is a straightforward solution to visualize the
schedules. It is a better and easier solution than a textual
format to understand schedules and their dependencies. This
method is a common solution for human-resource
scheduling, and in this paper, it is calling gantt mapping
(e.g., Figure 1).
Figure 1. Schedule gantt map
G. Graph mapping
In MeS, the description of the events and the
schedules in hierarchical graphs is necessary, and it is useful
to handle and debug large and complex schedules. It needs a
hierarchical description of events and resulting schedule
changes. To define the schedules and event parameters, the
graph model needs to be characterized. These characteristics
are attributes of the nodes and edges of the graphs [5] (e.g.,
node ID, event). A graph mapping represents the event
dependency between schedules [12] as shown in Figure 2.
Figure 2. GraphViz output of schedule tree with all data
H. Visualization of schedule changes
When an event happens, it means that the
execution scenario and system states are changed. It needs a
new plan, and the SM has to be generated. However, it is
important that the designer can comparable schedules to find
out what changes happened. Mes generates this information,
but a quick overview of the SM is needed which is called
meta-visualization. MesViz has to be able to present when
the event happens, what kind of changes were caused and
which elements were changed. Examples are job and
messages durations or allocation decisions as shown in
Figure 3.
Figure 3. meta-visualization
MeSViz uses ChartDirector to design extensive
chart types. It utilizes a layered architecture, supporting
graphical images formats (e.g., PDF, SVG, PNG, JPG, GIF
and BMP) in C++ [11]. MeSViz has direct access to MeS
classes for generating the gantt mapping using the
ChartDirector library. It uses the GraphViz format for the
GVEdit application and other graph generator tools. It uses
multi-threading to increase performance.
After a schedule was generated, the visualizer is called and
started to read, and process AM, PM and SM directly from
the scheduler class to provide input data to the Basic-
Visualizer (BV). BV is the core of the meta-visualizer. To
create meta-visual data, it needs more data of valid schedules
which are included in the data tree. They contain specific
AM, SM, CM, their top and down node addresses and IDs
for parent and child nodes.
E. Outputs and formats
In MesViz, we have three graphical output file
types and two text files.
1. Schd_Vis_XXXXX.png: This file is the basic output of
each generated schedule which is visualized. XXXXX is the
schedule ID numbering.
2. MetaSchd_Vis_XX_YY.png: This file is advanced output
which visualizes, calculates and presents a difference of two
related schedules (before and after an event) in the tree of the
scheduled events (e.g., Figure 2). XX and YY are the IDs of
relevant schedules and will be accessible and addressable in
the output of GVEdit, and output text files. To generate this
output, MesViz needs to read SM and AM, PM of parent and
child nodes and events of each schedule and their IDs.
3. Output.txt: Schedule trees generate this file via a
write_to_file class. This class is responsible for generating
input formats of BV and meta-visualizer and text files of
node connections and attributes which can be processed by
GVEdit (e.g., Figure 4). This file includes all possibilities of
nodes and events and shows all wrong or correct data which
is built by the scheduler.
digraph G {
0-> 1 [label= "Slack Event (Job #6, new ET=10)"color= green] ;
1-> 2 [label= "Slack Event (Job #8, new ET=10)"color= green] ;
2-> 3 [label= "Slack Event (Job #0, new ET=25)"color= green] ;}
Figure 4. Example a simply generated data with three node
4. Output2.txt: After removing duplicated nodes or null
events, this file is generated to be used by GVEdit.
5. Graph_Tree.png: The last step is generating a graph
mapping of meta schedules that GVEdit reads from
output.txt, output2.txt and generate them. Figure 2 is the
result of the above example.
F. Composite tasks, time alignment, and node
Decision variables, constants, and constraints lead
to a visual picture with all information aligned and allocated
at accurate locations with semantic connections between
elements via colored lines and text.
G. Single Schedule Gantt mapping
Each basic gantt map contains various information
that presents all data of the schedule in one picture (cf.
Figure 1). The description of these data contains:
1. Schedule ID on the top row.
2. Total makespan time in the top of a table column.
3. Node ID and switch ID at the left of a table row.
4. Message ID, sender, and recover job, injection time,
duration, visited hops and switches on the bottom row with
black color.
5. Job ID, execution time, starting time, WCET, finishing
time and related nodes on the bottom column with red color.
6. Each job aligned with the exact start and finish time and
node coordination with green color and its label.
7. Each message aligned at the exact time and switch
coordination with blue color and corresponding labels.
8. Each sent message connected by a yellow line to its
sender job and each received message linked by a green line
to the receiver job.
H. Multi-Schedule Gantt mapping
For each existing event, a multi gantt map is created
by the combination of two schedules for better detection of
the differences between them. This information displays
various changes which help to compare related schedules
and provide a better understanding of the system activities
(e.g., Figure 3). The description of these data contains:
1. Start event time with the vertical red line.
2. Parent schedule elements with a darker color than a child.
3. Display makespan changes.
4. Display event information.
5. Track which jobs and messages changed.
6. Parent and child IDs on top.
I. Graph mapping of meta-schedules
Graph mapping of meta-schedules is the last step
of visualization. This phase is related to the size and
complexity of models needed to use different graph
visualizer tools. For simple models and in this paper
Graphviz used. For big data, the yEd graph editor and Gephi
can be used. Each graph contains and shows this
1. The schedule ID on each node.
2. Event details (e.g., the name of the event, job ID,
execution time.)
3. Each event edge connection presented with a specific
color (e.g., slack with light green or job finish with blue
color). IV. Example / Case Study
To evaluate basic schedules and meta-schedules
visualized by MeSViz, we prepared input elements for MeS.
It was run on a virtual cluster machine with 12 cores of an
Intel Xeon E5-2450 2.2 GHz and 60GB RAM on Ubuntu
14.04.5 (GNU/Linux 3.13.0-93-generic x86_64).
To find out the behavior of MeSViz, it was run with
one simple and a complex model.
B. Simple Model
For the first test, a simple model with limited
conditions and elements for fast debugging was designed.
The properties are as follows:
1. SM Content: The AM includes 5 jobs and 7 messages,
while the PM includes 7 nodes (5 cores and 2 switches). The
CM includes 5 slack events with NewExecutionTime=50, 5
battery events with new energy levels, and 7 faults via node
2. Output results: The basic visualizer generates 94 gantt
maps from the basic-scheduler (Figure 1) and MeSViz
generates six gantt maps (Figure 3) from MeS. GVEdit
generates the graph mapping with 37 nodes.
C. Complex Model
After the simple model study, a complex model was
introduced to test MeS and MESViz better.
1. SM Content: The AM included 15 jobs and 15
messages, while the PM includes 20 nodes (16 cores and 4
switches). The CM included 14 slack events with
NewExecutionTime, 5 battery events with new energy
levels, 13 faults with node crashes, 14 faults with link faults
and babbling idiots, and 14 faults with message omission
2. Output results: BV generates 3048 gantt maps from the
basic-scheduler, and the meta visualizer generates 35 meta-
visual gantt maps from MeS. GVEdit generates a graph map
with 37 nodes.
D. Discussion
MeSViZ is capable of generating basic and meta-gantt
maps and graph maps. Analyzing these results helps to find
out several design faults:
1. Incorrect configuration: MeSViZ helps an to detect
incorrect input data (e.g., a message does not connect to
a job or makes a wrong loop between cores and
switches). On another hand, if the MeS tool includes
faulty constraints or conditions, then incorrect schedules
will be generated. Finding these types of errors in text
and log reports is a time-consuming and tedious task.For
example, a design fault can be found in a complex
schedule in Figure 5, where job14 is the sender of M14
and job11 is the receiver of M14.
Figure 5. Invalid Results found in complex schedule
The problem is the execution time of job11, which
finishes earlier than M14. In another example, job5
finished later than M8 and job10 started earlier than M8,
which means that the crossed lines for messages indicate
a wrong schedule.
2. Mes Incorrect data: When the visualizer builds invalid
results form MeS data then we will have wrong results
in MeSViz as shown for example in Figure 6. M12 in
the old schedule has a right connection to the sender
and receiver jobs (12-13), but in the new schedule, it
has a crossed line.
Figure 6. Meta-schedule gantt map generated from MeS class
3. Incorrect pointer references: Other problems that we
found were wrong references in the MeS tree for
schedule nodes. It is caused when we do not care for
the pruning of zero references in the MeS data tree
(e.g., Figure 7). Other problems are shown on the left
side of Figure 7.
Figure 7. Reference to zero address
4. Event trace: The difference of edge colors in graph map
helped better-finding event changes and behaviors
(e.g., Figure 2).
5. As a significant visualization result, too fast
evaluation schedules needed to attention direction
and slope of the connection lines the sender and
receiver job to each message (Error! Reference
source not found.Figure 6).
In Error! Reference source not found. and Error!
Reference source not found. system designer easily
can find which job or message is not aligned
Algorithm 1. Slop Evaluation 1
Algorithm 2. Slop Evaluation 2
By finding the mentioned problems, MeSViz proved that it
is a trustable solution to discover scheduling challenges. We
corrected the scheduler (e.g., data structure, elements, and
algorithms) and some new control conditions and constraints
were added to MeSViz. The new results were re-evaluated
and had shown that the scheduler and all items work
correctly (e.g., Figure 1 and Figure 3).
In this article, we introduced MeSViz, a software
tool that visualizes schedules and meta schedules on
adaptive TT and MPSoC platforms. This tool provides a
systematic way to realize a meta-visualizer regarding design,
simulation, and analysis of visualizing MeS.
The primary purpose is to prepare a graphical visualizer
interface tool for visualizing schedules and meta-schedules
as gantt mappings at different layers and levels. It guides
engineers and developers to get a fast and straightforward
understandable abstract overview of behavior for different
events. It is related to decision variables, constraints of the
scheduling algorithm and modeling. It can be used as a
scientific or educational tool to investigate how the MeS
algorithms behave when an event happens and how AM,
PM, and SM are changed to adapt to each situation.
MeSViz can support and display a wide range of resources
and tasks for adaptive TT systems. It helps to improve the
stability of platforms and to validate meta-schedules in an
easy and fast way to find bugs, overlaps, and collisions in
schedules and their hierarchy. It also helps to provide better
maintenance even with the sudden arrival of events in the
system. The schedule for each event that is generated by
MeS can be shown separately and each connectivity, group
of events and start time for each MeS can take a different
color according to the types. MeSViz provides two distinct
visualization levels of schedules for basic and meta-
schedules.As a part of the future work, we will work on more
scalability and parametric features to cover a broad range of
problems and integrate web-based outputs and reports for
online knowledge sharing and teamwork collaboration. This
tool not only can be used in computer science but also for
other scheduling problems that need a visualization (e.g.,
human resource, job scheduling, Multiple Resource
Constrained Scheduling).
The Europian project SAFEPOWER has supported this
work under the Grant Agreement No. 687902.
[1] R. Obermaisser, Time-triggered communication, CRC Press, 2001.
[2] M. Peter, "Visualization of scheduling in real-time embedded systems.
2013.," University of Stuttgart, Stuttgart, 2013.
[3] Hunold; Sascha; Ralf Hoffmann; Suter, Frédéric, "Jedule: A tool for
visualizing schedules of parallel applications," in 39th International
Conference on Parallel Processing Workshops ,IEEE, 2010.
[4] Brunst; D, Kranzlm¨uller; Muller; S., M.; Nagel, W. E., "Tools for
scalable parallel program analysis: Vampir NG, MARMOT, and DeWiz,"
Int. J. Comput. Sci. Eng, vol. 4, no. 3, p. 149161, 2009.
[5] A. M, "PhD THESIS: Allocation, Assignment and Scheduling for
Multi-processor System on Chip," December 2006.
[6] Cortés; Alejandro, Luis ; Eles, Petru; peng, Zebo, "Quasi-Static
Scheduling for Multiprocessor Real-Time Systems with Hard and Soft
Tasks," in Embedded and Real-Time Computing Systems and Applications,
[7] Persya; Christy, A; Gopalakrishnan Nair, TR, "Model-Based Design of
Super Schedulers Managing Catastrophic Scenario in Hard Real-Time
Systems," in Information Communication and Embedded Systems
(ICICES), 2013.
[8] Kopetz, H.; Bauer, G, "The time-triggered architecture," Proceedings
of the IEEE, vol. 91, pp. 112-126, 2003.
[9] H. Kopetz, Real-Time Systems, Second Edition ed., Springer
Science+Business Media, LLC, 2011.
[10] Murshed, Ayman ; Obermaisser, Roman; , Hamidreza,; Khalifeh, Ala;
Ahmadian, Hamidreza, "Scheduling and Allocation of Time-Triggered and
Event-Triggered Services for Multi-Core Processors with Networks-on-a-
Chip," in In Industrial Informatics (INDIN), 2015.
[11] "ChartDirector," Advanced Software Engineering , [Online].
[12] Hoeseok; Yang; Soonhoi, Ha, "Pipelined data parallel task
mapping/scheduling technique for MPSoC," in Proceedings of the
conference on Design, automation and test in Europe, 2009.
[13] "XML Schema Tutorial,"
[14]M.Cumming, "The GNOME Project,"
[15] HAN, Gang, et al. SAFE: Security-aware FlexRay scheduling engine.
In: Design, Automation and Test in Europe Conference and Exhibition
(DATE), 2014. IEEE, 2014. p. 1-4.
[16] SZILAGY, Chris; KOOPMAN, Philip. A flexible approach to
embedded network multicast authentication. 2008.
[17] TANASA, Bogdan, et al. Scheduling for fault-tolerant
communication on the static segment of FlexRay. In: Real-Time Systems
Symposium (RTSS), 2010 IEEE 31st. IEEE, 2010. p. 385-394.
Optimal scheduling of switched FlexRay networks. In: Design,
Automation & Test in Europe Conference & Exhibition (DATE), 2011.
IEEE, 2011. p. 1-6.
[19] MANUAL, CPLEX User’s. IBM ILOG CPLEX Optimization Studio,
Version 12 Release 7. 1987-2016.
[20] SCHMIDT, Ece Guran; SCHMIDT, Klaus. Message scheduling for
the flexray protocol: The dynamic segment. IEEE Transactions on
Vehicular Technology, 2009, 58.5: 2160-2169.
[21] R. Bosch GmbH, CAN Specification, Version 2, Sept. 1991.
[22] FlexRay Consortium. FlexRay Communications System Protocol
Specification, Version 2.1, Revision A, December 2005.
[23] Peti, P., Obermaisser, R., Tagliabo, F., Marino, A., & Cerchio, S.
(2005, May). An integrated architecture for future car generations.
In Object-Oriented Real-Time Distributed Computing, 2005. ISORC 2005.
Eighth IEEE International Symposium on (pp. 2-13). IEEE.
[24] “Flying Air Taxis from Germany Conquer the,
” World
... Compared to purely static scheduling, our approach provides more energy efficiency and enhanced flexibility. Compared to our own previous research [3,6,7] and [8], this work does not focus on introducing a new architecture for scheduling or meta-scheduling technique. Instead, we provide an improved, extended, more flexible and reliable metascheduling architecture [9,10] for MPSoCs and NoCs. ...
... Compared to our previous work [3,6,7] and [8,11], which was only able to assign a single task per core, the algorithm presented in this article is now also able to assign multiple tasks per core on a multi-core platform. As part of our solution, we had to develop a scenario-based graph traversal algorithm and tool that called MeS [3] and a backtracking algorithm based on this tool for identifying and managing events. ...
... We extended the MeS for scenario-based scheduling and supporting multi-task on multi-cores, also a concrete power model with discrete frequencies on cores and routers. In this work compare to previous works [3,6,7] we are improving new several strategies in different algorithm and methods. In our first strategy, we use a deadline, list of tasks and messages to create schedules concerning the dependencies from the corresponding task and messages. ...
Conference Paper
1 Abstract-Complex electronic systems are used in safety-critical applications (e.g., aerospace, nuclear stations), for which the certification standards demand the use of assured design methods and tools. Meta-scheduling is a way to manage the complexity of adaptive systems via predictable behavioural patterns established by static scheduling algorithms. This paper proposes a meta-scheduling algorithm for adaptive time-triggered systems based on Networks-on-a-Chip (NoCs). The meta-scheduling algorithm computes an individual schedule for each dynamic event of slack occurrence. Each dynamic slack occurrence triggers the shift to a more energy-efficient schedule. Dynamic frequency scaling of cores and routers is used to improve the energy efficiency, while preserving the temporal correctness of time-triggered computation and communication activities (e.g., collision avoidance, timeliness). Mixed-Integer Quadratic Programming (MIQP) is used to optimise the schedules Experimental results for an example scenario demonstrate that the presented meta-scheduling algorithm provides on average a power reduction of 34%. Our approach was able to deploy 93 dynamic slack schedules compared to the single slack schedule of using static slack scheduling.
... In addition, the tool provides components for visualization and scheduling and high performance with a modular architecture that enables the selection of several scheduling parameters. MeS uses MeSViz to visualize the results [42] and MeSViz uses the ChartDirector library to generate gantt maps [43]. ...
... Finally, all events and visited results are visualized [42] (cf. Algorithm 2). ...
... The evaluation of MeS results needs a visualization tool. Meta-Scheduling Visualizer (MeSViz) is an advanced tool which is designed to visualize and displays SM contents (e.g., jobs, cores, messages, allocation, assignment) and arrange them in an understandable visualized way [42]. To evaluate the total energy savings for both cores and the NoC, performance, and deadline misses of our algorithm, MeSViZ is customized to calculate and display the energy consumption of cores EnergySM_Core, routers EnergySM_R and each SM E_SMx. ...
Conference Paper
Full-text available
Nowadays, energy-efficiency, energy-management, and energy-saving are essential issues in embedded systems. Many real-time embedded systems need to adapt at run-time to critical events such as faults which may arise within the system or changing environmental conditions. Time-triggered systems are frequently used in safety-critical applications, because precomputed schedules improve predictability and fault containment. Nevertheless, flexibility and resource-efficiency can be conceded by shifting between static scenario-based schedules that are generated by meta-scheduling tools and techniques. Application models, platform models and context models are used by meta-scheduling tools to plan reactions to events and generate meta-schedules. An example of a significant event is dynamic-slack, which can be used to increase the energy-efficiency in systems by changing communication and execution time plans. While methods and algorithms for energy-efficiency, energy-management and energy-saving are used in many applications (e.g., mobile phones, smart TVs), their applicability is still restricted in safety-critical systems. In a multi-core chip, the NoC technology contributes significantly to the overall energy consumption of an MPSoC. Hence, this paper proposes a meta-scheduler for Dynamic Voltage and Frequency Scaling (DVFS) in time-triggered multi-core architectures. The evaluation of correctness and energy-efficiency for cores and routers is carried out experimentally and analytically for dynamic slack-events. The results are monitored, analyzed and validated with a meta-scheduling visualization tool (MeSViz).
... Our algorithms and tools, used in [12,13,36], are extended with support for frequency scaling in a TT multi-core architecture. This technique can also be used for TTS with mixed-criticality [19], while meeting requirements for adaptivity, energy efficiency, and fault-tolerance, as in [25]. ...
Full-text available
ABSTRACT Complex electronic systems are used in many safety-critical applications (e.g., aerospace, automotive, nuclear stations), for which certification standards demand the use of assured design methods and tools. Scenario-based meta-scheduling (SBMeS) is a way of managing the complexity of adaptive systems via predictable behavioral patterns established by static scheduling algorithms. SBMeS is highly relevant to the internet of things (IoT) and real-time systems. Real-time systems are often based on time-triggered operating systems and networks and can benefit from SBMeS for improved energy-efficiency, flexibility and dependability. This thesis introduces an SBMeS algorithm that computes an individual schedule for each relevant combination of events such as dynamic slack occurrences. Dynamic frequency scaling of cores and routers is used to improve energy efficiency while preserving the temporal correctness of time-triggered computation and communication activities (e.g., collision avoidance, timeliness). Models of applications, platforms and context are used by scheduling tools to prepare reactions to events and to generate meta-schedules. In this work, techniques and tools are developed to schedule a set of tasks and messages on Network-on-chip (NoC) architectures to minimize total energy consumption, considering time constraints and adjustable frequencies. This algorithm is intended for mixed-criticality and safety-critical adaptive time-triggered systems and can cover fault-tolerance requirements. It can also help to react to fault events by recovering the system. We also introduce a meta-scheduling visualization tool (MeSViz) for visualizing schedules. We also introduce a meta-scheduling visualization tool (MeSViz) for visualizing schedules. We experimentally and analytically evaluate the schedules’ energy-efficiency for cores and routers. In addition, the timing is analytically evaluated, based on static slack and dynamic slack events. Simulation results show that our dynamic slack algorithm produces, on average, an energy reduction of 64.4% in a single schedule and 41.61% energy reduction for NoCs. By compressing the schedule graphs the memory consumption can be reduced by more than 61%. KURZBESCHREIBUNG In vielen sicherheitskritischen Anwendungen (z.B. Luft- und Raumfahrt, Automotive, Kernkraftwerke) kommen komplexe elektronische Systeme zum Einsatz, für die Zertifizierungsnormen den Einsatz von sicheren Konstruktionsmethoden und -tools vorschreiben. Die Szenario-basierte Meta-Planung (SBMeS) ist eine Möglichkeit, die Komplexität von adaptiven Systemen über vorhersehbare Verhaltensmuster zu steuern, die durch statische Planungsalgorithmen festgelegt werden. SBMeS ist sehr bedeutsam für das Internet der Dinge (IoT) und Echtzeitsysteme. Echtzeitsysteme basieren oft auf zeitgesteuerten Betriebssystemen und Netzwerken und können von SBMeS für mehr Energieeffizienz, Flexibilität und Zuverlässigkeit profitieren. Diese Abhandlung stellt einen SBMeS-Algorithmus vor, der einen individuellen Zeitplan für jede relevante Kombination von Ereignissen wie dynamische Schlupfereignisse berechnet. Die dynamische Frequenzskalierung von Prozessorkernen und Routern dient der Verbesserung der Energieeffizienz unter Beibehaltung der zeitlichen Korrektheit von zeitgesteuerten Berechnungs- und Kommunikationsaktivitäten (z.B. Kollisionsvermeidung, Echtzeitfähigkeit). Mit Hilfe von Modellen von Anwendungen, Plattformen und Kontexten werden Planungswerkzeuge eingesetzt, um Reaktionen auf Ereignisse vorzubereiten und Meta-Planungen zu generieren. Im Rahmen dieser Arbeit werden Techniken und Werkzeuge entwickelt, um eine Reihe von Berechnungen und Nachrichten auf Network-On-Chip (NoC)-Architekturen zu planen, mit dem Ziel, den Gesamtenergieverbrauch unter Berücksichtigung von Zeitvorgaben und einstellbaren Frequenzen zu minimieren. Der Algorithmus unterstützt sicherheitskritische adaptive zeitgesteuerte Systeme und kann die Anforderungen hinsichtlich der Fehlertoleranz abdecken. Er kann auch dazu beitragen auf Störungsfälle zu reagieren, indem er das System wiederherstellt. Außerdem stellen wir ein Meta-Planungstool (MeSViz) zur Visualisierung von zeitgesteuerten Plänen vor. Wir analysieren und bewerten die Energieeffizienz der Pläne experimentell für Prozessorkerne und Router. Darüber hinaus wird das Zeitverhalten anhand von statischen und dynamischen Schlupfereignissen analytisch bewertet. Simulationsergebnisse zeigen, dass unser dynamischer Schlupfalgorithmus im Durchschnitt eine Energieeinsparung von 64,4% in einem einzigen Zeitplan und 41,61% Energieeinsparung für NoCs erbringt. Durch die Komprimierung der Zeitpläne kann der Speicherverbrauch um mehr als 61% reduziert werden.
... Table 4 summarizes the numerical measurement results for the three scenarios. In each scenario, all possible slack combinations of different tasks were taken into consideration for the computation of the multi-schedule graph [30]. Each row of the table corresponds to an observed makespan value and it contains the number of schedules in the MG with this makespan, the corresponding power consumption in milliwatt and the power reduction percentage achieved by the proposed adaptation mechanisms. ...
Full-text available
The static resource allocation in time-triggered systems offers significant benefits for the safety arguments of dependable systems. However, adaptation is a key factor for energy efficiency and fault recovery in Cyber-Physical System (CPS). This paper introduces the Adaptive Time-Triggered Multi-Core Architecture (ATMA), which supports adaptation using multi-schedule graphs while preserving the key properties of time-triggered systems including implicit synchronization, temporal predictability and avoidance of resource conflicts. ATMA is an overall architecture for safety-critical CPS based on a network-on-a-chip with building blocks for context agreement and adaptation. Context information is established in a globally consistent manner, providing the foundation for the temporally aligned switching of schedules in the network interfaces. A meta-scheduling algorithm computes schedule graphs and avoids state explosion with reconvergence horizons for events. For each tile, the relevant part of the schedule graph is efficiently stored using difference encodings and interpreted by the adaptation logic. The architecture was evaluated using an FPGA-based implementation and example scenarios employing adaptation for improved energy efficiency. The evaluation demonstrated the benefits of adaptation while showing the overhead and the trade-off between the degree of adaptation and the memory consumption for multi-schedule graphs.
Full-text available
Many embedded systems, especially real-time systems, are used in safety-critical applications such as cars and aircraft. The consequences of different scheduling algorithms for such systems have to be properly understood. Software which simulates scheduling processes supports the research and development of new scheduling policies. It may be used for educational purposes, as simulation and visualization enhance the understanding of the consequences of scheduling decisions. This thesis introduces new, flexible, and extensible discrete event-driven simulation software. The software focuses on but is not limited to scheduling policies primarily used in real-time and embedded systems. Contrary to most existing scheduling simulators, it synchronously simulates and visualizes the current simulation result. In order to inspect the current scheduling situation in closer detail, the software is designed to allow pausing the simulation automatically on the occurrence of specific points of interest or manually at an arbitrary time. The simulation model is specified by a human-readable file which is loaded by the software. During the simulation, elements are added to the simulation model and each element is visualized. The simulation meta-model is designed to support a variety of system configurations. It supports shared resources with several units as well as multiple processing units. A set of scheduling policies and resource access protocols for single-core systems as well as a basic multi-core protocol were implemented and demonstrate the functionality of the software.
Full-text available
The conventional design of real-time approaches depends heavily on the normal performance of systems and it often becomes incapacitated in dealing with catastrophic scenarios effectively. There are several investigations carried out to effectively tackle large scale catastrophe of a plant and how real-time systems must reorganize itself to respond optimally to changing scenarios to reduce catastrophe and aid human intervention. The study presented here is in this direction and the model accommodates catastrophe generated tasks while it tries to minimize the total number of deadline miss, by dynamically scheduling the unusual pattern of tasks. The problem is NP hard. We prove the methods for an optimal scheduling algorithm. We also derive a model to maintain the stability of the processes. Moreover, we study the problem of minimizing the number of processors required for scheduling with a set of periodic and sporadic hard real time tasks with primary/backup mechanism to achieve fault tolerance. EDF scheduling algorithms are used on each processor to manage scenario changes. Finally we present a simulation of super scheduler with small, medium and large real time tasks pattern for catastrophe management.
Full-text available
The FlexRay communication protocol is expected to be the de facto standard for high-speed, in-vehicle communication. In this paper, we formally investigate the scheduling problem for the dynamic segment (DS) of FlexRay. We take the bounds on the generation times and the timing requirements of the signals into consideration to propose a reservation-based scheduling approach that preserves the flexible medium access of the DS. To obtain efficient schedules, we formulate a nonlinear integer programming problem (NIP) that minimizes the required duration of the DS. This NIP is then decomposed into two linear binary integer programming problems to facilitate the computation of feasible message schedules. An experimental study illustrates our message scheduling approach for the DS of FlexRay.
Conference Paper
Full-text available
In this paper, we propose a multi-task mapping/scheduling technique for heterogeneous and scalable MPSoC. To utilize the large number of cores embedded in MPSoC, the proposed technique considers temporal and data parallelisms as well as task parallelism. We define a multi-task mapping/scheduling problem with all these parallelisms and propose a QEA(quantum-inspired evolutionary algorithm)-based heuristic. Compared with an ILP (Integer Linear Programming) approach, experiments with real-life examples show the feasibility and the efficiency of the proposed technique.
Conference Paper
Full-text available
This paper introduces the concept of switched FlexRay networks and proposes two algorithms to schedule data communication for this new type of network. Switched FlexRay networks use an intelligent star coupler, called a switch, to temporarily decouple network branches, thereby increasing the effective network bandwidth. Although scheduling for basic FlexRay networks is not new, prior work in this domain does not utilize the branch parallelism that is available when a FlexRay switch is used. In addition to the novel exploitation of branch parallelism, the scheduling algorithms proposed in this paper also support all slot multiplexing options as defined in the FlexRay v 3.0 protocol specification. This includes support for the newly added repetition rates and support for multiplexing frames from different sending nodes in the same slot. Our first algorithm quickly produces a schedule given the communication requirements, network topology and FlexRay parameters, but cannot guarantee an optimal schedule in terms of the bandwidth efficiency and extensibility. Therefore, a second, branch-and-price algorithm is introduced that does find optimal schedules.
Conference Paper
Multi-core processors are gaining increasing importance in safety-relevant embedded real-time systems, where temporal guarantees must be ensured despite the sharing of on-chip resources such as processor cores and networks-on-a-chip. At the same time, many applications comprise workloads with different timing models including time-triggered and even-triggered communication. This paper introduces a scheduling model based on Mixed Integer Linear Programming (MILP) supporting the allocation of computational jobs to processing cores as well as the scheduling of messages and the selection of paths on networks-on-a-chip. The model supports dependencies between computational jobs and it combines both time-triggered and event-triggered messages. Phase-alignment of time-triggered messages is performed, while avoiding collisions between time-triggered messages and satisfying bandwidth constraints for event-triggered messages. Example scenarios are solved optimally using the IBM CPLEX optimizer yielding minimal computational and communication latencies.
Conference Paper
In this paper, we propose SAFE (Security Aware FlexRay scheduling Engine), to provide a problem definition and a design framework for FlexRay static segment schedule to address the new challenge on security. From a high level specification of the application, the architecture and communication middleware are synthesized to satisfy security requirements, in addition to extensibility, costs, and end-to-end latencies. The proposed design process is applied to two industrial case studies consisting of a set of active safety functions and an X-by-wire system respectively.
Large-scale high-performance computing systems pose a tough obstacle for today's program analysis tools. Their demands in computational performance and memory capacity for processing program analysis data exceed the capabilities of standard workstations and traditional analysis tools. A comparison of the sophisticated approaches of Vampir NG (VNG), the Debugging Wizard DeWiz and the correctness-checking tool MARMOT provides novel ideas for scalable parallel program analysis. While VNG exploits the power of cluster architectures for near real-time performance analysis, DeWiz utilises distributed computing infrastructures for distinct analysis activities. MARMOT combines automatic runtime and partially distributed analysis.
Distributed embedded systems are becoming increasingly vulnerable to attack as they are connected to external networks. Unfortunately, they often have no built-in authentication capability. Multicast authentication mechanisms required to secure embedded networks must function within the unique constraints of these systems, making it difficult to apply previously proposed schemes. We propose an authentication approach using message authentication codes which exploits the time-triggered nature of many embedded systems by putting only a few authentication code bits in each message, and by requiring authentication to be confirmed by the correct reception of multiple messages. This approach can work for both state transition commands and reactive control messages, and enables a tradeoff among per-message authentication cost, application-level latency, and the probability of induced system failure. Authentication parameters can be tuned on a per-message basis while satisfying typical wired embedded network constraints.