scispace - formally typeset
Search or ask a question

Showing papers in "IEEE Transactions on Computers in 1997"


Journal Article•DOI•
TL;DR: A taxonomy of division algorithms is presented which classifies the algorithms based upon their hardware implementations and impact on system design, finding that, for low-cost implementations where chip area must be minimized, digit recurrence algorithms are suitable.
Abstract: Many algorithms have been developed for implementing division in hardware. These algorithms differ in many aspects, including quotient convergence rate, fundamental hardware primitives, and mathematical formulations. The paper presents a taxonomy of division algorithms which classifies the algorithms based upon their hardware implementations and impact on system design. Division algorithms can be divided into five classes: digit recurrence, functional iteration, very high radix, table look-up, and variable latency. Many practical division algorithms are hybrids of several of these classes. These algorithms are explained and compared. It is found that, for low-cost implementations where chip area must be minimized, digit recurrence algorithms are suitable. An implementation of division by functional iteration can provide the lowest latency for typical multiplier latencies. Variable latency algorithms show promise for simultaneously minimizing average latency while also minimizing area.

329 citations


Journal Article•DOI•
Ajay Bakre1, B. R. Badrinath2•
TL;DR: I-TCP as mentioned in this paper is an indirect transport layer protocol for mobile wireless environments, which can isolate mobility and wireless related problems using mobility support routers (MSRs) as intermediaries, which also provide backward compatibility with fixed network protocols.
Abstract: With the advent of small portable computers and the technological advances in wireless communications, mobile wireless computing is likely to become very popular in the near future. Wireless links are slower and less reliable compared to wired links and are prone to loss of signal due to noise and fading. Furthermore, host mobility can give rise to periods of disconnection from the fixed network. The use of existing network protocols, which were developed mainly for the high bandwidth and faster wired links, with mobile computers thus gives rise to unique performance problems arising from host mobility and due to the characteristics of wireless medium. Indirect protocols can isolate mobility and wireless related problems using mobility support routers (MSRs) as intermediaries, which also provide backward compatibility with fixed network protocols. We present the implementation and performance evaluation of I-TCP, which is an indirect transport layer protocol for mobile wireless environments. Throughput comparison with regular (BSD) TCP shows that I-TCP performs significantly better in a wide range of conditions related to wireless losses and host mobility. We also describe the implementation and performance of I-TCP handoffs.

245 citations


Journal Article•DOI•
TL;DR: It is shown that, by choosing hashing functions at random from a particular class, called H/sub 3/, of hashing functions, the analytical performance of hashing can be achieved in practice on real-life data.
Abstract: Hashing is critical for high performance computer architecture. Hashing is used extensively in hardware applications, such as page tables, for address translation. Bit extraction and exclusive ORing hashing "methods" are two commonly used hashing functions for hardware applications. There is no study of the performance of these functions and no mention anywhere of the practical performance of the hashing functions in comparison with the theoretical performance prediction of hashing schemes. In this paper, we show that, by choosing hashing functions at random from a particular class, called H/sub 3/, of hashing functions, the analytical performance of hashing can be achieved in practice on real-life data. Our results about the expected worst case performance of hashing are of special significance, as they provide evidence for earlier theoretical predictions.

242 citations


Journal Article•DOI•
TL;DR: Rover as mentioned in this paper is a software toolkit that supports the construction of both mobile-transparent and mobile-aware applications, which can be used to enable existing applications to run in a mobile environment without alteration.
Abstract: Rover is a software toolkit that supports the construction of both mobile-transparent and mobile-aware applications. The mobile-transparent approach aims to enable existing applications to run in a mobile environment without alteration. This transparency is achieved by developing proxies for system services that hide the mobile characteristics of the environment from applications. However, to excel, applications operating in the harsh conditions of a mobile environment must often be aware of and actively adapt to those conditions. Using the programming and communication abstractions present in the Rover toolkit, applications obtain increased availability, concurrency, resource allocation efficiency, fault tolerance, consistency, and adaptation. Experimental evaluation of a suite of mobile applications demonstrates that use of the toolkit requires relatively little programming overhead, allows correct operation, substantially increases interactive performance, and dramatically reduces network utilization.

240 citations


