Showing papers on "Distributed object published in 1994"

Methods and systems for object-based relational distributed databases

Abstract: An object-based relational distributed database system and associated methods of operation that transforms data stored in a plurality of remote, heterogeneous user databases into a homogeneous data model is disclosed. Data stored in distributed, heterogeneous user database structures is homogenized by mapping into object attributes of predetermined instances of objects forming to a conceptual model that relates the various heterogeneous databases. The object attributes are stored in remote databases at client sites, which can be separate computer systems from the heterogeneous user databases or separate processes running on a computer system that maintains the heterogeneous user databases. The system stores location information and status information relating to the homogenized data in a centralized object broker for object management, thereby facilitating location and retrieval of data items from one or more of the remote, heterogeneous user databases.

Distributed hypermedia method for automatically invoking external application providing interaction and display of embedded objects within a hypermedia document

Abstract: A system allowing a user of a browser program on a computer connected to an open distributed hypermedia system to access and execute an embedded program object. The program object is embedded into a hypermedia document much like data objects. The user may select the program object from the screen. Once selected the program object executes on the user's (client) computer or may execute on a remote server or additional remote computers in a distributed processing arrangement. After launching the program object, the user is able to interact with the object as the invention provides for ongoing interprocess communication between the application object (program) and the browser program. One application of the embedded program object allows a user to view large and complex multi-dimensional objects from within the browser's window. The user can manipulate a control panel to change the viewpoint used to view the image. The invention allows a program to execute on a remote server or other computers to calculate the viewing transformations and send frame data to the client computer thus providing the user of the client computer with interactive features and allowing the user to have access to greater computing power than may be available at the user's client computer.

Method and apparatus for dynamic update of an existing object in an object editor

Abstract: User interface objects are stored in a user interface object archive which is a database physically located in the shared library of an associated application program. In order to facilitate "localization", or preparation of an application developed in one language for use in an "area" or a locale which uses another language, the user interface objects are stored in a hierarchical locale tree within the archive. All objects are stored in the base or root of the hierarchy, but only those objects which require a translation are stored in an area associated with a more specific locale. At runtime, a complete collection of objects is assembled by starting at the desired locale and proceeding up the hierarchy level-by-level. Translated objects at lower levels of the hierarchy "override" those at higher levels so that the most complete translations of each object are obtained during this search. The user interface objects which are stored in an archive are actually created via a predefined "constructor" program, and, in order to allow newly-created user interface objects to use the predesigned constructor program, each user interface object is contained in a special "escort" object that interfaces with the constructor program. A user can edit an existing object, and change its class. This results in a new object of the new class being created. The existing attributes of the old object are transferred to the new object. Only the attributes known to the common base class or classes of the two objects are transferred. The new object is substituted for the old object, and the old object is deleted.

Method and system for dynamically generating object connections

Abstract: A method and system for dynamically generating object connections is provided. In a preferred embodiment, a connection can be generated between a source object and a sink object using a connection point object. A source object has connection point objects where each connection point object corresponds to a particular interface. A sink object implements one or more notification interfaces for connecting to a source object. A connection point object of a source object can connect to multiple notification interfaces, which belong to one or more sink objects. A connection point object keeps track of pointers to the notification interfaces to which it has been connected. In order to generate a connection, a sink object requests from a source object a connection point object corresponding to a particular interface. The source object determines whether it supports such a connection point object, and if so returns a pointer to the connection point interface of the determined connection point object. The sink object then requests to be connected to the connection point object using the returned connection point interface pointer and passes a reference to a notification interface of the sink object corresponding to the particular interface. The connection point object then stores the reference to the notification interface of the sink object, creating a connection between the sink object and the source object. At some later time, the source object can utilize the connection to notify the sink object through the connected notification interfaces.

Object oriented data store integration environment for integration of object oriented databases and non-object oriented data facilities

Abstract: A method and apparatus for accessing and effectively integrating non-object oriented data stores with object applications. An integrating environment is implemented wherein an application using a distributed object database and object database management system (ODBMS) is provided with an interface to external data stores in a manner so as to effect location transparency. The application, accessing data via the ODBMS, can manipulate data in foreign data stores which include external data that is mapped and converted into objects for use by object applications. A storage management application program interface ("SM API"), effects a functional interface for handling objects, referencing objects, implementing iteration and indexing of objects, and implementing object transaction and cache handling. The SM API is part of a modular architecture that includes an external storage manager which implements classes that provide the foundation for engaging external data stores, and which maps and converts external data into objects that can be manipulated by an application using the ODBMS.

