Mohan Ahuja

Flush primitives for asynchronous distributed systems

We present three channel primitives for sending messages: two-way-flush, forward-flush, and backward-flush, collectively termed Flush. A non-FIFO channel that supports Flush will be termed an F-channel. F-channels can permit as much concurrency as non-FIFO channels and yet retain the properties of FIFO channels that lead to simplicity of reasoning in design and proofs of correctness of distributed algorithms. We illustrate these claims using examples of distributed algorithms for taking global snapshots and in the process we also illustrate that use of these primitives weaker definition of a channel state compared to defining it as a sequence of messages.

On job scheduling on a hypercube

The problem of scheduling n independent jobs on an m-dimensional hypercube system to minimize the finish time is studied. Each job J/sub i/, where 1 >

A basic unit of computation in distributed systems

The authors define basic units of computation in distributed systems, whether communicating synchronously or asynchronously, as comprising indivisible logical units of computation that take the system from one ground state to another. It is explained how a computation can be viewed as a partial order over the basic units of the computation. The problem of detecting the basic units is considered. One algorithm for creating ground states during a computation in an asynchronously communicating system with FIFO channels is given, and an existing algorithm that implicitly creates ground states in a synchronously communicating system is referenced. The significance of the basic unit is explained, and its applications are given.<<ETX>>

An implementation of F-channels

An F-channel can permit as much concurrency as a non-first-in-first-out (FIFO) communication channel and yet retain the properties of a FIFO channel that lead to simplicity of reasoning in design and proofs of the correctness of distributed algorithms. The author presents an implementation of an F-channel on top of a non-FIFO channel that derives its non-FIFO nature from a message taking any of the alternate paths from the source to the destination in the underlying network in which each channel is either an F-channel implemented using some other implementation or recursively using the implementation presented or a FIFO channel. The correctness of the implementation is proven. >

An implementation of F-channels, a preferable alternative to FIFO channels

An F-channel can permit as much concurrency as a nonFIFO channel and yet retain the properties of a FIFO channel that leads to simplicity of reasoning in design and proofs of the correctness of distributed algorithms. This is one of the major reasons that makes it preferable to a FIFO channel and make its implementation important. This and other reasons for its superiority over a FIFO channel are discussed, and it is proposed that systems should provide implementation of F-channels. Reasons are discussed for this proposal which are based on the principle that a system should provide an interface to the users that makes algorithm design easy and that leads to efficient user efforts and system operation. Implementation of an F-channel on top of a nonFIFO channel is presented.<<ETX>>

An O( n log n ) feasibility algorithm for preemptive scheduling of n independent jobs on a hypercube

Abstract We present a new feasibility algorithm to decide if n independent jobs can be finished by a given deadline T on an m -dimensional hypercube system. It takes O( n log n ) time and generates a schedule with at most n −2 preemptions. A previously known algorithm takes O( n 2 ) time and produces a schedule with up to 1 2 n(n−1) preemptions.

An implementation of flush channels based on a verification methodology

Flush channels generalize more conventional asynchronous message passing protocols. A distributed system that uses flush channels allows a programmer the flexibility of specifying the delivery order of each message in relation to other messages transmitted on the channel. An implementation technique that follows directly from a verification methodology for flush channels is presented. A relatively formal argument in support of the technique is included.<<ETX>>

Performance evaluation of two concurrency control protocols for distributed databases with multiversioned entities

The authors evaluate and compare the performance of two concurrency control protocols for distributed databases with multiversioned entities, assuming that each transaction incrementally declares its access set from the successive parts of the preordered entities. The first protocol is called protocol proposed (PP). The second is a variant of the protocol proposed by D.P. Reed (1978), here called RP1. Performance results for these protocols are collected using simulations. Key performance issues of PP are studied and relative performance of PP and RP1 is compared. Extra memory requirement is the most important cost for PP, while the cost associated with abortion of transactions are most important for RP1. For slow communication networks, at all workloads except some range of low workloads, PP performs better than RP1. For fast networks, between low to very high workloads RP1 performs better for a range of parameters. At extremely high workloads, both perform poorly, but the higher memory requirement of PP is more tolerable than the high abortion rate of RP1. A protocol similar to PP is proposed that permits universioned entities and so does not have extra memory cost and has the advantages of PP.<<ETX>>

Proof rules for flush channels

Flush channels generalize conventional asynchronous communication constructs such as virtual circuits and datagrams. They permit the programmer to specify receipt-order restrictions on a message-by-message basis, providing an opportunity for more concurrency in a distributed program. A Hoare-style partial correctness verification methodology for distributed systems which use flush channel communication is developed, and it is shown that it it possible to reason about such systems in a relatively natural way. >

Units of computation in fault-tolerant distributed systems

We develop a framework that helps in developing understanding of a fault-tolerant distributed system and so helps in designing such systems. We define a unit of computation in such systems, referred to as a molecule, that has a well defined interface with other molecules, i.e. has minimal dependence on other molecules. The smallest such unit-an indivisible molecule-is termed as an atom. We show that any execution of a fault-tolerant distributed computation can be seen as an execution of molecules/atoms in a partial order, and such a view provides insights into understanding the computation, particularly for a fault tolerant system where it is important to guarantee that a unit of computation is either completely executed or not at all and system designers need to reason about the states after execution of such units. We prove different properties satisfied by molecules and atoms, and present algorithms to detect atoms in an ongoing computation and to force the completion of a molecule. We illustrate the uses of the developed work in application areas such as debugging, checkpointing, and reasoning about stable properties.<<ETX>>