Bodhisattwa Mukherjee

Improving performance by use of adaptive objects: experimentation with a configurable multiprocessor thread package

Since the mechanisms of an operating system can significantly affect the performance of parallel programs, it is important to customize operating system functionality for specific application programs. The authors first present a model for adaptive objects and the associated mechanisms, then they use this model to implement adaptive locks for multiprocessors which adapt themselves according to user-provided adaptation policies to suit changing application locking patterns. Using a parallel branch and bound program, they demonstrate the performance advantage of adaptive locks over existing locks.<<ETX>>

A machine independent interface for lightweight threads

Recently, lightweight thread libraries have become a common entity to support concurrent programming on shared memory multiprocessors. However, the disparity between primitives offered by operating systems creates a challenge for those who wish to create portable lightweight thread packages. What should be the interface between the machine-independent and machine-dependent parts of the thread library? We have implemented a portable lightweight thread library on top of Unix on a KSR-1 supercomputer, BBN Butterfly multiprocessor, SGI multiprocessor, Sequent multiprocessor and Sun 3/4 family of uniprocessors. This paper first compares the nature and performance of the OS primitives offered by these machines. We then present procedure-level abstraction that is efficiently implementable on all the architectures and is a sufficient base upon which a user-level thread package can be built.

KTK: kernel support for configurable objects and invocations

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/spl lsqb/22/spl rsqb/. >

Distributed shared abstractions (DSA) on multiprocessors

Any parallel program has abstractions that are shared by the programs multiple processes. 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. The primary contribution of the DSA library 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. The principal results presented are: a demonstration that the fragmentation of object state across different nodes of a multiprocessor machine can significantly improve program performance; and 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 librarys evaluation uses synthetic workloads and a parallel implementation of a branch and bound algorithm for solving the traveling salesperson problem (TSP).

Experiments With Configurable Locks for Multiprocessors

Operating system kernels typically offer a fixed set of mechanisms and primitves. However, the attainment high of performance for a variety parallel application requires the availability of reconfigurable and extensible operattng system kernel primitives. In this paper, we present an implementation of multiprocessor locks that can be reconfigured dynamically.

Implementation of scalable blocking locks using an adaptive thread scheduler

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. 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.

KTK: configurable objects and invocations

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.<<ETX>>