Method for providing automatic and dynamic translation of object oriented programming language-based message passing into operation system message passing using proxy objects

Abstract: The present invention provides a method and apparatus for the distribution of objects and the sending of messages between objects that are located in different processes. Initially, a "proxy" object is created in the same process as a sender object. This proxy acts as a local receiver for all objects in the local program. When the proxy receives a message, the message is encoded and transmitted between programs as a stream of bytes. In the remote process, the message is decoded and executed as if the sender was remote. The result follows the same path, encoded, transmitted, and then decoded back in the local process. The result is then provided to the sending object.

Method and apparatus for moving subtrees in a distributed network directory

Abstract: A method of moving leaf objects and subtrees in computer networks that employ a distributed network directory is disclosed. The method employs the existing directories and an authentication procedure for each server. A first object that is under the physical control of the administrator of one partition of the distributed network directory requests access to a second object that is under the physical control of the administrator of another partition of the distributed network directory. The directory verifies that the access control list of the first object includes the second object. The access control list of the second object is then checked to verify that it includes a reference to the first object as an object that is permitted access to the second object. As a result, access is only granted in response to requests from objects that appear in the access control list of the second object. a method of synchronizing the access control lists based upon an authoritative access control list is also disclosed.

Method and apparatus to secure digital directory object changes

Abstract: A method of providing authoritative access control to computer networks that employs a distributed network directory using a static means of resolving object attributes is disclosed. The method employs the existing directories and an authentication procedure for each server. A first object that is under the physical control of the administrator of one partition of the distributed network directory requests access to a second object that is under the physical control of the administrator of another partition of the distributed network directory. The directory verifies that the access control list of the first object includes the second object. The access control list of the second object is then checked to verify that it includes a reference to the first object as an object that is permitted access to the second object. As a result, access is only granted in response to requests from objects that appear in the access control list of the second object. A method of synchronizing the access control lists based upon an authoritative access control list is also disclosed.

DistView: support for building efficient collaborative applications using replicated objects

Abstract: The ability to share synchronized views of interactions with an application is critical to supporting synchronous collaboration. This paper suggests a simple synchronous collaboration paradigm in which the sharing of the views of user/application interactions occurs at the window level within a multi-user, multi-window application. The paradigm is incorporated in a toolkit, DistView, that allows some of the application windows to be shared at a fine-level of granularity, while still allowing other application windows to be private. The toolkit is intended for supporting synchronous collaboration over wide-area networks. To keep bandwidth requirements and interactive response time low in such networks, DistView uses an object-level replication scheme, in which the applicaton and interface objects that need to be shared among users are replicated. We discuss the design of DistView and present our preliminary experience with a prototype version of the system.

Object oriented network system for allocating ranges of globally unique object identifiers from a server process to client processes which release unused identifiers

Abstract: A system for generating globally unique identifiers for objects in a distributed object oriented database. In one embodiment the system comprises at least two processors connected by means of a network to a processor executing a server process which provides globally unique identifiers for objects throughout the network. Each processor on the network may execute one or more client processes, each of which may run transactions against the database. Each such client process transmits a request to the server process which provides the globally unique identifiers when that client process requires a globally unique object identifier for objects which the requesting client process is creating. In response to the request, the server which provides globally unique identifiers transmits a range of globally unique object identifiers to the requesting client process. The requesting client process then allocates object identifiers from this range of globally unique object identifiers to the objects it is creating. Upon completion of the allocation of the globally unique object identifiers to the objects which have been created, the requesting client process then returns any unused globally unique object identifiers to the server for use by other client processes.

Object based system for software maintenance

