A warm welcome to the 2024 IEEE World Congress on Services (SERVICES). With Professor Zhi Jin and Professor Michael Sheng serving as the Congress General Chairs, I trust everyone will have a rewarding experience participating in the IEEE Computer Society's flagship annual event in services computing, whether attending on-site or remotely.

A warm welcome to the 2024 IEEE World Congress on Services (SERVICES). With Professor Zhi Jin and Professor Michael Sheng serving as the Congress General Chairs, I trust everyone will have a rewarding experience participating in the IEEE Computer Society's flagship annual event in services computing, whether attending on-site or remotely.

This paper was solicited as a "vision" talk for the 2019 eScience conference. It is based on my assessment of the role AI will have on eScience in the years ahead. While machine learning methods are already being well integrated into computing practice, this paper will look at another area: the role AI will play as an assistant to our daily research work.

We generalize MapReduce, Iterative MapReduce and data intensive MPI runtime as a layered Map-Collective architecture with Map-All Gather, Map-All Reduce, MapReduce Merge Broadcast and Map-Reduce Scatter patterns as the initial focus. Map-collectives improve the performance and efficiency of the computations while at the same time facilitating ease of use for the users. These collective primitives can be applied to multiple runtimes and we propose building high performance robust implementations that cross cluster and cloud systems. Here we present results for two collectives shared between Hadoop (where we term our extension H-Collectives) on clusters and the Twister4Azure Iterative MapReduce for the Azure Cloud. Our prototype implementations of Map-All Gather and Map-All Reduce primitives achieved up to 33% performance improvement for K-means Clustering and up to 50% improvement for Multi-Dimensional Scaling, while also improving the user friendliness. In some cases, use of Map-collectives virtually eliminated almost all the overheads of the computations.

Scientific workflows have become an integral part of cyberinfrastructure as their computational complexity and data sizes have grown. However, the complexity of the distributed infrastructure makes design of new workflows, determining the right management policies, debugging, testing or reproduction of errors challenging. Today, workflow engines manage the dependencies between tasks of workflows and there are tools available to wrap scientific codes. There is a need for a customizable, isolated and manageable testing container for design, evaluation and deployment of distributed workflows. To build such an environment, we need to be able to model and represent, capture and possibly reuse the execution flows within each task of a workflow that accurately captures the execution behavior. In this paper, we present the design and implementation of WORKEM, an extensible framework that can be used to represent and emulate workflow execution state. We also detail the use of the framework in two specific case studies (a) design and testing of an orchestration system (b) generation of a provenance database. Our evaluation shows that the framework has minimal overheads and can be scaled to run hundreds of workflows in short durations of time and with a high amount of parallelism.

In the recent decades we have witnessed a major revolution in the computer field. The major challenges posed by applications in fields of bioinformatics, earth sciences or weather forecasting, among others, have caused the proliferation of complex solutions, such as grid, cloud and highperformance computing. The common objective of all these disciplines is the sharing of hardware and software resources to provide an infrastructure in which to run efficiently these applications. Particularly, grid computing has been one of the most important computing topics in the last years. Within this context, the GADA workshop arose in 2004 as a forum for researchers in grid computing and its application to data analysis. From then until 2008, GADA became a reference conference for researchers in grid, covering also a broader set of disciplines, although grid computing continued to play a key role in the set of main topics of the conference. This special issue includes the eight best papers presented at the International Conference on Grid Computing, High Performance and Distributed Application (GADA 2008) from a total of 31 submissions with an acceptance rate of 26%. GADA 2008 was held in conjunction with the On The Move Conferences during November 2008 in Monterrey, Mexico. Each submitted paper was reviewed by three reviewers and one of the program chairs, and a total of 70 reviewers were involved in the review process of GADA 2008. A further review stage was performed to select the papers for this special issue. Topics covered by these papers include grid modelling, performance and scalability. Three different papers address the important topic of grid modelling. Branco et al. [1] describe the experience in the development of the data management middleware DQ2, used in the ATLAS experiment for the Large Hadron Collider (HLC). From this experience, they have identified an important degree of uncertainty over the behaviour of large grid infrastructures. From the analysis of this uncertainty, they propose novel modelling and simulation techniques for Data Grids. van der Aalst et al. [2] show a formal description of the grid in terms of a Colored Petri Net (CPN). This formalism can be used as a conceptual model of a grid environment, and also allows you to perform various types of analysis, including performance analysis. The model has been validated by means of experiments in a testbed grid architecture. Montes et al. [3] present a methodology based on data mining techniques for the building of a global behaviour model of the grid. This methodology deals with the complexity of grid environments, providing a simple model that can be used for administrative purposes. The validation of the model has been performed by means of real and simulated case studies.

