If you are going to be at Supercomputing this year, check out GPULib (including a demo on a GPU “supercomputer” I spent some time working on earlier this week). From the press release:

Tech-X Corporation invites you to visit us at our booth (Booth #1713) at the SC09, November 14 – 20, 2009, in Portland, OR.

We will be demonstrating VORPAL, our highly-configurable multiphysics simulation application for modeling the interaction of matter with electromagnetic fields and GPULib, our library of mathematical kernels for GPU computing.

We will also be demonstrating GPULib in the Microway booth, booth #434.

Also, attend the Exhibitor Forum, on Wednesday, November 18, at 4:00PM, in Room E147-148, where Svetlana Shasharina, Ph.D., will be presenting “VizSchema: A Unified Interface for Visualization of Scientific Data”.

Full disclosure: I work for Tech-X Corporation and worked on the IDL bindings and examples for GPULib.

Henry Markram’s TED talk shows how high-performance computing (including many excellent visualizations) are being used to understand the human brain.

Henry Markram says the mysteries of the mind can be solved – soon. Mental illness, memory, perception: they’re made of neurons and electric signals, and he plans to find them with a supercomputer that models all the brain’s 100,000,000,000,000 synapses.

Link via datavisualization.ch.

NVIDIA’s Fermi architecture at Oak Ridge:

Oak Ridge National Laboratory (ORNL) announced plans today for a new supercomputer that will use NVIDIA®’s next generation CUDA™ GPU architecture, codenamed “Fermi”. Used to pursue research in areas such as energy and climate change, ORNL’s supercomputer is expected to be 10-times more powerful than today’s fastest supercomputer.

NVIDIA’s Fermi GPU makes an 8x performance improvement in double precision compared to current GPUs. It also includes 512 CUDA cores, as compared to the Tesla’s 240.

There are a lot of features targeted for high-performance computing in Fermi. Ars Technica writes about Fermi:

For the first time, the GPU gets support for advanced control flow mechanisms like indirect branches and fine-grained exception handling—neither of these features are particularly important for the immediate or near-term gaming market, but they’ll greatly enhance Fermi’s attractiveness as an HPC coprocessor.

Software will be very important in NVIDIA’s efforts:

NVIDIA will combine Fermi’s new level of GPU programmability with a full complement of software support for everything from DirectX and DirectCompute to OpenCL, C++, and Fortran. NVIDIA is also placing a heavy emphasis on development tools and developer support, and in doing so it acknowledges that competing in the many-core market is just as much a software battle as it is a hardware battle.

Last year, we were able to get our hands on a Tesla supercomputer, I am hoping to see Fermi in action.

Mac OS X 10.6 “Snow Leopard” is available for pre-order from Amazon.com for $29. One of the features of Snow Leopard, is OpenCL, basically a wrapper around CUDA which is emerging as a standard for writing GPU processing code.

GPULib 1.2 was released last week and is available on the Tech-X website. This release focused on improved MATLAB bindings with a few important bug fixes for the IDL bindings along with a few new kernels. Full release notes below.

Changes/new features in GPULib version 1.2

General

• The main focus of this release is on the improved MATLAB bindings.
• Some new kernels were added since the release of version 1.0.8

GPULib kernels

• gpuAtan2, gpuFmod, gpuPow

IDL bindings

• Support for the new kernels. For the time being, these functions only support float and double (so no complex types) and no affine transform arguments.
• Added example bwtest.pro showing the use of page-locked variables for fast CPU/GPU data transfer.
• Added finite-different time-domain example demonstrating the use of views for efficient array sub-selection
• Added spectral angle mapper example.
• Bug fixes for decon_hubble example
• improved documentation

MATLAB bindings

MATLAB GPULib version 1.2 has many major changes from the previous release. READ the README!

First and foremost, there are two distinct and completely separate interfaces to the library. They should NEVER be intermingled.

• The accArray class replaces the old gpuArray class from the previous release. This interface requires MATLAB R2008a or higher. This interface has automatic garbage collection, overloaded operators, and overloaded versions of native MATLAB functions, …
• “gpu” interface class can be used with older versions of MATLAB though it’s not clear how far back one can go.

The interface was redesigned for speed. The accArray class is about 2.5X faster than the gpuArray interface for many functions tested. Some of the “gpu”-prefixed functions can be up to 10X faster than the gpuArray interface.

MATLAB GPULib has many new functions including:

• fft, ifft, fft2, and ifft2
• Reduction operations, including sum, cumsum, prod, cumprod, … These functions support 1D vectors and 2D matrices currently.
• Single (Complex) and Double (Complex) precision versions of Matrix Multiplication, Transpose and Complex Conjugate Transpose.

The accArray class does not support the subsref.m (i.e. b=A(i)), subsasgn.m (i.e. A(i)=b), or array concatentation functions like A=[B; C; D], These will be supported in future releases.

The “gpu” interface supports subscripting through the gpuSubsref, gpuSubsasgn, and gpuSub2ind functions.

Both interfaces support page-locked host memory allocation via cudaMallocHost. This gives the possibility of much faster memory transfer from CPU memory to GPU memory and back.

Both interfaces include more comprehensive native MATLAB-like documentation.

New examples include: bench, bwtest, fdtd, and fftExample.

Full disclosure: I work for Tech-X Corporation and worked on the IDL bindings and examples for GPULib.

Randal Schwartz recently gave a talk called “Dynamic Returns” dealing with misconceptions about dynamically typed languages (published as episode 135 of the Industry Misinterpretations podcast). His audience for the talk is composed of Smalltalk developers, but the points made are general and equally valid for other dynamic languages like IDL, Python, etc (at least in concept). The six myths are that statically typed languages like Java, C++, and C:

1. reduce development cost
2. increase speed of development
3. eliminate need for some tests
4. improve run-time stability
5. scale better
6. are faster

I agree that the first five points are indeed myths, but I’m not sure IDL has the tools for making IDL as fast or faster than a statically typed language. I know Python has a lot more tools in this area: Pyrex, Psyco, ctypes, f2py, and a bunch more. Of course, there are some things in IDL’s favor: the thread pool automatically uses multiple processors for array operations, there are libraries to make GPU computing and cluster computing easier, and a fairly straight-forward way to extend IDL using C when needed.

Peter Messmer from Tech-X Corporation gave a presentation about GPUlib at VISualize 2009 last week. Peter and I also stayed around after the IDL presentations to do hands on training for GPULib. The training was well attended; it was good to see the interest in GPU computing with IDL. Most people did not bring a laptop, making it less “hands on” than we had originally intended, but it was good to be able to answer individual questions.

I’m wondering what the interest in an actual training class for high-performance computing in IDL would be? It could cover standard IDL techniques as well as GPU and cluster computing (MPI and task farming).

Full disclosure: I work for Tech-X Corporation and worked on the IDL bindings and examples for GPULib.

Peter Messmer and I will be doing a hands-on demo with GPULib after the talks on the first day of VISualize 2009 (5 pm on April 15 at the same location). If you are interested, you need to sign-up. We’ll get you started with what you need to know to begin using GPULib to get big speedups in your code.

Please install GPULib beforehand. Don’t worry if your laptop doesn’t have a CUDA enabled graphics card, GPULib has a pure IDL emulation mode that can be used in class.

VISualize 2009 is an IDL user group meeting organized by ITT VIS in Washington, DC, scheduled for April 15-16.

Peter Messmer will be talking about GPULib and I will be helping with the hands on demo/training at the end of the day. Plenty of other IDL gurus will be speaking: Liam Gumley, Craig Markwardt, Rob Dimeo, Ronn Kling, and others.

Peter and I will also be hanging out for the second day, discussing ENVI.