Rafik Henia

Scenario Aware Analysis for Complex Event Models and Distributed Systems

The set of executing tasks in modern hard real time systems may change during system execution. This change, called scenario change, may lead to a transient overload situation due to the interference of different task set executions, thus necessitating timing requirement verification. Previously developed approaches analyzing response times across scenario changes are limited to strict periodic task event models and restricted to uniprocessor systems, while existing methods adapted for the analysis of distributed systems are not suitable for the analysis across scenario changes. In this paper, we eliminate the restrictions concerning task event models and present a scheduling analysis methodology allowing response time calculation across a scenario change for multi-scenario distributed systems.Research shows that significant energy saving can be achieved in wireless sensor networks by using mobile elements (MEs) capable of carrying data mechanically. However, the low movement speed of MEs hinders their use in data-intensive sensing applications with temporal constraints. To address this issue, we propose a rendezvous-based approach in which a subset of nodes serve as the rendezvous points (RPs) that buffer data originated from sources and transfer to MEs when they arrive. RPs enable MEs to collect a large volume of data at a time without traveling long distances, which can achieve a desirable balance between network energy saving and data collection delay. We develop two rendezvous planning algorithms, RP-CP and RP-UG. RP-CP finds the optimal RPs when MEs move along the data routing tree while RP-UG greedily chooses the RPs with maximum energy saving to travel distance ratios. We design the rendezvous-based data collection protocol that facilitates reliable data transfers from RPs to MEs in presence of significant unexpected delays in ME movement and network communication. Our approach is validated through extensive simulations.

Influence of different system abstractions on the performance analysis of distributed real-time systems

System level performance analysis plays a fundamental role in the design process of real-time embedded systems. Several different approaches have been presented so far to address the problem of accurate performance analysis of distributed embedded systems in early design stages. The existing formal analysis methods are based on essentially different concepts of abstraction. However, the influence of these different models on the accuracy of the system analysis is widely unknown, as a direct comparison of performance analysis methods has not been considered so far. We define a set of benchmarks aimed at the evaluation of performance analysis techniques for distributed systems. We apply different analysis methods to the benchmarks and compare the results obtained in terms of accuracy and analysis times, highlighting the specific effects of the various abstractions. We also point out several pitfalls for the analysis accuracy of single approaches and investigate the reasons for pessimistic performance predictions.

Context-aware performance analysis for efficient embedded system design

Performance analysis has many advantages in theory compared to simulation for the validation of complex embedded systems, but is rarely used in practice. To make analysis more attractive, it is critical to calculate tight analysis bounds. This paper shows that advanced performance analysis techniques taking correlations between successive computation or communication requests as well a correlated load distribution into account can yield much tighter analysis bounds. Cases where such correlations have a large impact on system timing are especially difficult to simulate and, hence, are an ideal target for formal performance analysis.

Improved offset-analysis using multiple timing-references

In this paper, we present an extension to existing approaches that capture and exploit timing-correlation between tasks for scheduling analysis in distributed systems. Previous approaches consider a unique timing-reference for each set of time-correlated tasks and thus, do not capture the complete timing-correlation between task activations. Our approach is to consider multiple timing-references which allow us to capture more information about the timing-correlation between tasks. We also present an algorithm that exploits the captured information to calculate tighter bounds for the worst-case response time analysis under a static priority preemptive scheduler

Context-Aware Scheduling Analysis of Distributed Systems with Tree-Shaped Task-Dependencies

In this paper, we present a new technique which exploits timing-correlation between tasks for scheduling analysis in multiprocessor and distributed systems with tree-shaped task-dependencies. Previously developed techniques also allow capturing and exploiting timing-correlation in distributed systems. However they are only suitable for linear systems, where tasks cannot trigger more than one succeeding task. The new technique presented in this paper allows capturing timing-correlation between tasks in parallel paths in a more accurate way, enabling its exploitation to calculate tighter bounds for the worst-case response time analysis for tasks scheduled under a static priority preemptive scheduler.

Improved response time analysis of tasks scheduled under preemptive Round-Robin

Round-Robin scheduling is the most popular time triggered scheduling policy, and has been widely used in communication networks for the last decades. It is an efficient scheduling technique for integration of unrelated system parts, but the worst-case timing depends on the system properties in a very complex way. The existing works on response time analysis of task scheduled under Round-Robin determine very pessimistic response time bounds, without considering in detail the interactions between tasks. This may lead to a degradation of the efficiency of Round-Robin scheduling algorithm, and becomes a practical obstacle to its application in realtime systems. In this paper we present an approach to compute much tighter best-case and worst-case response time bounds of tasks scheduled under preemptive Round-Robin, including also the effects of the scheduling algorithm.

Improved Output Jitter Calculation for Compositional Performance Analysis of Distributed Systems

Compositional performance analysis iteratively alternates local scheduling analysis techniques and output event model propagation between system components to enable performance analysis of heterogeneous distributed systems. In spite of its high scalability and adaptability, the compositional approach may suffer from overestimated results compared with other system performance verification techniques. The main reason is an incomplete consideration of event sequence correlations. In this paper we present a new technique that improves the output jitter calculation by correlating jitter and response times and offers significantly tighter analysis bounds.

Integrating Formal Timing Analysis in the Real-Time Software Development Process

When designing complex real-time software, it is very difficult to predict how design decisions may impact the system timing behavior. Usually, the industrial practices rely on the subjective judgment of experienced software architects and developers. This is however risky since eventual timing errors are only detected after implementation and integration, when the software execution can be tested on system level, under realistic conditions. At this stage, timing errors may be very costly and time consuming to correct. Therefore, to overcome this problem we need an efficient, reliable and automated timing estimation method applicable already at early design stages and continuing throughout the whole development cycle. Formal timing analysis appears at first sight to be the adequate candidate for this purpose. However, its use in the industry is conditioned by a smooth and seamless integration in the software development process. This is not an easy task due to the semantic mismatches between the design and analysis models but also due to the missing link between the analysis and the testing phase after code implementation. In this paper, we present a timing analysis framework we developed in the context of the industrial design of satellite on-board software, allowing an early integration and full automation of formal timing verification activities in the development process of real-time embedded software, as a mean to decrease the design time and reduce the risks of costly timing failures.

Transformation of SDL specifications for system-level timing analysis

Complex embedded systems are typically specified using multiple domain-specific languages. After code-generation, the implementation is simulated and tested. Validation of non-functional properties, in particular timing, remains a problem because full test coverage cannot be achieved for realistic designs. The alternative, formal timing analysis, requires a system representation based on key application and architecture properties. These properties must first be extracted from a system specification to enable analysis. In this paper we present a suitable transformation of SDL specifications for system-level timing analysis. We show ways to vary modeling accuracy in order to apply available formal techniques. A practical approach utilizing a recently developed system model is presented.

Integrating model-based formal timing analysis in the industrial development process of satellite on-board software

As a consequence of the increasing complexity of modern real-time applications, the need for an efficient, reliable and automated performance estimation method throughout the whole development cycle becomes essential. Model-based formal timing analysis appears at first sight to be the adequate candidate for this purpose. However, its use in the industry is conditioned by a smooth and seamless integration in the development process. This is not an easy task due to the semantic mismatches between the design and timing analysis models but also due to the missing links to the testing phase after code implementation. In this paper, we present a model-based timing analysis framework we developed in the industrial context of satellite on-board software. The framework enables overcoming the above mentioned problems, thus allowing a fully integration and automation of model-based timing verification activities in the development process, as a mean to shorten the design time and reduce risks of timing failures.