SimSo: A Simulation Tool to Evaluate Real-Time

Multiprocessor Scheduling Algorithms

Maxime Chéramy, Pierre-Emmanuel Hladik, Anne-Marie Déplanche

To cite this version:

Maxime Chéramy, Pierre-Emmanuel Hladik, Anne-Marie Déplanche. SimSo: A Simulation Tool to
Evaluate Real-Time Multiprocessor Scheduling Algorithms. 5th International Workshop on Analysis
Tools and Methodologies for Embedded and Real-time Systems (WATERS), Jul 2014, Madrid, Spain.
6 p. �hal-01052651�

HAL Id: hal-01052651

https://hal.archives-ouvertes.fr/hal-01052651
Submitted on 8 Aug 2014

HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est

archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents
entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non,
lished or not. The documents may come from émanant des établissements d’enseignement et de
teaching and research institutions in France or recherche français ou étrangers, des laboratoires
abroad, or from public or private research centers. publics ou privés.
 SimSo: A Simulation Tool to Evaluate Real-Time
Multiprocessor Scheduling Algorithms
Maxime Chéramy∗ , Pierre-Emmanuel Hladik∗ and Anne-Marie Déplanche†
∗ CNRS,
LAAS, 7 avenue du colonel Roche, F-31400 Toulouse, France
Univ de Toulouse, INSA, LAAS, F-31400 Toulouse, France
† IRCCyN UMR CNRS 6597, (Institut de Recherche en Communications et Cybernétique de Nantes), ECN,

1 rue de la Noe, BP92101, F-44321 Nantes cedex 3, France

Abstract—In this paper, we present SimSo, a simulator de- Contribution. This paper presents SimSo and the main nov-
signed for the comparison and the understanding of real- elties that now enable to conduct large scheduling evaluations
time scheduling policies. This tool is designed to facilitate the using it. It is indeed possible to automate the simulation of
implementation of schedulers in a realistic way. Currently, more
than twenty-five scheduling algorithms are available in SimSo. A scheduling algorithms from the generation of the systems to
particular attention is paid to the control of the computation time the collection of the resulting data. The main task generators
of the jobs therefore introducing more flexibility, for instance by are now included and the number of available schedulers
taking into account cache-related preemption delays. In addition, increased from five to more than twenty-five. Our methodology
SimSo offers an easy way to generate the tasksets, to perform to automate the evaluation of multiple scheduling algorithms
simulations and to collect data from the experiments.
is described through an example.
Paper organization. The remainder of this paper is orga-
I. I NTRODUCTION nized as follows: in Section II, related work is summarized.
Section III presents SimSo, and Section IV shows how it can
Davis and Burns referenced more than thirty real-time be used through an example. Finally, Section V provides some
multiprocessor scheduling algorithms in 2011 [11] and more concluding remarks and envisages future work.
than a dozen of new algorithms have emerged since then,
e.g. [26], [22]. Such a large number of scheduling algorithms
II. R ELATED W ORK
makes their evaluation and comparison difficult. The evalua-
tion generally comes from theoretical analysis, simulation or Our work addresses the evaluation of the performance of
an actual implementation, according to criteria that can include scheduling algorithms using empirical measures. Empirical
utilization bounds, success rates, number of preemptions, evaluations of scheduling algorithms focus on the overheads
migrations, and/or algorithm complexity. involved in scheduling decisions. The main studied causes of
Our long-term objective is to compare the various sched- overheads are context switches, preemptions, migrations and
ulers with ease while taking into account the capacity of the computational complexity. Two approaches are typically con-
hardware architecture (e.g. caches, dynamic frequency scaling, sidered to evaluate them. The first one is based on measured
or system overheads) to have an effect on their performance. performance on a real platform with a dedicated operating
This effect is currently very difficult to evaluate using theoret- system, e.g. the experiments done with LITMUSRT [4], an
ical analyses such as schedulability tests or resource augmen- extension of the Linux Kernel developed at the University
tation. On the other hand, while using a real system would of North Carolina, or the experimental work of Lelli et
seem to be a better approach, the effective implementation al. [20] on a dedicated implementation of Linux with RM
of a scheduler as an operating system component requires a and EDF multiprocessor schedulers. This method could also
substantial amount of time and the results are too specific be conducted on a cycle-accurate simulated architecture with a
to the system. As a consequence, we think that simulation real operating system as in [31]. The second approach is to use
could be a good compromise to efficiently evaluate scheduling tools dedicated to the simulation of real-time systems. Most of
algorithms. these tools are designed to validate, test and analyze systems.
This paper deals with SimSo, our tool to simulate mul- MAST [16] proposes a set of tools to model and analyze
tiprocessor real-time schedulers and that aims at facilitating distributed real-time systems with, for instance, feasibility tests
the design of experimental evaluations. In a prior publication, or sensitivity analyses. MAST also includes a simulator, JSim-
some design choices regarding the simulation kernel have MAST. Cheddar [28] proposes a GUI comprising a simulator,
been presented [7]. More recently, we showed using SimSo many feasibility tests and it is also used to simulate AADL
how the use of the WCET could bias the evaluation of models. RTSIM [5] is a collection of programming libraries
scheduling algorithms and how the impact of the caches could for the simulation of real-time control systems. It is used in
be integrated in the simulation [8]. As a consequence, the particular for experimenting new scheduling algorithms. The
concept of execution time model was introduced. last version was published in 2007.
 STORM [30] and YARTISS [6] are the closest tools to
