Bank transaction fraud results in over $13B annual losses for banks, merchants, and card holders worldwide. Much of this fraud starts with a Point-of-Compromise (a data breach or a ”skimming” operation) where credit and debit card digital information is stolen, resold, and later used to perform fraud. We introduce this problem and present an automatic Points-of-Compromise (POC) detection procedure. BreachRadar is a distributed alternating algorithm that assigns a probability of being compromised to the different possible locations. We implement this method using Apache Spark and show its linear scalability in the number of machines and transactions. BreachRadar is applied to two datasets with billions of real transaction records and fraud labels where we provide multiple examples of real Points-of-Compromise we are able to detect. We further show the effectiveness of our method when injecting Points-of-Compromise in one of these datasets, simultaneously achieving over 90% precision and recall when only 10% of the cards have been victims of fraud.

The complexity of systems is considered an obstacle to the progress of the IT industry. Autonomic computing is presented as the alternative to cope with the growing complexity. It is a holistic approach, in which the systems are able to configure, heal, optimize, and protect by themselves. Web-based applications are an example of systems where the complexity is high. The number of components, their interoperability, and workload variations are factors that may lead to performance failures or unavailability scenarios. The occurrence of these scenarios affects the revenue and reputation of businesses that rely on these types of applications. In this article, we present a self-healing framework for Web-based applications ( SHõ WA). SHõ WA is composed by several modules, which monitor the application, analyze the data to detect and pinpoint anomalies, and execute recovery actions autonomously. The monitoring is done by a small aspect-oriented programming agent. This agent does not require changes to the application source code and includes adaptive and selective algorithms to regulate the level of monitoring. The anomalies are detected and pinpointed by means of statistical correlation. The data analysis detects changes in the server response time and analyzes if those changes are correlated with the workload or are due to a performance anomaly. In the presence of performance anomalies, the data analysis pinpoints the anomaly. Upon the pinpointing of anomalies, SHõ WA executes a recovery procedure. We also present a study about the detection and localization of anomalies, the accuracy of the data analysis, and the performance impact induced by SHõ WA. Two benchmarking applications, exercised through dynamic workloads, and different types of anomaly were considered in the study. The results reveal that (1) the capacity of SHõ WA to detect and pinpoint anomalies while the number of end users affected is low; (2) SHõ WA was able to detect anomalies without raising any false alarm; and (3) SHõ WA does not induce a significant performance overhead (throughput was affected in less than 1%, and the response time delay was no more than 2 milliseconds).

HTTP video-streaming is leading delivery of video content over the Internet. This phenomenon is explained by the ubiquity of web browsers, the permeability of HTTP traffic and the recent video technologies around HTML5. However, the inclusion of multimedia requests imposes new requirements on web servers due to responses with life spans that can reach dozens of minutes and timing requirements for data fragments transmitted during the response period. Consequently, web-servers require real-time performance control to avoid playback outages caused by overloading and performance anomalies. We present SHStream, a self-healing framework for web servers delivering video-streaming content that provides (1) load admittance to avoid server overloading, (2) prediction of performance anomalies using online data stream learning algorithms, (3) continuous evaluation and selection of the best algorithm for prediction, and (4) proactive recovery by migrating the server to other hosts using container-based virtualization techniques. Evaluation of our framework using several variants of Hoeffding trees and ensemble algorithms showed that with a small number of learning instances, it is possible to achieve approximately 98% of recall and 99% of precision for failure predictions. Additionally, proactive fail over can be performed in less than 1 second.

The adaptation of a cloud infrastructure is an ongoing process. Cloud adaptation aims to provide the cloud infrastructure with the necessary computational resources to meet the agreed SLAs and, simultaneously, optimize the resources usage. In a cloud, the consumers are typically limited to the SLAs defined in advance with the cloud service provider. This creates a strong dependence in the cloud provider, and gives little room for maneuver when the cloud customers need to adapt the infrastructure very quickly to avoid service degradations. In this paper we present a framework that aims to reduce this gap. The SHõWA framework is targeted for self-healing Web-based applications. It detects workload and performance anomalies from the consumer perspective and interacts with the cloud service provider to dynamically adjust the infrastructure. From the experimental study conducted, is noteworthy the role of SHõWA to avoid the degradation of service upon the occurrence of load and resource contention scenarios.