Management architectures are well discussed in the literature, but their application in real life settings has not been as well covered. Automatic management of a system involves many more complexities than closing the control-loop by reacting to sensor data and executing corrective actions. In this paper, we discuss those complexities and propose solutions to those problems on top of Hasthi management framework, where Hasthi is a robust, scalable, and distributed management framework that enables users to manage a system by enforcing management logic authored by users themselves. Furthermore, we present in detail a real life case study, which uses Hasthi to manage a large, SOA based, e-science cyberinfrastructure.

Today's scientific workflows use distributed heterogeneous resources through diverse grid and cloud interfaces that are often hard to program. In addition, especially for time-sensitive critical applications, predictable quality of service is necessary across these distributed resources. VGrADS' virtual grid execution system (vgES) provides an uniform qualitative resource abstraction over grid and cloud systems. We apply vgES for scheduling a set of deadline sensitive weather forecasting workflows. Specifically, this paper reports on our experiences with (1) virtualized reservations for batchqueue systems, (2) coordinated usage of TeraGrid (batch queue), Amazon EC2 (cloud), our own clusters (batch queue) and Eucalyptus (cloud) resources, and (3) fault tolerance through automated task replication. The combined effect of these techniques was to enable a new workflow planning method to balance performance, reliability and cost considerations. The results point toward improved resource selection and execution management support for a variety of e-Science applications over grids and cloud systems.

With the emergence of service oriented architecture, service orchestration has been an important paradigm of building large-scale distribute systems. The performance of orchestrating services is critical to the entire system. Meanwhile,with the growing complexity the programmability of writing service orchestration program has became a pressing concern. In this paper, we presents a service orchestration library which provides C# function API for orchestration constructs derived from the web-service workflow language WS-BPEL. The library implements those constructs by mapping WS-BPEL concurrent semantic into asynchronous events and join-patterns provided in Microsoft CCR; meanwhile the library provides the abstraction to ease the service orchestration programming. We will demonstrate how to use this library together with Microsoft DSS, a lightweight service runtime, to program service workflows which can efficiently scale to platforms from single multicore CPU, to clusters of distributed computers.

Due to their scale, complexity, and dynamic nature, e-science cyber-infrastructures have raised major system management challenges. It has been argued that employing system management frameworks to monitor and control large scale systems is a possible solution to address these challenges. This paper presents an application of a management framework, known as Hasthi (Sanskrit name of Elephant which represents robustness), to manage an e-science project called linked environments for atmospheric discovery (LEAD). Hasthi is a generic framework that manages a system according to rules written by administrators, where rules define how Hasthi should respond to changes and failures. Using LEAD as an example, we demonstrate how such extensible management framework can be utilized to manage a complex system, while describing common problems and solutions.

Microarray technology is a high-throughput experimental technique that can measure expression levels of hundreds of thousands of genes simultaneously. To interpret massive data from gene-expression microarray experiments, biologists encounter computational and analytical challenges. This is especially challenging for small research labs that lack local computing and bioinformatics expertise. Here, we introduce a virtual analysis system for microarray gene expression data in computing clouds with flexible and configurable GUI workflow engine so that biologists are able to analyze the data in many angles without worrying about computational and bioinformatics issues.

Abstract Provenance metadata in e‐Science captures the derivation history of data products generated from scientific workflows. Provenance forms a glue linking workflow execution with associated data products, and finds use in determining the quality of derived data, tracking resource usage, and for verifying and validating scientific experiments. In this article, we discuss the scope of provenance collected in the Karma provenance framework used in the LEAD Cyberinfrastructure project, distinguishing provenance metadata from generic annotations. We further describe our approaches to querying for different forms of provenance in Karma in the context of queries in the first provenance challenge. We use an incremental, building‐block method to construct provenance queries based on the fundamental querying capabilities provided by the Karma service centered on the provenance data model. This has the advantage of keeping the Karma service generic and simple, and yet supports a wide range of queries. Karma successfully answers all but one challenge query. Copyright © 2007 John Wiley & Sons, Ltd.

