Much contemporary research benefits from the operation of the Grid for large-scale data storage, sharing, analysis, processing and simulation. However, existing grid systems typically require users to have good IT skills, which is a hurdle for many scientists. Providing easier usability of grid systems is a big challenge. A number of systems, frameworks and portals have been developed over the past few years, however they have mostly been designed to work based on several assumptions in a particular environment, and it is not easy to adapt them to different needs or environments. In this paper, we present our system that adopts several new technologies and acts as a broker and a gateway to regional grid resources. Interaction and usability are improved by multiple interfaces aimed at users with different requirements and IT skills: a modern and easy-to-use web interface, a SOAP web service interface and a Restful interface. The usability of this system is demonstrated in a case study.

Abstract Data‐oriented workflows are often used in scientific applications for executing a set of dependent tasks across multiple computers. We discuss how these can be modeled using lambda calculus, and how ideas from functional programming are applicable in the design of workflows. Such an approach avoids the restrictions often found in workflow languages, permitting the implementation of complex application in logic and data manipulation. This paper explains why lambda calculus is an appropriate model for workflow representation, and how a suitably efficient implementation can provide a wide range of capabilities to developers. The presented approach also permits high‐level workflow features to be implemented at user level, in terms of a small set of low‐level primitives provided by the language implementation. Copyright © 2009 John Wiley & Sons, Ltd.

One of the objectives of e-Research is to help scientists to accomplish their research, including scientific experiments, more effectively and efficiently. Web services provide communication between different platforms by using standardized SOAP message protocols. Hence, it is often productive to implement web service interfaces for the integration of experimental infrastructure into a collaborative e-Science framework. In this context, transfer and management of experimental data is an important problem. SOAP messaging is primarily oriented towards XML character data, with binary data transmitted with, for example, a base64 character encoding. However, as scientific experiments often generate binary data, transferring binary information by applying an encoding algorithm can slow down the performance of the system. The notion of web service attachment, has been introduced to solve this problem. In this paper, we illustrate how we use web services with attachments to improve binary data transfer performance. We present results of tests, using Axis2 and XFire APIs, conducted over a campus IAN, an inter-city WAN, and an intercontinental WAN. We also make some comparison with the use of GridFTP.

MPICH is probably the most widely used implemen- tation of MPI. Recent versions of MPICH optimize the performance of some collective communications by switching between different algorithms depending on whether the message size is greater or less than a given change-over point, which is currently hard- coded in MPICH, based on measurements on clusters with one CPU per node. We have used MPI bench- marks to find the optimum change-over points for different systems, and found that they can vary sig- nificantly for different networks and different numbers of processes per node. In some cases significant per- formance improvements can be obtained by enabling MPICH to be customized in this way, particularly on clusters with more than one CPU per node. KEY WORDS MPI benchmarks, parallel computer, network per- formance, collective communication.

We present the architecture of nreduce, a distributed virtual machine which uses parallel graph reduction to run programs across a set of computers. It executes code written in a simple functional language which supports lazy evaluation and automatic parallelisation. The execution engine abstracts away details of parallelism and distribution, and uses JIT compilation to produce efficient code. This work is part of a broader project to provide a programming environment for developing distributed applications which hides low-level details from the application developer. The language we have designed plays the role of an intermediate form into which existing functional languages can be transformed. The runtime system demonstrates how distributed execution can be implemented directly within a virtual machine, instead of a separate piece of middleware that coordinates the execution of external programs.

Our current research into programming models for parallel Web services composition is targeted at providing mechanisms for obtaining higher throughput for large scale compute and data intensive programs that delegate part of their computation to services, and making it easier to develop such applications. The ability to invoke multiple service calls at one time on different machines enables different portions of the program to be executed concurrently. We are addressing this through an implementation of an existing functional language, XSLT. Our implementation uses a dataflow execution model, and includes a compiler to build dataflow graphs from XSLT source code. This paper describes the execution model used to obtain parallelism and compose Web services, as well as the compilation process used to create the dataflow graphs. Our aim with this paper is to present the design of our system and demonstrate that XSLT provides a suitable model for distributed execution and parallel composition of Web services.

The results produced by five different MPI benchmark programs on an SGI Altix 3700 are analyzed and compared. There are significant differences in the results for some MPI operations. We investigate the reasons for these discrepancies, which are due to differences in the measurement techniques, implementation details and default configurations of the different benchmarks. The variation in results on the Altix are generally much greater than on a distributed memory machine, due primarily to the ccNUMA architecture and the importance of cache effects, as well as some implementation details of the SGI MPI libraries

