The OMG's Real‐Time CORBA (RT‐CORBA) and Fault‐Tolerant CORBA (FT‐CORBA) specifications make it possible for today's CORBA implementations to exhibit either real‐time or fault tolerance in isolation. While real‐time requires a priori knowledge of the system's temporal operation, fault tolerance necessarily deals with faults that occur unexpectedly, and with possibly unpredictable fault recovery times. The MEAD (Middleware for Embedded Adaptive Dependability) system attempts to identify and to reconcile the conflicts between real‐time and fault tolerance, in a resource‐aware manner, for distributed CORBA applications. MEAD supports transparent yet tunable fault tolerance in real‐time, proactive dependability, resource‐aware system adaptation to crash, communication and timing faults with bounded fault detection and fault recovery. Copyright © 2005 John Wiley & Sons, Ltd.
Applications on Grids require scalable and online performance analysis tools. The execution environment of such applications includes a large number of processors. In addition, some of the resources such as the network will be shared with other applications. This requires applications to adapt dynamically to resource changes. The article presents the requirements of Grid application classes for performance analysis tools. It introduces a new analysis environment currently being developed for teraflop computers within the Peridot project at Technische Universität München. This environment applies a distributed automatic performance analysis approach. It is based on a formal specification of performance properties in the APART specification language. It uses a hierarchy of analysis agents that obtain performance data from a configurable monitoring system. This scalable design allows performance analysis for large Grid applications. Copyright © 2005 John Wiley & Sons, Ltd.
This work gives a detailed analysis of the relative performance of the recently installed Earth Simulator and the next top four systems in the Top500 list using predictive performance models. The Earth Simulator uses vector processing nodes interconnected using a single-stage, cross-bar network, whereas the next top four systems are built using commodity based superscalar microprocessors and interconnection networks. The performance that can be achieved results from an interplay of system characteristics, application requirements and scalability behavior. Detailed performance models are used here to predict the performance of two codes representative of the ASCI workload, namely SAGE and Sweep3D. The performance models encapsulate fully the behavior of these codes and have been previously validated on many large-scale systems. One result of this analysis is to size systems, built from the same nodes and networks as those in the top five, that will have the same performance as the Earth Simulator. In particular, the largest ASCI machine, ASCI Q, is expected to achieve a similar performance to the Earth Simulator on the representative workload. Published in 2005 by John Wiley & Sons, Ltd.This article is a U.S. Government work and is in the public domain in the U.S.A.
The vision of Grid computing is to facilitate worldwide resource sharing among distributed collaborations. With the help of numerous national and international Grid projects, this vision is becoming reality and Grid systems are attracting an ever increasing user base. However, Grids are still quite complex software systems whose efficient use is a difficult and error‐prone task. In this paper we present performance engineering techniques that aim to facilitate an efficient use of Grid systems, in particular systems that deal with the management of large‐scale data sets in the tera‐ and petabyte range (also referred to as data Grids). These techniques are applicable at different layers of a Grid architecture and we discuss the tools required at each of these layers to implement them. Having discussed important performance engineering techniques, we investigate how major Grid projects deal with performance issues particularly related to data Grids and how they implement the techniques presented. Copyright © 2005 John Wiley & Sons, Ltd.
The growing gap between sustained and peak performance for scientific applications is a well-known problem in high-performance computing. The recent development of parallel vector systems offers the potential to reduce this gap for many computational science codes and deliver a substantial increase in computing capabilities. This paper examines the intranode performance of the NEC SX-6 vector processor, and compares it against the cache-based IBM Power3 and Power4 superscalar architectures, across a number of key scientific computing areas. First, we present the performance of a microbenchmark suite that examines many low-level machine characteristics. Next, we study the behavior of the NAS Parallel Benchmarks. Finally, we evaluate the performance of several scientific computing codes. Overall results demonstrate that the SX-6 achieves high performance on a large fraction of our application suite and often significantly outperforms the cache-based architectures. However, certain classes of applications are not easily amenable to vectorization and would require extensive algorithm and implementation reengineering to utilize the SX-6 effectively. Copyright © 2005 John Wiley & Sons, Ltd.
Plasma simulation is an important example of a high‐performance computing application where computer science issues are of great relevance. In a plasma, each particle, electron or ion, interacts with the external fields and with other particles in ways that can be readily and effectively emulated using object‐oriented programming. However, the great cost of plasma simulations has traditionally discouraged object‐oriented implementations due to their perceived inferior performance compared with classic procedural FORTRAN or C. In the present paper, we revisit this issue. We have developed a Java particle‐in‐cell code for plasma simulation, called Parsek. The paper considers different choices for the object orientation and tests their performance. We find that coarse‐grained object orientation is faster and practically immune from any degradation compared with a standard procedural implementation (with static classes). The loss in performance for a fine‐grained object orientation is a factor of about 50%, which can be almost completely eliminated using advanced Java compilation techniques. The Java code Parsek also provides an interesting realistic application of high‐performance computing to compare the performance of Java with FORTRAN. We have conducted a series of tests considering various Java implementations and various FORTRAN implementations. We have also considered different computer architectures and different Java Virtual Machines and FORTRAN compilers. The conclusion is that with Parsek, object‐oriented Java can reach CPU speed performances more or less comparable with procedural FORTRAN. This conclusion is remarkable and it is in agreement with the most recent benchmarks, but is at variance with widely held misconceptions about the alleged slowness of Java. Copyright © 2005 John Wiley & Sons, Ltd.
Java is an attractive choice for numerical, as well as other, algorithms due to the software engineering benefits of object‐oriented programming. Because numerical programs often use large arrays that do not fit in the cache, they suffer from poor memory performance. To hide memory latency, we describe a new unified compile‐time analysis for software prefetching arrays and linked structures in Java. Our previous work used data‐flow analysis to discover linked data structure accesses. We generalize our prior approach to identify loop induction variables as well, which we call recurrence analysis. Our algorithm schedules prefetches for all array references that contain induction variables. We evaluate our technique using a simulator of an out‐of‐order superscalar processor running a set of array‐based Java programs. Across all of our programs, prefetching reduces execution time by a geometric mean of 23%, and the largest improvement is 58%. We also evaluate prefetching on a PowerPC processor, and we show that prefetching reduces execution time by a geometric mean of 17%. Because our analysis is much simpler and quicker than previous techniques, it is suitable for including in a just‐in‐time compiler. Traditional software prefetching algorithms for C and Fortran use locality analysis and sophisticated loop transformations. We further show that the additional loop transformations and careful scheduling of prefetches from previous work are not always necessary for modern architectures and Java programs. Copyright © 2005 John Wiley & Sons, Ltd.
Leveraged by the success of applications aiming at the ‘free’ sharing of data in the Internet, the paradigm of peer‐to‐peer (P2P) computing has had substantial consideration devoted to it recently. This paper presents a high‐level abstraction for remote object interaction in a P2P environment, called borrow/lend (BL). We present the principles underlying our BL abstraction, and illustrate how this abstraction can be used to program P2P applications in Java. We contrast our abstraction with established abstractions for distributed programming such as the remote method invocation or the tuple space, illustrating how the BL abstraction, obviously influenced by such previous abstractions, unifies flavors of these, but also how it captures the constraints specific to P2P environments. Copyright © 2005 John Wiley & Sons, Ltd.
Advanced parallel applications based on the message-passing paradigm are difficult to design and implement, especially when solution adaptive techniques are used and three-dimensional problems on complex geometries are faced, which yield the use of unstructured Grids. We present the building blocks for a parallel-adaptive scheme for the solution of time-dependent and nonlinear partial differential equations. To minimize computational requirements, h-adaptivity is introduced via parallel, local Grid adaptation. Novel techniques to avoid hanging nodes are introduced, these assure conforming meshes of hybrid element type in three space dimensions. As a core of the adaptive scheme, local multigrid methods are used to solve the arising linear systems rapidly in parallel. Dynamic Grid changes from h-adaptivity lead to load imbalance during run time, therefore dynamic load balancing and migration is performed to exploit the aggregated performance of large processor sets efficiently. Real-world calculations arising from density-driven flow problems in porous media are performed using the presented parallel-adaptive solution strategy. The computations are analyzed with regard to speedup. Timings of Grid adaptation, dynamic load balancing/migration and numerical solution scheme show that large-scale runs on 512 processors gain an overall parallel, numerical speedup of up to 278. A further reduction of the element count by h-adaptivity by a factor of up to 195 shows the enormous capabilities of the presented parallel-adaptive multigrid based solution scheme. Copyright © 2005 John Wiley & Sons, Ltd.
This paper addresses functionality and implementation of a HPJava version of the Adlib collective communication library for data parallel programming. We begin by illustrating typical use of the library, through an example multigrid application. Then we describe implementation issues for the high‐level library. At a software engineering level, we illustrate how the primitives of the HPJava language assist in writing library methods whose implementation can be largely independent of the distribution format of the argument arrays. We also describe a low‐level API called mpjdev, which handles basic communication underlying the Adlib implementation. Finally we present some benchmark results, and some conclusions. Copyright © 2005 John Wiley & Sons, Ltd.
We present the design of an Enterprise JavaBeans (EJBs) caching architecture, and show that EJB caching can greatly improve application throughput in clustered environments. Throughput is improved because data serving is offloaded from the database server to the cache‐enabled application server. EJB caching is successful because it exploits the low‐latency connections between the database server and application servers that exist in a clustered environment. An important feature of our architecture is that the caching function is transparent to applications that use it. The cache‐enabled application server uses the same (EJB) programming model, and the same transactional semantics, as provided by non‐caching architectures. Copyright © 2005 John Wiley & Sons, Ltd.
This discussion addresses a number of urban legends about concurrency in an attempt to separate the myth from the fact. These legends are as follows: 1 concurrent = parallel; 2 coroutining = concurrency; 3 synchronization = mutual exclusion; 4 Dekker < Peterson; 5 concurrency = library; 6 inheritance anomaly = major concurrency problem; 7 signalling = hints; 8 spurious wakeup = efficiency. Identifying and understanding the fundamental concepts underlying concurrency is essential to the field. Equally important is not to confuse sequential and concurrent concepts. Finally, approaches based solely on efficiency are insufficient to justify a weak or difficult to use concurrent concept or construct. Copyright © 2005 John Wiley & Sons, Ltd.
The design of the Parallel Ocean Program (POP) is described with an emphasis on portability. Performance of POP is presented on a wide variety of computational architectures, including vector architectures and commodity clusters. Analysis of POP performance across machines is used to characterize performance and identify improvements while maintaining portability. A new design of the POP model, including a cache blocking and land point elimination scheme, is described with some preliminary performance results. Published in 2005 by John Wiley & Sons, Ltd.This article is a U.S. Government work and is in the public domain in the U.S.A.
Improvements in performance modeling and identification of computational regimes within software libraries is a critical first step in developing software libraries that are truly agile with respect to the application as well as to the hardware. It is shown here that Pareto ranking, a concept from multi-objective optimization, can be an effective tool for mining large performance datasets. The approach is illustrated using software performance data gathered using both the public domain LAPACK library and an asynchronous communication library based on IBM LAPI active message library. Copyright © 2005 John Wiley & Sons, Ltd.
The U.K. e-Science Programme is a £250 million, five-year initiative which has funded over 100 projects. These application-led projects are underpinned by an emerging set of core middleware services that allow the coordinated, collaborative use of distributed resources. This set of middleware services runs on top of the research network and beneath the applications we call the ‘Grid’. Grid middleware is currently in transition from pre-Web Service versions to a new version based on Web Services. Unfortunately, only a very basic set of Web Services embodied in the Web Services Interoperability proposal, WS-I, are agreed by most IT companies. IBM and others have submitted proposals for Web Services for Grids—the Web Services ResourceFramework and Web Services Notification specifications—to the OASIS organization for standardization. This process could take up to 12 months from March 2004 and the specifications are subject to debate and potentially significant changes. Since several significant U.K. e-Science projects come to an end before the end of this process, the U.K. needs to develop a strategy that will protect the U.K.'s investment in Grid middleware by informing the Open Middleware Infrastructure Institute's (OMII) roadmap and U.K. middleware repository in Southampton. This paper sets out an evolutionary roadmap that will allow us to capture generic middleware components from projects in a form that will facilitate migration or interoperability with the emerging Grid Web Services standards and with ongoing OGSA developments. In this paper we therefore define a set of Web Services specifications, which we call ‘WS-I+’ to reflect the fact that this is a larger set than currently accepted by WS-I, that we believe will enable us to achieve the twin goals of capturing these components and facilitating migration to future standards. We believe that the extra Web Services specifications we have included in WS-I+ are both helpful in building e-Science Grids and likely to be widely accepted. Copyright © 2005 John Wiley & Sons, Ltd.
In this paper, we investigate the issues to support Java RMI over Bluetooth environments. Our supports include several technical items. First, we develop a set of protocol stack layers written in Java for Bluetooth support, called JavaBT . In JavaBT , the HCI layer provides a uniform interface of accessing the Bluetooth hardware capabilities. The L2CAP provides connection-oriented and connection-less data services to upper layer protocols with protocol multiplexing capability, segmentation and reassembly operation, and group abstractions. These two layers of protocol driver can help programmers to write Bluetooth applications in the Java programming language. Next, we provide supports in L2CAP layer with socket for RMI socket. This enables the support of Java RMI over Bluetooth environments with efficiency.In addition, we model the cost for the access patterns of Java RMI communications. The cost model is used to guide the formation and optimizations of the scatternets of Bluetooth environments associated Java RMI environments. In our approach, we first perform a method for initial configurations for the number of piconets. This is based on well-known BTCP [2] algorithm. However, this does not take the access patterns of RMI communications into considerations. In our method, we provide a cost model for access patterns of RMI communications. With the support of runtime profiling in Java, we can then dynamically re-configure the scatternets to optimize the Java RMI performance over scatternets. This is particularly useful for systems with periodical behaviors or system behaviors with similarity related to historical or profiling data. With the cost model for access patterns of RMI communications, we then perform a two step algorithm. In the first stage, we employ a recursive spectral bisection method and KL-refinement procedure to cluster nodes making the frequent transmissions. After this stage, a post-configuring method is used to determine the role of nodes and form the scatternet topology.In the experiment, we evaluate the robustness of our implementation of RMI software over Bluetooth environments. We perform experiments of numerous benchmarks from RMI Benchmark Suite [1], DHPC Java Benchmarks, and the Java Grande Forum MPJ Benchmarks. In our testbed, the EBDKs (Ericsson Bluetooth Develop Kit) are connected to two computers by the COM port. We test the performance on one node and two nodes, respectively. The one node version is a sequential version and the two node version is a parallel version with RMI over Bluetooth.Despite limited COM port performance, we still observe performance gains on Hamming, EP, Series, RayTracer, and SelSort. The performance is shown in Figure 1. Note that due to the server and client are different machines, the optimal speedup for this case is around 1.7 times. With better connections between host and Bluetooth devices, we expect the performance to be improved. With the data rate in the peak to be 723k bps, it's still much slower than fast Ethernet. Therefore, the type of numerical applications run well with RMI over Bluetooth can also be observed from our experimental results. Note that our support with RMI over Bluetooth also gives more high-level control with Bluetooth environments. System loads in the OS level can also be distributed to remote site servers with RMIs.
Java programmers cannot help but be aware of the advent of C#, the .NET network environment, and a host of new supporting technologies, such as Web services. Before taking the big step of moving all development to a new environment, programmers will want to know what are the advantages of C# as a language over Java, and whether the new and interesting features of C# and .NET can be incorporated into existing Java software. This paper surveys the advantages of C# and then presents and evaluates experience with connecting it to Java in a variety of ways. The first way provides evidence that Java can be linked to C# at the native code level, albeit through C++ wrappers. The second is a means for retaining the useful applet feature of Java in the server‐side architecture of Web services written in C#. The third is by providing a common XML‐based class for the development of graphical user interfaces (GUIs), which can be incorporated into Java or C#. An added advantage of this system, called Views, is that it can run independently of the resource‐intensive development environment that would otherwise be needed for using C#. A major advantage of the methods described in this paper is that in all cases the Java program is not affected by the fact that it is interfacing with C#. The paper concludes that there are many common shared technologies that bring Java and C# close together, and that innovative ways of using others can open up opportunities not hitherto imagined. Copyright © 2005 John Wiley & Sons, Ltd.