what we aim. They offer a simulator to conduct evaluation
on scheduling algorithms with the possibility to easily join
new scheduling policies. However, due to its time triggered
simulation engine, STORM does not provide an efficient
way to model the unit of time below a tick of simulation
which is a significant limitation for us. YARTISS is certainly
the most suitable tool to evaluate scheduling algorithms by
considering overheads or hardware effects. However, we began
the implementation of our tool in 2011, before YARTISS was
published. Moreover, its design is focused on the study of
energy consumption and customizing it for our needs would Fig. 1. Interactions between main class instances. Processor, Task, Job and
Timer are Process objects and can have multiple instances.
have been difficult.
III. S IM S O
To facilitate the experimentation of scheduling algorithms, The design of SimSo allows it to take into consideration
we thus propose a dedicated tool: SimSo1 , a real-time schedul- various time overheads that occur during the life of the system.
ing simulator designed to be easy to use as well as extend. This This includes direct overheads such as context-switches and
software is freely available under an open source license. scheduler calls (with fixed time penalties) but also indirect
The design of SimSo has been driven by the components overheads with a simplified system of locks to forbid the
available in real systems so that practical issues regarding the parallel execution of a scheduler if needed. Such overheads
implementation can be taken into consideration. Such issues are applied on the processor they are supposed to occur (e.g.
would have been hard or even impossible to integrate into the time spent in the scheduler is taken into account on the
theoretical studies. processor that called the scheduler).
We would also like to draw attention to the fact that the
A. Architecture
above-mentioned overheads only consume extra-time without
The core of SimSo relies on SimPy2 , a process-based changing the time used to execute the jobs. Indeed, as an
discrete-event simulation framework. The use of discrete-event example, these overheads do not take into account the possible
simulation allows it to deal with short and long durations at the cache misses that could slow down a job and increase its
same cost. Its process-based nature offers a convenient way to duration. This important aspect can also be taken into account
express the behavior of the simulated components. by SimSo and is explained in section III-D.
The characteristics of a system are modeled by a Con-
figuration object that contains all the information about the B. Writing a Scheduler
system (tasksets, processors, duration, scheduler, etc). This The first requirement for the experimentation of a real-
object provides some methods to configure the system but also time scheduling policy is, undoubtedly, a way to specify the
to save it into an XML file. algorithm. This should be able to deal with any kind of online
Figure 1 shows the main classes of SimSo and their mutual scheduler: global, partitioned, semi-partitioned, etc. Moreover,
interactions. The design of SimSo is inspired by real systems: the implementation of a scheduler in a simulator should also
there are processors, tasks, jobs, timers, etc. Each of these be realistic in the sense that it should rely on mechanisms
objects simulates the behavior of the corresponding part on available on a real system. For instance, the choice of which
the system: Tasks release the jobs; Jobs emulate the execution processor should run the scheduler may have an impact on
of the task’s code; Timers can launch a method on a processor the performance or even the schedulability. Another example
at a given time; etc. The instances of Processors are actually is the finite precision of the timers: this may introduce a tiny
the central part of the simulation because they simulate both difference compared to the theoretical schedule and cause a
a processor and the operating system executing on it. Each major issue.
processor can execute a job or be interrupted to execute a One of the advantages of using a simulator is to simplify
method of the scheduler. Finally, the Scheduler object is not an the experimentation. Writing a scheduler should therefore be
active process. It could be considered as a part of the operating as easy as possible and rely on useful methods. We decided to
system and as a consequence, its methods are only called by use Python, a high-level language that benefits from a growing
the Processors. interest from the scientific community (e.g. the SciPy project).
The Model object is the conductor of the simulation. It takes In practice, most of the schedulers that we have implemented
as a parameter the Configuration object. When the run model contain less than 200 lines of code. The language is different to
method is called, the objects described above are created and the one that would be used on a real implementation, however,
launched. this does not change the underlying algorithms and logic.
1 SimSo: http://homepages.laas.fr/mcheramy/simso/ A scheduler for SimSo is a Python class that inherits
2 SimPy: http://simpy.readthedocs.org/ from the Scheduler class and is loaded dynamically into the
simulator. The following methods must be implemented: assignment algorithms (First-Fit, Next-Fit, Best-Fit, Worst-Fit,
• init: The init method is called when the simulation starts, with or without an initial sorting). This class is intended to
it is used to initialize the scheduler. ease the development of a partitioned scheduler, but it is not
• on activate: This method is called whenever a job is mandatory.
activated. On the other side, when migration is permitted, scheduling
• on terminated: This method is called when the execu- algorithms are referred to as global. A first category of global
tion of a job is done or when a job is aborted. schedulers use a single list of active tasks and assign a priority
• schedule: This method returns the scheduling decisions. to each task. For an architecture with m processors, the m
This method is called when a processor has been re- jobs with the highest priority run in parallel. The following
quested to take a scheduling decision. This request is algorithms belonging to that category are available in SimSo:
usually done during a job activation, a job termination G-RM, G-EDF, G-FL [13], EDF-US [29], PriD [18], EDZL,
or by a timer. M-LLF [24] and more recently U-EDF [22].
As an example, figure 2 shows the source code of a global Baruah introduced the concept of fairness as a way to
multiprocessor Earliest Deadline First scheduler3 . achieve optimality in terms of schedulability. SimSo provides
such PFair schedulers with PD2 and its work-conserving
from simso.core import Scheduler variant ER-PD2 [1]. Subsequently, it was demonstrated that the
class G_EDF(Scheduler): fairness constraint could be released to only apply at the job
def init(self):
self.ready_list = [] boundaries and thus could reduce the number of preemptions
def on_activate(self, job): and migrations. This led to the BFair and DP-Fair techniques.
self.ready_list.append(job)
# Send a "schedule" event to the processor. We have implemented such schedulers: LLREF [9], LRE-
job.cpu.resched()
TL [15], DP-WRAP [21], BF [31] and NVNLF [14].
def on_terminated(self, job):
# Send a "schedule" event to the processor. In order to reduce the number of migrations, some hy-
job.cpu.resched()
brid approaches, termed semi-partitioned approaches, combine
def schedule(self, cpu):
decision = None # No change. the advantages of global and partitioned scheduling. At the
if self.ready_list: present time, SimSo proposes three semi-partitioned sched-
# Look for a free processor or the processor
# running the job with the least priority. ulers: EDHS [19], EKG [2] and RUN [26].
key = lambda x: (1 if not x.running else 0,
x.running.absolute_deadline if x.running else 0)
cpu_min = max(self.processors, key=key)
D. Execution Time Model
# Obtain the job with the highest priority within the ready list.
job = min(self.ready_list, key=lambda x: x.absolute_deadline) When simulation is used to study the schedulability of
# If the selected job has a higher priority a system, it is usual that the tasks meet their worst-case
# than the one running on the selected cpu:
if (cpu_min.running is None or execution time at each job. However, the use of the WCET
cpu_min.running.absolute_deadline > job.absolute_deadline):
self.ready_list.remove(job) is in fact very pessimistic: the worst-case is an upper-bound
if cpu_min.running:
self.ready_list.append(cpu_min.running) that is hardly reached by the jobs, and it is even less likely
# Schedule job on cpu_min.
decision = (job, cpu_min) that the jobs of all the tasks meet their WCET at the same
return decision time. As a consequence, we believe that the WCET approach
should not be the only way to compare policies in terms
Fig. 2. Code of a global multiprocessor Earliest Deadline First scheduler. of performance. It is non-realistic and gives an advantage to
some scheduling policies that highly depend on the WCET.
C. Available Schedulers Relatedly, schedulers capable to take benefits from shorter
computation times cannot be fairly evaluated. In [8], we give
In order to check the ability to express a wide range some experimental results that illustrate this fact.
of algorithms, we have already implemented more than 25 Also, many scheduling evaluations only focus on the num-
schedulers. The main uniprocessor schedulers, RM, DM, FP, ber of preemptions and migrations because they are the source
EDF and M-LLF [24] are available. The DVFS schedulers of overheads. A preemption induces a system overhead due to
Static-EDF and CC-EDF [25] are also available. the context-switching, but it may also increase the computation
The library of schedulers provided with SimSo also includes time of a job by causing extra cache misses. In fact, Mogul and
a large variety of multiprocessor real-time scheduling algo- Berg have shown that the Cache-Related Preemption Delays
rithms, from partitioning to global ones. (CRPD) are more important than the system overheads. To
The partitioned approach forbids migrations and neces- increase realism, it is essential to integrate CRPD within the
sitates a static allocation of the tasks to the processors. computation time of the jobs.
The schedulers P-EDF and P-RM are available (they use As a consequence of the two previous remarks, it is
the Decreasing First-Fit assignment algorithm). Moreover, a desirable to have the possibility to simulate a system with
dedicated class is provided in SimSo to offer the possibility customized durations of jobs, depending on the purpose of the
to choose any uniprocessor scheduler and one of the available simulation. In SimSo this point is achieved with the Execution
3 A minor modification to this code would reduce the number of migrations Time Models (ETM). An ETM is a class that determines the
by executing a job in the same processor than its previous execution. duration of the jobs during the simulation. Figure 3 shows
the communication between a job and the ETM object (there the taskset until the targeted total utilization is reached
is a single ETM object for all the jobs). The ETM object is [19], [27]. The number of tasks is therefore variable.
informed by the jobs of any scheduling event. The job will • The algorithms UUniFast-Discard and RandFixedSum
use the get ret method to get a lower bound of its remaining generate a taskset with a given number of tasks and
execution time and, when that time is up, the job calls that a given total utilization [12]. At the present time, this
method again until it returns 0. methods seem to be the most efficient in generating
tasksets with a weak bias.
These algorithms only generate a set of utilization rates and
must thus be combined with a period generator. The following
algorithms are made available in SimSo:
• Uniform distributions in various fixed ranges: Most eval-
uations use it and this is certainly an interesting way
to study the influence of the periods, but it may not be
Fig. 3. Interface of any execution time model. relevant for realistic cases.
• Log-uniform choice of periods [10]: For a period range of