Abstract We review the efforts of the Open Grid Computing Environments collaboration. By adopting a general three‐tiered architecture based on common standards for portlets and Grid Web services, we can deliver numerous capabilities to science gateways from our diverse constituent efforts. In this paper, we discuss our support for standards‐based Grid portlets using the Velocity development environment. Our Grid portlets are based on abstraction layers provided by the Java CoG kit, which hide the differences of different Grid toolkits. Sophisticated services are decoupled from the portal container using Web service strategies. We describe advance information, semantic data, collaboration, and science application services developed by our consortium. Copyright © 2006 John Wiley & Sons, Ltd.

A Web services-based publish/subscribe system has the potential to create an Internet scale interoperable event notification system which is important for grid computing as it evolves a service-oriented architecture. WS-Messenger is designed to be a Web services-based message broker that can decouple event producers and event consumers and achieve scalable, reliable and efficient message delivery. In this paper, we discuss some challenges that are unique to Web services-based publish/subscribe systems and the key features that distinguish WS-Messenger from other existing message brokers. We then present the architecture and the technology used in WS-Messenger. Performance tests indicate WS-Messenger performs better than the WS-Notification implementation in Globus Toolkit 4 (GT4) and it can be used as a complement to GT4 to improve its scalability. We lastly describe its application to grid workflow orchestration in the LEAD project.

Data-driven computational science on community computational resources is frequently of a magnitude and scale that it requires that computations be done remotely, generating resulting data collections that are too large to be shipped back to a user's workstation. Service-oriented middleware is well equipped to carry out actions on behalf of a user, but SOA middleware does not address user trust in the privacy of their actions and security of their data. In this paper we develop a model that represents the trust relationship between the users and their remote resources in the grid system. We show how one can construct a trusted relationship from the model, with an emphasis on the importance of context to a specific trust relationship.

The prevailing binding of SOAP to HTTP specifies that SOAP messages be encoded as an XML 1.0 document which is then sent between client and server. XML processing however can be slow and memory intensive, especially for scientific data, and consequently SOAP has been regarded as an inappropriate protocol for scientific data. Efficiency considerations thus lead to the prevailing practice of separating data from the SOAP control channel. Instead, it is stored in specialized binary formats and transmitted either via attachments or indirectly via a file sharing mechanism, such as GridFTP or HTTP. This separation invariably complicates development due to the multiple libraries and type systems to be handled; furthermore it suffers from performance issues, especially when handling small binary data. As an alternative solution, binary XML provides a highly efficient encoding scheme for binary data in the XML and SOAP messages, and with it we can gain high performance as well as unifying the development environment without unduly impacting the Web service protocol stack. In this paper we present our implementation of a generic SOAP engine that supports both textual XML and binary XML as the encoding scheme of the message. We also present our binary XML data model and encoding scheme. Our experiments show that for scientific applications binary XML together with the generic SOAP implementation not only ease development, but also provide better performance and are more widely applicable than the commonly used separated schemes

Event notification plays an important role in the orchestration of distributed systems. Web services-based event notification is an important step to achieve an interoperable messaging system on the Internet scale. However, different incompatible specifications have been proposed to specify the Web services interfaces for Web services-based event notification systems. The WS-Eventing specification and the WS-Notification specifications are two major initiatives. WS-Messenger is our implementation of both specifications. A mediation approach is used to reconcile the differences between these two specifications. In this paper, we propose a "normalization-processing-customization" (NPC) model for mediation among competing Web services and show how this model is used in WS-Messenger to reconcile the incompatibility between these two specifications. The NPC model is flexible and scalable. The mediation implementation in WS-Messenger is efficient with a very small overhead

The increasing ability for the Earth sciences to sense the world around us is resulting in a growing need for data-driven applications that are under the control of data-centric workflows composed of grid- and Web-services. The focus of our work is on provenance collection/or these workflows, 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, based on a loosely-coupled publish-subscribe architecture for propagating provenance activities, satisfies the needs of detailed provenance collection while 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)

Indiana University provides powerful compute, storage, and network resources to a diverse local and national research community every day. IU's facilities have been used to support data-intensive applications ranging from digital humanities to computational biology.For this year's bandwidth challenge, several IU researchers will conduct experiments from the exhibit floor utilizing the resources that University Information Technology Services currently provides.Using IU's newly constructed 535 TB Data Capacitor and an additional component installed on the exhibit floor, we will use Lustre across the wide area network to simultaneously facilitate dynamic weather modeling, protein analysis, instrument data capture, and the production, storage, and analysis of simulation data.

