We will review some of the major results in random graphs and some of the more challenging open problems. We will cover algorithmic and structural questions. We will touch on newer models, including those related to the WWW.

Random graphs

In this note, we revisit the problem of scheduling stabilizing control tasks on embedded processors. We start from the paradigm that a real-time scheduler could be regarded as a feedback controller that decides which task is executed at any given instant. This controller has for objective guaranteeing that (control unrelated) software tasks meet their deadlines and that stabilizing control tasks asymptotically stabilize the plant. We investigate a simple event-triggered scheduler based on this feedback paradigm and show how it leads to guaranteed performance thus relaxing the more traditional periodic execution requirements.

/pdf/event-triggered-real-time-scheduling-of-stabilizing-control-t1gebqsndp.pdf

Event-Triggered Real-Time Scheduling of Stabilizing Control Tasks

Aspect] is a simple and practical aspect-oriented extension to Java With just a few new constructs, AspectJ provides support for modular implementation of a range of crosscutting concerns. In AspectJ's dynamic join point model, join points are well-defined points in the execution of the program; pointcuts are collections of join points; advice are special method-like constructs that can be attached to pointcuts; and aspects are modular units of crosscutting implementation, comprising pointcuts, advice, and ordinary Java member declarations. AspectJ code is compiled into standard Java bytecode. Simple extensions to existing Java development environments make it possible to browse the crosscutting structure of aspects in the same kind of way as one browses the inheritance structure of classes. Several examples show that AspectJ is powerful, and that programs written using it are easy to understand.

An overview of AspectJ

We present a methodology for modeling heterogeneous real-time components. 
Components are obtained as the superposition of three layers :
Behavior, specified as a set of transitions; Interactions between transitions
of the behavior; Priorities, used to choose amongst possible interactions. 
A parameterized binary composition operator is used to compose components layer by layer.

We present the BIP language for the description and composition of layered components as well 
as associated tools for executing and analyzing components on a dedicated platform. The language
provides a powerful mechanism for structuring interactions involving rendezvous and broadcast.
We show that synchronous and timed systems are particular classes of components. Finally, we
provide examples showing the utility of the BIP framework in heterogeneous component
modeling.

Modeling Heterogeneous Real-time Components in BIP

This paper presents algorithms for the automatic synthesis of real-time controllers by finding a winning strategy for certain games defined by the timed-automata of Alur and Dill. In such games, the outcome depends on the players' actions as well as on their timing. We believe that these results will pave the way for the application of program synthesis techniques to the construction of real-time embedded systems from their specifications.

On the synthesis of discrete controllers for timed systems

The controller synthesis paradigm provides a general framework for scheduling real-time applications. Schedulers can be considered as controllers of the applications; they restrict their behavior so that given scheduling requirements are met. We study a modeling methodology based on the controller synthesis paradigm. The methodology allows to get a correctly scheduled system from timed models of its processes in an incremental manner, by application of composability results which simplify schedulability analysis. It consists in restricting successively the system to be scheduled by application of constraints defined from scheduling requirements. The latter are a conjunction of schedulability requirements that express timing properties of the processes and policy requirements about resource management. The presented methodology allows a unified view of scheduling theory and approaches based on timing analysis of models of real-time applications.

/pdf/scheduler-modeling-based-on-the-controller-synthesis-4nd5px5l40.pdf

Scheduler Modeling Based on the Controller Synthesis Paradigm

We present a framework integrating specification and scheduler generation for real time systems. In a first step, the system, which can include arbitrarily designed tasks (cyclic or sporadic, with or without precedence constraints, any number of resources and CPUs) is specified as a timed Petri net. In a second step, our tool generates the most general non preemptive online scheduler for the specification, using a controller synthesis technique.

/pdf/a-framework-for-scheduler-synthesis-54af8vbnq1.pdf

A framework for scheduler synthesis

We present novel techniques for efficient controller synthesis for untimed and timed systems with respect to invariance and reachability properties. In the untimed case, we give algorithms for controller synthesis in the context of finite graphs with controllable and uncontrollable edges, distinguishing between the actions of the system and its environment, respectively. The algorithms are on-the-fly, since they return a controller as soon as one is found, which avoids the generation of the whole state space.

In the timed case, we use the model of timed automata extended with controllable and uncontrollable discrete transitions. Our controller-synthesis method here is only half on-the-fly, since it relies on the a-priori generation of a finite model (graph) of the timed automaton, as quotient of the time-abstracting bisimulation. The quotient graph is essentially an untimed graph, upon which we can apply the untimed on-the-fly algorithms to compute a timed controller.

/pdf/on-the-fly-controller-synthesis-for-discrete-and-dense-time-33afprd7v4.pdf

On-the-Fly Controller Synthesis for Discrete and Dense-Time Systems

We examine to what extent implementation of timed automata can be achieved using the standard semantics and appropriate modeling, instead of introducing new semantics. We propose an implementation methodology which allows to transform a timed automaton into a program and to check whether the execution of this program on a given platform satisfies a desired property. This is done by modeling the program and the execution platform, respectively, as an untimed automaton and a collection of timed automata. We also study the problem of property preservation, in particular when moving to a better execution platform. We show that some subtleties arise regarding the definition of better, in particular for digital clocks. The fundamental issue is that faster clocks result in better sampling and therefore can introduce more behaviors.

Implementation of timed automata : An issue of semantics or modeling?

We examine to what extent implementation of timed automata can be achieved using the standard semantics and appropriate modeling, instead of introducing new semantics. We propose an implementation methodology which allows to transform a timed automaton into a program and to check whether the execution of this program on a given platform satisfies a desired property. This is done by modeling the program and the execution platform, respectively, as an untimed automaton and a collection of timed automata. We also study the problem of property preservation, in particular when moving to a “better” execution platform. We show that some subtleties arise regarding the definition of “better”, in particular for digital clocks. The fundamental issue is that faster clocks result in better “sampling” and therefore can introduce more behaviors.

/pdf/implementation-of-timed-automata-an-issue-of-semantics-or-5gujiqbg5y.pdf

Karine Altisen

Papers

Scheduler Modeling Based on the Controller Synthesis Paradigm

A framework for scheduler synthesis

On-the-Fly Controller Synthesis for Discrete and Dense-Time Systems

Implementation of timed automata : An issue of semantics or modeling?

Implementation of timed automata: an issue of semantics or modeling?