OpenCL Stream abstraction
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Trivernis 9070f7d48e Add controlled panic on send error
Signed-off-by: Trivernis <trivernis@protonmail.com>
4 years ago
.idea Add copyright notice to source files 4 years ago
src Add controlled panic on send error 4 years ago
.gitignore Add executor and required structs for execution 4 years ago
Cargo.toml Add controlled panic on send error 4 years ago
LICENSE Create LICENSE 4 years ago
README.md Update readme and rename stream module 4 years ago

README.md

Rust OpenCL Stream Executor

This crate provides abstractions over opencl execution to allow the streaming of results. This crate does not provide abstractions over the ocl crate directly but allows to use the provided stream executor to optimise the execution process.

Usage

use crate::executor::OCLStreamExecutor;
use ocl::ProQue;

fn main() {
    // create the ProQue
    let pro_que = ProQue::builder()
        .src("
            __kernel void bench_int(const uint limit, __global int *NUMBERS) {
                uint id = get_global_id(0);
                int num = NUMBERS[id];
                for (int i = 0; i < limit; i++) {
                    num += i;
                }
                NUMBERS[id] = num;
            }",
        )
        .dims(1)
        .build()
        .unwrap();
    
    // create the executor
    let stream_executor = OCLStreamExecutor::new(pro_que);

    // execute a closure that provides the results in the given stream
    let mut stream = stream_executor.execute_unbound(|ctx| {
        let pro_que = ctx.pro_que();
        let tx = ctx.sender();
        let input_buffer = pro_que.buffer_builder().len(100).fill_val(0u32).build()?;

        let kernel = pro_que
            .kernel_builder("bench_int")
            .arg(100)
            .arg(&input_buffer)
            .global_work_size(100)
            .build()?;
        unsafe {
            kernel.enq()?;
        }

        let mut result = vec![0u32; 100];
        input_buffer.read(&mut result).enq()?;

        for num in result {
            // send the results to the receiving thread
            tx.send(num)?;
        }

        Ok(())
    });

    let mut count = 0;

    // calculate the expected result values
    let num = (99f32.powf(2.0) + 99f32) / 2f32;
    // read the results from the stream
    while let Ok(n) = stream.next() {
        assert_eq!(n, num as u32);
        count += 1;
    }
    assert_eq!(count, 100)
}