By Topic

Object Orientation in Operating Systems, 1993., Proceedings of the Third International Workshop on

Date 9-10 Dec. 1993

Filter Results

Displaying Results 1 - 25 of 40
  • Proceedings Third International Workshop on Object Orientation in Operating Systems

    Save to Project icon | Request Permissions | PDF file iconPDF (21 KB)  
    Freely Available from IEEE
  • Sharing objects in a distributed system

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

    This paper presents a design for the use of DSM techniques and system-supported synchronisation to support shared access to persistent objects in a distributed environment. We adopt a hybrid approach where the system granularity is sometimes pages and sometimes objects. We are interested in providing shared access to small (i.e., less than a page) objects in a general purpose, language-independent environment, and supporting both DSM and RPC object access mechanisms View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Disk management for object-oriented databases

    Page(s): 222 - 225
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (244 KB)  

    An object-oriented database provides persistent storage for a large number of objects. These objects may be very small, and the access patterns are likely to be not as uniform as the mostly sequential reads and writes seen in file-systems. For example, the 007 benchmark for object-oriented databases specifies a number of traversals that follow pointers around a graph of objects. Given these differences between file-systems and object-oriented databases, disk management techniques used in file-systems will not perform well if naively applied to object-oriented databases. This paper proposes three disk management strategies for object-oriented databases. These strategies are based on earlier work on file-systems. They differ from this earlier work in their support for a large number of small objects and non-sequential access patterns View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Operating systems: why object-oriented?

    Page(s): 25 - 30
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (440 KB)  

    The implementor of an operating system service faces inherent dilemmas in choosing implementation strategies. A new approach to operating system design is emerging in which, rather than attempting to hide these dilemmas, they are exposed to clients, using a meta-protocols. Object-oriented programming techniques play an important role in enabling meta-protocols to expose these dilemmas to the client in a principled and modular fashion View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • An extended scheduling mechanism for nested transactions

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

    In this paper, an extension to Moss' scheduling mechanism for nested transactions is presented. The extended mechanism allows (1) non-leaf transactions to access object data, (2) ancestor and descendent transactions to execute concurrently, (3) threads within transactions to be created without creating subtransactions and (4) both transactional and nontransactional operations to be handled. The mechanism is described in an implementation-independent form and its properties are outlined. Rationales but no formal proof of its correctness are provided. The implementation and performance of the extended scheduling mechanism is discussed briefly View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Distributed/concurrent garbage collection in distributed shared memory systems

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

    We present a distributed and concurrent garbage collection algorithm that is well suited for distributed shared memory systems. Traversal of objects during garbage collection happens “in place” in the sense that the objects are not moved to any special node for traversal. Thus garbage collection activity does not interfere with the caching and locality inherent to the application. Cyclic garbage is reclaimed without moving objects, physically or logically. Furthermore, cycles are handled naturally by the algorithm and it is not necessary that a special mechanism be introduced for this purpose. Local garbage collection is asynchronous. Global garbage collection is realized by pair-of-nodes communication; no global synchronization is required. In this sense, the algorithm is scalable. Non-ideal communication channel are allowed and no bound on message delivery time is required View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Object mitosis: a systematic approach to splitting objects across subsystems

    Page(s): 182 - 185
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (264 KB)  

    An experimental method, called object mitosis, is presented. Object mitosis is a systematic process for splitting an analysis object into design objects that reside in multiple subsystems. The problem of high coupling between subsystems is discussed and object mitosis is shown to be a possible solution View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Caching in an object oriented system

    Page(s): 95 - 106
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (888 KB)  

    Caching is an important technique for improving performance in distributed systems. However, in general it has been performed on an ad-hoc basis, with each component of the system having to invent its own caching techniques. In the Spring operating system we provide a unified caching architecture that can be used to cache a variety of different kinds of remote objects. For any given kind of object, this architecture lets different client processes within a single machine share a single cache for accessing remote objects. This caching is performed by a separate cacher process on the machine local to client processes, the caching is transparent to the clients, and the cached information is kept coherent. This architecture has been used to implement caching for files and for naming contexts View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Automatic configuration of dynamically alterable object oriented systems

    Page(s): 158 - 161
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (320 KB)  

    Customization is a powerful tool, but to be truly useful its application must require a minimum of expertise and effort from the programmer. While many programming languages provide support for modularity and encapsulation, it is object-oriented languages with their associated object constructor/destructor mechanisms which provide the key to automating customizations of complex system specifications. We outline a scheme for such a configuration mechanism in the context of the PEACE system, a dynamically alterable object-oriented parallel operating system. Our mechanism is largely transparent to the user, using the C++ programming language and its associated object constructors and destructors to generate an initial version of system configuration information from a combination of user-specified parameters and system defaults. This initial configuration information is automatically installed at system invocation, and is also dynamically alterable at runtime. The information is used by the PEACE system and its applications to guide dynamic system alterations such as loading and/or garbage-collecting of system components on demand,but the same approach is also applicable in other contexts View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Programming multicomputers using shared objects

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

    Multiprocessors and multicomputers differ in important ways in terms of hardware and software. One kind of machine is hard to build but easy to program, and the other is easy to build but hard to program. We believe that by using shared objects as a programming paradigm, it is possible to combine the best properties of these two models. In this paper, we describe how it can be done. Our solution is based on having the programmer declare objects that can be potentially shared among processes on all machines in the system. These objects are passive-they are invoked by threads, but do not themselves contain internal threads. The shared objects act as though they are in a common shared memory (even though they are not), and can be accessed by all authorized processes by simply invoking their methods. Each method operates only on a single object View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • KTK: configurable objects and invocations

    Page(s): 236 - 240
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (320 KB)  

    The Kernel Toolkit (KTK) is an object-based operating system kernel and programming library that offers explicit support for on- and off-line object configuration. We first present the basic configuration mechanisms offered by KTK. We address the utility of KTK by reference to results that use these mechanisms for the dynamic configuration of an application-level abstraction in a parallel program: a global queue in a parallel branch-and-bound code for solving the travelling salesman problem (TSP). We also present results of additional performance gains, attained by online configuration of a second abstraction in TSP, a mutex lock protecting the global queue View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Distribution and object granularities

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

    Objects are widely used to build distributed applications, since they provide a clean interface which may be used in handling remote communications between a client and a server. However there is still an open issue whether large objects and small objects should be handled in the same way from both the language and system points of view. The most widely supported view is the client/server model in which large objects (usually the remote server objects) are distinguished from small local objects used inside a server object. In this approach distribution is associated only to server objects bet not to local objects We believe that there actually exist at least two granularities of objects, but they should not be differentiated by the distribution property. Programming in the small and programming in the large are well known in centralized programming models, and define fine-grained passive entities to build and structure coarse-grained active applications. Distribution is an orthogonal property which may be applied to both types of objects. This results in defining fine-grained passive objects, which may be distributed as in the blackboard approach, used to build coarse-grained active objects or servers, which in turn may communicate using the client/server model View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Implementing orthogonal persistence: a simple optimization using replicating collection

    Page(s): 177 - 181
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (336 KB)  

    Orthogonal persistence provides a safe and convenient model of object persistence. We have implemented a transaction system which supports orthogonal persistence in a garbage collected heap. In our system, replicating collection provides efficient concurrent garbage collection of the heap. In this paper, we show how replicating garbage collection can also be used to reduce commit operation latencies in our implementation. We describe how our system implements transaction commit. We explain why the presence of nonpersistent objects can add to the cost of this operation. We show how to eliminate these additional costs by using replicating garbage collection. The resulting implementation of orthogonal persistence should provide transaction performance that is independent of the quantity of nonpersistent data in use. We expect efficient support for orthogonal persistence to be valuable in operating systems applications which use persistent data View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Shadows-a flexible support system for objects in distributed systems

    Page(s): 73 - 81
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (732 KB)  

    Shadows is a simple, but flexible, architecture based upon only three hey facilities: object servers, object migration and location-transparent operation invocation. We show how several powerful object properties such as object caching, object shareability, and persistence can easily be created by exploiting only these three concepts. The Shadows architecture requires only capabilities found in common object-oriented languages and modern operating systems. An instance of the Shadows architecture has been implemented in C++ on a distributed memory multiprocessor system View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Binding should be flexible in a distributed system

    Page(s): 216 - 217
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (132 KB)  

    Existing distributed reference mechanisms have serious shortcomings when it comes to supporting dynamically shared objects. We are looking at support for type safety and fragmented objects, i.e. object groups for persistence, replication, or distributed data management. Our position is that a single binding protocol should take care of these needs in a flexible and general fashion. When objects are shared dynamically, it is in the general case impossible to decide at compile time whether a reference is type-safe. Furthermore, new types and classes are created while the system is running. This creates a need for dynamic instantiation of objects, dynamic linking of code, and dynamic type checking of references. Objects are often fragmented i.e. constructed as a group of sub-objects in separate locations. For instance, a persistent object is composed of an on-disk image and zero or more in-memory images. To reference a fragmented object, we reference a specific “factory” fragment. At bind time, the factory selects one of its fragments as the target. The ability to redirect the reference to another fragment is essential, even after binding has been made. We are currently specifying a general binding protocol that supports the needs stated above. It is designed to support late binding and language- or application-specific policies. It is conceptually simple but recursive. An actual implementation may terminate the recursion at any point, trading off performance and simplicity against completeness View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Vista: a microstorage architecture that implements file systems and object databases

    Page(s): 194 - 198
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (416 KB)  

    Vista is a system for storing, retrieving and manipulating data that supports a new generation of applications that provide more powerful features for end users. Vista does not directly implement these end user features, but it provides technology that allows applications to easily implement them. To understand the design of Vista, it is important to first understand these end user features. Although most of these features can be implemented in a file system, they are not simply extensions to files. They also apply to other storage models, and some fit more closely with other, more powerful, storage models. Vista and the microstorage architecture extends the popular idea of separating policy from mechanism to storage architectures by separating the storage model from the underlying storage mechanism. Until now, file systems, databases, and object stores were viewed as separate systems with their own semantics and implementation. Data in one system could not be used in another, and applications were designed to work with only one system. Vista unifies these system, by implementing them on a common substrate so they share data seamlessly. In Vista, different applications or different parts of the same application may use different storage models to manipulate the same data View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Type structured file system

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

    Describes the design of Nebula, a dynamic, object-based, typed file system. Nebula uses types to create well-structured files as well as to export existing files in the Internet environment. This allows for backward scalability. Files in Nebula are abstractions and are defined by objects. Nebula assumes a flat global namespace, and operations are provided to manipulate logical namespaces View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The design of a universal class store

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

    Persistent object stores have invoked much interest in recent years with the combination of the concepts of an object repository and the reuse of code and class definitions. One such store implemented at the University of Cape Town (UCT), exhibits the problems underlying most of these stores in that they require to have their own environment and open their own operating system, thus making them inaccessible to users on standard computer systems. Perhaps the most efficient methods of implementing such stores, in modern large address space computers uses memory mapping and distributed shared memory to provide access to the object store. Whereas if the use of memory mapping for objects is very efficient in a high speed local environment it presents problems when implemented over a wide area network. One alternative approach is the access of the object store by means of remote procedure calls to an object server. This paper describes work being undertaken to combine these two approaches by using the facilities provided by the OSF DCE to provide high reliability remote access, while using the distributed shared memory paradigm to provide high speed local access. The description of the object store and the access mechanisms using DCE are described View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Lockup of a client object cache and how to avoid it

    Page(s): 233 - 235
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (184 KB)  

    This paper presents the problem of client object cache lockup in a distributed object-oriented database system where storage is recovered by garbage collection. If garbage collection is augmented with the ability to discard reachable unmodified versions of persistent objects, cache lockup is greatly reduced. This paper outlines some remaining questions about this technique for managing an object cache View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The substrate object model and architecture

    Page(s): 31 - 40
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (860 KB)  

    Operating system kernels are difficult to build, hard to change and a problem to adapt to new hardware. This is particularly true when the operating system tries to simulate a general-purpose multiprocessor on a cluster of workstations. The substrate architecture presented here uses lessons from language design to facilitate the evolution of existing operating systems. A reflective object model that clearly separates instances, interfaces and implementations is the basis of this architecture. The object-model implementation allows flexible and dynamic composition of interfaces and implementations. The language environment and object model is used to create substrates, building block components of a multiprocessor environment View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A persistent system in real use-experiences of the first 13 years

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

    Eumel and its advanced successor L3 are operating systems built by GMD which have been used, for 13 years and 4 years respectively, as production systems in business and education. More than 2000 Eumel systems and 500 L3 systems have been shipped since 1979 and 1988. Both systems rely heavily on the paradigm of persistence (including fault-surviving persistence). Both data and processes, in principle all objects are persistent, files are implemented by means of persistent objects (not vice versa) etc. In addition to the principles and mechanisms of Eumel/L3, general and specific experiences are described: these relate to the design, implementation and maintenance of the systems over the last 13 years. For general purpose timesharing systems the idea is powerful and elegant, it can be efficiently implemented, but making a system really usable is hard work View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Strange bedfellows: issues in object naming under Unix

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

    Naming plays a key role in the design of any system that exports services or resources. Object systems may export many different categories of names: instances, components of records, types, etc. Operating systems export the names of files, devices, and services. Integrating an object base with existing operating system facilities can improve accessibility of the object base resources. We consider the benefits and pitfalls of integrating an object base namespace with the Unix namespace View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Object migration in a heterogeneous world-a multi-dimensional affair

    Page(s): 62 - 72
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (880 KB)  

    The ability to change the physical location of objects is considered indispensable in today's highly distributed computing world. As a direct offspring of process migration, object-oriented operating systems now offer object migration as a core mechanism. These systems usually equate migration with a change in physical location. Location is only one attribute whose changes are worth considering. Other attributes evolve as well during the lifetime of an object. Examples include changes in state representation and failure handling semantics. All such attribute changes can be integrated within a generalized object migration model. This results in an N-dimensional space, the object habitat, where object migration is expressed in terms of coordinate changes. This paper introduces the habitat model, and illustrates its application within the COMET heterogeneous distributed computing system. Within COMET, the habitat is a three-dimensional space with location, class and flavor coordinate axes View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Efficient support for incremental customization of OS services

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

    Efficient, incremental customization of operating system (OS) services can be achieved using a two-fold strategy that consists of (i) an object-oriented architecture that relies on composition to facilitate code reuse and customization, and (ii) an OS implementation that places a minimal set of trusted functions into the kernel (all remaining functions are collocated with application code in user-level protection domains) View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Capability-based protection in the Mungi operating system

    Page(s): 108 - 115
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (676 KB)  

    A single address space operating system is an excellent environment for the implementation of distributed object-based systems. The tissue of providing effective and efficient protection of objects in such an environment has, however, not been addressed satisfactorily. This paper presents the protection mechanism of Mungi, which is based on password capabilities. A system-maintained data structure called the capability tree is used for the long-term storage of capabilities, and reflects the hierarchical structure of object privacy. A second system data structure, the active protection domain, allows the system to find capabilities quickly when validating memory accesses. The model supports inheritance of protection domains, as well as temporary extension of protection domains to support privileged procedures. Untrusted programs can be confined to run in a restricted protection domain. The protection system performs efficiently on conventional architectures, and is simple enough that most programs do not need to be aware of its operation View full abstract»

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