The Inverse Discrete Cosine Transform (IDCT) is commonly used for image and video decoding. Due to the ubiquitous nature of this application area, very efficient implementations of the IDCT transform are of great importance and have lead to the development of highly optimized libraries. The popular libjpeg-turbo library contains 1000s of lines of handwritten assembly code utilizing SIMD instruction sets for a variety of architectures. We present an alternative approach, implementing the 8x8 2D IDCT written in the image processing language Halide - a high-level, functional language that allows for concise, portable, parallel and very efficient code. We show how less than 100 lines of Halide can replace over 1000 lines of code for each architecture in the libjpeg-turbo library to perform JPEG decoding. The Halide implementation is compared for ARMv8 and x86-64 SIMD extensions and shows a 5-25 percent performance improvement over the SIMD code in libjpeg-turbo while also being much easier to maintain and port to new architectures.

Summary A parallel implementation of an agent‐based, artificial life model for graphical processing units (GPUs) is presented. The model represents predator‐prey populations as a collection of agents (animats) who act independently and interact with their environment and each other. Individual animat interactions include avoidance, mating, and hunting which contribute to emergent behavior in the system as a whole such as herd formation and defensive spirals. Computational simulations of the model exploring the behavior of the model are limited in size due to the large populations that may result from certain environments and rule combinations. Parallel methods for computing the model on GPUs and a CUDA implementation are presented and are shown to provide a significant performance improvement over existing sequential implementations without simplifying the model behavior. The reduced simulation run‐time can allow both larger systems to be computed and a wider range of rule combinations that may produce larger populations to be investigated in a feasible amount of time.

Connected-component labelling remains an important and widely-used technique for processing and analysing images and other forms of data in various application areas. Different data sources produce components with different structural features and may be more or less suited to certain connected-component labelling algorithms. Although many efficient serial algorithms exist, determining connected-components on Graphical Processing Units (GPUs) is of interest as many applications use GPUs for processing other parts of the application and labelling on the GPU can avoid expensive memory transfers. The general problem of connected-component labelling is discussed and two existing GPU-based algorithms are discussed-label-equivalence and Komura-equivalence. A new GPU-based, parallel component-labelling algorithm is presented that identifies and eliminates redundant operations in the previous methods for rectilinear two- and three-dimensional datasets. A set of test-cases with a range of structural features and systems sizes is presented and used to evaluate the new labelling algorithm on modern NVIDIA GPU devices and compare it to existing algorithms. The results of the performance evaluation are presented and show that the new algorithm can provide a meaningful performance improvement over previous methods across a range of test cases.

We evaluate the vector performance of the Halide domain-specific language for a computational photography application targeted at Android devices. Our application has existing implementations in C++ and ARM NEON and these are used as a baseline for performance comparisons with Halide. We give a very brief introduction to Halide concepts and describe the structure of our application. We describe how each stage of the algorithm is implemented and measure the performance of our Halide implementation on 3 popular vector architectures, x86-64 AVX2, ARMv7 NEON and ARMv8.

SUMMARY Graphical processing units (GPUs) are good data‐parallel performance accelerators for solving regular mesh partial differential equations (PDEs) whereby low‐latency communications and high compute to communications ratios can yield very high levels of computational efficiency. Finite‐difference time‐domain methods still play an important role for many PDE applications. Iterative multi‐grid and multilevel algorithms can converge faster than ordinary finite‐difference methods but can be much more difficult to parallelize with GPU memory constraints. We report on some practical algorithmic and data layout approaches and on performance data on a range of GPUs with CUDA. We focus on the use of multiple GPU devices with a single CPU host and the asynchronous CPU/GPU communications issues involved. We obtain more than two orders of magnitude of speedup over a comparable CPU core. Copyright © 2011 John Wiley & Sons, Ltd.

Abstract Many simulations in the physical sciences are expressed in terms of rectilinear arrays of variables. It is attractive to develop such simulations for use in 1‐, 2‐, 3‐ or arbitrary physical dimensions and also in a manner that supports exploitation of data‐parallelism on fast modern processing devices. We report on data layouts and transformation algorithms that support both conventional and data‐parallel memory layouts. We present our implementations expressed in both conventional serial C code as well as in NVIDIA's Compute Unified Device Architecture concurrent programming language for use on general purpose graphical processing units. We discuss: general memory layouts; specific optimizations possible for dimensions that are powers‐of‐two and common transformations, such as inverting, shifting and crinkling. We present performance data for some illustrative scientific applications of these layouts and transforms using several current GPU devices and discuss the code and speed scalability of this approach. Copyright © 2010 John Wiley & Sons, Ltd.

Finite difference methods continue to provide an important and parallelisable approach to many numerical simulations problems. Iterative multigrid and multilevel algorithms can converge faster than ordinary finite difference methods but can be more difficult to parallelise. Data parallel paradigms tend to lend themselves particularly well to solving regular mesh PDEs whereby low latency communications and high compute to communications ratios can yield high levels of computational efficiency and raw performance. We report on some practical algorithmic and data layout approaches and on performance data on a range of Graphical Processing Units (GPUs) with CUDA. We focus on the use of multiple GPU devices with a single CPU host.

Abstract Graphical processing units (GPUs) have recently attracted attention for scientific applications such as particle simulations. This is partially driven by low commodity pricing of GPUs but also by recent toolkit and library developments that make them more accessible to scientific programmers. We discuss the application of GPU programming to two significantly different paradigms—regular mesh field equations with unusual boundary conditions and graph analysis algorithms. The differing optimization techniques required for these two paradigms cover many of the challenges faced when developing GPU applications. We discuss the relevance of these application paradigms to simulation engines and games. GPUs were aimed primarily at the accelerated graphics market but since this is often closely coupled to advanced game products it is interesting to speculate about the future of fully integrated accelerator hardware for both visualization and simulation combined. As well as reporting the speed‐up performance on selected simulation paradigms, we discuss suitable data‐parallel algorithms and present code examples for exploiting GPU features like large numbers of threads and localized texture memory. We find a surprising variation in the performance that can be achieved on GPUs for our applications and discuss how these findings relate to past known effects in parallel computing such as memory speed‐related super‐linear speed up. Copyright © 2009 John Wiley & Sons, Ltd.

Robot soccer teams consist of a number of robots each performing a different role within the team. The roles discussed in this paper are: goalie, defender, attacker, supporter and centre. These roles are too often statically assigned to the robots at the start of the game. Knowledge-based techniques can be used to assign these roles dynamically to allow the team to adopt the optimal behaviour for each situation. Dynamic strategy choice can also be implemented within the same knowledge-based system. A strategy (defend or attack) can be chosen based on robot and ball location which in turn determines which roles should be used in play. Once the roles are defined, they will be assigned to the best robot for each role in turn based on role importance. Testing within the Teambot simulator shows a significant in score and ball control dominance over the same team with static role allocation. This paper presents the knowledge-based role assignment approach employed and the favourable results obtained.