The International Journal of High Performance Computing Applications

In this article, we address the problem of computing, storing and sorting, at an interactive rate, all of the intersections between millions of triangles (a 3D scene) and millions of rays starting from the same point. In this paper we focus on the fast GPU construction of a grid in projective space referencing the triangles of a 3D scene. We introduce a fast GPU algorithm used to build a grid of the rays constituting the scene, in the same projective space. This ray-based grid is computed during the initialization of the scene, which allows us to achieve higher performance, and to construct the triangle-based grid in distinct passes for very large scenes, without having to manage memory transfers between CPU and GPU. This algorithm works the same way for both static and dynamic scenes, allowing us to achieve interactive processing of complex and dynamic scenes. These optimizations are used to speed up the geometrical computations used in the nuclear field to evaluate the impact of radiative sources on an operator. These geometrical computations are similar to those of traditional ray tracing, except that only highly coherent rays are thrown in our application, and that we are looking for all intersections along each ray.

We have developed a framework that uses multicore CPUs and GPUs found on personal computers to accelerate the computations needed for a class of deformable object modeling algorithms. In recent years there has been a growing interest in using deformable objects in computer applications such as animation, video games, garment CAD, and surgical simulation. Deformable object modeling is quite expensive computationally. However, since most of the related calculations can be parallelized, we have developed a framework that utilizes NVIDIA’s CUDA technology to accelerate a set of deformable object modeling algorithms by transferring their core computations to the GPU. Our results show that frame rates can be improved more than 20 times using GPU compared with using a multicore CPU. In addition, we have developed a method called Local Shape Matching which is an extension to the Shape Matching method. Using this new method we have achieved fast and robust simulations whose implementations have good numerical stability.

The current generation of graphics cards allows great flexibility in programming. With the introduction of general purpose programming languages for graphics cards, many fields of scientific application will benefit greatly from adapting to this new programming model. Due to the differences in the memory and execution models, not all algorithms can be applied. However, the lattice Boltzmann method can be used to great effect. It allows the simulation of fluids using basic arithmetic operations with a linear complexity, as will be demonstrated. Additionally, the discrete element method can also be adapted to the new model. After outlining the methods themselves and the integration of these two methods into a single simulation, this article will show a way to implement it on graphics cards using the CUDA platform.

Wait states in parallel applications can be identified by scanning event traces for characteristic patterns. In our earlier work we defined such inefficiency patterns for MPI-2 one-sided communication, although still based on a serial trace-analysis scheme with limited scalability. In this article we show how wait states in one-sided communications can be detected in a more scalable fashion by taking advantage of a new scalable trace-analysis approach based on a parallel replay, which was originally developed for MPI-1 point-to-point and collective communication. Moreover, we demonstrate the scalability of our method and its usefulness for the optimization cycle with applications running on up to 32,768 cores.

The following article has been retracted from publication in International Journal of High Performance Computing Applications due to duplicate publication arising from error. Color and texture analysis on emerging parallel architectures Francisco D Igual, Rafael Mayo, Timothy DR Hartley, Ümit V Çatalyürek, Antonio Ruiz, and Manuel Ujaldon, International Journal of High Performance Computing Applications August 2012 26:237-259. Below version of the article stands as the version on record. Color and texture analysis using emerging parallel architectures Francisco D Igual, Rafael Mayo, Timothy DR Hartley, Ümit V Çatalyürek, Antonio Ruiz, and Manuel Ujaldon, International Journal of High Performance Computing Applications November 2011 25: 404-427. Our special thanks to the author for drawing attention to the duplication, thereby allowing for the literature to be corrected.

High-performance scientific applications are usually built from software modules written in multiple programming languages. This raises the issue of language interoperability which involves making calls between languages, converting basic types, and bridging disparate programming models. Babel provides a feature-rich, extensible, high-performance solution to the language interoperability problem currently supporting C, C++, FORTRAN 77, Fortran 90/95, Fortran 2003/2008, Python, and Java. Babel supports object-oriented programming features and interface semantics with runtime enforcement. In addition to in-process language interoperability, Babel includes remote method invocation to support hybrid parallel and distributed computing paradigms.

This paper presents an approach to programming and running scientific applications on grid and cloud infrastructures based on two principles: the first one is to follow a component-based programming model, the second is to apply a flexible technology which allows for virtualization of the underlying infrastructure. The solutions described in this paper include high-level composition and deployment consisting of a scripting-based environment and a manager system based on an architecture description language (ADL), a dynamically managed pool of component containers, and interoperability with other component models such as Grid Component Model (GCM). We demonstrate how the proposed methodology can be implemented by combining the unique features of the Common Component Architecture (CCA) model together with the H2O resource sharing platform, resulting in the MOCCA component framework. Applications and tests include data mining using the Weka library, Monte Carlo simulation of the formation of clusters of gold atoms, as well as a set of synthetic benchmarks. The conclusion is that the component approach to scientific applications can be successfully applied to both grid and cloud infrastructures.

This work deals with the solution of large non-Hermitian linear systems on desktop workstations with multiple graphics processing units (GPUs). While our implementation is motivated by the need to accelerate volume conductor modeling for bioelectrical brain imaging, the problem itself is common in scientific computing. Whenever a complex partial differential equation is numerically solved, a typically non-Hermitian sparse complex linear system needs to be solved. For problem sizes in the millions, this can take a long time even with highly optimized CPU-based solvers. Our GPU-accelerated solver outperforms an optimized OpenMP-based reference running on two quad-core CPUs by a factor of up to 31× in single precision and up to 7× in double precision, at the cost of a very modest hardware upgrade of two dual-GPU GTX 295 graphics cards. A pair of stronger Fermi GPUs (GTX 480) achieves speedups of 30× in single precision and 15× in double precision.

The computational performance of magnetohydrodynamic (MHD) code is evaluated on two typical scalar-type supercomputer systems. We have carried out performance tuning of a three-dimensional MHD code for space plasma simulations on the HA8000 (with 8192 cores) and SR16000/L2 (with 1344 cores) supercomputer systems. For parallelization of the MHD code, we use four different methods, that is, regular one-dimensional, two-dimensional and three-dimensional domain decomposition methods and a cache-hit type of three-dimensional domain decomposition method. We found that the regular three-dimensional decomposition of the MHD model is suitable for the HA8000 system, and the cache-hit type of three-dimensional decomposition is suitable for SR16000/L2 systems. As a result of these runs, we achieved a performance efficiency of almost 15% on the HA8000 and 20% on the SR16000/L2 for MHD code.

The scalability and efficiency of graph applications are significantly constrained by conventional systems and their supporting programming models. Technology trends such as multicore, manycore, and heterogeneous system architectures are introducing further challenges and possibilities for emerging application domains such as graph applications. This paper explores the parallel execution of graphs that are generated using the Barnes–Hut algorithm to exemplify dynamic workloads. The workloads are expressed using the semantics of an exascale computing execution model called ParalleX. For comparison, results using conventional execution model semantics are also presented. We find improved load balancing during runtime and automatic parallelism discovery by using the advanced semantics for exascale computing.