Abstract: A computer implemented system and method for automatically generating an executable version is based on component objects and events. Object-oriented language concepts of encapsulation, inheritance, and message passing are employed to simplify the specification and execution steps. Software maintenance includes the steps of assembling executable systems from defined component parts such as source code files and object code files. An object definition is provided for each software component containing a specification of its dependency upon other objects and processing methods that must be executed to create that object. An event definition is created for each process that is to be applied to the component objects. The event definition includes a specification of any prerequisite events and conditions for delivery of the event message. An object dependency interpreter is provided to recursively control the passing of events to the objects for action. It ensures that any prerequisite events are first executed and that any objects upon which the current object is dependent are processed before the present object. Inheritance is employed to simplify object definition through the definition of generic objects which the object dependency interpreter instantiates for processing. Mapped memory is used to store an object data structure containing the representation of component objects and event objects. Additional storage is used to retain component object file system status.

Method and system for optimizing static and dynamic binding of presentation objects with the object data they represent

Abstract: A data processing system having an object oriented environment. The object oriented environment includes a plurality of graphic user interface objects and a plurality of application objects, each graphic user object having a unique identifier and a selected attribute and each application object having a preselected response. Graphic user interface objects associated with an application object are identified. A table is created specifying relationships between the graphic user interface objects and each graphic user interface object and the application object. Each time the application object is initialized, the table is used to specify objects within the application object.

System and method for adding new waitable object types to object oriented computer operating system

Abstract: An object based operating system for a multitasking computer system provides objects which represent the architecture or interrelationships of the system's resources. Access to certain objects is required in order to use corresponding resources in the system. All objects have a consistent data structure, and a consistent method of defining the operations which apply to each type of object. As a result, it is relatively easy to add new types of system objects to the operating system. Waitable objects are used to synchronize the operation of one or more processes with one another or with specified events. The system provides routines for generating new types of waitable objects, and thereby generating a modified operating system, without modifying other aspects of the operating system's kernel.

Using a Position History-Based Protocol for Distributed Object Visualization