Journal Article•DOI•
TL;DR: This work considers the problem of communications over a wireless channel in support of data transmissions from the perspective of small portable devices that must rely on limited battery energy, and proposes a simple probing scheme and a modified scheme that yields slightly better performance but requires some additional complexity.
Abstract: We consider the problem of communications over a wireless channel in support of data transmissions from the perspective of small portable devices that must rely on limited battery energy. We model the channel outages as statistically correlated errors. Classic ARQ strategies are found to lead to a considerable waste of energy, due to the large number of transmissions. The use of finite energy sources in the face of dependent channel errors leads to new protocol design criteria. As an example, a simple probing scheme, which slows down the transmission rate when the channel is impaired, is show? to be more energy efficient, with a slight loss in throughput. A modified scheme that yields slightly better performance but requires some additional complexity is also studied. Some references on the modeling of battery cells are discussed to highlight the fact that battery charge capacity is strongly influenced by the available "relaxation time" between current pulses. A formal approach that can track complex models for power sources, including dynamic charge recovery, is also developed.

205 citations


Journal Article•DOI•
TL;DR: The system performance impact of floating-point division latency for varying instruction issue rates is presented and the performance implications of shared multiplication hardware, shared square root, on-the-fly rounding and conversion, and fused functional units are examined.
Abstract: Floating-point division is generally regarded as a low frequency, high latency operation in typical floating-point applications. However, in the worst case, a high latency hardware floating-point divider can contribute an additional 0.50 CPI to a system executing SPECfp92 applications. This paper presents the system performance impact of floating-point division latency for varying instruction issue rates. It also examines the performance implications of shared multiplication hardware, shared square root, on-the-fly rounding and conversion, and fused functional units. Using a system level study as a basis, it is shown how typical floating-point applications can guide the designer in making implementation decisions and trade-offs.

192 citations


Journal Article•DOI•
Yi-Min Wang1•
TL;DR: This paper defines the least stringent of these models ("FDAS"), and puts it in context with other models defined in the literature, and introduces a concept called "rollback-dependency tractability" that enables this analysis to be performed efficiently for a certain class of checkpoint and communication models.
Abstract: In this paper, we consider the problem of constructing consistent global checkpoints that contain a given set of checkpoints. We address three important issues related to this problem. First, we define the maximum and minimum consistent global checkpoints containing a set S, and give algorithms to construct them. These algorithms are based on reachability analysis on a rollback-dependency graph. Second, we introduce a concept called "rollback-dependency tractability" that enables this analysis to be performed efficiently for a certain class of checkpoint and communication models. We define the least stringent of these models ("FDAS"), and put it in context with other models defined in the literature. Significant in this is a way to use FDAS to provide efficient rollback recovery for applications that do not satisfy perfect piecewise determinism. Finally, we describe several applications of the theorems and algorithms derived in this paper to demonstrate the capability of our approach to unify, generalize, and extend many previous works.

180 citations


Journal Article•DOI•
TL;DR: The rationale for a functional simulation tool, called DEPEND, which provides an integrated design and fault injection environment for system level dependability analysis is presented and techniques developed to simulate realistic fault scenarios, reduce simulation time explosion, and handle the large fault model and component domain associated with system level analysis are presented.
Abstract: The paper presents the rationale for a functional simulation tool, called DEPEND, which provides an integrated design and fault injection environment for system level dependability analysis. The paper discusses the issues and problems of developing such a tool, and describes how DEPEND tackles them. Techniques developed to simulate realistic fault scenarios, reduce simulation time explosion, and handle the large fault model and component domain associated with system level analysis are presented. Examples are used to motivate and illustrate the benefits of this tool. To further illustrate its capabilities, DEPEND is used to simulate the Unix-based Tandem triple-modular-redundancy (TMR) based prototype fault-tolerant system and to evaluate how well it handles near-coincident errors caused by correlated and latent faults. Issues such as memory scrubbing, re-integration policies, and workload dependent repair times, which affect how the system handles near-coincident errors, are also evaluated. Unlike any other simulation-based dependability studies, the accuracy of the simulation model is validated by comparing the results of the simulations with measurements obtained from fault injection experiments conducted on a production Tandem machine.

160 citations


Journal Article•DOI•
Nitin H. Vaidya1•
TL;DR: In this paper, the authors show that a large increase in latency is acceptable if it is accompanied by a relatively small reduction in overhead, and for equidistant checkpoints, optimal checkpoint interval is typically independent of checkpoint latency.
Abstract: Checkpointing reduces loss of computation in the presence of failures. Two metrics characterize a checkpointing scheme: checkpoint overhead and checkpoint latency. The paper shows that a large increase in latency is acceptable if it is accompanied by a relatively small reduction in overhead. Also, for equidistant checkpoints, optimal checkpoint interval is shown to be typically independent of checkpoint latency.

