Following is the source for the Doctor Dobb's Journal article Part 15 Using Pixel Buffer Objects with CUDA and OpenGL. This source includes Microsoft Visual Studio build files as well as a Linux command-line to build an executable.

Many thanks to Joe Stam at NVIDIA for providing the Visual Studio build files. Joe also notes you need to remove the following lines from perlinKernelPBO.cu:

#include <cutil_gl_inline.h>

#include <cuda_gl_interop.h>

 Major chip manufacturers are developing next-generation microprocessor designs that are heterogeneous/hybrid in nature, integrating homogeneous x86-based multicore CPU components and GPU components. The MAGMA (Matrix Algebra on GPU and Multicore Architectures) project’s goal is to develop innovative linear algebra algorithms and to incorporate them into a library that is

• similar to LAPACK in functionality, data storage, and interface

but targeting the

• next-generation of highly parallel, and heterogeneous processors.

This will allow scientists to effortlessly port any of their LAPACK-relying software components and to take advantage of the new architectures. MAGMA is designed to run on homogeneous x86-based multicores and take advantage of GPU components (if available). This is achieved by developing a class of multi-level blocking algorithms that split the computation into tasks of varying granularity (e.g. large for available GPUs) and dynamically scheduling their execution.

The transition from small tasks (of small block size) to large tasks is done in a recursive fashion where the intermediate for the transition tasks are executed in parallel using dynamic scheduling. The new algorithms, when run on just homogeneous x86-based multicores, outperform vendor implementations (e.g. MKL) in LAPACK accuracy and data layout (no block data-layouts). Adding a GPU increases the performance proportionally to the GPU’s computational characteristics. These results are for the one-sided matrix factorizations – LU, QR, and Cholesky. Work on the two-sided factorizations, e.g. Hessenberg reduction, shows more drastic performance improvements (significantly exceeding an order of magnitude) when comparing homogeneous multicores to hybrid multicores+GPUs. The main reason for these performance improvements is mainly due to the fact that the two-sided factorizations have bandwidth limitations that can not be overcome using just homogeneous multicores. In addition to standard accuracy algorithms (LAPACK compliant accuracy), we develop algorithms within MAGMA that would allow a user-defined tradeoff between accuracy and speed. These algorithms are based on mixed-precision arithmetic and take advantage of GPU’s still much higher single vs double precision arithmetic.

 The scaling of serial algorithms cannot rely on the improvement of CPUs anymore. The performance of classical Support Vector Machine (SVM) implementations has reached its limit and the arrival of the multi core era requires these algorithms to adapt to a new parallel scenario. Graphics Processing Units (GPU) have arisen as high performance platforms to implement data parallel algorithms. In this project, it is described how a naïve implementation of a multiclass classifier based on SVMs can map its inherent degrees of parallelism to the GPU programming model and efficiently use its computational throughput. Empirical results show that the training and classification time of the algorithm can be reduced an order of magnitude compared to a classical solver, LIBSVM, while guaranteeing the same accuracy.

Please find attached the multisvm 2.0 release of the source code.

The link to the source code repository where future versions will be available is http://code.google.com/p/multisvm/

* Sample datasets were removed due to their large file size. These can be obtained from the code repository site or the LIBSVM site.

** To compile the code please add the following CUDA libraries to the bin folder of the project or download the release code from the google code repository (which already contains these as part of the visual studio solution).

     cublas64_30_14.dll

     cudart64_30_14.dll

     cudpp64_30_14.dll

     cufft64_30_14.dll

     cutil64.dll

     glew64.dll

     glut32.dll

We present an OpenCL enhanced version of the x264 video encoder, using GPUs to accelerate the processing of motion estimation and other significant parts of the algorithm. We present a system wide approach, where we concentrate on the whole encoder architecture, not only in accelerating the critical paths.

This demo includes the full source code for the OpenCL enhanced version of x264, plus some scripts to fetch images from "Big Buck Bunny" and encode them using x264. Please note that the download of the source images might take a long time and take some serious space in your hard drive (~3.4G). We are working in adding the source code to the x264 development tree.

More info can be found at: http://li5.ziti.uni-heidelberg.de/x264gpu/

This code is a GPU implementation of the 'hybrid-ss-min' function of the Unafold package computing RNA secondary structure.