In this paper, we describe the SHõWA framework and evaluate its ability to recover from performance anomalies in Web-based applications. SHõWA is meant to automatically detect and recover from performance anomalies, without calling for human intervention. It does not require manual changes to the application source code or previous knowledge about its implementation details. The application is monitored at runtime and the anomalies are detected and pinpointed by means of correlation analysis. A recovery procedure is performed every time an anomaly is detected. An experimental study was conducted to evaluate the recovery process included in the SHõWA framework. The experimental environment considers a benchmarking application, installed in a high-availability system. The results show that SHõWA is able to detect and recover from different anomaly scenarios, before any visible error, higher-latency or work-in-progress loss is observed. It proved to be efficient in terms of time of repair. The performance impact induced on the managed system was low: the response time penalty per request varied between 0 and 2.21 milliseconds, the throughput was affected in less than 1%.

Continuity is a critical aspect of video-streaming services due to large user abandonment costs resulting from interruptions in the middle of video playback. Server performance problems in particular are in the origin of soft failures manifested as degradation of video quality, which can have the same impact on viewer experience as hard failures (e.g., abrupt connection termination). Predicting both failure types is essential to avoid their propagation to end-users by means of proactive repairs. This paper addresses the problem of predicting and diagnosing performance problems in streaming servers in terms of its main cause (client-workload overloading and performance anomaly) for proactive repair, server capacity planning and fault repair. Evaluation of the approach using several machine learning algorithms showed that (1) Bayesian Networks predicted 93% of failures, (2) prediction performance is worse for performance anomalies than for client-workload overloading, (3) diagnosis correctness for predicted failures is 100% for client-workload overloading failures and approximately 98% for performance anomalies.

Video-streaming services are dominating the Internet, delivering content for video-on-demand, TV, education and collaborative work. Service parameters addressing quality and continuity of video content have a special importance due to the human sensitiveness to variations on video quality and decades of quality patterns absorbed by traditional TV users. Thus, the performance analysis and repair lifecycle at server and network levels is mandatory to avoid degradation of user experience. At the network level, there are several effective techniques based on temporal and spatial data redundancy, though they deeply depend on healthy servers with enough resources to afford both the client and recovery workloads. Excess of streaming workloads and performance anomalies (i.e., server resources exhaustion not explained by client requests) are typical causes of server performance failures. The former is often caused by memory caching of popular videos, which impacts the number of requests accepted by the server and consequently blurs load admittance mechanisms when the workload changes. The latter is caused by server internal factors independent of client workloads (e.g., memory leaks and maintenance activities). Separating client workload related failures from performance anomalies is mandatory for selection of immediate repair actions, capacity planning and to support fault repair. We evaluated the performance of Naive Bayes and C4.5 Trees algorithms for classification of these failure states using client and server performance metrics. Results shown that it is possible to predict the type of failure with levels of recall and accuracy higher than 90% for workload types with different popularity levels.

The web-based applications are exposed to a large spectrum of factors that may affect their availability and performability. The mean-time-to-detect (MTTD) and the mean-time-to-repair (MTTR) are considered of utmost importance to reduce the failure impacts. In this context, the combination of multiple monitoring techniques is commonly adopted to provide IT staff with information useful for timely detection and recovery from the failures. In this paper we provide an experimental study about the detection abilities provided by the monitoring tools that are being used nowadays in web-based applications. Besides the system-level, end-to-end and container-level monitoring techniques we incorporate an application-level monitoring technique. This technique provides the detection of performance anomalies by performing a correlation analysis among application parameters collected by an aspect-oriented program. The detection latency, the number of end-users affected, the coverage analysis and the overhead achieved by each monitoring technique, was evaluated considering different anomaly scenarios. Despite the importance of the monitoring techniques complementarity, the results achieved by the application-level monitoring are very interesting: it has detected 100% of the anomaly scenarios tested, for 73% of the anomalies it was the fastest detection technique, and due to the low detection latency it contributes to reduce the number of end-users experiencing the anomalies.