157 citations


Journal Article•DOI•
TL;DR: A method is proposed for deriving the necessary commands from a correctness proof of the underlying algorithm in a formalism based on temporal relations among operation executions to synchronize memory accesses.
Abstract: A multiprocess program executing on a modern multiprocessor must issue explicit commands to synchronize memory accesses. A method is proposed for deriving the necessary commands from a correctness proof of the underlying algorithm in a formalism based on temporal relations among operation executions.

140 citations


Journal Article•DOI•
TL;DR: In this article, the problem of finding an optimal and suboptimal task allocation (i.e., to which processor should each module of a task or program be assigned) in distributed computing systems with the goal of maximizing the system reliability is considered.
Abstract: We consider the problem of finding an optimal and suboptimal task allocation (i.e., to which processor should each module of a task or program be assigned) in distributed computing systems with the goal of maximizing the system reliability (i.e., the probability that the system can run the entire task successfully). The problem of finding an optimal task allocation is known to be NP-hard in the strong sense. We present an algorithm for this problem, which uses the idea of branch and bound with underestimates for reducing the computations in finding an optimal task allocation. The algorithm reorders the list of modules to allow a subset of modules that do not communicate with one another to be assigned last, for further reduction in the computations of optimal task allocation for maximizing reliability. We also present a heuristic algorithm which obtains suboptimal task allocations in a reasonable amount of computational time. We study the performance of the algorithms over a wide range of parameters such as the number of modules, the number of processors, the ratio of average execution cost to average communication cost, and the connectivity of modules. We demonstrate the effectiveness of our algorithms by comparing them with recent competing task allocation algorithms for maximizing reliability available in the literature.

Journal Article•DOI•
TL;DR: A technique to enhance multicomputer routers for fault-tolerant routing with modest increase in routing complexity and resource requirements is described, which handles solid faults in meshes.
Abstract: A technique to enhance multicomputer routers for fault-tolerant routing with modest increase in routing complexity and resource requirements is described. This method handles solid faults in meshes, which includes all convex faults and many practical nonconvex faults, for example, faults in the shape of L or T. As examples of the proposed method, adaptive and nonadaptive fault-tolerant routing algorithms using four virtual channels per physical channel are described.

Journal Article•DOI•
TL;DR: A general model for constructing minimal length checking sequences employing a distinguishing sequence based on characteristics of checking sequences and a set of state recognition sequences is proposed.
Abstract: A general model for constructing minimal length checking sequences employing a distinguishing sequence is proposed. The model is based on characteristics of checking sequences and a set of state recognition sequences. Some existing methods are shown to be special cases of the proposed model and are proven to construct checking sequences. The minimality of the resulting checking sequences is discussed and a heuristic algorithm for the construction of minimal length checking sequences is given.

Journal Article•DOI•
TL;DR: The authors present a full radix-4 CORDIC algorithm in rotation mode and circular coordinates and its corresponding selection function, and propose an efficient technique for the compensation of the nonconstant scale factor.
Abstract: Traditionally, CORDIC algorithms have employed radix-2 in the first n/2 microrotations (n is the precision in bits) in order to preserve a constant scale factor. The authors present a full radix-4 CORDIC algorithm in rotation mode and circular coordinates and its corresponding selection function, and propose an efficient technique for the compensation of the nonconstant scale factor. Three radix-4 CORDIC architectures are implemented: 1) a word serial architecture based on the zero skipping technique, 2) a pipelined architecture, and 3) an application specific architecture (the angles are known beforehand). The first two are general purpose implementations where redundant (carry-save) or nonredundant arithmetic can be used, whereas the last one is a simplification of the first two. The proposed architectures present a good trade-off between latency and hardware complexity when compared with existing CORDIC architectures.

