Search

An important new paradigm in software engineering has been the emergence of distributed component architectures. In this context, components are reusable building blocks for the construction of software systems (Thomas, 1997; Krieger and Adler, 1998). Modern systems for composing components include Microsoft’s ActiveX/DCOM and Sun’s JavaBeans and JavaStudio. Conceptually, a user has a palette of components from which to choose, and can compose or wire them together to create complete applications. Mechanisms are provided for defining new components which follow standards specifying interfaces, methods by which external codes can interact with the component. A useful model is that of a software integrated circuit; as a hardware IC has a specified set of pins that allow it to be connected with other IC’s without requiring details of internal representations or methods, software IC’s rely on published interfaces.

Researchers from several universities, national laboratories, software companies, and government funding agencies participated in the 1998 Scientific Integrated Development Environments for Knowledge, Information, and Computing Workshop. This meeting summarized the state-of-the-art in the area of problem-solving environments (PSEs) for scientific and engineering computation, and mapped out directions for future research. This report presents some of the results from the meeting and recommends promising areas for further work. It describes the need for PSEs, lists characteristics that many PSEs share and lists a few current systems. Design goals and future directions, with an emphasis on research issues, are outlined, followed by summary findings and conclusions.

Foreword * Preface * Part I: Programming Complexity of SAMR Algorithms. Systems engineering for high-performance computing software: The HDDA/DAGH infrastructure for implementation of parallel structured adaptive mesh. HAMR: The hierarchical adaptive mesh refinement system. AMR++: A design for parallel object-oriented adaptive mesh refinement. RSL: A parallel runtime system library for regional atmospheric models with nesting. Software abstractions and computational issues in parallel structured adaptive mesh methods for electronic structure calculations. Structured adaptive mesh refinement using high performance fortran * Part II: Applicability and Numerical Challenges of SAMR Methods. The dynamics of localized coherent structures and the role of adaptive software in multiscale modeling. Progress, results, and experiences in developing an adaptive solver for steady state turbulent reacting flows in industrial boilers and furnaces. Making arbitrarily small black holes: Experiences with AMR in numerical relativity. A hybrid AMR application for cosmology and astrophysics * List of Participants

Despite construction of powerful parallel systems and networked computational grids, achieving a large fraction of peak performance for a range of applications has proven very difficult. In this paper, we describe the components of Delphi, an integrated performance measurement and prediction environment that places system design on a solid performance engineering basis.

In this paper we discuss some experiences with javar, which is a prototype Java restructuring compiler that supports the automatic conversion of serial loops into constructs that use the multi-threading mechanism of the language to exploit any parallelism in these loops. Expressing parallelism in Java itself clearly has the advantage that the transformed program remains portable. After compilation of the transformed Java program into bytecode, speedup can be obtained on any platform on which the Java Virtual Machine implementation supports the true parallel execution of threads, whereas we will see that the threads only induce a slight overhead on uni-processors.

Modern technology provides the infrastructure necessary to develop distributed applications capable of using the power of multiple supercomputing resources and exploiting their diversity. The performance potential offered by distributed supercomputing is enormous, but it is hard to realize due to the complexity of programming in such environments. In this paper we introduce PARDIS, a system designed to overcome this challenge, based on ideas underlying the Common Object Request Broker Architecture (CORBA), a successful industry standard. PARDIS is a distributed environment in which objects representing data-parallel computations, called SPMD objects, as well as non-parallel objects present in parallel programs, can interact with each other across platforms and software systems. Each of these objects represents a small encapsulated application and can be used as a building block in the construction of powerful distributed metaapplications. The objects interact through interfaces specified in the Interface Definition Language (IDL), which allows the programmer to integrate within one metaapplication components implemented using different software systems. Further, support for non-blocking interactions between objects allows PARDIS to build concurrent distributed scenarios.

HPC++ is a C++ library and language extension framework that is being developed by the HPC++ consortium as a standard model for portable parallel C++ programming. This paper describes an initial implementation of the HPC++ Parallel Standard Template Library (PSTL) framework. This implementation includes seven distributed containers as well as selected algorithms. We include preliminary performance results from several experiments using the PSTL.

The design and implementation of portable, efficient, and expressive mechanisms for I/O on complex distributed data structures—such as found in adaptive parallel applications—is a challenging problem that we address in this paper. We describe the design, programmer interface, implementation, and performance of pC++/streams , a library that provides an expressive mechanism for I/O on distributed arrays of variable-sized objects in pC++, an object-parallel language. pC++/streams is intended for developers of parallel programs requiring efficient high-level I/O abstractions for checkpointing, scientific visualization, and debugging. pC++/streams is an implementation of d/streams , a language-independent abstraction for buffered I/O on distributed data structures. We describe the d/streams abstraction and present performance results on the Intel Paragon and SGI Challenge showing that d/streams can be implemented efficiently and portably.