Streaming media is now one of the killer applications on the Internet. Availability in streaming services is a critical concern, as consumer expectations are drawn around decades of traditional TV experience. Server performance has particular importance in streaming, as its sensitiveness to delays makes it vulnerable to performance anomalies. Current work on server-level performance analysis fails to cope with performance failures not explained by the workload. We propose a self-healing architecture for streaming servers sustained by a biological metaphor of heart that explores proactive server recovery by anticipating performance failures through detection of arrhythmias (transmission delays of streaming content) and session probing. We evaluated the approach in RTSP streaming through experimental work in several resource exhaustion scenarios. Results have shown that our approach is able to predict and localize service failures several seconds before their occurrence for most failure scenarios.

The most important factor in the assessment of the availability of a system is the mean-time to repair (MTTR). The lower the MTTR the higher the availability. A significant portion of the MTTR is spent in the detection and localization of the cause of the failure. One possible method that may provide good results in the root-cause analysis of application failures is run-time profiling. The major drawback of run-time profiling is the performance impact. In this paper we describe two algorithms for selective and adaptive profiling of web-based applications. The algorithms make use of a dynamic profiling interval and are mainly triggered when some of the transactions start presenting some symptoms of performance anomaly. The algorithms were tested under different types of degradation scenarios and compared to static sampling strategies. We observed through experimentation that the pinpoint of performance anomalies, supported by the data collected using the adaptive profiling algorithms, stills timely as with full-profiling while the response time overhead is reduced in almost 60%. When compared to a non-profiled version the response time overhead is less than 1.5%. These results show the viability of using run-time profiling to support quickly detection and pinpointing of performance anomalies and enable timely recovery.

Failure detection in Web Applications is a topic of paramount importance. There are several papers in the literature about end-to-end monitoring of web-sites. Most of those systems use a distributed set of probes, located in different places in the Internet, and conduct some remote checking of the main HTML pages of the web-sites. This approach seems viable and many web-sites are already using some commercial services that provide this type of monitoring. In this paper we present new insights about the nature of user-visible failures in web-sites. We conducted an experimental study in the Internet by monitoring a set of 20 well-known web-sites during a one-month period. The results achieved are interesting for the whole community that is studying the reliability of the Internet and Internet Sites.

Performance management and dependability are two of the fundamental issues in business-critical applications. The ability to detect the occurrence of performance failures and anomalies has raised the attention of researchers in the last years. It is in fact a difficult problem, since a visible change in the performance can result from some natural cause (e.g., workload variations, upgrades) or by some internal anomaly or fault that may end up in a performance failure or application crash. Distinguish between the two scenarios is the goal of the framework presented in this paper. Our framework is targeted for web-based and component-based applications. It makes use of AOP-based monitoring, data correlation techniques and time-series alignment algorithms to spot the occurrence of performance anomalies avoiding false alarms due to workload variations. The paper includes some experimental results that show the effectiveness of our techniques under the occurrence of dynamic workloads and some fault-load situations.

EDGeS is an European funded Framework Program 7 project that aims to connect desktop and service grids together. While in a desktop grid, personal computers pull jobs when they are idle, in service grids there is a scheduler that pushes jobs to available resources. The work in EDGeS goes well beyond conceptual solutions to bridge these grids together: it reaches as far as actual implementation, standardization, deployment, application porting and training. One of the work packages of this project concerns monitoring the overall EDGeS infrastructure. Currently, this infrastructure includes two types of desktop grids, BOINC and XtremWeb, the EGEE service grid, and a couple of bridges to connect them. In this paper, we describe the monitoring effort in EDGeS: our technical approaches, the goals we achieved, and the plans for future work.

We experimentally evaluate the performance overhead of the virtual environments VMware Player, QEMU, VirtualPC and VirtualBox on a dual-core machine. Firstly, we assess the performance of a Linux guest OS running on a virtual machine by separately benchmarking the CPU, file I/O and the network bandwidth. These values are compared to the performance achieved when applications are run on a Linux OS directly over the physical machine. Secondly, we measure the impact that a virtual machine running a volunteer @home project worker causes on a host OS. Results show that performance attainable on virtual machines depends simultaneously on the virtual machine software and on the application type, with CPU-bound applications much less impacted than IO-bound ones. Additionally, the performance impact on the host OS caused by a virtual machine using all the virtual CPU, ranges from 10% to 35%, depending on the virtual environment.