Journal Article•DOI•
TL;DR: The proposed algorithm uses knowledge of the current cost of a checkpoint when it decides whether or not to place a checkpoint, and its behavior is close to the off-line optimal algorithm that uses a complete knowledge of checkpointing cost.
Abstract: Checkpointing enables us to reduce the time to recover from a fault by saving intermediate states of the program in a reliable storage. The length of the intervals between checkpoints affects the execution time of programs. On one hand, long intervals lead to long reprocessing time, while, on the other hand, too frequent checkpointing leads to high checkpointing overhead. In this paper, we present an on-line algorithm for placement of checkpoints. The algorithm uses knowledge of the current cost of a checkpoint when it decides whether or not to place a checkpoint. The total overhead of the execution time when the proposed algorithm is used is smaller than the overhead when fixed intervals are used. Although the proposed algorithm uses only on-line knowledge about the cost of checkpointing, its behavior is close to the off-line optimal algorithm that uses a complete knowledge of checkpointing cost.

Journal Article•DOI•
TL;DR: A model of lossless image compression in which each band of a multispectral image is coded using a prediction function involving values from a previously coded band of the compression, and how the ordering of the bands affects the achievable compression is considered.
Abstract: In this paper, we consider a model of lossless image compression in which each band of a multispectral image is coded using a prediction function involving values from a previously coded band of the compression, and examine how the ordering of the bands affects the achievable compression. We present an efficient algorithm for computing the optimal band ordering for a multispectral image. This algorithm has time complexity O(n/sup -/) for an n-band image, while the naive algorithm takes time /spl Omega/(n!). A slight variant of the optimal ordering problem that is motivated by some practical concerns is shown to be NP-hard, and hence, computationally infeasible, in all cases except for the most trivial possibility. In addition, we report on our experimental findings using the algorithms designed in this paper applied to real multispectral satellite data. The results show that the techniques described here hold great promise for application to real-world compression needs.

Journal Article•DOI•
TL;DR: This paper introduces two arctangent radices and shows that about 2/3 of the rotation directions can be derived in parallel without any error.
Abstract: Each coordinate rotation digital computer iteration selects the rotation direction by analyzing the results of the previous iteration. In this paper, we introduce two arctangent radices and show that about 2/3 of the rotation directions can be derived in parallel without any error. Some architectures exploiting these strategies are proposed.

Journal Article•DOI•
Jie Wu1, Ke Huang1•
TL;DR: This paper presents an interconnection structure, called the balanced hypercube, which is a variation of the standard hypercube with desirable properties of strong connectivity, regularity, and symmetry, and shows a fault-tolerant embedding of rings in balanced hypercubes.
Abstract: In this paper, we present an interconnection structure, called the balanced hypercube, which is a variation of the standard hypercube with desirable properties of strong connectivity, regularity, and symmetry. The proposed structure is a special type of load balanced graph designed to tolerate processor failure. In balanced hypercubes, each processor has a backup (matching) processor that shares the same set of neighboring nodes. Therefore, tasks that run on a faulty processor can be reactivated in the backup processor to provide efficient system reconfiguration. Other properties of balanced hypercubes are examined. It is also shown that odd-dimensional balanced hypercubes have smaller diameters than that of standard hypercubes. As an application of balanced hypercubes, we show a fault-tolerant embedding of rings in balanced hypercubes.

Journal Article•DOI•
TL;DR: A new scheduling algorithm is presented, ROBUST, that efficiently takes advantage of limits on the tightness of task deadlines to provide improved overload performance and is asymptotically optimal.
Abstract: No on-line scheduling algorithm operating in an uniprocessor environment can guarantee to obtain a useful processor utilization greater than 0.25 under conditions of overload. This result holds in the general case, where the deadlines of the input tasks can be arbitrarily "tight." We address here the issue of improving overload performance in environments where there is a limit on the tightness of task deadlines. In particular, we present a new scheduling algorithm, ROBUST, that efficiently takes advantage of these limits to provide improved overload performance and is asymptotically optimal. We also introduce the concept of overload tolerance, wherein a system's overload performance never falls below its design capacity, and describe how ROBUST may be used to construct overload tolerant systems.