GridXSLT is an implementation of the XSLT programming language designed for distributed Web service orchestration. Based on the functional semantics of the language, it compiles programs into dataflow graphs which can be efficiently executed across a collection of machines in a cluster or grid environment. Calls to Web services can be made using the standard function call semantics provided by the language, and occur in parallel using the dataflow model of computation. The programmer is not required to explicitly specify the parallelism, as the details of how programs are scheduled and executed in a distributed environment are abstracted away by the runtime engine. XSLT provides a higher level programming model than many other approaches to Web services composition; we explore its use here as a means of easing the task of orchestrating the interactions between services. In addition to the normal XSLT syntax, our system also supports programs written in XSLiTe, an alternative syntax we have developed which uses more concise representations of language constructs, increasing the ease of development, and bringing code readability closer to that of traditional programming languages. Our goal is to ease the construction of applications based on Web services composition, such as those used in eScience and other fields in which service oriented architectures are prominent

Summary form only given. Random number generators are one of the most common numerical library functions used in scientific applications. The standard random number generator provided within Java is fine for most purposes, however it does not adequately meet the needs of large-scale scientific applications, such as Monte Carlo simulations. Previous work has addressed some of these problems by extending the standard random API in Java and providing an implementation that includes a choice of several different generator algorithms. One issue that was not addressed in this work was concurrency. Implementations of the standard Java random number generator use synchronized methods to support the use of the generator across multiple Java threads, however this is a sequential bottleneck for parallel applications. Here we present a proposal for further extending the standard API to support parallel generation of random number streams, which we have implemented in JAPARA, a Java parallel random number generator library for high-performance computing.

Summary form only given. We give an overview of two related tools that we have developed to provide more accurate measurement and modelling of the performance of message passing programs and communications on distributed memory parallel computers. MPIBench uses a very precise, globally synchronised clock to measure the performance of MPI communication routines, and can generate probability distributions of communication times, not just the average values produced by other MPI benchmarks. This allows useful insights into MPI communications performance of parallel computers, particularly the effects of network contention. PEVPM provides a simple, fast and accurate technique for performance modelling and prediction of message-passing parallel programs. It uses a virtual parallel machine to simulate the execution of the parallel program. The effects of network contention can be accurately modelled by sampling from the probability distributions generated by MPIBench. These tools are particularly useful on Beowulf clusters with commodity Ethernet networks, where relatively high latencies, network congestion and TCP problems can significantly affect communication performance, and can be difficult to model accurately using other tools. Experiments with example parallel programs demonstrate that PEVPM gives accurate performance predictions on Beowulf clusters. We also show that modelling communication performance using average times rather than sampling from probability distributions can give misleading results, particularly for a large number of processors.

Parallel computers are now commonly used for computational science and engineering, and many applications in these areas use random number generators. For some applications, such as large-scale Monte Carlo simulations, it is crucial that the random number generator have good randomness properties. Many programs are available for testing the quality of sequential random number generators, but very little work has been done on testing parallel random number generators. We present some techniques for empirical testing of random number generators on parallel computers, using tests based on computational science applications as examples. In particular, we focus on tests based on parallel algorithms developed for Monte Carlo simulations of the two dimensional Ising model, for which exact results are known. Preliminary results of these tests are presented for several parallel random number generators. Current address. 1 Introduction Parallel computers are now commonly used for computatio...

The Living Textbook creates a unique learning environment enabling teachers and students to use educational resources on multimedia information servers, supercomputers, parallel databases, and network testbeds. We have three innovative educational software applications running in our laboratory, and under test in the classroom. Our education-focused goal is to learn how new, learner-driven, explorative models of learning can be supported by these high bandwidth, interactive applications and ultimately how they will impact the classroom of the future.

The author has implemented a set of computational physics codes on a network of IBM RS/6000 workstations used as a distributed parallel computer. He compares the performance of the codes on this network, using both standard Ethernet connections and a fast prototype switch, and also on the nCUBE/2, a MIMD parallel computer. The algorithms used range from simple, local, and regular to complex, non-local, and irregular. He describes his experiences with the hardware, software and parallel languages used, and discusses ideas for making distributed parallel computing on workstation networks more easily usable for computational physicists.>

Abstract Monte Carlo cluster update algorithms are extremely efficient for simulating spin models near their phase transitions, where local update algorithms suffer severe critical slowing down. Unfortunately, as the cluster algorithms are highly irregular as well as nonlocal, they are much more difficult to parallelize efficiently. The main difficulty lies in identifying which spins belong to which cluster. In this paper we investigate a number of cluster identification algorithms, both sequential and parallel, which we have implemented on serial, SIMD and MIMD computers.