Bruce D. D'Amora

Pervasive 3D viewing for product data management

Mechanical computer-aided design (MCAD) applications traditionally focus on the design and analysis phases of the production process. However, these applications typically require powerful workstations with large storage systems and high-performance 3D graphics adapters, which can be expensive. One approach is to use server-side rendering and transmission of video streams to the PDA via a wireless connection. This requires continuous connectivity to a server and may not provide adequate interactivity due to bandwidth and latency issues. Our goal was to provide a stand-alone solution that could achieve interactive frame rates for users who require access to MCAD 3D models during stages of the manufacturing process where using design workstations is impractical or limited. In this scenario, a user at a remote manufacturing location requires access to an MCAD drawing of a specific part. The user can reference this part with our PDA 3D viewer (called the IBM Mobile 3D Viewer) and annotate it with customer feedback or speculative design changes.

High-performance server systems and the next generation of online games

Developing a massively multiplayer online game which utilizes physically based simulation to provide realistic behaviors requires numerical integration functions with inherently high computational costs. This simulation, performed on the individual clients of a peer-to-peer networked game or for a client/server online game, presents challenges due to many factors, including limited computing resources at the client level and network latency in the propagation of a clients state to other clients. Computationally intensive simulation may adversely affect performance and result in a situation in which little processing capacity is left for other aspects of the game. In this paper, we explore how a game developer who is aware of these issues might create a game for IBMs recently announced Cell Broadband EngineTM processor; we also present an example of the development of a game in which multiple human and robotic characters interact with static and dynamic objects in a virtual environment. Although our experience suggests that porting code to the Cell Broadband Engine core with minimal use of its synergistic processing elements (SPEs) should not be expected to produce significant performance gains at this time, the potential of the Cell SPEs to improve performance is considerable. We discuss performance and design and implementation decisions, with programmability issues being especially noted.

Accelerating Computational Fluid Dynamics on the IBM Blue Gene/P Supercomputer

Computational Fluid Dynamics (CFD) is an increasingly important application domain for computational scientists. In this paper, we propose and analyze optimizations necessary to run CFD simulations consisting of multi-billion-cell mesh models on large processor systems. Our investigation leverages the general industrial Navier-Stokes open-source CFD application, Code_Saturne, developed by Electricité de France (EDF). Our work considers emerging processor features such as many-core, Symmetric Multi-threading (SMT), Single Instruction Multiple Data (SIMD), Transactional Memory, and Thread Level Speculation. Initially, we have targeted per-node performance improvements by reconstructing the code and data layouts to optimally use multiple threads. We present a general loop transformation that will enable the compiler to generate OpenMP threads effectively with minimal impact to overall code structure. A renumbering scheme for mesh faces is proposed to enhance thread-level parallelism and generally improve data locality. Performance results on IBM Blue Gene/P supercomputer and Intel Xeon Westmere cluster are included.

Virtual science on the move: Interactive access to simulations on supercomputers

The concept that scientists and engineers should be able to monitor and control simulations running on supercomputers has been discussed and implemented since the late 1980s. The recent explosion in the variety and capabilities of mobile devices allows this access to be taken to a new level, since the simulations running on supercomputers can be accessed as users are moving around in their normal work activities. This means that they have to be able to connect and disconnect at will from the simulation running on the supercomputer, without disturbing its execution. We present a general framework for such “mobile supercomputing” within the framework of Web services standards. To illustrate the potential of our method, we present a particular application of this framework to provide a rich mobile interface to a lattice-Boltzmann simulation of complex fluids running on an IBM Blue Gene/Q supercomputer.

Multiple threads and parallel challenges for large simulations to accelerate a general Navier–Stokes CFD code on massively parallel systems

Computational fluid dynamics is an increasingly important application domain for computational scientists. In this paper, we propose and analyze optimizations necessary to run CFD simulations consisting of multibillion‐cell mesh models on large processor systems. Our investigation leverages the general industrial Navier–Stokes CFD application, Code_Saturne, developed by Electricité de France for incompressible and nearly compressible flows. In this paper, we outline the main bottlenecks and challenges for massively parallel systems and emerging processor features such as many‐core, transactional memory, and thread level speculation. We also present an approach based on an octree search algorithm to facilitate the joining of mesh parts and to build complex larger unstructured meshes of several billion grid cells. We describe two parallel strategies of an algebraic multigrid solver and we detail how to introduce new levels of parallelism based on compiler directives with OpenMP, transactional memory and thread level speculation, for finite volume cell‐centered formulation and face‐based loops. A renumbering scheme for mesh faces is proposed to enhance thread‐level parallelism. Copyright

A data-centric algorithm for automated detection and extraction of isoparametric surfaces

The traditional workflow for high-performance computing simulation is often to prepare input, run a simulation, and visualize the results as a post-processing step. In the biomedical and seismic industries, these results comprise uniform 3D arrays that can approach tens of petabytes depending on the domain. Visually exploring output data requires significant system resources and time, as data is moved between the simulation cluster and the visualization cluster. Resources and time can be conserved if the simulation and visualization can access the same system resources and data. End-to-end workflow time can be decreased if the simulation and visualization can be performed simultaneously. Data-centric visualization provides a platform in which the same high-performance server can execute both the simulation and visualization. In this paper, we discuss a visualization framework for exploring very-large data sets using both direct and isoparametric point extraction volume rendering techniques. Our design considers accelerators available in next-generation servers using IBM Power technology and GPUs (graphics processing units). GPUs can accelerate generation and compression of two-dimensional display images that can be transferred across a network to a variety of display devices. Users will be able to remotely steer visualization and simulation applications. In this paper, we discuss an early implementation and additional challenges for future work.

Renumbering Methods to Unleash Multi‐Threaded Approaches for a General Navier‐Stokes Implementation

Our investigation leverages the general industrial Navier‐Stokes open‐source Computational Fluid Dynamics (CFD) application, Code_Saturne, developed by Electricite de France (EDF). We deal with how to take advantage of the emerging processor features such as many‐cores, Simultaneous Multi‐Threading (SMT) and Thread Level Speculation (TLS), through a mixed MPI/multithreads approach. We focus here on the per‐node performance improvements and present the constraints for a multithreads implementation to solve the general 3D Navier‐Stokes equations using a finite volume discretization into polyhedral cells. We describe a simple and efficient mesh numbering scheme allowing us to introduce OpenMP and Thread Level Speculation implementations with minimal impact to overall code structure.