Person:
Ahamad, Mustaque

Permanent Link
https://hdl.handle.net/1853/71046
Associated Organization(s)
Organizational Unit
ORCID
ArchiveSpace Name Record

Filters

1991 - 1999 16
16
16
16
16
Reset filters

Settings
Start date: 1991 × End date: 1999 ×

Publication Search Results

Now showing 1 - 10 of 16
Thumbnail Image
Item

Enabling Interactive Applications over the Internet

1999 , Krishnaswamy, Vijaykumar , Ganev, Ivan Borissov , Dharap, Jaideep M. , Ahamad, Mustaque

As computers become pervasive in the home and community and homes become better connected, new applications will be deployed over the Internet. Interactive Distributed Applications involve users in multiple locations, across a wide area network, who interact and cooperate by manipulating shared objects. A timely response to user actions, which can potentially update the state of the objects, is an important requirement. Because of the inherent heterogeneity of the environment, traditionally distributed applications are built using technologies like distributed objects. These technologies are built around a central server paradigm which is undesirable because the response time for the actions of interactive users is always subject to communication latencies.Our approach is to extend these technologies with aggressive caching and replication mechanisms without changing the remote object interface to the applications. Thus, caching and replication are done transparently to provide interactive response time and to improve scalability. A flexible caching framework is presented, where objects can be cached in an application specific manner. It provides multiple consistency protocols that enable tradeoffs between the consistency of a cached object's state at a particular client, and the communication resources available at the client. At runtime, clients can specify their consistency requirements which can vary across different clients. This can be done via a Quality of Service specification interface that is meaningful at the application level. This paper presents the caching framework, its implementation and some preliminary performance results.

View
Thumbnail Image
Item

The Design Space for Data Replication Algorithms in Interactive Groupware

1998 , Bhola, Sumeer Kumar , Ahamad, Mustaque

Interactive (Synchronous) Groupware encompasses a wide range of applications, like collaborative whiteboards, text editors, engineering CAD (Computer Aided Design), Distributed Virtual Environments, and multi-player games. A very critical requirement for all these applications is the need to share data, which can be replicated to provide better responsiveness, fault-tolerance and scalability. Despite the existence of many systems and distributed algorithms for replication in interactive groupware, there is little agreement on the shared data abstraction to provide, or on the general algorithmic approach. Similarly, there is general lack of uniformity in the terminology used to describe such algorithms. This paper attempts to rectify this situation by (1) Describing the fundamental data requirements of interactive groupware, (2) Developing a data abstraction which is appropriate for meeting these requirements, (3) Developing a general algorithmic structure and terminology to express the characteristics of algorithm instances, and (4) Classifying the algorithms proposed in the research literature.

View
Thumbnail Image
Item

Exploiting Temporal and Spatial Constraints on Distributed Shared Objects

1996 , West, Richard , Schwan, Karsten , Tacic, Ivan , Ahamad, Mustaque

The advent of gigabit network technologies has made it possible to combine sets of uni- and multiprocessor workstations into a distributed, massively-parallel computer system. Middleware, such as distributed shared objects (DSO), attempts to improve programmability of such systems, by providing globally accessible 'object' abstractions. Early research on distributed shared object systems concerned protocols to maintain consistency across replicated 'memory' objects. Such systems are well suited to scientific applications but have limited support for multimedia or groupware applications. This paper addresses the state sharing needs of complex distributed applications with (1) high-frequency symmetric data accesses to shared objects, (2) unpredictable and limited locality of data access, (3) dynamically changing sharing behavior, and (4) potential data races. We show that a DSO system that exploits application-level temporal and spatial constraints on shared objects can outperform shared object protocols which do not exploit application-level constraints. We describe the features of our S(emantic) DSO and compare three application specific consistency protocols, developed to run on our system against entry consistency for a sample application having the four properties mentioned above.

View
Thumbnail Image
Item

Evaluation of Causal Distributed Shared Memory for Data-race-free Programs

1994 , John, Ranjit , Ahamad, Mustaque

Distributed Shared Memory (DSM) is becoming an accepted abstraction for programming distributed systems. Although DSM simplifies the programming of distributed applications, maintaining a consistent view of shared memory operations across processors in a distributed system can be expensive. The causal consistency model of DSM can allow more efficient implementations of DSM because it requires that only causally ordered memory operations be viewed in the same order at different processors. Also, weakly ordered systems have been proposed which advocate the use of synchronization information to reduce the frequency of communication between processors. We have implemented a system that exploits both the weaker consistency of causal memory and the synchronization information used in weakly ordered systems. Consistency is ensured by locally invalidating data that is suspected to be causally overwritten and this is only done when certain synchronization operations complete at a processor. Data-race-free programs can be written in this system assuming that the system provided sequentially consistent memory. By implementing applications that have a variety of data sharing patterns, we show that performance comparable to message passing implementations of the applications can be achieved in the causal DSM system. The improved performance is due to a significant reduction in communication costs compared to the implementation of a strongly consistent memory system. These results show that causal memory can meet the consistency and performance requirements of many distributed applications.

View
Thumbnail Image
Item

1/k Phase Timestamping for Replica Consistency in Interactive Collaborative Applications

1999 , Bhola, Sumeer Kumar , Ahamad, Mustaque

