Ayal Itzkovitz

Thread migration and its applications in distributed shared memory systems

Abstract In this paper we describe the way thread migration can be carried in distributed shared memory (DSM) systems. We discuss the advantages of multi-threading in DSM systems and the importance of preempted dynamic thread migration. The proposed solution is implemented in MILLIPEDE: an environment for parallel programming over a network of (personal) computers. MILLIPEDE implements transparent computation migration mechanism: a mobile computation thread in a MILLIPEDE application can be suspended almost at every point during its lifetime and be resumed on another host. This mechanism can be used to better utilize system resources and improve performance by balancing the load and solving ping-pong situations of memory objects, and to provide user ownership on his workstation. We describe how some of these are implemented in the MILLIPEDE system. MILLIPEDE, including its thread migration module, is fully implemented in user-mode (currently on Windows-NT) using the standard operating system APIs.

Toward Integration of Data Race Detection in DSM Systems

We present a distributed algorithm, called djit, for detecting data races in dsm systems. djit is designed as a dsm add-on, detecting a race condition as soon as one is created. It instantly displays to the user the precise place in the program where the race occurred. There are no false detections, and no data races are missed. We have implemented djit on top of millipage?a fine granularity, page-based dsm system. Our implementation makes novel use of the operating system protection mechanisms. In particular, we propose a protection cache, which can be used for local logging of accesses to variables. As a result, our implementation does not increase the message complexity of the execution, piggybacking all its communication activity on top of the dsm-related messages. The performance figures show that our data race detection mechanism has only a minor influence on performance. The measured overheads, averaging only few percent, are two orders of magnitude smaller than those achieved in previous work. Thus, our technique makes the integration of on-the-fly data race detection during the regular dsm execution feasible for the first time.

Symphony: An Infrastructure for Managing Virtual Servers

A virtual server is a server whose location in an internet is virtual; it may move from one physical site to another, and it may span a dynamically changing number of physical sites. In particular, during periods of high load, it may grow to new machines, while in other times it may shrink into a single host, and may even allow other virtual servers to run on the same host. This paper describes the design and architecture of Symphony, a management infrastructure for executing virtual servers in internet settings. This design is based on combining CORBA technology with group communication capabilities, for added reliability and fault tolerance.

Supporting multiple parallel programming paradigms on top of the Millipede virtual parallel machine

The MILLIPEDE system is a small yet powerful interface of a virtual parallel machine (VPM) on top of distributed computing environments. MILLIPEDE is thus a convenient environment for porting various existing parallel programming languages, for the design of new parallel programming languages, and for the development of parallel applications. MILLIPEDE is fully implemented at the Technion on a cluster of PCs running Windows-NT. We briefly describe the MILLIPEDE interface and discuss the implementation issues of several parallel languages.

Dynamic adaptation of sharing granularity in DSM systems

The tradeoff between false sharing elimination and aggregation in Distributed Shared Memory (DSM) systems has a major effect on their performance. Some studies in this area show that fine grain access is advantageous, while others advocate the use of large coherency units. One way to resolve the tradeoff is to dynamically adapt the granularity to the application memory access pattern. In this paper we propose a novel technique for implementing multiple sharing granularities over page based DSMs. We present protocols for efficient switching between small and large sharing units during runtime. We show that applications may benefit from adapting the memory sharing to the memory access pattern, using both coarse grain sharing and fine grain sharing interchangeably in different stages of the computation. Our experiments show a substantial improvement in the performance using adapted granularity level over using a fixed granularity level.

Symphony: Managing Virtual Servers in the Global Village

A virtual server is a server whose location in an internet is virtual; it may move from one physical site to another, and it may span a dynamically changing number of physical sites. In particular, during periods of high load, it may grow to new machines, while in other times it may shrink into a single host, and may even allow other virtual servers to run on the same host. This paper describes the design and architecture of Symphony, a management infrastructure for executing virtual servers in internet settings. This design is based on combining CORBA technology with group communication capabilities, for added reliability and fault tolerance.

Mechanisms for just-in-time allocation of resources to adaptive parallel programs

Adaptive parallel computations-computations that can adapt to changes in resource availability and requirement-can effectively use networked machines because they dynamically expand as machines become available and dynamically acquire machines as needed. While most parallel programming systems provide the means to develop adaptive programs, they do not provide any functional interface to external resource management systems. Thus no existing resource management system has the capability to manage resources on commodity system software, arbitrating the demands of multiple adaptive computations written using diverse programming environments. This paper presents a set of novel mechanisms that facilitate dynamic allocation of resources to adaptive parallel computations. The mechanisms are built on low-level features common to many programming systems, and unique in their ability to transparently manage multiple adaptive parallel programs that were not developed to have their resources managed by external systems. We also describe the design and the implementation of the initial prototype of ResourceBroker, a resource management system built to validate these mechanisms.

Millipede: Easy parallel programming in available distributed environments

Millipede is a generic run-time system for executing parallel programming languages in distributed environments. In this project, a set of basic constructs which are sufficient for most parallel programming languages is identified. These constructs are implemented on top of a cluster of workstations such that in order to run a specific parallel programming language in this distributed environment, all that is needed is a compiler, or a preprocessor, that maps the source language parallel code to the Millipede constructs. Some performance measurements of parallel programs on Millipede are also presented.

Parallel Vertex-To-Vertex Radiosity on a Distributed Shared Memory System

In this paper we describe the parallel implementation of the Vertex-To-Vertex Radiosity method on a cluster of PC hosts with a Distributed Shared Memory interface (DSM). We first explain how we use stochastic rays to compute the Form-Factor. We then proceed to describe the implementation of this method on top of the millipede system, a virtual parallel machine that runs on top of available distributed environments. We discuss a step-by-step process for exploiting millipedes optimization mechanisms. Despite the relatively slow communication medium, the optimization process leads from initial slowdown to high speedups.