In this paper, we present an approach for software rejuvenation based on automated self-healing techniques that can be easily applied to off-the-shelf application servers. Software aging and transient failures are detected through continuous monitoring of system data and performability metrics of the application server. If some anomalous behavior is identified, the system triggers an automatic rejuvenation action. This self-healing scheme is meant to disrupt the running service for a minimal amount of time, achieving zero downtime in most cases. In our scheme, we exploit the usage of virtualization to optimize the self-recovery actions. The techniques described in this paper have been tested with a set of open-source Linux tools and the XEN virtualization middleware. We conducted an experimental study with two application benchmarks (Tomcat/Axis and TPC-W). Our results demonstrate that virtualization can be extremely helpful for failover and software rejuvenation in the occurrence of transient failures and software aging.

In this paper we show how we applied BitTorrent data distribution techniques to the BOINC middleware. Our goal was to decentralize BOINC's data model to take advantage of client network capabilities. To achieve this, we developed a prototype that adds BitTorrent functionality for task distribution and conducted small- scale tests of the environment. Additionally, we measured the impact of the BitTorrent components in both the BOINC client and server, and compared it with the original implementation. Our preliminary results indicate that the BitTorrent client had a negligible influence on the BOINC client's computation time, even in the case where it was seeding extensively. The BOINC server, on the contrary, showed an unexpectedly low bandwidth output when seeding the file, as well as spikes on CPU usage. Current results show the BitTorrent scenario allows clients to share the burden of data distribution on BOINC with almost no negative influence on compute time. This paper will discuss the tests that were performed, how they were evaluated, as well as some improvements that could be made to future tests to enhance server-side efficiency.

Desktop grid systems reached a preeminent place among the most powerful computing platforms in the planet. Unfortunately, they are extremely vulnerable to mischief because volunteers can output bad results, for reasons ranging from faulty hardware (like over-clocked CPUs) to intentional sabotage. To mitigate this problem, desktop grid projects replicate work units and apply majority voting, typically on 2 or 3 results. In this paper, we observe that this form of replication is powerless against malicious volunteers that have the intention and the (simple) means to ruin the project using some form of collusion. We argue that each work unit needs at least 3 voters and that voting pools with conflicts enable the master to spot colluding malicious nodes. Hence, we post- process the voting pools in two steps: i) we use a statistical approach to identify nodes that were not colluding, but submitted bad results; ii) we use a rather simple principle to go after malicious nodes which acted together: they might have won conflicting voting pools against nodes that were not identified in step i. We use simulation to show that our heuristic can be quite effective against colluding nodes, in scenarios where honest nodes form a majority.

Web applications are highly sensitive to the occurrence of user-visible failures. Despite the usage of system-level monitoring tools there are still some application-level errors that escape to those tools and end up to be seen in the Web pages of the final users. Complementary error detection mechanisms should then be used to overcome this problem.In this paper, we present an experimental study where we measured the effectiveness of four different error-detection mechanisms under different fault-load. For the effect we used two benchmarks (JPetstore and TPC-W) and a software fault-injector. The results show that although system-level monitoring tools are very effective in most of the cases, there are other detection mechanisms that present a better latency and coverage when dealing with errors at the application-level. Particularly, the usage of external monitoring schemes seems to be of utmost importance.