The XML signature specification provides a rich and flexible message signature model for XML documents, and it has been adopted by SOAP applications to provide message-level security. However, the XML signature design introduces a number of complex processing steps, such as canonicalization and XPath filtering, that often lead to performance and scalability problems when encountering extremes of size and rate in the processing of XML. In this paper, we focus on the performance of validating large signed XML messages, as might be sent by a scientific application using grid Web services. We present the design and implementation of the GHPX/SSSV system for the streaming validation of SOAP digital signature. Our model consists of a streaming canonicalization and optimized SOAP signature validation. We present an empirical study of the performance characteristics of these streaming validation features. Based on our evaluations we conclude that the streaming validation model can not only provide high performance, but is also memory efficient.

This work describes an approach to building Grid applications based on the premise that users who wish to access and run these applications prefer to do so without becoming experts on Grid technology. We describe an application architecture based on wrapping user applications and application workflows as Web services and Web service resources. These services are visible to the users and to resource providers through a family of Grid portal components that can be used to configure, launch, and monitor complex applications in the scientific language of the end user. The applications in this model are instantiated by an application factory service. The layered design of the architecture makes it possible for an expert to configure an application factory service with a custom user interface client that may be dynamically loaded into the portal.

The benefits of component technologies are well known: they enable encapsulation, modular construction of applications and software reuse. The DOE sponsored common component architecture (CCA) as stated in R. Armstrong et al. (1999) project adopts a component-based approach for building large scale scientific applications. On the other hand, the Web services-based open grid service architecture (OGSA) and infrastructure (OGSI) based on I. Foster et al. (2002) come close to defining a component architecture for the Grid. Using an approach where a CCA component is modeled as a set of Grid services, the XCAT3 framework allows for CCA components to be compatible with the OGSI specification. This enables CCA components to be accessible via standard Grid clients, especially the ones that are portal-based. For CCA compatibility, XCAT3 uses interfaces generated by the Babel toolkit based CASC (2003), and for OGSI compatibility, it uses the Extreme GSX toolkit based on Indiana University Extreme Computing Lab. Grid Service Extensions (2003). In this paper, we describe our experience in implementing the XCAT3 system, and how it can be used to compose complex distributed applications on the Grid in a modular fashion.

The most important recent development in Grid systems is the adoption of the Web Services model as its basic architecture. The result is called the Open Grid Services Architecture (OGSA). This paper describes a component framework for distributed Grid applications that is consistent with that model. The framework, called XCAT, is based on the U.S. Department of Energy Common Component Architecture (CCA) but with an implementation based on the standard Web Services stack. Using this framework, an application programmer can compose an application from a set of distributed components. The result is a set of Web Services that collectively represent the executing application instance. This paper describes the basic architecture of XCAT and the design issues to be considered for a component to serve as both a CCA and Open Grid Service Infrastructure (OGSI) service.

Grid systems span manifold organizations and application domains. Because this diverse environment inevitably engenders multiple protocols, interoperability mechanisms are crucial to seamless, pervasive access. This paper presents the design, rationale, and implementation of the Proteus multiprotocol library for integrating multiple message protocols, such as SOAP and JMS, within one system. Proteus decouples application code from protocol code at run-time, allowing clients to incorporate separately developed protocols without recompiling or halting. Through generic serialization, which separates the transfer syntax from the message type, protocols can also be added independently of serialization routines. We also show performance-enhancing mechanisms for Grid services that examine metadata, but pass actual data through opaquely (such as adapters). The interface provided to protocol implementors is general enough to support protocols as disparate as our current implementations: SOAP, JMS, and binary. Proteus is written in C++; a Java port is planned.

The design and prototype implementation of the XCAT Grid Science Portal is described in this paper. The portal lets grid application programmers easily script complex distributed computations and package these applications with simple interfaces for others to use. Each application is packaged as a "notebook" which consists of web pages and editable parameterized scripts. The portal is a workstation-based specialized "personal" web 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) [32] or Autopilot [15] sensors. Notebooks can be "published" and 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.

