Search

This paper describes Stardust, an environment for parallel programming on networks of heterogeneous machines. Stardust runs on distributed memory multicomputers and networks of workstations. Applications using Stardust can communicate both through message-passing and through distributed shared memory. Stardust includes a mechanism for application reconfiguration. This mechanism is used to balance the load of the machines hosting the application, as well as for tolerating machine restarts (anticipated or not). At reconfiguration time, application processes can migrate between heterogeneous machines and the number of application processes can vary (increase or decrease) depending on the available resources. Stardust is currently implemented on a heterogeneous system including an Intel Paragon running Mach/OSF1 and a set of Pentiums running Chorus/classiX. The paper details the design and implementation of Stardust, as well as its performance.

Mobile computing is going to change the way, computers are used today. However mobile computing environment has features like high mobility, frequent disconnections, and lack of resources, such as memory and battery power. Such features make applications, running on mobile devices, more susceptible to faults. Checkpointing is a major technique to confine faults and restart applications faster. In this paper, we present a coordinated checkpointing algorithm for deterministic applications. We are using anti-messages along-with selective logging to achieve faster recovery and reduced energy consumption. Our algorithm is non-blocking in nature and avoids unnecessary computation. We ask only minimum number of processes to take the checkpoint and also take in to account the limited storage available at mobile devices.

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.

A Java Execution Environment (JEE) presents lots of advantages for embedded architectures. In this paper, we present an approach to build a dependable Java execution environment for Wireless PDAs. It is based on a modular software architecture. Our on-going works focus on reducing software errors, increasing the security of the software and minimizing native software pieces of code to increase the overall stability of the platform by transferring operating system features in Java world.

The use of wireless PDAs is foreseen to outrun the one of PCs in the near future. However, for this to actually happen, adequate software environments must be devised in order to allow the execution of various types of applications. This paper introduces the base features of such an environment, which is a customizable JVM-based middleware. In particular, the middleware platform embeds services for appropriate resource management and for supporting novel PDA-oriented applications.

Large-scale distributed systems are very attractive for the execution of parallel applications requiring a huge computing power. However, their high probability of site failure is unacceptable, especially for long time running applications. In this paper, we address this problem and propose a checkpointing mechanism relying on a recoverable distributed shared memory (DSM) in order to tolerate single node failures. Although most recoverable DSMs require specific hardware to store recovery data, our scheme uses standard memories to store both current and recovery data. Moreover, the management of recovery data is merged with the management of current data by extending the DSM's coherence protocol. This approach takes advantage of the data replication provided by a DSM in order to limit the amount of transferred pages during the checkpointing. The paper also presents an implementation and a preliminary performance evaluation of our recoverable DSM on a 56-node Intel Paragon. >