• support for multicore CPUs via OpenMP
• support for CUDA 3.0 and new GPUs based on the Fermi architecture
• support for the Ocelot virtual machine
• pseudo random number generation
• key-value reduction
• set intersection
• and many more

The Thrust web page provides a quick-start guide, online documentation, many examples and introductory slides. Thrust is open-source software distributed under the OSI-approved Apache License v2.0.

From the press release:

The use of Graphics Processing Units (GPUs) as general purpose accelerators has been a growing trend in high-performance computing (HPC). Until now, use of GPUs from Fortran applications has been extremely limited. Developers targeting GPU accelerators have had to program in C at a detailed level using sequences of function calls to manage movement of data between the x64 host and GPU, and to offload computations from the host to the GPU. The PGI Accelerator Fortran and C compilers automatically analyze whole program structure and data, split portions of an application between a multi-core x64 CPU and a GPU as specified by user directives, and define and generate a mapping of loops to automatically use the parallel cores, hardware threading capabilities and SIMD vector capabilities of modern GPUs.

The PGI Accelerator programming model is available now in the PGI Fortran and C compilers on Linux as an extended free preview for all PGI 9.0 licensees through the end of 2009. Additional PGI 9.0 new features include several Fortran 2003 incremental features, Intel Xeon EX (Nehalem) optimizations including support for SSE 4.1/4.2, Six-Core AMD Opteron (Istanbul) support and optimizations, full OpenMP 3.0 support in C++, an all-new graphical interface on the PGDBG OpenMP/MPI debugger, enhancements to the PGPROF performance profiling environment, and support for Fedora Core 10/11, SuSE 11.1 and Ubuntu 9.

Thrust is open source under the Apache 2.0 license and available now at http://thrust.googlecode.com. Download Thrust and check out the Thrust tutorial to get started.

The thrust::host_vector and thrust::device_vector containers simplify memory management and transfers between host and device. Thrust provides efficient algorithms for:

• sorting – thrust::sort and thrust::sort_by_key
• transformations – thrust::transform
• reductions – thrust::reduce and thrust::transform_reduce
• scans – thrust::inclusive_scan and thrust::transform_inclusive_scan
• And many more!

You can refer to the online documentation for a complete listing and join the thrust-users discussion group.

As the following code example shows, Thrust programs are concise and readable.

#include <thrust/host_vector.h>
#include <thrust/device_vector.h>
#include <thrust/generate.h>
#include <thrust/sort.h>
#include <cstdlib>

int main(void)
{
    // generate random data on the host
    thrust::host_vector<int> h_vec(20);
    thrust::generate(h_vec.begin(), h_vec.end(), rand);

    // transfer to device and sort
    thrust::device_vector<int> d_vec = h_vec;
    thrust::sort(d_vec.begin(), d_vec.end());
    return 0;
}

Thrust provides high-level primitives for composing interesting computations.  This example computes the norm of a vector.

#include <thrust/transform_reduce.h>
#include <thrust/functional.h>
#include <thrust/device_vector.h>
#include <thrust/host_vector.h>
#include <cmath>

// square<T> computes the square of a number f(x) -> x*x
template <typename T>
struct square
{
    __host__ __device__
    T operator()(const T& x) const {
        return x * x;
    }
};

int main(void)
{
    // initialize host array
    float x[4] = {1.0, 2.0, 3.0, 4.0};

    // transfer to device
    thrust::device_vector<float> d_x(x, x + 4);

    // setup arguments
    square<float>      unary_op;
    thrust::plus<float> binary_op;
    float init = 0;

    // compute norm
    float norm = std::sqrt( thrust::transform_reduce(d_x.begin(),
                                                     d_x.end(),
                                                     unary_op, init, binary_op) );
    std::cout << norm << std::endl;
    return 0;
}