Shaula Yemini

Optimistic recovery in distributed systems

Optimistic Recovery is a new technique supporting application-independent transparent recovery from processor failures in distributed systems. In optimistic recovery communication, computation and checkpointing proceed asynchronously. Synchronization is replaced by causal dependency tracking, which enables a posteriori reconstruction of a consistent distributed system state following a failure using process rollback and message replay. Because there is no synchronization among computation, communication, and checkpointing, optimistic recovery can tolerate the failure of an arbitrary number of processors and yields better throughput and response time than other general recovery techniques whenever failures are infrequent.

Typestate: A programming language concept for enhancing software reliability

The authors introduce a new programming language concept, called typestate, which is a refinement of the concept of type. Whereas the type of a data object determines the set of operations over permitted on the object, typestate determines the subset of these operations which is permitted in a particular context. Typestate tracking is a program analysis technique which enhances program reliability by detecting at compile-time syntactically legal but semantically undefined execution sequences. These include reading a variable before it has been initialized and dereferencing a pointer after the dynamic object has been deallocated. The authors define typestate, give examples of its application, and show how typestate checking may be embedded into a compiler. They discuss the consequences of typestate checking for software reliability and software structure, and summarize their experience in using a high-level language incorporating typestate checking.

High speed and robust event correlation

The authors describe a network management system and illustrate its application to managing a distributed database application on a complex enterprise network.

A coding approach to event correlation

This paper describes a novel approach to event correlation in networks based on coding techniques. Observable symptom events are viewed as a code that identifies the problems that caused them; correlation is performed by decoding the set of observed symptoms. The coding approach has been implemented in SMARTS Event Management System (SEMS), as server running under Sun Solaris 2.3. Preliminary benchmarks of the SEMS demonstrate that the coding approach provides a speedup at least two orders of magnitude over other published correlation systems. In addition, it is resilient to high rates of symptom loss and false alarms. Finally, the coding approach scales well to very large domains involving thousands of problems.

Volatile logging in n-fault-tolerant distributed systems

The authors introduce two enhancements to optimistic recovery which allow messages to be logged without performing any I/O to stable storage. The first permits messages to be instantaneously logged in volatile storage, as in the sender-based message logging technique of D.B. Johnson and W. Zwaenepoel (1987), but without their restriction of single-fault-tolerance. The second permits message data and/or message arrival orders not to be logged in circumstances where this information can be reconstructed in other ways. They show that the combination of these two optimizations yields a transparent n-fault-tolerant system which logs to stable storage only those messages received from the outside world and a very small number of additional messages.<<ETX>>

A modular verifiable exception handling mechanism

This paper presents a new model for exception handling, called the replacement model. The replacement model, in contrast to other exception-handling proposals, supports all the handler responses of resumption, termination, retry, and exception propagation, within both statements and expressions, in a modular, simple, and uniform fashion. The model can be embedded in any expression-oriented language and can also be adapted to languages which are not expression oriented with almost all the above advantages. This paper presents the syntactic extensions for embedding the replacement model into Algol 68 and its operational semantics. An axiomatic semantic definition for the model can be found in [27].

NIL: An integrated language and system for distributed programming

This paper presents features of the NIL programming language which support the construction of distributed software systems: (1) a process model in which no pointers or shared data are visible, (2) interprocess communication via synchronous and asynchronous message passing, (3) compile-time typestate checking , guaranteeing module isolation and correct finalization of data, (4) dynamic binding of statically typed ports under the control of capabilities. We discuss how these features are defined in NIL, illustrate the consequences of these decisions for the design of distributed systems, and compare these decisions with those made in other programming languages with similar objectives.

Network management by delegation: the MAD approach

Network management systems built on a client/server model centralize responsibilities in client manager processes, with server agents playing restrictive support roles. As a result, managers must micro-manage agents through primitive steps, resulting in ineffective distribution of management responsibilities, failure-prone management bottlenecks, and limitations for real time responsiveness. We present a more flexible paradigm, the Manager-Agent Delegation (MAD) framework. It supports the ability to extend the functionality of servers (agents) at execution time, allowing flexible distribution of management responsibilities in a distributed environment. MAD can store and instantiate delegated scripts, and provides a concurrent runtime environment, where they can execute asynchronously without requiring the managers intervention. A delegation protocol allows a manager to transfer programs, create process instances, and control their execution. We describe the delegation model, its application to network management, and the design of a prototype implementation.

High-level language debugging for concurrent programs

An integrated system design for debugging distributed programs written in concurrent high-level languages is described. A variety of user-interface, monitoring, and analysis tools integrated around a uniform process model are provided. Because the tools are language-based, the user does not have to deal with low-level implementation details of distribution and concurrency, and instead can focus on the logic of the program in terms of language-level objects and constructs. The tools provide facilities for experimentation with process scheduling, environment simulation, and nondeterministic selections. Presentation and analysis of the programs behavior are supported by history replay, state queries, and assertion checking. Assertions are formulated in linear time temporal logic, which is a logic particularly well suited to specify the behavior of distributed programs. The tools are separated into two sets. The language-specific tools are those that directly interact with programs for monitoring of and on-line experimenting with distributed programs. The language-independent tools are those that support off-line presentation and analysis of the monitored information. This separation makes the system applicable to a wide range of programming languages. In addition, the separation of interactive experimentation from off-line analysis provides for efficient exploitation of both user time and machine resources. The implementation of a debugging facility for OCCAM is described.

Interactive blackbox debugging for concurrent languages

We describe a novel approach to the design of portable integrated debugging tools for concurrent languages. Our design partitions the tools set into two categories. The language specific tools take into account the particular features of a programming language for on-line experimenting with and monitoring of distributed programs. The language independent tools support off-line presentation and analysis of the monitored information. The separation of the language independent tools from the language specific tools allows adapting the tools to support debugging for a broad category of concurrent programming languages. The separation of interactive experimentation from off-line analysis provides for efficient exploitation of both user time and machine resources. We present an overview of our design and describe the implementation of a prototype debugging facility for OCCAM.