Several Execution Time Models are already available in 1-1000ms, the log-uniform distribution generates an equal
SimSo. The simplest model consists of using the WCET of number of tasks in each time band (1-10ms, 10-100ms,
the tasks for their execution time. A second one uses a random 100-1000ms) whereas a uniform distribution would gen-
duration for each job to meet a given average execution time erate 90% of the periods in the range 100-1000ms.
(ACET). The ACET model uses a normal distribution defined • Random draw among a fixed set of values: One could

by its mean, its standard deviation and is bounded by the argue that in an industrial system, the periods are de-
WCET. Another model detects the preemptions and migrations rived from the specifications, which are partly written
and extends the WCET4 of the job using fixed time penalties. by humans. Task periods are therefore more likely to be
Finally, a more complex model tries to simulate the state of rounded.
the caches. In this latter model, the execution time of the jobs Other period generators could also be added in the future.
depends on the events that happen while they are active. This For instance, Goossens [17] suggested a method to reduce
ETM is also interesting because it simulates the impact of the hyper-period of the system by using periods that can be
shared caches and, as a consequence, it is impossible to know decomposed in a limited number of prime numbers.
in advance when a job will end since it depends on external
events. F. Collecting Simulation Results
These models can also deal with Dynamic Voltage and Fre- In order to evaluate scheduling algorithms, some data must
quency Scaling (DVFS). Indeed, when the speed of a processor be collected from the simulation. The literature proposes many
is changed, the job that was running on it is preempted and measures, here is a non-exhaustive list of data that could be
resumed in order to inform the ETM and to reevaluate its recovered:
remaining execution time. The current DVFS model simply Success rate: The ratio between the number of jobs that
considers that a job consumes its computation time propor- have exceeded their deadline and the number of jobs. It gives
tionally to the speed of the processor. This is obviously a a performance indicator on the schedulability of a taskset.
simplified assumption, but it is possible to implement more Preemptions and migrations: Preemptions and migrations
realistic ETM models to deal with DVFS. are a factor of overhead and many recent schedulers are
Similarly, it should also be possible to add an energy focusing on their reduction. A distinction is made between
consumption model. job migration and task migration since they may have not the
E. Generation of Tasksets same implications.
Scheduler calls: The algorithm of a scheduler requires some
A taskset is defined by the number of tasks, their utilization
time to determine which jobs should run on the processors.
factor, periods, deadlines and the total utilization. Bini and
Some scheduling policies are known to make many scheduling
Buttazzo showed how the random generation of the tasksets
decisions, and some require a significant amount of time to
can bias the experimental results of some scheduling algo-
compute. Therefore, it is interesting to keep track of the
rithms on uniprocessor [3].
number of calls to the various methods of the scheduler.
For the multiprocessor case, several methods are used by
Normalized laxity: Lelli et al. proposed to measure the
the researchers to generate the tasksets. The most common
performance of a scheduler by computing the normalized
algorithms are implemented in SimSo:
laxity [20]. The laxity of a job is its relative deadline minus its
• Kato et al. use an approach inspired by the algorithm
response-time. The laxity of each job of each task is divided
described by Ripoll et al. where tasks are appended to by the task period in order to obtain a normalized laxity. A
4 In this case, the WCET is defined as the worst-case execution time without greater normalized laxity is synonym of a better safety and
any interruption. better reactivity.
 During the simulation of a system with SimSo, every signif- 10% of the WCET. Each system is simulated on the interval
