Volume 9, Number 4
A Distributed Object Model for the JavaTM System
By Ann Wollrath, Roger Riggs, and Jim Waldo
AbstractWe show a distributed object model for the JavaTM System (hereafter referred to simply as "Java") that retains as much of the semantics of the Java object model as possible, and only includes differences where they make sense for distributed objects. The distributed object system is simple, in that a) distributed objects are easy to use and to implement, and b) the system itself is easily extensible and maintainable. We have designed such a model and implemented a system that supports remote method invocation (RMI) for distributed objects in Java. This system combines aspects of both the Modula-3 Network Objects system and Spring's subcontract and includes some novel features.
To achieve its goal of seamless integration in the language, the system exploits the use of object serialization (pickling) to transmit arguments and return values and also exploits unique features of Java in order to dynamically load stub code to clients. The system includes distributed reference-counting garbage collection for distributed objects and will include activation of object servers in the future.
Pickling State in the JavaTM System
By Roger Riggs, Jim Waldo, Ann Wollrath and Krishna Bharat
AbstractThe JavaTM system (hereafter referred to simply as "Java") inherently supports the transmission of stateless computation in the form of object classes. In this paper we address the related task of capturing the state of a Java object in a serialized form for the purposes of transmission or storage, to be used later in reconstituting an equivalent object. This is accomplished by a mechanism known as pickling.
Pickling is the process of creating a serialized representation of objects. Pickling defines the serialized form to include meta information that identifies the type of each object and the relationships between objects within a stream. Values and types are serialized with enough information to insure that the equivalent typed object and the objects to which it refers can be recreated. Unpickling is the complementary process of recreating objects from the serialized representation.
Pickling and unpickling extract from the Java Virtual machine, at runtime, any meta information needed to pickle the fields of objects. Class specific methods are only required to customize the pickling process.
Smart Messages: An Object-Oriented Communication Mechanism for Parallel Systems
By Eshrat Arjomandi, William G. O'Farrell and Gregory V. Wilson
AbstractABC++ is a portable object-oriented type-safe class library for parallel programming in C++. It supports active objects, synchronous and asynchronous object interactions, and object-based shared regions on both shared- and distributed-memory parallel computers. ABC++ is written in, and compatible with, standard C++ : no language extensions or pre-processors are used. This paper focuses on its use of an object-oriented technique called smart messages to support object interactions. Smart messages demonstrate the effectiveness of object-oriented programming in encapsulating low-level details of concurrency and in improving software portability.
Design and Performance of an Object-Oriented Framework for High-Speed Electronic Medical Imaging
By Irfan Pyarali, Timothy H. Harrison and Douglas C. Schmidt
AbstractThis paper describes the design and performance of an object-oriented communication framework being developed by the Health Imaging division of Eastman Kodak and the Electronic Radiology Laboratory at Washington University School of Medicine. The framework is designed to meet the demands of next-generation electronic medical imaging systems, which must transfer extremely large quantities of data efficiently and flexibly in a distributed environment. A novel aspect of this framework is its seamless integration of flexible high-level CORBA distributed object computing middleware with efficient low-level socket network programming mechanisms. In the paper, we outline the design goals and software architecture of our framework, describe how we resolved design challenges, and illustrate the performance of the framework over high-speed ATM networks.
Object Caching in a CORBA Compliant System
By R. Kordale, M. Ahamad and M. Devarakonda
AbstractDistributed object systems provide the key to building large scale applications that can execute on a range of platforms. The Common Object Request Broker Architecture (CORBA) specification from OMG attempts to address interoperability and heterogeneity issues that arise in such systems. Our goal is to investigate performance issues for distributed object systems. We claim that object caching is a must for improved performance and scalability in distributed object systems. However, this important technique and implementation issues related to it have not been widely studied in the context of distributed object systems and have not been addressed in CORBA specifications so far. In this paper, we discuss the design and implementation of Flex, a scalable and flexible distributed object caching system. Flex is built on top of Fresco, which uses the CORBA object model. Fresco runs on the UNIX operating system and our implementation of Flex exploits the features of object technology, Fresco and UNIX. This system allows us to quantify the performance improvements for object invocations that are made possible by caching.
By Peter H. Salus
Contributors to This Issue