The wide-spread phenomenon of software (running image) aging is known to cause performance degradation, transient failures or even crashes of applications. In this work we describe first a method for monitoring and modeling of performance degradation in SOA applications, particularly application servers. This method works for a large class of the aging processes caused by resource depletion (e.g. memory leaks). It can be deployed non-intrusively in a production environment, under arbitrary service request distributions. Based on this schema we investigate in the second part of the paper how machine learning (classification) algorithms can be used for proactive detection of performance degradation or sudden drops caused by aging. We leverage the predictive power of these algorithms with several techniques to make the measurement-based aging models more adaptive and more robust against transient failures. We evaluate several state-of-the-art classification methods for their accuracy and computational efficiency in this scenario. The studies are performed on a data set generated by a TPC-W benchmark instrumented with a memory leak injector. The results show that the probing method yields accurate aging models with low overhead and the machine learning approach gives statistically significant short-term predictions of degrading application performance. Both approaches can be used directly to fight aging via adaptive software rejuvenation (restart of the application), for operator alerting, or for short-term capacity planning.

Automated modeling of software aging processes is a prerequisite for cost-effective usage of adaptive software rejuvenation as a self-healing technique. We consider the problem of such automated modeling in server-type applications whose performance degrades depending on the "work" done since last rejuvenation, for example the number of served requests. This type of performance degradation - caused mostly by resource depletion - is common, as we illustrate in a study of the popular Axis Soap server 1.3. In particular, we propose deterministic models for approximating the leading indicators of aging and an automated procedure for statistical testing of their correctness. We further demonstrate how to use these models for finding optimal rejuvenation schedules under utility functions. Our focus is on the important case that the utility function is the average of a performance metric (such as maximum service rate). We also consider optional SLA constraints under which the performance should never drop below a specified level. Our approach is verified by a study of the aging processes in the Axis Soap 1.3 server. The experiments show that the deterministic modeling technique is appropriate in this case, and that the optimization of rejuvenation schedules can greatly improve the average maximum service rate of an aging application.

In this paper, we present an approach for software rejuvenation based on automated self-healing techniques that can be easily applied to off-the-shelf Application Servers and Internet sites. Software aging and transient failures are detected through continuous monitoring of system data and performability metrics of the application server. If some anomalous behavior is identified the system triggers an automatic rejuvenation action. This self-healing scheme is meant to be the less disruptive as possible for the running service and to get a zero downtime for most of the cases. In our scheme, we exploit the usage of virtualization to optimize the self-recovery actions. The techniques described in this paper have been tested with a set of open-source Linux tools and the XEN virtualization middleware. We conducted an experimental study with two applications benchmarks (Tomcat/Axis and TPC-W). Our results demonstrate that virtualization can be extremely helpful for software rejuvenation and fail-over in the occurrence of transient application failures and software aging.

In this paper, we present a checkpoint sharing methodology to improve turnaround time of applications run over desktop grid environments. In fact, volatility of desktop grid nodes reduces the efficiency of such environments when a fast turnaround time is sought, since a task might get stalled if its assigned machine remains unavailable for a somewhat long period of time (long at the scale of the computation). The rationale behind our approach is to permit checkpoint reuse, so that when a computation is forced to move from one node to another, it can be restarted from an intermediary point provided by the last saved checkpoint. We study the effects of sharing checkpoints in application turnaround time simulating three scheduling algorithms based on first come first served: FCFS, FCFS-AT and FCFS-TR. The targeted environment consists of institutional desktop grids. Our results show that sharing checkpoints is particularly effective in volatile environments, yielding performance improvement up to three times relatively to schemes based on private checkpoints. Furthermore, for non-volatile environments, a simple timeout strategy produces good results.

In this paper, we present a checkpoint-based scheme to improve the turnaround time of bag-of-tasks applications executed on institutional desktop grids. We propose to share checkpoints among desktop machines in order to reduce the negative impact of resource volatility. Several scheduling policies are evaluated in our study: FCFS, adaptive timeouts, simple replication, replication with checkpoint on demand, and prediction-based checkpointing combined with replication. We used a set of real traces collected from an academic desktop grid environment to perform trace-driven simulations of the proposed scheduling algorithms. The results show that using a shared checkpoint approach may considerably reduce the turnaround time of the applications when compared to the private checkpoints methodology.

