Crate accel

GPGPU framework for Rust based on CUDA Driver API

Setup

Currently (0.3.0), accel works only on Linux system. Windows support will come in future release (0.3.x or 0.4~).

1. Install CUDA on your system

2. Setup Rust environement using rustup (Requires 1.42 or later)

3. Add nvptx64-nvidia-cuda target and install ptx-linker, or run

   curl -sSL https://gitlab.com/termoshtt/accel/raw/master/setup_nvptx_toolchain.sh | bash

Examples

accel works with stable Rust

[dependencies]
accel = "=0.3.0-alpha.2"

Do NOT add accel-core to [dependencies]. It will be linked automatically into the device code.

Vector Add

use accel::*;

#[kernel]
unsafe fn add(a: *const f32, b: *const f32, c: *mut f32, n: usize) {
    let i = accel_core::index();
    if (i as usize) < n {
        *c.offset(i) = *a.offset(i) + *b.offset(i);
    }
}

fn main() -> error::Result<()> {
    let device = Device::nth(0)?;
    let ctx = device.create_context();

    // Allocate memories on GPU
    let n = 32;
    let mut a = DeviceMemory::<f32>::zeros(ctx.clone(), n);
    let mut b = DeviceMemory::<f32>::zeros(ctx.clone(), n);
    let mut c = DeviceMemory::<f32>::zeros(ctx.clone(), n);

    // Accessible from CPU as usual Rust slice (though this will be slow)
    for i in 0..n {
        a[i] = i as f32;
        b[i] = 2.0 * i as f32;
    }
    println!("a = {:?}", a.as_slice());
    println!("b = {:?}", b.as_slice());

    // Launch kernel synchronously
    add(ctx,
        1 /* grid */,
        n /* block */,
        &(&a.as_ptr(), &b.as_ptr(), &c.as_mut_ptr(), &n)
    ).expect("Kernel call failed");

    println!("c = {:?}", c.as_slice());
    Ok(())
}

Assertion on GPU

use accel::*;

#[kernel]
fn assert() {
    accel_core::assert_eq!(1 + 2, 4);  // will fail
}

fn main() -> error::Result<()> {
    let device = Device::nth(0)?;
    let ctx = device.create_context();
    let result = assert(ctx, 1 /* grid */, 4 /* block */, &());
    assert!(result.is_err()); // assertion failed
    Ok(())
}

Print from GPU

use accel::*;

#[kernel]
pub fn print() {
    let i = accel_core::index();
    accel_core::println!("Hello from {}", i);
}

fn main() -> error::Result<()> {
    let device = Device::nth(0)?;
    let ctx = device.create_context();
    print(ctx, 1, 4, &())?;
    Ok(())
}

Re-exports

pub use device::*;

pub use linker::*;

pub use memory::*;

pub use module::*;

pub use profiler::*;

pub use stream::*;

Modules

device

CUDA Device and Context

error

linker

CUDA JIT compiler and Linkers

memory

Memory management

module

CUDA Module (i.e. loaded PTX or cubin)

profiler

Profiling GPU kernels and host CUDA API calls

stream

Macros

contexted_call

contexted_new

ffi_call

ffi_new

Attribute Macros

kernel