By Topic

Object Orientation in Operating Systems, 1992., Proceedings of the Second International Workshop on

Date 24-25 Sept. 1992

Filter Results

Displaying Results 1 - 25 of 48
  • Proceedings of the Second International Workshop on Object Orientation in Operating systems (Cat. No.92TH0477-0)

    Save to Project icon | Request Permissions | PDF file iconPDF (70 KB)  
    Freely Available from IEEE
  • Inheritance in unlikely places: using objects to build derived implementations of flat interfaces

    Page(s): 341 - 345
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (448 KB)  

    Traditional operating systems typically provide a number of flat, non-object oriented interfaces through which system services are provided to applications. Typically such services are provided by large, monolithic implementations, with no provision for deriving related implementations through inheritance or other means. Nonetheless, it is possible to provide flexible, object oriented views of otherwise flat, non-object oriented interfaces. Furthermore, these views can be used to build new implementations of these same flat interfaces in terms of other ones. This approach can bring the benefits of objects such as enhanced and/or application specific implementations of standard services to both building and using otherwise fixed, flat interfaces which for one reson or another cannot be changed. The paper presents this paradigm and some of the benefits derived from it, citing several real systems as examples View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A technique for documenting the framework of an object-oriented system

    Page(s): 288 - 300
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (900 KB)  

    The paper presents techniques for documenting the design of frameworks for object-oriented systems and applies the approach to the design of a configurable message passing system. The technique decomposes a framework into six concerns: the class hierarchy, protocols, control flow, synchronization, entity relationships and configurations of the system. An abstract description of each concern is specified using standard notations. Subtyping is used to ensure that the abstract specifications apply to the abstract classes, concrete classes, and instances of the system. The message passing framework documented with these techniques is general, portable, and efficient. It supports parallel message based applications on both tightly coupled shared memory architectures and loosely coupled distributed memory architectures. The message passing system framework has been coded in C++, runs on the Choices operating system, and has been benchmarked on a system of Encore Multimax 320 tightly-coupled multiprocessors. The system is being implemented on a network of SUN SPARCstation 2s View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Implementing persistent objects in the Apertos operating system

    Page(s): 66 - 79
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (872 KB)  

    The paper presents a way of providing users with a persistent object running under the Apertos operating system. The authors present an implementation of persistent objects by using object migration between metaspaces in the reflective object architecture. An Apertos object is stored into stable storage by migrating to a storage metaspace that is an abstraction of object storage. They also present the current status of the implementation View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Implementing real-time aspects and distribution in an object-oriented language: the DEAL experience

    Page(s): 280 - 284
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (400 KB)  

    As part of a research project to realize a reliable distributed operating system (DEDOS) with a guaranteed real-time response an object-oriented language, called DEAL (DEDOS Application Language), has been defined to deal with specific aspects most sequential languages do not cover. The language allows the creation of programs for execution on a multiprocessor configuration, with access to services of other programs. The first version of this language is simply an extension of C++. The paper describes implementation issues of the DEAL runtime environment and the preprocessor that translates DEAL programs to C++ programs View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A persistent object infrastructure for heterogeneous distributed systems

    Page(s): 49 - 56
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (652 KB)  

    A persistent object infrastructure enables applications to uniformly invoke operations on active (in-memory) and passive (stored) objects, i.e. it provides a single level object store. Objects are automatically moved between secondary storage and main memory by the infrastructure, so the impedance mismatch between the type systems of applications and the type systems of secondary storage abstractions like databases and file systems is eliminated from application programs. The paper describes a prototype of a persistent object system which has been designed for ANSA, an architecture for building heterogeneous object-based distributed systems. The prototype has been developed in ANSAware which is an example implementation of ANSA View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A generic fragmented object structured framework for distributed storage support

    Page(s): 57 - 65
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (652 KB)  

    The authors propose a generic framework for storage support in a distributed environment. This comprises a set of storage abstractions and storage policies; data clusters, cluster containers, and container domains, supporting sharing, caching, and replication. These abstractions and these policies are structured as fragmented objects (FOs), such that each storage system designer can offer the appropriate tradeoffs to its targeted applications. The core set of main abstractions is discussed; their interfaces are presented; and the FO-structuring of the cluster abstraction is detailed View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Generic system support for shared objects synchronization

    Page(s): 153 - 157
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (312 KB)  

    The paper presents a proposal for a synchronization mechanism to be integrated in a virtual machine supporting distributed shared objects. This mechanism was initially inspired by the synchronization model of the Guide system, based on counters and activation conditions. The mechanism is intended to support synchronized objects written in several languages View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Proxies, application interfaces, and distributed systems

    Page(s): 212 - 220
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (584 KB)  

    Proxy objects are local representatives of remote objects in a distributed system. The authors use proxies to construct a transparent application programming interface (API) for the Choices distributed operating system. In earlier work, proxies were used in Choices to provide a protected, object-oriented interface to system objects. The addition of Remote Proxies allows applications to access all resources in a uniform way by simply invoking methods on objects, irrespective of whether they are local, in the kernel, in a different user virtual address space or remote. They also extend proxies to optimize access to remote and protected objects and to provide support for changing server interfaces. They describe a new remote procedure call (RPC) facility for invoking methods on remote objects through the proxy mechanism. The API is made dynamically reconfigurable by using table lookup to perform all functions normally provided by stubs in conventional RPC implementations. The API permits new versions of a service to be introduced without requiring recompilation of application client code View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The object-oriented advantage in prototyping a remote file system

    Page(s): 190 - 199
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (740 KB)  

    The authors have prototyped a remote file system for the Choices object-oriented operating system that permits the caching strategy to be user selectable on a per file basis. Choices provides a convenient object-oriented toolkit for building file systems, which they employed, reusing code whenever possible. The client provides the driving force in the architecture. The server maintains a small cache, fulfills requests, and performs callbacks. The client supports both whole file caching and block caching. Only the client needs to be aware of the type of caching being used for a particular file. Different clients can provide different caching strategies at the same time but the data within a client it is kept consistent. The server and client cooperate to maintain the consistency of the file system via callbacks. Because of the object-oriented architecture of the Choices file system they were able to prototype the system in approximately 6 weeks. There was a significant amount of code reuse View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A persistent class store for Choices

    Page(s): 352 - 359
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (796 KB)  

    There has been much work undertaken on persistent stores in recent years, some of which has been in general object stores. One of the latter stores exists currently in the Choices operating system. This store permits persistent storage containers to be created and persistent objects to be inserted into these containers. In addition security and garbage collection facilities are provided. The paper illustrates an approach being undertaken to augment the Choices persistent storage mechanisms by implementing separate class stores for persistent objects using many of the basic mechanisms provided by the Choices persistent store, but permitting multiple persistent stores to coexist with objects containing references between stores. In addition it incorporates many of the database ideas for optimising the accesses by clustering the data using the locality of the data in the backing store, and providing support for a query language facility. Currently the design only includes a single store however the extension of this store to a distributed persistent store is discussed View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Using virtual addresses as object references

    Page(s): 245 - 248
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (316 KB)  

    An alternative to surrogates is to use ordinary virtual addresses for inter-object referencing. Usually (but not always) this involves mapping distributed or persistent data into specified parts of the application's address space relying on page faults to trap and resolve references to nonresident data. The choice between these two referencing schemes involves tradeoffs. Virtual addresses promise easier integration with programming languages and faster local pointer dereferences, whereas surrogates can simplify object-based aspects of storage management, such as garbage collection and heap compaction. The key justifications for surrogate pointers are eliminated by 64-bit address spaces and proper operating system virtual memory support. When these facilities are available, the flexibility of surrogate pointers may not be worth their cost View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Protection in an object-oriented distributed virtual machine

    Page(s): 273 - 277
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (348 KB)  

    The paper describes the principles of a protection model based on objects and its implementation of an object-oriented distributed virtual machine. The model is based on access lists, method groups, and visibility restrictions. It is currently being implemented on the Guide-2 system View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Persistency support for mobile objects in the COMET heterogeneous environment

    Page(s): 38 - 48
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (824 KB)  

    Open distributed computing in an internetwork environment has gained considerable attention. The paper presents COMET, A common object management environment that investigates basic problems associated with distributed computing in an internet environment with mobile objects. COMET's persistency support is based on typed memory, manipulated by persistent actions. The use of typed memory enables transparent handling of the presentation management issues that are unavoidable in a heterogeneous environment. Persistent actions on the other hand ensure that the typed memory is manipulated in a consistent manner. The typed memory approach presents a conceptually simple persistency model to the object programmer. The approach is general enough to be applied to other problem areas, e.g. for the realization of replicated and atomic objects View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Cross-address space dynamic linking

    Page(s): 250 - 256
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (548 KB)  

    The authors describe an algorithm and implementation of dynamic linking that allows one user process to link a program in another address space without compromising the security of the other address space and without requiring the linking process to enter kernel mode. The same technique can also be used to load program code into an existing address space, e.g., for debugging or other purposes. The implementation makes extensive use of objects in the Spring object-oriented operating system. They have extracted the dynamic linking function from the operating system, and made it available to user programs as a replaceable library service. In the process, they have taken advantage of features present in a modern, object-oriented operating system to simplify the dynamic linker View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Pointer swizzling at page fault time: efficiently and compatibly supporting huge address spaces on standard hardware

    Page(s): 364 - 377
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (8 KB)  

    Pointer swizzling at page fault time is a novel address translation mechanism that exploits conventional address translation hardware. It can support huge address spaces efficiently without long hardware addresses; such large address spaces are attractive for persistent object stores, distributed shared memories, and shared address space operating systems. This swizzling scheme can be used to provide data compatibility across machines with different word sizes, and even to provide binary code compatibility across machines with different hardware address sizes. Pointers are translated (`swizzled') from a long format to a shorter hardware-supported format at page fault time. No extra hardware is required, and no continual software overhead is incurred by presence checks or indirection of pointers. This pagewise technique exploits temporal and spatial locality in much the same way as a normal virtual memory; this gives it many desirable performance characteristics, especially given the trend toward larger main memories. It is easy to implement using common compilers and operating systems View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A new model of abstraction for operating system design

    Page(s): 346 - 349
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (352 KB)  

    This historical basis of operating systems work has been the concept of black-box abstraction. But this traditional notion of abstraction fails to support emerging practice in the operating system community where, more and more, one seems to want to give clients access to previously internal aspects of the implementation. The authors present a new model of abstraction, dual-abstraction, and show how to think about existing work under that model. They also discuss some issues for future work that the new model makes evident View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Implementing fault-tolerant object systems on distributed memory multiprocessors

    Page(s): 172 - 179
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (696 KB)  

    The design and implementation of an object management layer for a distributed memory multiprocessor system is described. It has been used for supporting an object-oriented fault-tolerant system (Arjuna). The authors discuss how various aspects of distribution transparency (location, access, migration, concurrency, replication and failure) have been incorporated in the design View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A model for persistent shared memory addressing in distributed systems

    Page(s): 2 - 12
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (792 KB)  

    COOL v2 is an object oriented persistent computing system for distributed programming. With COOL v2, C++ objects can be persistent and shared freely between applications and distributed across sites in a completely transparent manner from the programmer's point of view. To address the problem of maintaining distributed shared data coherency, data persistency and address allocation coherency the authors, developed the persistent context space model which encapsulates distributed shared memory and persistent memory, and controls distributed shared memory address allocation. The paper outlines existing solutions of object addressing in persistent and distributed environments and contrasts these with the persistent context space model and its integration in an operating system architecture View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • OMOS-an object server for program execution

    Page(s): 200 - 209
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (784 KB)  

    The benefits of object-oriented programming are well known, but popular operating systems provide very few object-oriented features to users, and few are implemented using object-oriented techniques themselves. The authors discuss a mechanism for applying object-oriented programming concepts to program binding (linking) and execution. They describe OMOS, an object/meta-object server that embodies a flexible object framework. The OMOS framework projects an object-oriented structure onto programs and shared libraries that may not have been originally developed for use within an object-oriented environment. This framework provides natural facilities for inheritance, interposition, and overloading of operations, as well as development of classes with dynamically evolving behavior View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Distribution + persistence = global virtual memory

    Page(s): 96 - 99
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (284 KB)  

    The Distributed Systems Group at the University of New South Wales is constructing a distributed operating system based on global virtual memory (GVM). The system combines local and remote storage into a single large virtual address space. This provides a uniform method for naming and accessing objects regardless of their location, removes the distinction between persistent and transient data, and simplifies the migration of data and processes. The GVM system uses conventional computing nodes connected to specialised network interfaces. A fault-tolerant migration and replication protocol keeps the system operational and consistent in case of network errors or node crashes. Password capabilities are used to control access to the GVM View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Closing the gap between different object models

    Page(s): 378 - 383
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (480 KB)  

    Programming language, database and operating system objects are essentially implementation variants of the same basic programming paradigm, i.e. objects as found in object-oriented programming languages. Yet, these object models differ significantly with regard to programming support, granularity, lifetime, persistence, concurrency, fault-tolerance and others. The paper points out the differences between these object models and argues that it makes sense to provide one generalized dynamic object model. A technique to define and use operating system objects in the same way as programming language objects independent from the object model provided by the underlying operating system is shown View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Controlling concurrent access to objects in the Raven system

    Page(s): 148 - 152
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (400 KB)  

    The paper presents the rationale and design of the concurrency control features of Raven, an object-oriented distributed and parallel programming language and system. Raven's parallel constructs support coarse grained parallelism and are designed to permit programmers to use parallelism with relative ease. To achieve this Raven provides automatic concurrency control on an object's instance data at method invocation time. Raven allows multiple execution threads to access an object strictly for reading or a single execution thread to access an object for the updating of instance data. Raven is operational on a variety of machine architectures, including a shared memory multiprocessor. Experience indicates Raven's concurrency support simplifies the task of converting sequential code to run in a parallel or distributed environment View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The role of operating systems in object-oriented distributed multimedia platforms

    Page(s): 134 - 141
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (688 KB)  

    Considerable progress has been made in the development of technologies to support distributed multimedia computing, but application platforms are needed to make such technology accessible to application programmers. The paper sets out requirements for such platforms and discusses the role of operating systems in object-oriented platform support. The authors describe an initial approach to providing such a platform which attempted to factor out all real-time aspects of multimedia support onto a hardware based multimedia network interface unit. This solution has been partially successful but lacks the flexibility and level of integration subsequently demanded by application programmers. Their response has been to re-design the multimedia network interface unit, placing more emphasis on the provision of dynamic services which require real-time operating system support. The new design described exploits and extends features of a distributed object-oriented micro-kernel to provide the necessary system wide support View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A distributed GC for object oriented systems

    Page(s): 221 - 229
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (692 KB)  

    The authors describe a distributed garbage collector protocol targeted for uncooperative distributed object oriented systems. The protocol has been implemented on a distributed Lisp system and a few performance measurements are discussed. Since this implementation, they have refined deeply the protocol to address non FIFO channels. A new reference model is proposed along with the protocol to improve invocation efficiency View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.