This paper describes a set of tools for annotating and exploring program source code on the World Wide Web (WWW). These tools are part of a project to build an electronic textbook for parallel programming that exploits the Caltech Archetypes model of program construction. The tools provide a simple way for Fortran, HPF and C++ programmers to add special annotations to source codes that allow the source code to be converted automatically into WWW hypertext documents. In addition, special compiler based tools examine the source code and discover all subroutine call sites and automatically build the hypertext links to the appropriate subroutine definitions. In the case of parallel C++, a complete class browser has been constructed in HTML and the compiler based tools generates the data base of application specific type and program information.

pC++ is an object-parallel extension to the C++ programming language. This paper describes the current language definition and illustrates the programming style. Exampies of parallel linear algebra operations are presented and a fast Poisson solver is described in complete detail.

pC++ is a language extension to C++ designed to allow programmers to compose concurrent aggregate collection classes which can be aligned and distributed over the memory hierarchy of a parallel machine in a manner modeled on the High Performance Fortran Forum (HPFF) directives for Fortran 90. pC++ allows the user to write portable and efficient code which will run on a wide range of scalable parallel computer systems. The first version of the compiler is a preprocessor which generates Single Program Multiple Data (SPMD) C++ code. Currently, it runs on the Thinking Machine CM-5, the Intel Paragon, the BBN TC2000, the Kendall Square Research KSR-1, and the Sequent Symmetry. The authors describe the implementation of the runtime system, which provides the concurrency and communication primitives between objects in a distributed collection. To illustrate the behavior of the runtime system, they include a description and performance results on four benchmark programs.