Abstract: Users of distributed virtual reality applications interact with users located across the network. Similarly, distributed object visualization systems store dynamic data at one host and render it in real-time at other hosts. Because data in both systems is animated and exhibits unpredictable behavior, providing up-to-date information about remote objects is expensive. Remote hosts must instead apply extrapolation between successive update packets to render the object''s true animated behavior. This paper describes and analyzes a ``position history-based'''' protocol in which hosts apply several recent position updates to track the position of remote objects. The history-based approach offers smooth, accurate visualizations of remote objects while providing a scalable solution.

Object Location Control Using Meta-level Programming

Abstract: In distributed environments, location control of objects among hosts is a crucial concern. This paper proposes a new mechanism of object location control using meta-level programming which provides the following advantages to programmers. First, the description of location control can be separated from the application program by exploiting the meta-level architecture. This separation makes it easy for programmers to understand application programs and change location control policies. Second, it is possible for programmers to control object location using runtime information provided at the meta-level such as the number of remote messages. This information enables programmers to control object location more flexibly than in traditional distributed languages. The mechanism proposed in this paper has been implemented on an AL-1/D distributed reflective programming system. We show that our mechanism of location control using meta-level programming provides reasonable performance for a distributed application.

System for combining a global object identifier with a local object address in a single object pointer

Abstract: An object pointer data structure for efficiently combining an object identifier and an object address for use in object-oriented programming systems. An object address is a value that allows a client application or process to conduct high-performance operations on an object in the client's local virtual address space. An object identifier is a value that can be used to uniquely identify an object for the lifetime of that object across some defined domain, such as an entire universe of computer systems. The data structure of this invention defines an object pointer that is larger than the object address but smaller than the combination of the object identifier and object address. The truncated object pointer structure preserves all information from both object address and object identifier by forcing a portion of the local object address in each address space to be equal to a portion of the invariant object identifier. A local pointer mapping table may be used for efficiency in assigning local addresses to restored objects in each process.

Object based computer system having representation objects for providing interpretative views onto a data object

Abstract: Object based computer system which has objects and object parts which are either (a) semantic, relating to stored data, or (b) presentation, relating to presentation of the semantic objects to the user. Multiple presentation objects, or viewers, can be linked to a particular semantic object so that an intelligible user's model of the system results. Representation objects provide particular forms of presentation of data of the semantic objects and may be linked so that alternative and multiple presentations of the data of a semantic object are possible.

Complex associations: abstractions in object-oriented modeling

Abstract: Objects model phenomena and a phenomenon is usually a component. Information characterizing a component is encapsulated and accessible only by its methods. The relations between components are modeled explicitly by means of associations or references. A relation is also a phenomenon and objects can model this type of phenomena too. Components are usually related conceptually in diverse and subtle ways: Some relations are implicitly given and some are local to other more basic relations. Such kinds of relations are important for understanding the organization and cooperation of objects and may be supported in object-oriented analysis, design, and programming: An implicit association describes a relation between an object and objects local to this enclosing object, and a complex association describes an explicit relation between local objects in different enclosing objects. Such associations are described by classes and the objects have the usual properties including methods and attributes.

Dome: Distributed Object Migration Environment

Abstract: Dome is an object based parallel programming environment for heterogeneous distributed networks of machines. This paper gives a brief overview of Dome. We show that Dome programs are easy to write. A description of the load balancing performed in Dome is presented along with performance measurements on a cluster of DEC Alpha workstations connected by a DEC Gigaswitch. A Dome program is compared with a sequential version and one written in PVM. We also present an overview of architecture independent checkpoint and restart in Dome.

Designing Secure and Reliable Applications using Fragmentation-Redundancy-Scattering: An Object-Oriented Approach

Abstract: Security and reliability issues in distributed systems have been investigated for several years at LAAS using a technique called Fragmentation-Redundancy-Scattering (FRS). The aim of FRS is to tolerate both accidental and intentional faults: the core idea consists in fragmenting confidential information in order to produce insignificant fragments and then in scattering the fragments so obtained in a redundant fashion across a distributed system, such as a large network of workstations and servers. Of these workstations, in principle just the user’s own workstation needs to be regarded as trusted, whereas from this user’s viewpoint the other workstations and servers, which in all probability are under someone else’s control, can be untrusted devices.

Method and apparatus for object oriented interprocess message switching

Abstract: A method and apparatus for object oriented interprocess message switching between a sender process and a plurality of receiver processes is disclosed A sender process may address object oriented messages to a plurality of objects without knowing the identities of programs that handle or observe the object operations defined by the object types of the addressee objects, whether these programs are being executed, and how to start their execution if they are not being executed Object operations defined by object types may be inherited from predecessor object types Inherited object operations may also be overridden for "pre-processing" and "post-processing" One handler process and any number of observer processes are selected for each object oriented message Handler processes are selected for object oriented notice messages as well as object oriented request messages and vice versa Executing as well as non-executing processes (ie programs) are selected The sender process and the receiver processes may be executed on the same different computers in a network

High-Level Fault Tolerance in Distributed Programs

Abstract: We have been developing high-level checkpoint and restart methods for Dome (Distributed Object Migration Environment), a C++ library of data-parallel objects that are automatically distributed using PVM. There are several levels of programming abstraction at which fault tolerance mechanisms can be designed: high-level, where the checkpoint and restart are built into our C++ objects, but the program structure is severly constrained; high-level with preprocessing, where a preprocessor inserts extra C++ statements into the code to facilitate checkpoint and restart; and low-level, where periodically an interrupt causes a memory image to be written out. Because we consider portability (both of our libraries and of the checkpoints they produce) to be an important goal, we focus on the higher-level checkpointing methods. In addition, we describe an implementation of high-level checkpointing, demonstrate it on multiple architectures, and show that it is efficient enough to provide good expected run times with low overhead, even in the case of frequent failures.

Virtual images: interactive visualization of distributed object-oriented systems

Abstract: In spite of growing needs in many areas, there is a lack of powerful graphical interfaces for interacting with large and complex sets of objects. Debugging, management and monitoring tools for object-oriented distributed systems or databases, for instance, need new interfaces that allow high quality visualization and interaction.We propose to use 3D interactive animations for representing large numbers of objects, complex relationships, and dynamic execution of concurrent activities. These innovative graphical representations, that we call virtual images, provide a consistent and intuitive solution for integrating various functionalities, considerably increasing the amount of information processed by the user. This technique has been successfully applied without specific hardware, demonstrating the feasibility of such interfaces on non specialized workstations.

Method and apparatus for linking object managers for cooperative processing in an object oriented computing environment

Abstract: Object managers on different computing platforms (14a, 14b) communicate with each other in a cooperative manner, while allowing the objects on the computing platforms to communicate with each other using a remote procedure call which preserves the object oriented characteristics of data independence and encapsulation. Preferably, each object manager indicates to the other object manager whether local objects have successfully responded to remote messages. The object manager can thereby preserve integrity of the object oriented system by committing or rolling back the system in response to completion of specific tasks or failure to complete specific tasks, even though some of the tasks occurred outside the local object oriented computing environment.

Accessing remote data objects in a distributed memory environment using parallel address locations at each local memory to reference a same data object

Abstract: A mechanism and method for accessing remote data objects in a distributed memory environment is disclosed. In the distributed memory environment, a number of parallel processors are remote from each other and each has memory storage capacity with parallel address locations. For each data object stored in the local memory of a processor, that processor stores a variable at a specific location pointing to the address of the data object in its local memory. At the same (parallel) location in the local memories of all remote parallel processors, a variable pointing to the home processor for the data object is stored. In order to access the data object, it is only necessary to locate the identifier variable in the processor processing a program pointing to the processor having the data object in storage. Because of the parallel address space, the location will automatically point directly to the same address location in the home storage processor, and this address location contains the address pointing to the actual location of the data object in the local storage of that processor. Alternate means for updating the variable information on data object storage is also provided. In one system, changes are broadcast throughout the parallel processor environment while in the other system, changes are merely retained on the home processor or the home processor and one remote parallel processor responsible for recording changes in that region of the distributed memory environment. When accessed by another remote parallel processor, the change information will be transmitted.

The Object Binary Interface--C++ Objects for Evolvable Shared Class Libraries

Abstract: Object-oriented design and object-oriented languages support the development of independent software components such as class libraries. When using such components, versioning becomes a key issue. While various ad-hoc techniques and coding idioms have been used to provide versioning, all of these techniques have deficiencies - ambiguity, the necessity of recompilation or re-coding, or the loss of binary compatibility of programs. Components from different software vendors are versioned at different times. Maintaining compatibility between versions must be consciously engineered. New technologies such as distributed objects further complicate libraries by requiring multiple implementations of a type simultaneously in a program. This paper describes a new C++ object model called the Shared Object Model for C++ users and a new implementation model called the Object Binary Interface for C++ implementors.These techniques provide a mechanism for allowing multiple implementations of an object in a program. Early analysis of this approach has shown it to have performance broadly comparable to conventional implementations.

Method and system for visually debugging on object in an object oriented system

Abstract: A method and system for debugging an object from a plurality of objects forming an application in an object oriented system utilizing a graphic user interface. A number of the objects forming the application may include one or more action slots with each action slot containing one or more action objects. The present invention stores each action object with an action slot in an activation object in response to an event generated by user utilizing the graphic user interface. The event is associated with an action slot. Data sent to each action object is stored in the activation object. The data is data required to recreate the event caused by the user. Each time an event is generated, an activation object is created. These activation objects may be debugged utilizing a debugger.

An object-oriented, distributed architecture for large-scale Ada systems

Abstract: This paper presents an architectural model ideally suited for the description of large, distributed command and control systems This model is organized around multiple dimensions (or views) of software architecture and is used to describe the software architecture of a family of automated air traffic control systems currently under development by Hughes Aircraft of Canada Some of the features of this family of systems are described, and in particular the mechanism used for transparent access to objects This distributed object management mechanism illustrates the implementation of the most salient architectural principles used in the design

Recursive interfaces for reactive objects

Abstract: LiveWorld is a graphical environment designed to support research into programming with active objects. It offers novice users a world of manipulable objects, with graphical objects and elements of the programs that make them move integrated into a single framework. LiveWorld is designed to support a style of programming based on rule-like agents that allow objects to be responsive to their environment. In order to make this style of programming accessible to novices, computational objects such as behavioral rules need to be just as concrete and accessible as the graphic objects. LiveWorld fills this need by using a novel object system, Framer, in which the usual structures of an objectoriented system (classes, objects, and slots) are replaced with a single one, the frame, that has a simple and intuitive graphic representation. This unification enables the construction of an interface that achieves elegance, simplicity and power. Allowing graphic objects and internal computational objects to be manipulated through an integrated interface can provide a conceptual scaffolding for novices to enter into programming.