icant events are traced. At the end of the simulation, a Results of time 0-1000ms6 .
object is built to store these events and could be post-treated The Configuration objects were saved into XML files for po-
to compute measurements. Whereas this approach is actually tential reuse (it is interesting to repeat simulations on systems
heavier than just counting events such as the preemptions and with atypical results in order to obtain a better understanding.).
migrations during the simulation, this provides more flexibility.
B. Simulation and Collection of the Results
Indeed, it is not necessary to modify the code of the simulator
to add the computation of new measurements one did not think SimSo executed 5400 simulations which took approxima-
about. A set of methods are also available to ease the retrieval tively 2 hours on an Intel Core i7 processor.
of usual metrics such as the ones mentioned above. When a simulation is done, the number of preemptions and
SimSo provides a graphical user interface that helps to job migrations are extracted from the Results object built by
configure a system and run it. That GUI is capable of dis- the Model object. Preemptions caused by the system (e.g. the
playing common measures such as preemptions, migrations, scheduler is called but no decision is taken) are not taken into
or execution times. It is also possible to display a gantt account.
chart, which is very useful during the development of a In order to facilitate the analysis, we stored the data in an
scheduler. However, this GUI only shows the results for a SQLite3 database.
single simulation.
C. Analysis
G. Conducting an Evaluation Campaign From that database, another script draws the charts using
To conduct a large evaluation campaign, it is possible to use matplotlib, a plotting library for Python. Each point is the
SimSo as a Python module. This way, a Python script can be mean of the twenty tasksets sharing the same parameters. The
written to automate the creation of systems, their simulation results for 8 processors and a system utilization of 95% are
and the collection of the results. This choice was motivated by shown on Figure 4.
the fact that the studies can be very specific and a graphical A few comments on the results are provided here as a com-
user interface would be necessarily too frozen or too complex. plement to the figure. EKG generates a lot of migrations that
On the other hand, using a script is much more flexible. could be easily avoided with a better choice of the parameter
Everything that is possible using the graphical user interface K or other improvements [23]. The results for NVNLF are
is also possible from a script. getting better with more processors unlike the others. U-EDF
could probably do better combined with clustering. With more
IV. E XAMPLE than 20 tasks, RUN acts as a partitioned scheduler most of the
This section illustrates the use of SimSo in conducting an time. G-EDF provides better results in terms of preemptions
experiment on scheduling policies. SimSo is used as a module and migrations but a few jobs were aborted as a consequence
for a Python script and the steps described below have been of deadline misses. U-EDF and RUN could probably catch up
programmed. with G-EDF with a work-conserving variant.
This experiment focuses on the number of preemptions and V. C ONCLUSION
migrations in function of the number of tasks, for various
In this paper, we have presented SimSo, a simulation tool
numbers of processors and load. The objective is to compare
to evaluate the multiprocessor schedulers. Its objective is to
five schedulers: G-EDF, NVNLF, EKG5 , RUN and U-EDF.
facilitate the comparison of the numerous scheduling policies.
A. Generation of the Configurations To this end, we will conduct large campaigns of experiments
with many scheduling algorithms using the same tasksets. This
The first step is to define the characteristics of the simulated
should allow us to reproduce numerous experiments in order to
systems. For this example, we have selected the following
confirm or invalidate results. At the present time, more than
parameters:
twenty-five schedulers are available, showing that SimSo is
• Number of tasks: 20, 30, 40, 50, 60, 70, 80, 90, 100
capable of handling partitioned, global and hybrid scheduling
• Number of processors: 2, 4, 8
approaches.
• System utilization: 85%, 95%
The architecture of SimSo, in particular the scheduling in-
For each configuration (tasks, processors, utilization), terface, was briefly explained. Particular care has been taken to
twenty tasksets are generated using the methods offered by keep a realistic scheduling interface so that practical decisions
SimSo, leading to a total of 5400 systems (9 × 3 × 2 × 20 × 5). are not eluded. This has also enabled SimSo to take into
The RandFixedSum algorithm was used to determine the task consideration direct overheads such as the context-switches or
utilizations and the periods were chosen randomly within a scheduling decisions. Moreover, the computation time of the
log-uniform distribution between 2 and 100 ms. The ACET jobs is determined by a model that can be selected depending
Execution Time Model is used and, for each task, the expected on the purpose of the simulation. Hence, the computation time
value is set to 75% of the WCET and the standard deviation to
6 Unfortunately, the hyper-period for a set of 100 tasks with random periods
5 The parameter K has been set to the number of processors. is far too long to be considered (in years).
 10000