Interactive Collaborative applications, such as distributed virtual environments, collaborative CAD and multi-player games, are enabled by the data being shared across distributed users. The need to support such applications in a wide-area environment, and at the same time provide fast response to users, motivates replication of this shared data. The key characteristics of this shared data include short, incremental atomic operations for modifying this data,and the application's ability to predeclare access information for these operations. This and certain other differences from conventional replicated databases, motivate a different architecture for algorithms maintaining replica consistency. The main architectural differences include a complete separation of timestamping (for consistently ordering the operations) and execution of operations, propagation of the operation itself (instead of its effect) and local commit. We describe a specific consistency algorithm which does 2 phase timestamping (analogous to 2 phase locking) by sequentially acquiring stamps for objects accessed by an operation. Then we show how to eliminate the shrink phase and reduce the grow phase by a factor of k (when an operation accesses k objects), by concurrently getting all the stamps. This new algorithm is deadlock free and does not abort any operations.

View
Thumbnail Image
Item

Robust State Sharing for Wide Area Distributed Applications

1997 , Topol, Brad Byer , Ahamad, Mustaque , Stasko, John T.

In this article, we present the Mocha wide area computing infrastructure we are currently developing. Mocha provides support for robust shared objects on heterogeneous platforms, and utilizes advanced distributed shared memory techniques for maintaining consistency of shared objects that are replicated at multiple nodes to improve performance. In addition, our system handles failures that we feel will be common in wide area environments. For example, to ensure that the state of an object is not lost due to a node failure, updated state of the object can be disseminated to several other nodes. The overhead of such state dissemination can be controlled based on the level of availability needed for shared objects. We have used an approach that makes use of multiple communication protocols to improve the efficiency of shared object state transfers in Mocha. We also provide an empirical evaluation of our prototype implementation for both local and wide area networks and present a sample home service application written with the system.

View
Thumbnail Image
Item

System Support for Robust, Collaborative Applications

1995 , Chelliah, Muthusamy , Ahamad, Mustaque

Traditional transaction models ensure robustness for distributed applications through the properties of view and failure atomicity. It has generally been felt that such atomicity properties are restrictive for a wide range of application domains; this is particularly true for robust, collaborative applications because such applications have concurrent components that are inherently long-lived and that cooperate. Recent advances in extended transaction models can be exploited to structure long-lived and cooperative computations. Applications can use a combination of such models to achieve the desired degree of robustness; hence, we develop a system which can support a number of flexible transaction models, with correctness semantics that extend or relax serializability. We analyze two concrete CSCW applications - collaborative editor and meeting scheduler. We show how a combination of two extended transaction models, that promote split and cooperating actions, facilitates robust implementations of these collaborative applications. Thus, we conclude that a system that implements multiple transaction models provides flexible support for building robust, collaborative applications.

View
Thumbnail Image
Item

Responsiveness and Consistency Tradeoffs in Interactive Groupware

1998 , Bhola, Sumeer Kumar , Banavar, Guruduth S. , Ahamad, Mustaque

Interactive (or Synchronous) groupware is increasingly being deployed in widely distributed environments. Users of such applications are accustomed to direct manipulation interfaces that require fast response time. The state that enables interaction among distributed users can be replicated to provide acceptable response time in the presence of high communication latencies. We describe and evaluate design choices for protocols that maintain consistency of such state. In particular, we develop workloads which model user actions, identify the metrics important from a user's viewpoint, and do detailed simulations of a number of protocols to evaluate how effective they are in meeting user requirements.

View
Thumbnail Image
Item

Distributed Laboratories: A Research Proposal

1996 , Schwan, Karsten , Ahamad, Mustaque , Hudson, Scott E. , Limb, J. O. (John O.) , Ammar, Mostafa H. , Ezquerra, Norberto F. , Mukherjee, Amarnath , Potts, Colin , Ramachandran, Umakishore , Zegura, Ellen W. , Fujimoto, Richard M.

The continuing merger of computer and communication technologies is leading to a new computing/communications infrastructure of unprecedented magnitude, enabling new applications with broad economic and social impact. Yet, such applications pose major challenges to researchers in Computer Science and in application domains. The topic of the proposed research program is the realization of Distributed Laboratories, where individuals can interact with each other, and more importantly, with powerful, distributed computational tools as readily as if all were located in a single site. Our intent is to permit scientists, engineers, and managers at geographically distinct locations (including individuals 'tele-commuting' from home) to combine their expertise in solving shared problems, by allowing them to simultaneously view, interact with, and steer sophisticated computations executing on high performance distributed computing platforms.

View
Thumbnail Image
Item

Indigo: User-level Support for Building Distributed Shared Abstractions

1994 , Kohli, Prince , Ahamad, Mustaque , Schwan, Karsten

Distributed systems that consist of workstations connected by high performance interconnects offer computational power comparable to moderate size parallel machines. Middleware like Distributed Shared Memory (DSM) or Distributed Shared Objects (DSO) attempts to improve the programmability of such hardware by presenting to application programmers interfaces similar to those offered by shared memory machines. This paper presents the portable {\em Indigo} communications library which provides a small set of primitives with which arbitrary shared abstractions are easily and efficiently implemented across distributed hardware platforms. Sample shared abstractions implemented with Indigo include DSM and a variety of DSM protocols as well as fragmented objects, where object state is split across different machines and where fragment communications may be customized to application-specific consistency needs. The Indigo library's design and implementation are evaluated on two different target platforms, a workstation cluster and an IBM SP-2 machine. As part of this evaluation, a novel DSM system and consistency protocol are implemented and evaluated with several high performance applications. Application performance attained with the DSM system is compared to the performance experienced when utilizing the underlying basic message passing facilities or when employing Indigo to construct customized fragmented objects implementing the application's shared state. Such experimentation results in insights concerning the efficient implementation of DSM systems (e.g., how to deal with false sharing). It also leads to the conclusion that Indigo provides a sufficiently rich set of abstractions for efficient implementation of the next generation of parallel programming models for high performance machines.

View