Describes an approach to building a distributed software component system for scientific and engineering applications that is based on representing Computational Grid services as application-level software components. These Grid services provide tools such as registry and directory services, event services and remote component creation. While a service-based architecture for grids and other distributed systems is not new, this framework provides several unique features. First, the public interfaces to each software component are described as XML documents. This allows many adaptors and user interfaces to be generated from the specification dynamically. Second, this system is designed to exploit the resources of existing Grid infrastructures like Globus and Legion, and commercial Internet frameworks like e-speak. Third, and most important, the component-based design extends throughout the system. Hence, tools such as application builders, which allow users to select components, start them on remote resources, and connect and execute them, are also interchangeable software components. Consequently, it is possible to build distributed applications using a graphical "drag-and-drop" interface, a Web-based interface, a scripting language like Python, or an existing tool such as Matlab.

Distributed software component architectures provide promising approach to the problem of building large scale, scientific Grid applications [18]. Communication in these component architectures is based on Remote Method Invocation (RMI) protocols that allow one software component to invoke the functionality of another. Examples include Java remote method invocation (Java RMI)[25] and the new Simple Object Access Protocol (SOAP) [15]. SOAP has the advantage that many programming languages and component frameworks can support it. This paper describes experiments showing that SOAP by itself is not efficient enough for large scale scientific applications. However, when it is embedded in multi-protocol RMI framework, SOAP can be effectively used as a universal control protocol, that can be swapped out by faster, more special purpose protocols when large data transfer speeds are needed.

We use the term "Grid" to refer to a software system that provides uniform and location independent access to geographically and organizationally dispersed, heterogeneous resources that are persistent and supported. While, in general, Grids will provide the infrastructure to support a wide range of services in the scientific environment (e.g. collaboration and remote instrument control) in this paper we focus on services for high performance computing and data handling. We describe the services and architecture of NASA’s Information Power Grid ("IPG") - an early example of a large-scale Grid - and some of the issues that have come up in its implementation.

Describes work in progress to develop a standard for interoperability among high-performance scientific components. This research stems from the growing recognition that the scientific community needs to better manage the complexity of multidisciplinary simulations and better address scalable performance issues on parallel and distributed architectures. The driving force for this is the need for fast connections among components that perform numerically intensive work and for parallel collective interactions among components that use multiple processes or threads. This paper focuses on the areas we believe are most crucial in this context, namely an interface definition language that supports scientific abstractions for specifying component interfaces and a port connection model for specifying component interactions.

Information Power Grid (IPG) is the name of NASA's project to build a fully distributed computing and data management environment-a Grid. The IPG project has near, medium, and long-term goals that represent a continuum of engineering, development, and research topics. The overall goal is to provide the NASA scientific and engineering communities a substantial increase in their ability to solve problems that depend on use of large-scale and/or dispersed resources: aggregated computing, diverse data archives, laboratory instruments and engineering test facilities, and human collaborators. The approach involves infrastructure and services than can locate, aggregate, integrate, and manage resources from across the NASA enterprise. An important aspect of IPG is to produce a common view of these resources, and at the same time provide for distributed management and local control. In addition to addressing the overall goal of enhanced science and engineering, there is a potential important side effect. With a large collection of resources that have common use interfaces and a common management approach, the potential exists for a considerable pool of computing capability that could relatively easily, for example, be called on in extraordinary situations such as crisis response.

Grid systems, such as Globus, Legion and Globe, provide an infrastructure for implementing metacomputing over the Internet. The Component Architecture Toolkit (CAT) provides a software layer above the grid that facilitates programming and end-user interaction with the grid.

Development of high-performance distributed applications can be extremely challenging because of their complex runtime environment coupled with their requirement of high-performance. Such applications typically run on a set of heterogeneous machines with dynamically varying loads, connected by heterogeneous networks possibly supporting a wide variety of communication protocols. In spite of the size and complexity of such applications, they must provide the required high-performance mandated by their users. In order to achieve this goal, they need to adaptively utilize their computational and communication resources. The paper describes EMOP: a programming environment for building high-performance distributed systems. EMOP is designed on the lines of CORBA and uses an Object Request Broker (ORB) to support seamless communication between distributed application components. In order to provide adaptive utilization of communication resources, it uses the principle of open implementation to open up the communication mechanisms of its ORB. By virtue of its open architecture, the ORB supports multiple, possibly custom, communication protocols, along with automatic and user controlled protocol selection at run-time. In order to support adaptive utilization of computational resources, EMOP also provides a flexible and powerful set of load-balancing mechanisms that can be used to implement custom load-balancing strategies. The paper describes EMOP's Open ORB architecture and load balancing mechanisms, and uses a set of simple experiments to demonstrate their usefulness.