In this paper we present Chkpt2Chkpt, a desktop grid system that aims to reduce turnaround times of applications by replicating checkpoints. We target desktop computing projects with applications that are comprised of longrunning independent tasks, executed in hundreds or thousands of computers spread over the Internet. While these applications typically do local checkpointing to deal with failures, we propose to replicate those checkpoints in remote places to make them available to other worker nodes. The main idea is to organize the worker nodes of a desktop grid into a peer-to-peer Distributed Hash Table. Worker nodes can take advantage of this P2P network to keep track, share, manage and reclaim the space of the checkpoint files. We used simulation to validate our system and we show that remotely storing replicas of checkpoints can considerably reduce the turnaround times of the tasks, when compared to the traditional approaches where nodes manage their own checkpoints locally. These results make us conclude that the application of P2P techniques seems to be quite helpful in wide-scale desktop grid environments.

Web-services and service-oriented architectures are gaining momentum in the area of distributed systems and Internet applications. However, as we increase the abstraction level of the applications we are also increasing the complexity of the underlying middleware. In this paper, we present a dependability benchmarking study to evaluate and compare the robustness of some of the most popular SOAP-RPC implementations that are intensively used in the industry. The study was focused on Apache Axis where we have observed a high susceptibility of software aging. Building on these results we propose a new SLA-oriented software rejuvenation technique that proved to be a simple way to increase the dependability of the SOAP-server, the degree of self-healing and to maintain a sustained level of performance in the applications

This paper describes a study of predicting machine availabilities and user presence in a pool of desktop computers. The study is based on historical traces collected from 32 machines, and shows that robust prediction accuracy can be achieved even in this highly volatile environment. The employed methods include a multitude of classification methods known from data mining, such as Bayesian methods and support vector machines. Further contribution is a time series framework used in the study which automates correlations search and attribute selection, and allows for easy reconfiguration and efficient prediction. The results illustrate the utility of prediction techniques in highly dynamic computing environments. Potential applications for proactive management of desktop pools are discussed

This paper describes DGSchedSim, a trace driven simulator to evaluate scheduling algorithms focused on minimising turnaround time of applications executed in heterogeneous desktop grid systems. The simulator can be used to model task farming applications comprised of a set of independent and equal sized tasks similarly to numerous @Home public computing projects like the popular SETI@Home. DGSchedSim permits to assess scheduling policies under several scenarios allowing to control parameters such as the application's requirements (number of tasks, individual requirements of tasks like needed CPU time), the properties of the environment (machines computing capabilities and availabilities) and the characteristics of the execution (frequency and storage location of checkpoints, etc.). The simulations are driven by traces collected from real desktop grid systems. Besides DGSchedSim, the paper presents the Cluster Ideal Execution Time (CIET) algorithm that computes the ideal wall-clock time required by a fully dedicated and totally reliable cluster of M heterogeneous machines to process the T tasks of an application. As a test to the simulator capabilities, the paper analyses the suitability of two scheduling algorithms, FCFS and MinMax, for delivering fast turnaround time in desktop grids. Both algorithms, when combined with a centrally stored checkpoint policy, achieve efficiency close to 50% of CIET for certain scenarios.

In this paper we present results from an experimental study addressing the use of mobile agents in the retrieval of management information. We compare several agent-based models for distributed collection and processing of management data, focusing on performance but also considering network traffic and setup costs. This study reveals that in many situations the performance of mobile agent systems is mainly determined by distribution, rather than locality. Furthermore, it shows that despite its importance in the flexibility and adaptability of the management system, agent mobility does not increase the system performance.

In this paper, we will address the list of problems that have to be solved in mobile agent systems and we will present a set of fault-tolerance techniques that can increase the robustness of agent-based applications without introducing a high performance overhead. The framework includes a set of schemes for failure detection, checkpointing and restart, software rejuvenation, a resource-aware atomic migration protocol, a reconfigurable itinerary, a protocol that avoids agents to get caught in node failures and a simple scheme to deal with network partitions. At the end, we will present some performance results that show the effectiveness of these fault-tolerance techniques.

In this paper, we present briefly the implementation of a Java interface for WMPI, a Windows-based implementation of MPI. Then, we describe a system that is oriented for Web-based computing and present a solution to integrate WMPI with this tool by making use of a Java bridge component and the Java bindings for WMPI. This solution allows the execution of meta-applications over a mixed configuration of platforms, execution models and programming languages. The resulting system provides a way to solve the problem of heterogeneity and to unleash the potential of diverse computational resources and programming tools. Copyright © 2000 John Wiley & Sons, Ltd.

