Scalable Concurrent B-Trees Using Multi-Version Memory
We present a new algorithm for implementing a concurrent B-tree on a multiprocessor. The algorithm replicates B-tree nodes on multiple processors (particularly nodes near the root of the tree) to eliminate bottlenecks caused by contention for a single copy of each node. In contrast to other replication or caching strategies that provide some form of coherence, the algorithm uses a novel replication strategy, calledmulti-version memory. Multi-version memory weakens the semantics of coherent caches by allowing readers to access “old versions” of data. As a result, readers can run in parallel with a writer. Using multi-version memory for the internal nodes of a B-tree reduces the synchronization requirements and delays associated with updating the internal nodes. Experiments comparing the B-tree algorithm based on multi-version memory to other algorithms based on coherent replication show that using multi-version memory enhances throughput significantly, even for small numbers of processors, and also allows throughput to scale with increasing numbers of processors long past the point where other algorithms saturate and start to thrash.

title: PRELUDE: A System for Portable Parallel Software
abstract: In this paper we describe PRELUDE, a programming language and accompanying system support for writing portable MIMD parallel programs. PRELUDE supports methodology for designing and organizing parallel programs that makes them easier to tune for particular architectures and to port to new architectures. It builds on earlier work on Emerald, Amber, and various Fortran extensions to allow the programmer to divide programs into architecture-dependent and architecture-independent parts, and then to change the architecture-dependent parts to port the program to a new machine or to tune its performance on a single machine. The architecture-dependent parts of a program are specified by annotations that describe the mapping of a program onto a machine. PRELUDE provides a variety of mapping mechanisms similar to those in other systems, including remote procedure call, object migration, and data replication and partitioning. In addition, PRELUDE includes novel migration mechanisms for computations based on a form of continuation passing. The implementation of object migration in PRELUDE uses a novel approach based on fixup blocks that is more efficient than previous approaches, and amortizes the cost of each migration so that the cost per migration drops as the frequency of migrations increases.

title: Multi-version memory: software cache management for concurrent B-trees
abstract: The authors describe a new concurrent B-tree algorithm. The algorithm is designed to work well in large-scale parallel or distributed systems in which the number of processors sharing the tree is large or the communication delay between processors (or between processors and the global memory for a shared-memory system) is large relative to the speed of local computation. The basis of the algorithm is an abstraction that is similar to coherent shared memory, but provides a weaker semantics; this abstraction is called multiversion memory. Multi-version memory uses caches but weakens the semantics of ordinary shared memory by allowing process reading data to be given an old version of the data. This semantics is adequate for the non-leaf nodes in the B-tree algorithms presented.<<ETX>>

title: Pipes: linguistic support for ordered asynchronous invocations
abstract: We describe pipes, a new linguistic mechanism for sequences of ordered asynchronous procedure calls in multiprocessor systems. Pipes allow a sequence of remote invocations to be performed in order, but asynchronously with respect to the calling thread. Using pipes results in programs that are easier to understand and debug than those with explicit synchronization between asynchronous invocations. The semantics of pipes make no assumptions about the underlying architecture, which enhances code portability. However, the implementation of pipes by the language compiler can be optimized so as to take advantage of any underlying message ordering a particular architecture may provide. Pipes also provide application-transparent flow control for asynchronous invocations and are able to throttle invocations from multiple calling threads. We present four implementations of pipes and show that the performance and space overheads associated with pipes are low.

title: Computation migration: enhancing locality for distributed-memory parallel systems
abstract: We describe computation migration, a new technique that is based on compile-time program transformations, for accesing remote data in a distributed-memory parallel system. In contrast with RPC-style access, where the access is performed remotely, and with data migration, where the data is moved so that it is local, computation migration moves part of the current thread to the processor where the data resides. The access is performed at the remote processor, and the migrated thread portion continues to run on that same processor; this makes subsequent accesses in the thread portion local.
We describe an implementation of computation migration that consists of two parts: an implementation that migrates single activation frames, and a high-level language annotation that allows a programmer to express when migration is desired. We performed experiments using two applications; these experiments demonstrate that computation migration is a valuable alternative to RPC and data migration.

title: Understanding online archiving

title: Practical factorization of univariate polynomials over finite fields
abstract: Research presented fort to establish state-of-the-art Kent State University “ Kent, Ohio 44242-0001 here is part of an effactoring routines for polynomials. The foundation of such algorithms lies in the efficient factorization over a finite field GF(p~). The Cantor-Zassenhaus algorithm together with innovative ideas suggested by others is compared with the Berlekamp algorithm. The studies led us to design a hybrid algorithm that combine the strengths of the different approaches. The algorithms are also implemented and machine timings are obtained to measure the performance of these algorithms.

title: MP: a protocol for efficient exchange of mathematical expressions
abstract: The Multi Protocol (MP) is designed for integrating symbolic, numeric, graphics, document processing, and other tools for scientific computation, into a single distributed problem-solving environment. MP is layered, reflecting the logically distinct aspects of tool integration. Data representation issues are addressed by specifying a set of basic data types and a mechanism for constructing non-basic types. MP passes all data in the form of annotated parse trees. The parse tree provides a simple, flexible and tool-independent way to represent and exchange data, and annotations provide a powerful and generic expressive facility for transmitting additional information. MP also provides efficient encodings for numeric data and includes different types of optimizations to reduce the cost of exchanging data. The optimizations are important when transmitting large expressions typically encountered in symbolic and numeric computation. MP is extensible. Users can define additional sets of operators and annotations as well as tailor the generic optimization mechanisms to efficiently encode their own data structures. A clear distinction between MP-defined and user-defined definitions is enforced.

title: Hopf bifurcation and oscillations in a communication network with heterogeneous delays
abstract: In this paper, we investigate stability, bifurcation and oscillations arising in a single-link communication network model with a large number of heterogeneous users adopting a Transmission Control Protocol (TCP)-like rate control scheme with an Active Queue Management (AQM) router. In the system considered, different user delays are known and fixed but taken from a given distribution. It is shown that for any given distribution of delays, there exists a critical amount of feedback (due to AQM) at which the equilibrium loses stability and a limit cycling solution develops via a Hopf bifurcation. The nature (criticality) of the bifurcation is investigated with the aid of Lyapunov-Schmidt perturbation method. The results of the analysis are numerically verified and provide valuable insights into dynamics of the AQM control system.

title: Time-domain simulation of uniform and nonuniform multiconductor lossy lines by the method of characteristics
abstract: A numerical technique to compute the time-domain response of multiconductor lossy uniform and nonuniform lines terminated in general nonlinear elements is presented. The technique is based on the method of characteristics and is used to study the propagation characteristics of multiple coupled uniform and nonuniform transmission line structures terminated in linear and nonlinear elements. This includes signal delay, distortion and crosstalk in interconnections in high-frequency analog and digital integrated circuits and chip modules.