G-EDF

Sum preemptions and migrations

8000
EKG
Number of preemptions

Number of migrations
6000 NVNLF
RUN
4000 U-EDF
2000

0
20 30 40 50 60 70 80 90 100 20 30 40 50 60 70 80 90 100 20 30 40 50 60 70 80 90 100
Number of tasks Number of tasks Number of tasks
Fig. 4. Number of preemptions and migrations for a system with 8 processors and a (worst-case) total utilization of 95%. The simulation used random
durations for the job computation time.

of a job can either be a static duration, a random duration, [12] P. Emberson, R. Stafford, and R. Davis, “Techniques for the synthesis
or even take into account cache-related preemption delays. of multiprocessor tasksets,” in Proc. of WATERS, 2010.
[13] J. Erickson and J. Anderson, “Fair Lateness Scheduling: Reducing
Additionally, a small example shows the capability of SimSo Maximum Lateness in G-EDF-Like Scheduling,” in Proc. of ECRTS
to produce concrete results. ’12, 2012.
Future work includes an improvement of SimSo by intro- [14] K. Funaoka, S. Kato, and N. Yamasaki, “Work-conserving optimal real-
time scheduling on multiprocessors,” in Proc. of ECRTS ’08, 2008.
ducing cache interferences in the simulation and introducing [15] S. Funk and V. Nanadur, “LRE-TL: An Optimal Multiprocessor Schedul-
more complex task behaviors such as shared resources and ing Algorithm for Sporadic Task Sets,” in Proc. of RTNS, 2009.
precedence relations. [16] M. Gonzalez Harbour, J. Gutierrez Garcia, J. Palencia Gutierrez, and
J. Drake Moyano, “MAST: Modeling and analysis suite for real time
applications,” in Proc. of ECRTS ’01, 2001.
ACKNOWLEDGMENT [17] J. Goossens and C. Macq, “Limitation of the hyper-period in real-time
periodic task set generation,” in Proc. of the 9th International Conference
The work presented in this paper was conducted under the on Real-Time Systems (RTS), 2001.
research project RESPECTED (http://anr-respected.laas.fr/) [18] J. Goossens, S. Funk, and S. Baruah, “Priority-driven scheduling of
which is supported by the French National Agency for Re- periodic task systems on multiprocessors,” Real-Time Systems, vol. 25,
no. 2-3, 2003.
search (ANR), program ARPEGE. [19] S. Kato and N. Yamasaki, “Portioned EDF-based scheduling on multi-
processors,” in Proc. of EMSOFT, 2008.
R EFERENCES [20] J. Lelli, D. Faggioli, T. Cucinotta, and G. Lipari, “An experimental
comparison of different real-time schedulers on multicore systems,”
[1] J. Anderson and A. Srinivasan, “Early-release fair scheduling,” in Proc. Journal of Systems and Software, vol. 85, no. 10, 2012.
of ECRTS ’00, 2000. [21] G. Levin, S. Funk, C. Sadowski, I. Pye, and S. Brandt, “DP-FAIR: A
[2] B. Andersson and E. Tovar, “Multiprocessor scheduling with few pre- Simple Model for Understanding Optimal Multiprocessor Scheduling,”
emptions,” in Proc. of RTCSA, 2006. in Proc. of ECRTS ’10, 2010.
[3] E. Bini and G. C. Buttazzo, “Measuring the performance of schedula- [22] G. Nelissen, V. Berten, V. Nelis, J. Goossens, and D. Milojevic, “U-
bility tests,” Real-Time Syst., vol. 30, no. 1-2, 2005. EDF: An Unfair But Optimal Multiprocessor Scheduling Algorithm for
[4] J. Calandrino, H. Leontyev, A. Block, U. C. Devi, and J. Anderson, Sporadic Tasks,” in Proc of ECRTS ’12, July 2012.
“LITMUSRT : A testbed for empirically comparing real-time multipro- [23] G. Nelissen, S. Funk, and J. Goossens, “Reducing Preemptions and
cessor schedulers,” in Proc. of RTSS, 2006. Migrations in EKG,” in Proc. of RTCSA, Aug 2012.
[5] A. Casile, G. Buttazzo, G. Lamastra, and G. Lipari, “Simulation and [24] S.-H. Oh and S.-M. Yang, “A modified least-laxity-first scheduling
tracing of hybrid task sets on distributed systems,” in Proc. of RTCSA, algorithm for real-time tasks,” in Proc. of RTCSA, 1998.
1998. [25] P. Pillai and K. G. Shin, “Real-time dynamic voltage scaling for low-
[6] Y. Chandarli, F. Fauberteau, D. Masson, S. Midonnet, and M. Qamhieh, power embedded operating systems,” in Proc. of SOSP ’01, 2001.
“YARTISS: A Tool to Visualize, Test, Compare and Evaluate Real-Time [26] P. Regnier, G. Lima, E. Massa, G. Levin, and S. Brandt, “RUN: Optimal
Scheduling Algorithms,” in Proc. of WATERS, 2012. Multiprocessor Real-Time Scheduling via Reduction to Uniprocessor,”
[7] M. Chéramy, A.-M. Déplanche, and P.-E. Hladik, “Simulation of real- in Proc. of RTSS, 2011.
time multiprocessor scheduling with overheads,” in Proc. of SIMUL- [27] I. Ripoll, A. Crespo, and A. Mok, “Improvement in feasibility testing
TECH, 2013. for real-time tasks,” Real-Time Systems, vol. 11, no. 1, 1996.
[8] M. Chéramy, P.-E. Hladik, A.-M. Déplanche, and S. Dubé, “Simulation [28] F. Singhoff, J. Legrand, L. Nana, and L. Marcé, “Cheddar: A flexible
of real-time scheduling with various execution time models,” in Proc. real time scheduling framework,” Ada Lett., vol. XXIV, no. 4, 2004.
of the WiP session of SIES, 2014. [29] A. Srinivasan and S. Baruah, “Deadline-based scheduling of periodic
[9] H. Cho, B. Ravindran, and E. Jensen, “An optimal real-time scheduling task systems on multiprocessors,” Inf. Process. Lett., vol. 84, no. 2,
algorithm for multiprocessors,” in Proc. of RTSS, 2006. 2002.
[10] R. Davis and A. Burns, “Priority assignment for global fixed priority [30] R. Urunuela, A.-M. Déplanche, and Y. Trinquet, “STORM a simulation
pre-emptive scheduling in multiprocessor real-time systems,” in Proc. tool for real-time multiprocessor scheduling evaluation,” in Proc. of
of RTSS, 2009. ETFA, 2010.
[11] ——, “A survey of hard real-time scheduling for multiprocessor sys- [31] D. Zhu, D. Mosse, and R. Melhem, “Multiple-resource periodic schedul-
tems,” ACM Comput. Surv., vol. 43, no. 4, 2011. ing problem: how much fairness is necessary?” in Proc. of RTSS, 2003.