In order for mobile agents to be accepted as a basic technology for enabling electronic commerce, proper security mechanisms must be developed. Hosts must be protected from malicious agents, agents must be protected from other agents and also agents must be protected from malicious hosts. For solving the first three problems, existing technology from operating systems and distributed systems research can be used. The last problem is new and specific to the mobile agent paradigm and it is much harder to solve. Due to this problem, many say that mobile agents are not ready for the e-commerce systems. We discuss the security requirements of mobile agents in the context of electronic commerce and analyze how these requirements can be met. We show that, because of the characteristics of e-commerce systems, the security requirements of the agents and their users can be assured in real and open environments such as the Internet.

Checkpointing and rollback recovery is a very effective technique to tolerate transient faults and preventive shutdowns. In the past, most of the checkpointing schemes published in the literature were supposed to be transparent to the application programmer and implemented at the operating-system level. In recent years, there has been some work on higher-level forms of checkpointing. In this second approach, the user is responsible for the checkpoint placement and is required to specify the checkpoint contents. We compare the two approaches: system-level and user-defined checkpointing. We discuss the pros and cons of both approaches and we present an experimental study that was conducted on a commercial parallel machine.

Java is a very promising language for use in the simulation of physical models due to its object-oriented nature, portability, robustness and support for multithreading. This paper presents JWarp, a Java library for discrete-event parallel simulations. It is based on an optimistic model for synchronization of the simulation entities: the Time Warp mechanism. We introduce the main features of the library and discuss some of the implementation details. © 1998 John Wiley & Sons, Ltd.

One of the most interesting challenges to the high-performance community is to exploit the existing computing resources for executing long-running number-crunching applications. Several important issues have to be addressed, like portability, robustness, security, heterogeneity, load-balancing and fault-tolerance. Java is an emerging language that is receiving an extraordinary enthusiasm and acceptance from several fields of programming. Interestingly, it presents some nice characteristics that partially solve some of those problems. This paper briefly describes JET, a parallel library implemented on Java that supports the execution of parallel applications over the Web. It is oriented to master/worker applications which present a coarse-grain task distribution. The library provides a high-level programming interface, support for fault-tolerance and some schemes to mask the latency of the communication. It can be used to execute massively distributed applications using several computers connected to the Internet. © 1997 John Wiley & Sons, Ltd.

We present a checkpointing mechanism for a DSM system that, in spite of being invisible to the programmer, is quite efficient and portable. It is efficient because it is nonblocking, coordinated and thus domino-effect free. It offers some portability because it is built on top of MPI and uses only the services offered by MPI and a POSIX compliant local file system. As far as we know, this is the first real implementation of such a scheme for DSM. Along with the description of the algorithms used, we present experimental results obtained in a cluster of workstations, and discuss many insights that came out of the implementation effort. We hope that our research shows that efficient, transparent and portable checkpointing is viable for DSM systems.

This paper presents a checkpointing scheme that was implemented in a parallel library that runs on top of CHIMP/MPI. The main goals of the checkpointing mechanism are portability and efficiency. It runs on every platform supported by MPI in a machine-independent way. The scheme allows the migration of checkpoints and offers a flexible recovery mechanism based on data-reconfiguration. Some performance results will be presented at the end of the paper together with some techniques that can be used to increase the efficiency of the checkpointing mechanism.

A novel algorithm for checkpointing and rollback recovery in distributed systems is presented. Processes belonging to the same program must take periodically a nonblocking coordinated global checkpoint, but only a minimum overhead is imposed during normal computation. Messages can be delivered out of order, and the processes are not required to be deterministic. The nonblocking structure is an important characteristic for avoiding laying a heavy burden on the application programs. The method also includes the damage assessment phase, unlike previous schemes that either assume that an error is detected immediately after it occurs (fail-stop) or simply ignore the damage caused by imperfect detection mechanisms. A possible way to evaluate the error detection latency, which enables one to assess the damage made and avoid the propagation of errors, is presented.>