Journal Article•DOI•
TL;DR: This paper addresses the problem of allocating (assigning and scheduling) periodic task modules to processing nodes in distributed real-time systems subject to task precedence and timing constraints using the branch-and-bound technique to find an "optimal" allocation.
Abstract: This paper addresses the problem of allocating (assigning and scheduling) periodic task modules to processing nodes in distributed real-time systems subject to task precedence and timing constraints. Using the branch-and-bound technique, a module allocation scheme is proposed to find an "optimal" allocation that maximizes the probability of meeting task deadlines. The task system within a planning cycle is first modeled with a task flow graph which describes computation and communication modules, as well as the precedence constraints among them. To incorporate both timing and logical correctness into module allocation, the probability of meeting task deadlines is used as the objective function. The module allocation scheme is then applied to find an optimal allocation of task modules in a distributed system. The timing aspects embedded in the objective: function drive the scheme not only to assign task modules to processing nodes, but also to use a module scheduling algorithm (with polynomial time complexity) for scheduling all modules assigned to each node, so that all tasks maybe completed in time. In order to speed up the branch-and-bound process and to reduce the computational complexity, a dominance relation is derived. Several numerical examples are presented to demonstrate the effectiveness and practicality of the proposed scheme.

Journal Article•DOI•
TL;DR: This work demonstrates the feasibility of building complex asynchronous systems and gives an indication of the costs and benefits of the Micropipeline approach.
Abstract: An asynchronous implementation of the ARM microprocessor has been developed using an approach based on Sutherland's Micropipelines. The design allows considerable internal asynchronous concurrency. This paper presents the rationale for the work, the organization of the chip, and the characteristics of the prototype silicon. The design displays unusual properties such as nondeterministic (but bounded) prefetch depth beyond a branch instruction, a data dependent throughput, and employs a novel register locking mechanism. This work demonstrates the feasibility of building complex asynchronous systems and gives an indication of the costs and benefits of the Micropipeline approach.

Journal Article•DOI•
TL;DR: This paper presents a concise and efficient implementation of a method of producing De Bruijn sequences based on a recursive method due to A. Lempel (1970) that requires only O(2/sup n/) bit operations.
Abstract: This paper presents a concise and efficient implementation of a method of producing De Bruijn sequences. The implementation is based on a recursive method due to A. Lempel (1970). We provide code for a function that for each pair of integers n/spl ges/2 and 0/spl les/x<2/sup n-2/ returns a unique De Bruijn sequence of order-n. The implementation requires only O(2/sup n/) bit operations.

Journal Article•DOI•
M.M. Bae1•
TL;DR: This paper investigates methods to locate system resources to provide the most effective cost/performance trade-offs in a torus parallel machine and presents generalized resource placement methods based on the concept of covering radius of Lee distance codes.
Abstract: This paper investigates methods to locate system resources, such as expensive hardware or software modules, to provide the most effective cost/performance trade-offs in a torus parallel machine. This paper contains some solutions to perfect distance-t and perfectiquasi-perfect j-adjacency placement in a k-ary n-cube and a torus using Lee distance error-correcting codes. It also presents generalized resource placement (j-adjacency with distance-t placement) methods based on the concept of covering radius of Lee distance codes.

Journal Article•DOI•
Abstract: This paper argues that the cipher systems based on cellular automata (CA) proposed by S. Nandi et al. (1994) are affine and are insecure. A reply by S. Nandi and P. Pal Chaudhuri is given. The reply emphasizes the point that the regular, modular, cascadable structure of local neighborhood CA can be employed for building low cost cipher system hardware. This cost effective engineering solution can achieve desired level of security with larger size CA.

Journal Article•DOI•
TL;DR: It is shown that all the equivalence classes of four-variable functions are uniquely identified where majority of the classes have a single FPRM form as their representative.
Abstract: In this paper, we present a new method to characterize completely specified Boolean functions. The central theme of the classification is the functional equivalence (a.k.a. Boolean matching). Two Boolean functions are equivalent if there exists input permutation, input negation, or output negation that can transform one function to the other. We have derived a method that can efficiently identify equivalence classes of Boolean functions. The well-known canonical Fixed Polarity Reed-Muller (FPRM) forms are used as a powerful analysis tool. The necessary transformations to derive one function from the other are inherent in the FPRM representations. To identify uniquely each equivalence class, a set of well-known characteristics of Boolean functions and their variables (including linearity, symmetry, total symmetry, self-complement, and self-duality) are employed. It is shown that all the equivalence classes of four-variable functions are uniquely identified where majority of the classes have a single FPRM form as their representative. The Boolean matching has applications in technology mapping and in design of standard cell libraries.

