Distributed objects: An approach based on replication and migration
Ernesto Pimentel1999, JOURNAL OF OBJECT ORIENTED …
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
The achievement of efficient implementations is still considered an open problem in the distributed object-oriented programming languages field. In this paper we present an approach to implement in a reasonable efficient way distributed objects. This approach is based on the use of a protocol that allows objects to be migrated and replicated. The basic idea is to reduce the overhead of remote invocations among objects making them local. The effectiveness of our scheme requires a strict programming model, where object invocations must be enclosed between pairs of acquire and release operations, and operations are classified in commands or queries. Details of a thread based implementation are presented. Experiments with a parallel matrix multiply program and a parallel branch and bound program, executed in three different architectures, demonstrate that significant speedups can be obtained.
Related papers
Applying distributed shared memory techniques for implementing distributed objects
Object-Oriented Technologys, 1998
In this paper we study how the potential advantages of distributed shared memory (DSM) techniques can be applied to concurrent object-oriented languages. We assume a DSM scheme based on an entry consistency memory model and propose an object model that can incorporate that DSM scheme. The object model is characterized by the requirement of explicitly enclosing object invocations between acquire and release operations, and the distinction between command and query operations. Details of a thread-based implementation are discussed, and results show that significant speed-ups can be obtained. We also conclude that using kernel-level threads can lead to better performance, and the overhead versus userlevel threads is negligible.
Replication techniques for speeding up parallel applications on distributed systems
Concurrency: Practice and Experience, 1992
Most methods for programming loosely-coupled systems are based on message-passing. Recently, however, methods have emerged based on ''virtually'' sharing data. These methods simplify distributed programming, but are hard to implement efficiently, as loosely-coupled systems do not contain physical shared memory. We introduce a new model, the shared data-object model, that eases the implementation of parallel applications on loosely-coupled systems, but can still be implemented efficiently. In our model, shared data are encapsulated in passive data-objects, which are variables of userdefined abstract data types. To speed up access to shared data, data objects are replicated. This ability to replicate objects is a significant difference with other object-based models (e.g., Emerald and Amber). Also, by replicating logical objects rather than physical pages, our model has many advantages over shared virtual memory systems. This paper discusses the design choices involved in replicating objects and their effect on performance. Important issues are: how to maintain consistency among different copies of an object; how to implement changes to objects; and which strategy for object replication to use. We have implemented several options to determine which ones are most efficient. * We will sometimes use the term "object" as a shorthand notation for data-objects. Note, however, that unlike in most parallel object-based systems, objects in our model are purely passive.
Configuring Object-Based Distributed Programs
1991
The popularity of the object oriented programming paradigm has stimulated research into its use for parallel and distributed programming. The major issues which impact such use are concurrency control, object interfaces, binding and inheritance. This paper discusses the relative merits of current solutions to these issues and describes an approach based on the use of active objects with essentially explicit interfaces and bindings, and composition as a pragmatic alternative to inheritance. The key feature of our approach is the use of a configuration language to define program structure as a set of objects and their bindings. The configuration language includes facilities for hierarchic definition of composite objects, for parameterisation of objects, for replication of both object instances and interface interaction points, for conditional configurations with evaluation of guards at object instantiation, and even for recursive definition of objects. This separate and explicit description of program structure complements the object oriented concepts yet is missing from most other approaches. This approach, termed Configuration Oriented Programming, is illustrated by examples from the REX environment for the development of distributable software. This environment is being developed by the REX collaborative ESPRIT II project [REX 89].
NUTS: a Distributed Object-oriented Platform with High Level Communication Functions
Computing and Informatics / Computers and Artificial Intelligence, 1998
An extensible object-oriented platform NUTS for distributed computing is described which is based on an object-oriented programming environment NUT, is built on top of the Parallel Virtual Machine (PVM), and hides all low-level features of the latter. The language of NUTS is a concurrent object-oriented programming language with coarse- grained parallelism and distributed shared memory communication model imple- mented on
A framework for seamlesly making object oriented applications distributed
Advances in Parallel Computing, 2004
Objects, Replication and Decoupled Communication in Distributed Environments
We hav e developed the Object Space approach which integrates that communication style with object-oriented techniques. It allows encapsulation of protocols for interactions in distributed applications into classes, thus providing a newlev elofabstraction.
Object Models for Distributed or Persistent Programming
The Computer Journal, 1997
As use of object orientation for application development has increased, many researchers have investigated the design of object-based programming languages for the distributed and persistent programming. This paper concentrates on reviewing a number of object-oriented languages for distributed or persistent programming. In each case, the focus is on the object model supported and the mechanisms and policies employed in the implementation of distributed or persistent objects. In particular, each language reviewed has been chosen to illustrate a particular object model or implementation strategy.
Distributed Proxy: A Design Pattern for Distributed Object Communication
1997
This paper presents the Distributed Proxy pattern, a design pattern for distributed object communication. The Distributed Proxy pattern decouples distributed object communication from object specific functionalities. It further decouples logical communication from physical communication. The Distributed Proxy pattern enforces an incremental development process, encapsulates the underlying distribution mechanisms, and offers location transparency. 1 Intent The Distributed Proxy pattern decouples the communication between distributed objects by isolating distributionspecific issues from object functionality. Moreover, distributed communication is further decoupled into logical communication and physical communication parts. 2 Motivation An example motivates for the problems and respective forces involved in distributed object communication. 2.1 Example A distributed agenda application has several users which manipulate agenda items, either private (appointments) or shared (meetings). ...
Panel: Distributed object technology: the future
Proceedings. Technology of Object-Oriented Languages. TOOLS 24 (Cat. No.97TB100240), 1998
Distributed object technology is fast becoming a central part of the object-oriented paradigm. Building reliable object oriented systems to work in a distributed environment has become not only desirable but also essential t o many application areas. The object-oriented approach to system structure, with its strengths of encapsulation and modularity, has found extensive acceptance among developers and designers of distributed software systems. This panel discussed the many varied outcomes that may occur in the future in the distributed object arena. Questions addressed included: = What are the real problems in a distributed object world? = What do any of the proposed solutions, including Java, CORBA or DCOM, actually provide in addition to more establish solutions such as Sockets or RPC? = What technology will be best placed to provide the required solutions? 416
Irregular data-parallelism in a parallel object-oriented language by means of Collective Replication
2010
In parallel object-oriented languages it is hard to elegantly express efficient data-parallel operations on objects of an irregularly-shaped object structure that is spread across the parallel computing environment.
Related topics
Related papers
An object-oriented framework for high performance distributed applications
1993
Fora variety ofreasons, distributed applications often must beimplemented using exist ing conventional programming languages and operating systems. Creating new high perfor mance distributed applications without high-level support from the programming language or operating system requires thatthe mechanism of distribution be selected early in the de sign stage, reducing the flexibility and/or efficiency of the design and subsequent imple mentation. Adding distribution to existing applications can result in an inordinate amount of reengineering duetothecomplexity andheterogeneity of interapplication communication mechanisms and their interfaces. This paper describes a new architecture for high performance distributed applications and a supporting framework. This architecture applies object-oriented design and imple mentation techniques tobuild a framework forplatform-independent distributed application specification and implementation using existing programming languages and operating sys tems. It utilizes an efficient and extensible layering architecture that allows new abstract data types, new protocols, and new interprocess communication mechanisms to be addedas they become necessary. h 6.
On the performance of distributed objects
Journal of Systems Architecture, 2000
Early distributed shared memory systems used the shared virtual memory approach with ®xed-size pages, usually 1±8 KB. As this does not match the variable granularity of sharing of most programs, recently the emphasis has shifted to distributed object-oriented systems. With small object sizes, the overhead of inter-process communication could be large enough to make a distributed program too inecient for practical use. To support research in this area, we have implemented a user-level distributed programming testbed, DIPC, that provides shared memory, semaphores and barriers. We develop a computationally-ecient model of distributed shared memory using approximate queueing network techniques. The model can accommodate several algorithms including central server, migration and readreplication. These models have been carefully validated against measurements on our distributed shared memory testbed. Results indicate that for large granularities of sharing and small access bursts, central server performs better than both migration and read-replication algorithms. Read-replication performs better than migration for small and moderate object sizes for applications with high degree of read-sharing and migration performs better than readreplication for large object sizes for applications having moderate degree of read-sharing.
Design of the Kan distributed object system
Concurrency: Practice and Experience, 2000
Distributed software problems are often addressed with object-oriented solutions. Objects provide the benefits of encapsulation and abstraction that have proven useful in managing the complexity of sequential code. However, the management of distributed objects is typically by means of complex APIs, such as CORBA, DCOM, or Java RMI. The complexity of the APIs is itself a hurdle to the writing of efficient, robust programs. An alternate approach is to provide the programmer with a simple interface to an underlying object management layer that provides efficient access to objects and sufficient power for common distributed programming tasks. This paper describes the implementation of the Kan system. It has a clear, simple object model with powerful semantics, embodying such concepts as atomic transactions, asynchronous method calls, and multithreading. The model primitives help the programmer avoid common concurrent programming errors, allowing clean expressions of concurrent algorithms. Kan provides distributed objects (i.e. objects that can migrate or be replicated), rather than the remote objects of Java RMI. Nevertheless, Kan optimizations provide runtime object accesses that are as efficient as or more efficient than accesses made to a similar distribution control layer over Java RMI. We describe the optimizations and measure their runtime impacts.
Programming a distributed system using shared objects
1993
Building the hardware for a high-performance distributed computer system is a lot easier than building its software. In this paper we describe a model for programming distributed systems based on abstract data types that can be replicated on all machines that need them. Read operations are done locally, without requiring network traffic. Writes can be done using a reliable broadcast algorithm if the hardware supports broadcasting; otherwise, a point-to-point protocol is used. We have built such a system based on the Amoeba microkernel, and implemented a language, Orca, on top of it. For Orca applications that have a high ratio of reads to writes, we have measured good speedups on a system with 16 processors.
Distributed active objects: A methodological proposal and tool for distributed programming with transputer systems
Microprocessing and Microprogramming, 1993
bDpt. Lenguajes y Ciencias de la Computaci6n. Universidad de M::ilaga. El Ejido, s/n. 29013 M,'ilaga. SPAIN.
An Architectural Comparison of Distributed Object Technologies
As developers develop larger systems, distributed object technologies came into the foreground to handle complexity. This thesis examines popular architectures of component software which can be scaled to handle large scale distributed systems. These architectures include OLE by Microsoft, CORBA by the Object Management Group, and Java Beans by Sun. Many issues need to be examined, such as what platforms will the system run on and the size of the network the system will run on. The decision of what architecture is suitable for a given complex system is crucial. This thesis provides a comparative analysis to provide a rational basis for selection.
Distributed Object Management
International Journal of Cooperative Information Systems, 1992
Future information processing environments will consist of a vast network of heterogeneous, autonomous, and distributed computing resources, including computers (from mainframe to personal), information-intensive applications, and data (files and databases). A key challenge in this environment is providing capabilities for combining this varied collection of resources into an integrated distributed system, allowing resources to be flexibly combined, and their activities coordinated, to address challenging new information processing requirements. In this paper, we describe the concept of distributed object management, and identify its role in the development of these open, interoperable systems. We identify the key aspects of system architectures supporting distributed object management, and describe specific elements of a distributed object management system being developed at GTE Laboratories.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.