Distributed shared memory (DSM) systems allow programmers to use a shared memory programming model on distributed systems. However, DSM systems present new challenges to performance evaluation and debugging. While programmers write programs with a shared memory model using shared variables and shared memory synchronization primitives to coordinate processes, most performance problems arise from the implementation of these abstractions with messages. Because the DSM abstraction hides the underlying message passing, it is difficult to identify the sources of performance problems. We have developed an instrumentation system and performance evaluation techniques for DSM systems that correlate message passing behavior in the lower levels of a DSM system with the higher-level shared memory programming abstractions. We have developed a prototype tool called Xunify to demonstrate the feasibility of such an approach. Xunify provides graphical animations of DSM programs at three distinct levels and offers a powerful event filtering facility capable to help show system behavior corresponding to specific DSM constructs.

We address the multicast issue in a wide area WDM network in which a source broadcasts its message to some sites in the network. This problem can be formalized as the following optimal multicast tree problem. Given a directed graph G = (V, E) with a source s and a set S of nodes, assume that every node in S (⊂ V) is reachable from s. Associated with every link e ∈ E, there is a set Λ(e) of available wavelengths on it, |V| = n and |E| = m, find a multicast tree rooted at s including all the nodes in S with minimizing the cost of the tree, in terms of the sum of the cost of wavelength conversion at nodes and the cost of using wavelengths on links in the tree. That is, not only do we need to find a directed tree rooted at s, but also do we need to assign a specific wavelength Λ ∈ Λ(e) to every tree edge e and to set the switches at every node in the tree. Since this problem is NP-complete, it is unlikely that there is a polynomial algorithm to find an exact solution for it. Instead, we first present an approximation algorithm for the problem which runs in time O(k2n + km +kn log(kn) + (kn)1/e|S|), and delivers a solution within O(|S|e) of the optimal, for any fixed 0 > e ≤ 1. We then present a distributed version of the proposed algorithm. The communication and time complexities of the distributed algorithm are O(km) and O(kn) respectively, and the solution delivered is |S| times of the optimal, where k is the number of wavelengths in the network. Finally, we conduct some experiments to verify the applicability of the proposed algorithms. The experimental results matches our algorithmic claims.

A divide and conquer method well suited for the solution of band linear systems on massively parallel computers is presented. This method is applied in the PCG algorithm to solve large sparse linear systems. Implementations, including the low level SHMEM message passing environment and the OpenMP directives are analyzed on a T3D and an Origin 2000. Applications to the solution of Navier-Stokes equations in shallow domains are presented. Some features of the OpenMP Application Program Interface (API) useful to these applications are discussed.

Three paradigms for distributed-memory parallel computation that free application programmer from details of message passing are compared for an archetypal structured scientific computation -- a nonlinear, structured-grid partial differential equation boundary value problem -- using same algorithm on same hardware. All of paradigms -- parallel languages represented by Portland Group's HPF, (semi-)automated serial-to-parallel source-to-source translation represented by CAP-Tools from University of Greenwich, and parallel libraries represented by Argonne's PETSc -- are found to be easy to use for this problem class, and all are reasonably effective in exploiting concurrency after a short learning curve. The level of involvement required by application programmer under any paradigm includes specification of data partitioning, corresponding to a geometrically simple decomposition of domain of PDE. Programming in SPMD style for PETSc library requires writing only routines that discretize PDE and its Jacobian, managing subdomain-to-processor mappings (affine global-to-local index mappings), and interfacing to library solver routines. Programming for HPF requires a complete sequential implementation of same algorithm as a starting point, introduction of concurrency through subdomain blocking (a task similar to index mapping), and modest experimentation with rewriting loops to elucidate to compiler latent concurrency. Programming with CAPTools involves feeding same sequential implementation to CAPTools interactive parallelization system, and guiding source-to-source code transformation by responding to various queries about quantities knowable only at runtime. Results representative of the state of practice for a scaled sequence of structured grid problems are given on three of most important contemporary high-performance platforms: IBM SP, SGI Origin 2000, and CRAYY T3E.

