Isabelle Puaut

Using Bypass to Tighten WCET Estimates for Multi-Core Processors with Shared Instruction Caches

Multi-core chips have been increasingly adopted by the microprocessor industry. For real-time systems to exploit multi-core architectures, it is required to obtain both tight and safe estimates of worst-case execution times (WCETs). Estimating WCETs for multi-core platforms is very challenging because of the possible interferences between cores due to shared hardware resources such as shared caches, memory bus, etc. This paper proposes a compile-time approach to reduce shared instruction cache interferences between cores to tighten WCET estimations. Unlike [YAN08], which accounts for all possible conflicts caused by tasks running on the other cores when estimating the WCET of a task, our approach drastically reduces the amount of inter-core interferences. This is done by controlling the contents of the shared instruction cache(s), by caching only blocks statically known as reused. Experimental results demonstrate the practicality of our approach.

The performance of consistent checkpointing in distributed shared memory systems

This paper presents the design and implementation of a consistent checkpointing scheme for distributed shared memory (DSM) systems. Our approach relies on the integration of checkpoints within synchronization barriers already existing in applications; this avoids the need to introduce an additional synchronization mechanism. The main advantage of our checkpointing mechanism is that performance degradation arises only when a checkpoint is being taken; hence, the programmer can adjust the trade-off between the cost of checkpointing and the cost of longer rollbacks by adjusting the time between two successive checkpoints. The paper compares several implementations of the proposed consistent checkpointing mechanism (incremental, non-blocking, and pre-flushing) on the Intel Paragon multicomputer for several parallel scientific applications. Performance measures show that a careful optimization of the checkpointing protocol can reduce the time overhead of checkpointing from 8% to 0.04% of the application duration for a 6 mn checkpointing interval.

Distributed Garbage Collection of Active Objects with No Global Synchronisation

This paper presents an algorithm to perform distributed garbage collection of objects possessing their own thread of control (active objects). The relevance of garbage collection in a system of active objects is briefly discussed. The collector is comprised of a collection of independent local collectors loosely coupled to a global collector. The mutator (application), the local collectors and the global garbage collector run concurrently. Distributed cycles of garbage are detected. The algorithm does not require that the communication channels be reliable: messages may be lost, duplicated, or may arrive out of order. Moreover, local collectors are only loosely synchronised to help detecting global garbage.

An approach for fault-tolerance in hard real-time distributed systems

The presence of hard timing constraints makes the design of fault tolerant systems difficult because when tasks are replicated to treat errors, both the task replicas and the fault tolerance building blocks (e.g., consensus) must be taken into account in the feasibility tests. This paper is devoted to the description of an approach for managing failures in hard real time distributed systems. Our approach is based on the use of a task replication tool named Hydra which makes tasks fault-tolerant off-line through the replication of parts to their code. The contribution of our work is not to provide new replication strategies but rather to provide replication strategies that are simultaneously suited to real time constraints, transparent to application designers and flexible (i.e., adaptable to application requirements and with low dependence with the underlying run-time support and hardware). Further details on Hydra can be found in (Chevochot and Puaut, 1999).

A proposal for ensuring high availability of distributed multimedia applications

Recent advances in computing, like high-speed networks and data-compression, make extensible distributed multimedia applications a challenging application-domain of distributed systems. Such applications like VoD (Video on Demand) or real-time conferencing are characterized by QoS (quality of service) requirements which depend on the quality of video and sound transmitted to the client and on the respect of time constraints associated to video and audio data. Much work has been done in order to provide system support aimed at meeting these requirements. However, existing proposals do not integrate the consequence of failure occurrence on the guaranteed QoS. To deal with this issue, we propose a resource reservation model that integrates availability requirements of multimedia services in addition to the QoS constraints introduced above. Our paper details the resulting model together with its integration in a distributed system. In particular we show how the model implementation can be customized in the case of a VoD server.

Adaptive placement of method executions within a customizable distributed object-based runtime system: design, implementation and performance

This paper presents the design and implementation of a mechanism aimed at enhancing the performance of distributed object-based applications. This goal as achieved by means of a new algorithm implementing placement of method executions that adapts to processors load and to objects characteristics, the latter allowing to approximate the cost of methods remote execution. The behavior of the proposed placement algorithm is examined by providing performance measures obtained from its integration within a customizable distributed object-based runtime system. In particular, the cost of method executions using our algorithm is compared with the cost resulting from the standard placement technique that consists of executing any method on the storing node of its embedding object.

Arche: a framework for parallel object-oriented programming above a distributed architecture

This paper sketches our experience with the design and implementation of a parallel object-oriented language and it distributed run-time system. The language integrates two original mechanisms for concurrency control: a synchronization mechanism that does not interfere with inheritance nor with subtyping, and a mechanism that serves for managing object groups. Because of the increasing power of interconnection networks, the languages run-time system has been designed for a distributed architecture instead of a single multiprocessor machine. Furthermore, in order to ease the development of correct applications, we have chosen to rely on the run-time system to provide the required efficiency instead of offering the programmer low level primitives to be used for producing efficient code.<<ETX>>

Towards safe and efficient customization in distributed systems

Progress in microprocessor and communication system technology is leading to the emergence of new large scale distributed architectures whose power increases proportionally to the number of processor elements. Such architectures support execution of traditional distributed applications based on the client-server paradigm as well as parallel applications. Among other consequences, this framework requires the design of distributed operating systems that exhibit good performance for a wide range of applications. One way to achieve this consists of weakening the semantics of system functions, and to customize them to implement stronger semantics that match the applications needs. Customization in distributed systems must be achieved in a safe and efficient way. The safety property relates to the fact that a customized function must implement a stronger semantics than that of the base function. Efficiency of a customization mechanism is evaluated in terms of the performance penalty resulting from the invocation of a customized function instead of the base function; ideally, the penalty should equal the execution cost due to the added functionality as if it were directly supported by the underlying distributed system.This paper addresses support for safe and efficient customization in distributed systems at the design and implementation levels. Linguistic paradigms aimed at facilitating the design of safe customization are sketched in Section 2. In particular, we argue that behavioral subtyping, used in strongly-typed, object-oriented programming languages, helps the user to achieve safe customization: it can be used to reason about the strengthening of function semantics. Section 3 then addresses operating system support for implementing safe and efficient customization. Finally, Section 4 gives an overview of our current and future work that relates to the design and implementation of both linguistic and operating system paradigms aimed at safe and efficient customization within distributed systems.

Dealing with Heterogeneity in Stardust: An Environment for Parallel Programming on Networks of Heterogeneous Workstations

This paper describes the management of heterogeneity in Stardust, an environment for parallel programming above networks of heterogeneous machines, which can include distributed memory multi-computers and networks of workstations. Applications using Stardust can communicate both through message passing and distributed shared memory. Stardust is currently implemented on an heterogeneous system including an Intel Paragon running Mach/OSF1 and an ATM network of Pentiums running Chorus/classiX.

Isatis: A Customizable Distributed Object-Based Runtime System

This paper discusses the design and implementation of a customizable distributed object-based runtime system. Our main goal in the systems design was to provide a distributed object-based system supporting execution of various (concurrent) object-oriented languages, and that can be easily enriched with mechanisms for object management so as to fit the applications needs. Enrichment of the runtime system with a particular mechanism is illustrated through the integration of a facility that is aimed at enhancing the applications performance. This goal is achieved by means of a load balancing strategy that implements initial-placement of method executions and migration of data objects according to both the processors load and the objects features.