Recent developments in high speed networks on both sides of the Pacific including the vBNS, and the Abilene project in the US, and the Asia-Pacific Advanced Network (APAN) in the AP region, have been driven by the emergence of high speed networking as a central requirement for the support of basic science, engineering and other disciplines. The growth of international scientific collaborations in, for example, astronomy, high energy physics, medicine, and computational science leads to a requirement for a global data communications infrastructure on par with what is available domestically. This paper describes the establishment of a high bandwidth international Internet connection from the vBNS and other US networks to the Asia Pacific Advanced Network (APAN) and some of the applications driving this development.

Summary form only given. The traditional model of software design for large scale scientific problem solving is outdated. The emphasis is now on large teams that must build simulation software that integrates physical systems from multiple scientific disciplines. In addition to the problem of multi-disciplinary physics, the computational environment is now a grid of distributed resources consisting of large supercomputers, databases and networked instruments connected by high speed networks. Consequently, a new model for programming these applications is required. What is emerging is a programming style where the individual components of a large simulation can be located on remote systems and the application is built by composing these elements together to form a single distributed system. Building applications from software components is not a new idea. It has a rich history in the visualization and object oriented software design communities. More recently, the desktop top software industry has embraced this concept with systems like Java Beans, ActiveX and CORBA-Enterprise Beans. The author examines a new project to design a component architecture for scientific programming. He examines some of the design trade-offs that make this problem different from the conventional CA environment.

This paper provides a manual for javab, a prototype tool that supports the automatic detection and exploitation of implicit loop parallelism in JVM bytecode. Implicit parallelism is made explicit by means of the multi-threading mechanism provided by the JVM. Automatically exploiting implicit parallelism at bytecode level can be done independently from the source program and platform from which the bytecode was obtained, and independently from the platform on which the bytecode eventually will run. The parallelized bytecode remains architecturally neutral and may exhibit speedup on any platform that supports the true parallel execution of JVM threads. This project is supported by DARPA under contract ARPA F19628–94–C–0057 through a sub-contract from Syracuse University. © 1998 John Wiley & Sons, Ltd.

Java RMI provides an elegant and powerful model for invoking member functions on objects that exist in remote address spaces. Unfortunately, it is a Java-to-Java communication model, and in many of the scientific applications we would like Java objects to interact with modules written in C++ or Fortran. This paper explores the design of RMI and extracts a subset of the RMI object model that is compatible with C++ and HPC++ remote object semantics. This RMI subset has been implemented to run over the Nexus runtime system and is being used as part of the LSA distributed linear system analyzer project. © 1998 John Wiley & Sons, Ltd.

This paper describes PARDIS, a system containing explicit support for interoperability of PARallel DIStributed applications. PARDIS is based on the Common Object Request Broker Architecture (CORBA). Like CORBA, it provides interoperability between heterogeneous components by specifying their interfaces in a meta-language, the CORBA IDL, which call be translated into the language of interacting components. However, PARDIS extends the CORBA object model by introducing SPMD objects representing data-parallel computations. SPMD objects allow the request broker to interact directly with the distributed resources of a parallel application. This capability ensures request delivery to all the computing threads of a parallel application and allows the request broker to transfer distributed arguments directly between the computing threads of the client and the server. To support this kind of argument transfer, PARDIS defines a distributed argument type-distributed sequence-a generalization of CORBA sequence representing distributed data structures of parallel applications. In this paper we will give a brief description of basic component interaction in PARDIS and give an account of the rationale and support for SPMD objects and distributed sequences. We will then describe two ways of implementing argument transfer in invocations on SPMD objects and evaluate and compare their performance.

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.

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.

In this research note, we explore the potential of extending the Java Application Programming Interface with some mathematical primitives to improve the performance of certain operations in Java programs while maintaining portability. In particular, we show that providing straightforward native implementations of primitives from Level 1 BLAS can already improve the performance substantially. On multi-processors, combining this native Level 1 BLAS with the multi-threading mechanism of Java may even provide a simple and portable way to obtain a Java program that runs faster than compiled serial C code. © 1997 John Wiley & Sons, Ltd.

In this paper we show how implicit parallelism in Java programs can be made explicit by a restructuring compiler using the multi-threading mechanism of the language. In particular, we focus on automatically exploiting implicit parallelism in loops and multi-way recursive methods. Expressing parallelism in Java itself clearly has the advantage that the transformed program remains portable. After compilation of the transformed Java program into byte-code, speedup can be obtained on any platform on which the Java byte-code interpreter supports the true parallel execution of threads. Moreover, we will see that the transformations presented in this paper only induce a slight overhead on uni-processors. © 1997 John Wiley & Sons, Ltd.