In this paper we present the architecture and framework for a benchmark suite that has been developed as part of the DeSiDeRaTa project. The benchmark suite is representative of the emerging generation of distributed, mission-critical, real-time control systems that operate in dynamic environments. Systems that operate in such environments may have unknown worst- case scenarios, may have large variances in the sizes of the data and event sets that they process (and thus, have large variances in execution latencies and resource requirements), and may be very difficult to characterize statically, even by time-invariant statistical distributions. The benchmark suite (called DynBench) is useful for evaluation of the Quality of Service (QoS) management and/or Resource Management (RM) services in distributed real-time systems. As such, DynBench includes a set of performance metrics for the evaluation of the QoS and RM technologies in dynamic, distributed real-time systems. The paper demonstrates the successful application of DynBench in evaluation of the DeSiDeRaTa QoS management middleware.

Jeff Magee and Jeff Kramer John Wiley and Sons, New York, NY, 1999, 374 pp. ISBN 0471987107, $64.99 The book is an introductory text to the ideas, concepts, and topics of concurrency. The text focuses on understanding concepts and techniques, and problems of concurrency, not on the implementation or language. The author's overall goal is that by a combination of learning and doing using Java should make the process of acquiring the skills relating to concurrency interesting, enjoyable, and challenging. The Java language is thus used only for illustration and programming experience of the reader. The book is intended for a computer science student or software developer. A background in programming is expected, as well as some familiarity with the essential concepts of object-oriented programming. Knowledge of the Java programming language and operating systems concepts is beneficial but not required. After reading the text, a reader can expect to have a broad understanding of the concepts of concurrency, the problems that arise, methods to emphasis desirable properties in a concurrent system, and ways to avoid the undesirable ones. The text provides a systematic treatment of concepts, as means to rigorously specify and model concurrent systems, with Java examples to animate and illustrate the concepts discussed. The book is organized into twelve chapters, with three appendices. The first eight chapters provide a concise and comprehensive foundation of concurrency, with the remaining four chapters focusing on more advanced concepts. The latter four chapters are somewhat supplemental and can be read at the discretion of the reader. The content of the text is self-contained, with no reliance upon external references. The authors provide a concluding set of notes and further topics which reference external works, but these are not used in the chapter contents. The introduction provides the foundation for the book, and an idea of what will follow in the rest of the text. The basics of modeling and Java are covered. Authors follow with the concepts of processes, threads and with the idea of concurrency. The emphasis is on using Java, and on the notation used to define a concurrent process or thread. The discussion continues covering interleaving and asynchronous concurrency. Various details about composition of parallel processes and finite state processing modeling are presented. The programming of concurrent execution using Java is then examined via the concept of multiple threads. Here, sharing objects among Java threads is also discussed. The concept of conditional synchronization is covered next, and is used to construct a monitor. The methods of the base object in Java is used, and a waiting queue associated with a Java object is discussed and implemented. This discussion is followed by introduction of deadlock. Authors show the conditions necessary for a deadlock to occur and present an analysis of a concurrent system establishing that such a system is deadlock-free. The classic Dining Philosopher's problem is used to illustrate the distinction between finding deadlocks in models and in programs. The presentation continues with the safety property (that asserts that nothing bad happens), and the liveliness property (that asserts that nothing good happens). Here, authors use the material on model-based design to consolidate many of the concepts previously discussed. No one modeling method or design methodology is emphasized. Then creation and elimination of threads in a running program is covered next. The dynamic starting and stopping of Java threads is presented. The discussion moves then to messaging passing. Asynchronous and synchronous messaging is presented with Java programming examples. The concept of a rendezvous, allowing for interaction in a messaging system, is also presented. Based on the concepts developed so far filter-pipeline, supervisor-worker, and announcer-listener concurrent architectures are examined. Java programs demonstrating how the elements of each model interact at runtime are developed. The presentation completes with modeling and implementing of timed systems. Time is signaled by the passage of successive time ticks. The authors then elaborate on a system that is event-based rather than thread-based. Java programs are used to illustrate in implementation the concepts discussed. The three appendices provide a reference, specification, and listing of semantics for the finite-state modeling algebra used by the authors throughout the book. The text is ideal for teaching in a classroom environment, or for a motivated reader to use for self-paced learning. Its organization follows a logical train of discussion and thought, with each chapter building successively on the other, with the more difficult concepts and topics withheld until later. This gradual approach makes the material flow smoothly and cohesively from the beginning to the end. The book is intended as a textbook, so does organize the material and discussion as one, but does not become too dry or bland to stifle the reader's interest in the material. The examples are inter-mixed with the discussion to highlight and emphasize essential points the authors make in each chapter. The text illustrates concepts well under discussion, and does not become a long-winded recital of theory. The topics examined are fundamental to concurrency, and are well illustrated and discussed, but no one topic is examined extensively. The code examples are well written concerning the programming style, indentation and comments. A CD is provided, containing the codes from the book. In addition supplementary material consisting of presentation slides and an errata is provided on the author's WWW site, as well as on the CD. The book is up to date both on the topics of concurrency, and with the Java applets, code, and programs used to illustrate them. Later, as the Java language evolves, the examples may need to be updated, but for the time being the text well represents that state of the Java language. William F. Gilreath, Micron Technology, Inc., Boise Idaho

