Performance of ArrayFire JIT Code Generation

Oded ArrayFire, Benchmarks, Case Studies, Infrastructure 3 Comments

The ArrayFire library offers JIT (Just In Time) compiling for standard arithmetic operations. This includes trigonometric functions, comparisons, and element-wise operations. At run-time, ArrayFire aggregates these function calls using an Abstract Syntax Tree (AST) data structure such that when ever a JIT supported function is ''met'' it is added into the AST for a given variable instance. The AST of the variable is computed if one of the following conditions is met: an explication evaluation is required by the programmer using the eval() function member or the variable is required for the computation of a different variable that is not-JIT supported it. When the above occurs and the variable needs to be evaluated, the functions and variables in the AST ...

Beamforming with ArrayFire

Scott ArrayFire, Case Studies, CUDA Leave a Comment

Alessandro Savoia and researchers at Università degli Studi Roma Tre have achieved an order of magnitude improvement in the performance of a beamforming application using ArrayFire for GPU acceleration with CUDA-capable NVIDIA GPUs. This application involves conventional beamforming. Steps include the application of a time delay to each signal vector, summation across all vectors, and processing on the result. Processing includes demodulation, envelope extraction, and logarithmic compression. ArrayFire's functions for shifting, interpolation, and filtering made this application possible for acceleration on GPUs and reduced the time to develop significantly. Alessandro's benchmarks show that a CPU-only version was only running at 1 frame/sec, while the ArrayFire-accelerated version was running at 10-20 frames/sec, depending on the dataset. Alessandro and his team are looking forward to ...

ArrayFire + Scorpii Demo by CreativeC

Scott ArrayFire, Benchmarks, Case Studies, CUDA, Events Leave a Comment

CreativeC makes awesome compute + visualization systems. We got to see the demo in live action at the GPU Technology Conference last month. Tim Thomas was kind enough to let us film the demo showing how ArrayFire can be used to drive a multi-node, 9 GPU system in a physics application. Checkout the video below. If you are interested in high-throughput compute coupled with high-pixel visualizations, we recommend you talk with the folks at CreativeC. They are always pushing the envelope on what can be done with GPU computing and GPU visualizations. Also, if you have cool demos showing ArrayFire in action, let us know. We'd love to film your work and make it available on this blog! Related articles ...

ArrayFire Reception in France

John ArrayFire, Case Studies, CUDA, OpenCL Leave a Comment

As an engineers company, we spend a lot of time wrestling in the weeds of low-level GPU and accelerator codes. This is our battleground, and it can often be dizzying in its complexity. Our whole purpose is to hide that mess and tame those low-level beasts so that ArrayFire users get better performance than anyone else. The joy of ArrayFire comes when we get feedback from ArrayFire users, often from different parts of the world. For instance, the week I share excerpts from two recent emails we received in France: 1) From Barep, a French manufacturing company:  "I think ArrayFire is a 'must have' library. It's very easy to use and can be used under Linux and Windows. Personally, I'm happy ...

CUDA GPUs Boost Mars Research

ArrayFire Case Studies, CUDA, Jacket Leave a Comment

With the recent news release from NASA about the Mars Curiosity rover, and as a continuation of our previous post "Powering Mars Research", Brendan Babb is here again to provide us with an exciting look into Jacket's role in Mars research from the Curiosity rover . Brendan Babb and colleague Frank Moore, at the University of Alaska in Anchorage, work with NASA’s Jet Propulsion Lab to improve image quality and image compression of the Mars Rover images. Here is what Brendan had to tell us about the use of Jacket in his GPU computing challenges... Brendan Babb:  I was thrilled to watch the new Mars Rover Curiosity successful landing with my visiting nieces and nephews. The new rover will take pictures, ...

Fast Computatio​n of Isotropic Gradients with Jacket's Convolutions

ArrayFire Benchmarks, Case Studies, CUDA, Jacket Leave a Comment

Researchers from the École Polytechnique de Montréal showed that Jacket is very efficient to rapidly calculate 2D or 3D isotropic gradients in MATLAB® code. From a mathematical point of view, the isotropic gradients are characterized by their very precise orientation compared to the standard 1D finite difference discretizations. Using convolution functions developed by AccelerEyes, the method becomes very simple to apply and provides a very fast evaluation of isotropic gradients of functions or images. This type of isotropic discretization currently has an application in computational fluid dynamics. They are useful for simulating immiscible multiphase flows using the Lattice Boltzmann Method (LBM), where the orientation of the various fluid interfaces has to be computed very frequently and precisely. In multiphase flow ...

Genomics MATLAB® applications on the GPU

ArrayFire Benchmarks, Case Studies, CUDA, Jacket, Webinar Leave a Comment

Recently, AccelerEyes held a free webinar that dealt with accelerating genomics MATLAB applications on the GPU. We recently added new genomics examples to Jacket, and wanted to use this webinar to showcase these examples and run through some code. This was part of the free series of AccelerEyes webinars that provide a great opportunity for you to interact with AccelerEyes engineers, see demos executing live on GPUs, and learn about AccelerEyes products and services. Over the course of the last decade, GPUs have continued to advance at a large pace, and are leaving CPUs behind in some ways, specifically in terms of their ability to perform massively parallel computations. Jacket is proven to be very efficient at harnessing this ability ...

Image Processing with ArrayFire and OpenCV on the GPU

John ArrayFire, C/C++, Case Studies, CUDA Leave a Comment

ArrayFire is a great way to supplement OpenCV for faster processing on the GPU. Mcclanahoochie recently posted an interactive demo showing the use of OpenCV with ArrayFire for computing Local Contrast Enhancement on the GPU from webcam video. Mcclanahoochie also shows how easy it is to convert OpenCV Mat images into ArrayFire GPU array images, as seen in the code snippit below: All the source code is available on Google Code, linked to from his website. Simply download ArrayFire and OpenCV and try it out for yourself!

Time delay estimation algorithms with Jacket

ArrayFire Case Studies, Jacket Leave a Comment

Time delay estimation (TDE) techniques have many diverse signal processing applications: for instance, in such fields as radar, sonar, seismology, geophysics, and ultrasonics for identifying and localizing radiating sources. In this case study, we evaluate the performance of two algorithms developed by Markus Nentwig to find delay and scaling factor between two cyclic signals. The first algorithm uses linear least-squares fitting to estimate the delay. The second algorthm is iterative and relies on FFT-based cross-correlation. A MATLAB® implementation of both approaches can be found in Algorithm 1 and Algorithm 2, respectively. As the author pointed out, the algorithms are not suited for real-time applications since the whole signal needs to be known in advance. However, they can be very useful ...

SAR Image Formation Algorithms on the GPU

ArrayFire ArrayFire, Case Studies, CUDA, Jacket 1 Comment

Since the 1950s Synthetic aperture radar (SAR) systems have gained extreme popularity in both civilian and military domains due to their all-weather, day-or-night capabilities as well as the ability to render different views of a "target". However, the raw SAR data (phase-history data) must be preprocessed  since all point targets at each pulse instance are superimposed  and create a complex interference that is not very useful for target location. SAR image formation algorithms compress this target information in range (frequency) and along-track (azimuth) directions to obtain interpretable images. In the paper titled "SAR image formation toolbox for MATLAB®", Gorham L.A. and Moore L.J. of the Air Force Research Lab discuss the implementation of the matched filter and backprojection image formation ...