This paper considers the problem of designing numerical linear algebra computations with a parallel object oriented programming language. An extension to C++ based on a Concurrent Aggregate concept is used to describe a hierarchy of distributed structures including dense matrices, sparse matrices, banded matrices, vectors and the associated linear algebra. We show that these abstractions are ideal for describing BLAS3 style blocked computation. As an example we show how to build a distributed conjugate gradient algorithms for sparse matrix (based on the NAS sparse benchmark and we show results for four different parallel machines.

We present an object-oriented, parallel program­ ming paradigm, called the distributed collection model and an experimental language PC++ based on the model. In the distributed collection model, program­ mers can describe the data distribution of elemen ts among processors to utilize memory locality and a col­ lection construct is employed to build distributed struc­ tures. The model also supports the express of massive parallelism and a new mechanism for building hierar­ chies of abstractions. Our experiences with application programs in the PC++ programming environments as well as per formance results are also described in the paper.

Space–times with asymptotically flat nonsimply connected spacelike slices are shown to possess enough intrinsic geometric structure to guarantee the existence of singularities under conditions usually considered insufficient. In particular, it is shown that if the normal geodesics to the spacelike slice are converging on a suitable compact set, and the space–time satisfies a standard energy condition, then it is timelike geodesically incomplete. A similar result holds if the space–time satisfies the chronology and generic conditions.

The Pringle is a 64 processor MIMD computer with a 64 M (8 bit) instructions per second execution rate. (Copies are running at Purdue and Washington.) The Pringle runs programs written for the Configurable, Highly Parallel (CHiP) Computer. That is, the Pringle executes the 64 separate instruction streams as well as the interconnection (phase) stream that configures the lattice of a 64 processor CHiP computer. But the Pringle is not a CHiP. It gives the illusion of the CHiP machine's conflict-free, point-to-point communication using a 64 Mbit internal polled bus. In addition to describing the design goals and the Pringle architecture, this paper identifies two problems common to novel architecture implementation projects, the “wisdom of experience” problem and the “single instance” problem, and expalins how they were addressed for the Pringle.

A description is given of Faust, an integrated environment for the development of large, scientific applications. Faust includes a project-management tool, a context editor that is interfaced to a program database, and performance-evaluation tools. In Faust, all applications work is done in the context of projects, which serve as the focal point for all tool interactions. A project roughly corresponds to an executable program. Faust achieves functional integration through operations on common data sets maintained in each project. Sigma, a Faust tool designed to help users of parallel supercomputers retarget and optimize application code, helps them either fine-tune parallel code that has been automatically generated or optimize a new parallel algorithm's design. Faust includes a dynamic call-graph tool and an integrated, multiprocessor performance analysis and characterization tool set. >

We consider large, sparse linear systems that result from the discretization of partial differential equations on regular and ir regular domains, and we focus on the ap plication of the preconditioned conjugate gradient (PCCG) method to the solution of such systems. More specifically, our goal is the efficient implementation of the PCCG method on vector supercomputers. The contribution to the above goal is made by the introduction of a data struc ture that can be effectively manipulated on vector machines, the utilization of precon ditioning matrices obtained by incomplete factorization with diagonal update sets, and the introduction of new numbering schemes for both regular and irregular grids.

Sufficient topological conditions and some reasonable geometric properties near infinity are given on a partial Cauchy surface to study the occurrence of singularities and the topological structure of smooth event horizons. Conditions are given on electrovac space-times to show the horizon is a sphere without assuming the solution is stationary.

The subject of parallel computation has been around for almost 20 years and, until very recently, it has been an exotic subdiscipline of computer architecture and algorithm analysis. However, recently we have seen a fundamental shift in the role of parallelism studies in both academic computer science and in the computer industry. In particular, parallel computation issues are now a significant part of research in most branches of computer science and the industry sees parallelism as the only answer to the next generation of high performance machines. Because we can now build parallel systems with relative ease and because application programmers are now intensively involved in the use of these machines, the nature of basic research has shifted focus. In the past, when there were no real machines available, all we could do was make theoretical studies of parallel algorithm complexity and debate the merits of switching network design. Now the discipline more closely resembles other sciences in that there is a very active experimental branch of computer science that is busy testing new design theories and algorithms. The experimental work is driving new investigations of theoretical questions that have arisen from our need to fully understand this first generation of parallel hardware.

The speed and efficiency of the memory system is a key limiting factor in the performance of supercomputers. Consequently, one of the major concerns when developing a high-performance code, either manually or automatically, is determining and characterizing the influence of the memory system on performance in terms of algorithmic parameters. Unfortunately, the performance data available to an algorithm designer such as various benchmarks and, occasionally, manufacturer-supplied information, e.g. instruction timings and architecture component characteristics, are rarely sufficient for this task. In this paper, we discuss a systematic methodology for probing the performance characteristics of a memory system via a hierarchy of data-movement kernels. We present and analyze the results obtained by such a methodology on a cache-based multi-vector processor (Alliant FX/8). Finally, we indicate how these experimental results can be used for predicting the performance of simple Fortran codes by a combination of empirical observations, architectural models and analytical techniques.

As part of the AFOSR Fast Algorithms Initiative, the project focused on the design of parallel algorithms and the related software design problems associated with multiprocessor systems. The research work was divided into two phases. The primary emphasis of the first phase was to study new algorithm ideas for solving the large numerical linear algebra problems associated with two and three dimensional elliptic P.D.E. problems. The work in the second phase of the research was directed toward understanding the software mechanisms needed to map these algorithms to existing parallel computers. In the following paragraphs we detail our work in both areas.

The increasing ability for the sciences to sense the world around us is resulting in a growing need for datadriven e-Science applications that are under the control of workflows composed of services on the Grid. The focus of our work is on provenance collection for these workflows that are necessary to validate the workflow and to determine quality of generated data products. The challenge we address is to record uniform and usable provenance metadata that meets the domain needs while minimizing the modification burden on the service authors and the performance overhead on the workflow engine and the services. The framework is based on generating discrete provenance activities during the lifecycle of a workflow execution that can be aggregated to form complex data and process provenance graphs that can span across workflows. The implementation uses a loosely coupled publish-subscribe architecture for propagating these activities, and the capabilities of the system satisfy the needs of detailed provenance collection. A performance evaluation of a prototype finds a minimal performance overhead (in the range of 1% for an eight-service workflow using 271 data products).

New and compelling ideas are transforming the future of computing, bringing about a plethora of changes that have significant implications for our profession and our society and raising some profound technical questions. This Web extra video interview features Dan Reed of Microsoft giving us a sense of how new cloud architectures and cloud capabilities will begin to move computer science education, research, and thinking in whole new directions.

LEAD is a large-scale effort to build a service-oriented infrastructure that allows atmospheric science researchers to dynamically and adaptively respond to weather patterns to produce better-than-real time predictions of tornadoes and other “mesoscale” weather events. In this paper we discuss an architectural framework that is forming our thinking about adaptability and give early solutions in workflow and monitoring.

This paper describes the design and prototype implementation of the XCAT Grid Science Portal. The portal lets grid application programmers script complex distributed computations and package these applications with simple interfaces for others to use. Each application is packaged as anotebookwhich consists of web pages and editable parameterized scripts. The portal is a workstation-based specializedpersonalweb server, capable of executing the application scripts and launching remote grid applications for the user. The portal server can receive event streams published by the application and grid resource information published by Network Weather Service (NWS) [35] or Autopilot [16] sensors. Notebooks can bepublishedand stored in web based archives for others to retrieve and modify. The XCAT Grid Science Portal has been tested with various applications, including the distributed simulation of chemical processes in semiconductor manufacturing and collaboratory support for X-ray crystallographers.