This paper describes the prototype restructuring compiler javar, which can be used to make implicit parallelism in a Java program explicit by means of multi-threading. Although the prototype does not provide a complete Java front-end (unicode escapes are not supported and only limited semantic analysis has been implemented) and relies completely on the identification of ‘implicit’ parallelism by means of annotations, we hope that the research tool still provides sufficient functionality to make the parallelization of Java programs less complex and less error-prone. © 1997 John Wiley & Sons, Ltd.

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.

No abstract available.

No abstract available.

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.

No abstract available.

No abstract available.

In this paper we introduce a new model for the design of performance analysis and visualization tools. The system integrates static code analysis, relational database designs and a spreadsheet model of interactive programming. This system provides a general methodology for visualizing parallel program executions by providing correlation to the source program, a convenient method for rapidly developing new visualizations of the program and a framework for performance studies.

We present cm object-oriented, parallel programming paradigm, called the distributed collection model and an experimental language PC++ based on the model.In the distributed collection model, programmers can describe the data distribution of elements among processors to utilize memoy locality and a collection construct is employed to build distributed structures.The model also supports the express of massive parallelism and a new mechanism for building hierarchies of abstractions.Our experiences with application programs in the PC++ programming environments as well as performance results are also described in the paper.

The techniques of “load/store” memory reference modeling is based on deriving performance characteristics of the memory architecture of a computer by looking at the behavior of simple sequences of load, store and nop (null operation) instructions. The resulting data base can be used to match load/store templates against algorithm kernels to predict performance or as a source of data for testing analytical models of the architecture. In this paper we study the BBN GP1000 parallel processing system. We show how to build a subset of the load/store kernels needed to characterize the machine and illustrate the behavior of a simple model based on the data.

It is demonstrated how the behavior of a cache-based multi-vector-processor memory system can be systematically characterized and its performance experimentally correlated with key features of the address stream. The approach is based on the definition of a family of parameterized kernels used to explore specific aspects of the memory system's performance. The empirical results from this kernel suite provide the data from which architectural or algorithmic characteristics can be studied. The results of applying the approach to an Alliant FX/8 are presented and evaluated.>

In this paper we describe an interactive tool designed for performance prediction of parallel programs. Static performance prediction, in general, is a very difficult task. In order to avoid some inherent problems, we concentrate on reasonably structured scientific programs. Our prediction system, which is built as a sub-system of a larger interactive environment, uses a parser, dependence analyzer, database and an X-window based front end in analyzing programs. The system provides the user with execution times of different sections of programs. When there are unknowns involved, such as number of processors or unknown loop bounds, the output is an algebraic expression in terms of these variables. We propose a simple analytical model as an attempt to predict performance degradation due to data references in hierarchical memory systems. The predicted execution times of some Lawrence Livermore loop kernels are given together with the experimental values obtained by executing the loops on Alliant FX/8.

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.

Parallel supercomputers architectures with complex memory hierarchies or distributed memory systems have become very common. Unfortunately, the problems associated with restructuring software to take advantage of these memory systems are not eas-ily solved. This paper presents an overview of some of the mathematical issues behind several of these problems and attempts to give a brief look at some of the potential solutions. 1

The goals and architecture of the Faust environment are presented. The components of the Faust user-interface library are described. The Faust program abstraction supports three levels of detail: the process graph, the subroutine interconnection graph, and the program source code. Each level is described in detail.>

This paper studies a variation of a parallel multigrid PDE solver originally due to John Van Rosendale. This paper gives a detailed analysis of the method and discusses the large scale parallel structure. It will show that the method can be viewed as a data driven "large grain" systolic structure. At a lower level the algorithm is seen to be built from grid operators that are, in turn, denned by expressions involving vector functions.

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.

This paper describes two models of the cost of data movement in parallel numerical algorithms. One model is a generalization of an approach due to Hockney, and is suitable for shared memory multiprocessors where each processor has vector capabilities. The other model is applicable to highly parallel nonshared memory MIMD systems. In this second model, algorithm performance is characterized in terms of the communication network design. Techniques used in VLSI complexity theory are also brought in, and algorithm-independent upper bounds on system performance are derived for several problems that are important to scientific computation.