We present a framework for controlling coarse grained, component-level distributed performance and scalability simulations for enterprise IT system design. Examples of scalability simulation are presented, along with scale-up modeling functionality. This would allow a creation of meta-design simulation environments: a model development workflow with various levels of detail and a model-sharing paradigm integrated over common XML infrastructure.

Distributed systems were once the exception, constructed only rarely and with great difficulty by developers who spent significant amounts of time mastering the technology. Now, as modern software technologies have made distributed systems easier to construct, they have become the norm. Unfortunately, many distributed systems fail to meet their performance objectives when they are initially constructed. Others perform adequately with a small number of users but do not scale to support increased usage. These performance failures result in damaged customer relations, lost productivity for users, lost revenue, cost overruns due to tuning or redesign, and missed market windows. Our experience is that most performance failures are due to a lack of consideration of performance issues early in the development process, in the architectural phase. This paper discusses assessment of the performance characteristics of distributed software architectures using the Software Performance Engineering (SPE) approach. We describe the information required to perform such assessments, particularly the information about synchronization points and types of synchronization mechanisms, and the modeling approach. The case study demonstrates how to construct performance models for distributed systems and illustrates how simple models of software architectures are sufficient for early identification of performance problems.

Every transaction system supporting business processes must satisfy some computational performance requirements. If it does not, the system may have a significantly reduced value or become useless. The number of factors that influence performance of distributed transaction systems is so large, that the traditional capacity planning methods appropriate for centralized mainframe systems are not applicable. The most cost-effective method has proven to be predictive modeling. A combination of analytic and simulation modeling is most useful for analyzing and tuning performance of systems that have been designed or are in production. The task of designing a system ab initio given expected workloads and required performance/cost constraints is much harder. In this special issue, the paper by Marc Brittan and Janusz Kowalik describes a method for designing initial systems configurations and capacities. This paper focuses on predictive simulation modeling that is used for detailed performance analysis of existing systems. Such analyses may be motivated by what-if studies or by a desire to improve system's unsatisfactory performance.

Heterogeneous Distributed Computing (HDC) system consists of Workstations (WSs) and Personal Computers (PCs). In HDC system, each WS/PC may have different processor and performance. In order to take advantage of this diversity of processing power of a system, an effective task partitioning, scheduling, and load balancing are needed to get the optimum performance. This paper examines the effectiveness of task partitioning and scheduling strategies for image (raytracing) processing application on HDC system. The static and dynamic/Run-time Task Scheduling (RTS) strategies are shown inadequate for balancing the load of HDC system. Two adaptive tasks scheduling strategies are proposed for HDC image computing system. These adaptive strategies are: i) Master Initiate Sub-task size (MIS) strategy (based on centralized resources management approach), and ii) Worker Initiated Sub-task size (WIS) strategy (based on semi-decentralized resources management approach). The measured results show that the adaptive (MIS & WIS) strategies dramatically improve the performance of HDC raytracing system and remedy the defects of static and RTS strategies. Performances of the all investigated strategies are evaluated on manager/master and workers model of HDC system. In performance comparisons of MIS and WIS strategies, the WIS strategy shows a slightly better speedup and scalability over MIS strategy.