Journal Article•DOI•
TL;DR: In this article, the authors presented a testable AND-EXOR network using generalized Reed-Muller expressions (GRMs) instead of Positive Polarity Reed-muller expression (PPRMs).
Abstract: This paper presents a design method of easily testable AND-EXOR networks. It is an improvement of Reddy (1972) and Saluja-Reddy's (1975) methods, and has the following features. The network uses generalized Reed-Muller expressions (GRMs) instead of Positive Polarity Reed-Muller expressions (PPRMs). The average number of products for GRMs is less than half of that for PPRMs, and is less than that of sum-of-products expressions (SOPs). The network consists of a literal part, an AND part, an EXOR part, and a check part. The EXOR part can be a tree instead of a cascade. Thus, the network is faster. The test detects multiple stuck at faults under the assumption that the faults occur at most one part, either the literal part, the AND part, the EXOR part, or the check part.

Journal Article•DOI•
TL;DR: It is shown that only three virtual channels per physical channel are sufficient for tolerating multiple faulty regions in wormhole routing algorithms, and that f-cube4 leads to deadlocks for some extreme combinations of fault regions.
Abstract: Boppana and Chalasani (1995) present simple methods to enhance wormhole routing algorithms for fault-tolerance in meshes, In this brief paper, we note that one of their algorithms, f-cube4, can further be improved. In particular, we show that only three virtual channels per physical channel are sufficient for tolerating multiple faulty regions. We also show that our scheme does not lead to deadlock with any combination of faults, while f-cube4 leads to deadlocks for some extreme combinations of fault regions.

Journal Article•DOI•
TL;DR: Decisions on the profiles of dynamic constructs within a macro actor, such as a conditional and a data-dependent iteration, are shown to be optimal under some bold assumptions, and expected to be near-optimal in most cases.
Abstract: Scheduling dataflow graphs onto processors consists of assigning actors to processors, ordering their execution within the processors, and specifying their firing time. While all scheduling decisions can be made at runtime, the overhead is excessive for most real systems. To reduce this overhead, compile-time decisions can be made for assigning and/or ordering actors on processors. Compile-time decisions are based on known profiles available for each actor at compile time. The profile of an actor is the information necessary for scheduling, such as the execution time and the communication patterns. However, a dynamic construct within a macro actor, such as a conditional and a data-dependent iteration, makes the profile of the actor unpredictable at compile time. For those constructs, we propose to assume some profile at compile-time and define a cost to be minimized when deciding on the profile under the assumption that the runtime statistics are available at compile-time. Our decisions on the profiles of dynamic constructs are shown to be optimal under some bold assumptions, and expected to be near-optimal in most cases. The proposed scheduling technique has been implemented as one of the rapid prototyping facilities in Ptolemy. This paper presents the preliminary results on the performance with synthetic examples.

Journal Article•DOI•
TL;DR: The cost optimal release policy, which minimizes the total expected software cost, is discussed, which should be paid by the manufacturer if the software is delivered after the scheduled delivery time.
Abstract: The Hyper-Geometric Distribution software reliability growth Model (HGDM) was developed to estimate the number of remaining software faults after completing the test/debug phase. An important problem in the software development process is to determine when to stop testing and release the software to the users. In this paper, the cost optimal release policy, which minimizes the total expected software cost, is discussed. The total expected software cost here includes the penalty cost, which should be paid by the manufacturer if the software is delivered after the scheduled delivery time. The underlying software reliability growth model in our approach is the HGDM. Numerical examples are presented for illustration.

Journal Article•DOI•
TL;DR: An abstract characterization for shared state management in partitionable asynchronous distributed systems is given and how views can be enriched to convey structural and historical information relevant to the group's activity is shown.
Abstract: Distributed systems constructed using off-the-shelf communication infrastructures are becoming common vehicles for doing business in many important application domains. Large geographic extent due to increased globalization, increased probability of failures, and highly dynamic loads all contribute toward a partitionable and asynchronous characterization for these systems. In this paper, we consider the problem of developing reliable applications to be deployed in partitionable asynchronous distributed systems. What makes this task difficult is guaranteeing the consistency of shared state despite asynchrony, failures, and recoveries, including the formation and merging of partitions. While view synchrony within process groups is a powerful paradigm that can significantly simplify reasoning about asynchrony and failures, it is insufficient for coping with recoveries and merging of partitions after repairs. We first give an abstract characterization for shared state management in partitionable asynchronous distributed systems and then show how views can be enriched to convey structural and historical information relevant to the group's activity. The resulting, paradigm, called enriched view synchrony, can be implemented efficiently and leads to a simple programming methodology for solving shared state management in the presence of partitions.