Person:
Schwan, Karsten

Permanent Link
https://hdl.handle.net/1853/71682
Associated Organization(s)
Organizational Unit
ORCID
ArchiveSpace Name Record

Filters

1993 - 1994 6
6
6
6
6
6
Reset filters

Settings
Author: Mukherjee, Bodhisattwa ×

Publication Search Results

Now showing 1 - 6 of 6
  • Thumbnail Image
    Item
    KTK: Kernel Support for Configurable Objects and Invocations
    (Georgia Institute of Technology, 1994) Gheith, Ahmed M. ; Mukherjee, Bodhisattwa ; Silva, Dilma M. ; Schwan, Karsten
    The Kernel Tool Kit (KTK) is an object-based operating system kernel and parallel programming library that offers explicit support for on- and off-line program configuration. Specifically, KTK allows the specification of attributes for object classes, object instances, state variables, operations and object invocations. Attributes are interpreted by policy classes that may be varied separately from the abstractions with which they are associated. They can be used to vary object internal implementation and semantics without affecting the methods being invoked. In this paper, the runtime configuration of KTK attributes is shown to improve the runtime performance of multiprocessor applications. KTK is layered on a portable and configurable parallel programming substrate, a Mach Cthreads compatible runtime library.
  • Thumbnail Image
    Item
    Experiments with Configurable Locks for Multiprocessors
    (Georgia Institute of Technology, 1993) Mukherjee, Bodhisattwa ; Schwan, Karsten
    Operating system kernels typically offer a fixed set of mechanisms and primitives. However, recent research shows that the attainment of high performance for a variety of parallel applications may require the availability of variants of existing primitives or additional low-level mechanisms. One approach to solve this problem is to offer a lightweight, reconfigurable and extensible operating system kernel. An application may configure it to suit its needs, including the selection of appropriate low-level policies, the construction of new primitives on top of the existing ones or the extension with additional primitives. In this paper, we investigate kernel configurability and extensibility for a specific class of operating system primitives: those used for task or thread synchronization. We present an implementation of multiprocessor locks that can be reconfigured statically and dynamically. In addition, we develop a representation for the lock abstraction and an associated reconfiguration mechanism that may be used for the development of other configurable and extensible operating system abstractions.
  • Thumbnail Image
    Item
    A Survey of Real-Time Operating Systems -- Preliminary Draft
    (Georgia Institute of Technology, 1993) Mukherjee, Bodhisattwa ; Schwan, Karsten ; Ghosh, Kaushik
    This paper describes current research in real time operating systems. Due to its importance to real-time systems, we begin this survey with a brief summary of relevant results in real-time scheduling and synchronization. Real-time operating systems are described in terms of the primitives and constructs offered to application programs. In addition, the effects of underlying computer architectures on real-time operating systems are discussed, followed by a description of benchmarks and evaluation methods for real-time systems.
  • Thumbnail Image
    Item
    Implementation of Scalable Blocking Locks using an Adaptative Thread Scheduler
    (Georgia Institute of Technology, 1993) Mukherjee, Bodhisattwa ; Schwan, Karsten
    Blocking locks are commonly used in parallel programs to improve application performance and system throughput. However, most implementations of such locks suffer from two major problems -- latency and scalability. In this paper, we propose an implementation of blocking locks using scheduler adaptation which exploits the interaction between thread schedulers and locks. By experimentation using well-known multiprocessor applications on a KSR2 multiprocessor, we demonstrate how such an implementation considerably reduces the latency and improves the scalability of blocking locks.
  • Thumbnail Image
    Item
    Improving Performace by Use of Adaptive Objects: Experimentation with a Configurable Multiprocessor Thread Package
    (Georgia Institute of Technology, 1993) Mukherjee, Bodhisattwa ; Schwan, Karsten
    Operating system kernels typically offer a fixed set of mechanisms and primitives. However, recent research shows that the attainment of high performance for a variety of parallel applications may require the availability of variants of existing primitives or additional low-level mechanisms best suited for specific applications. One approach to addressing this need is to offer an adaptable and extensible operating system kernel. In this paper, we present a model for adaptive objects and associated mechanisms which may be used for the development of high performance operating system kernels for parallel and distributed systems. We use the model to implement a class of multiprocessor locks namely, adaptive locks which adapt themselves according to user-provided adaptation policies to suit any application locking pattern. Using a well-known multiprocessor application, the Travelling Sales Person program, we demonstrate the performance advantage of adaptive locks over existing locks.
  • Thumbnail Image
    Item
    Distributed Shared Abstractions (DSA) on Multiprocessors
    (Georgia Institute of Technology, 1993) Clemencon, Christian ; Mukherjee, Bodhisattwa ; Schwan, Karsten
    Any parallel program has abstractions that are shared by the program's multiple processes, including data structures containing shared data, code implementing operations like global sums or minima, type instances used for process synchronization or communication, etc. Such shared abstractions can considerably affect the performance of parallel programs, on both distributed and shared memory multiprocessors. As a result, their implementation must be efficient, and such efficiency should be achieved without unduly compromising program portability and maintainability. Unfortunately, efficiency and portability can be at cross-purposes, since high performance typically requires changes in the representation of shared abstractions across different parallel machines. The primary contribution of the DSA library presented and evaluated in this paper is its representation of shared abstractions as objects that may be internally distributed across different nodes of a parallel machine. Such distributed shared abstractions (DSA) are encapsulated so that their implementations are easily changed while maintaining program portability across parallel architectures ranging from small-scale multiprocessors, to medium-scale shared and distributed memory machines, and potentially, to networks of computer workstations. The principal results presented in this paper are (1) a demonstration that the fragmentation of object state across different nodes of a multiprocessor machine can significantly improve program performance and (2) that such object fragmentation can be achieved without compromising portability by changing object interfaces. These results are demonstrated using implementations of the DSA library on several medium-scale multiprocessors, including the BBN Butterfly, Kendall Square Research, and SGI shared memory multiprocessors. The DSA library's evaluation uses synthetic workloads and a parallel implementation of a branch-and-bound algorithm for solving the Traveling Salesperson Problem (TSP).