Struct Device

pub struct Device { /* private fields */ }

Implementations

impl Device

pub fn new(device_id: ClDeviceID) -> Device

impl Device

pub fn low_level_device(&self) -> &ClDeviceID

Examples found in repository

examples/simple_add/main.rs (line 35)

fn run_procedural() {
    let src = include_str!("simple_add.ocl");

    let mut platforms = Platform::list_all().unwrap();

    if platforms.len() == 0 {
        panic!("No platforms found!!!");
    }

    let platform = platforms.remove(0);
    let devices = Device::list_all_devices(&platform).unwrap();

    if devices.len() == 0 {
        panic!("No devices found!!!");
    }
    let context = Context::create(&devices[..]).unwrap();

    println!("creating program...");
    let unbuilt_program: UnbuiltProgram =
        UnbuiltProgram::create_with_source(&context, src).unwrap();

    let names = devices.iter().map(|d| d.low_level_device().name().unwrap());
    println!("building program on devices {:?}...", names);

    let program: Program = unbuilt_program
        .build(&devices[..])
        .unwrap_or_else(|e| panic!("Failed to build program {:?}", e));

    for device in devices[0..1].iter() {
        let program2 = (&program).clone();
        let r_count = program2.low_level_program().reference_count().unwrap();
        let prog_log = program2.low_level_program().get_log(device).unwrap();
        let prog_src = program2.low_level_program().source().unwrap();
        println!("Program log {:?} {:?}, {:?}", r_count, prog_log, prog_src);
        println!("Device {:?}", device);

        let command_queue: CommandQueue = CommandQueue::create(&context, device, None).unwrap();

        let vec_a = vec![1i64, 2, 3];
        let vec_b = vec![0i64, -1, -2];

        let len = vec_a.len();

        let work: Work = Work::new(len);
        let name = device.name().unwrap();
        println!("{}", name);

        let mem_a = Buffer::create_with_len::<i64>(&context, len).unwrap();
        let mem_b = Buffer::create_with_len::<i64>(&context, len).unwrap();
        let mem_c = Buffer::create_with_len::<i64>(&context, len).unwrap();
    
        println!("Creating kernel simple_add");
        let simple_add = Kernel::create(&program2, "simple_add").unwrap();

        println!("writing buffer a...");
        let _write_event_a = command_queue.write_buffer(&mem_a, &vec_a, None).unwrap();

        println!("writing buffer b...");
        let _write_event_b = command_queue.write_buffer(&mem_b, &vec_b, None).unwrap();

        println!("mem_a {:?}", mem_a);

        let mut lock_a = mem_a.write_lock();
        println!("setting simple_add arg 0 as mem_a");
        unsafe { simple_add.set_arg(0, &mut *lock_a).unwrap() };

        let mut lock_b = mem_b.write_lock();
        println!("setting simple_add arg 1 as mem_b");
        unsafe { simple_add.set_arg(1, &mut *lock_b).unwrap() };

        let mut lock_c = mem_c.write_lock();
        println!("setting simple_add mut arg 2 as mem_c");
        unsafe { simple_add.set_arg(2, &mut *lock_c).unwrap() };

        println!("calling enqueue_kernel on simple_add");
        let () = command_queue
            .enqueue_kernel(simple_add, &work, None)
            .unwrap();

        println!("Dropping locks...");
        std::mem::drop(lock_a);
        std::mem::drop(lock_b);
        std::mem::drop(lock_c);

        println!("done putting event into WaitList...");
        let mut vec_c: Vec<i64> = vec![0; len];

        let _read_event = command_queue.read_buffer(&mem_c, &mut vec_c, None).unwrap();

        println!("  {}", string_from_slice(&vec_a[..]));
        println!("+ {}", string_from_slice(&vec_b[..]));
        println!("= {}", string_from_slice(&vec_c[..]));
    }
}

pub fn list_devices_by_type( platform: &Platform, device_type: DeviceType, ) -> Output<Vec<Device>>

pub fn list_default_devices(platform: &Platform) -> Output<Vec<Device>>

pub fn list_all_devices(platform: &Platform) -> Output<Vec<Device>>

Examples found in repository

examples/simple_add/main.rs (line 24)

fn run_procedural() {
    let src = include_str!("simple_add.ocl");

    let mut platforms = Platform::list_all().unwrap();

    if platforms.len() == 0 {
        panic!("No platforms found!!!");
    }

    let platform = platforms.remove(0);
    let devices = Device::list_all_devices(&platform).unwrap();

    if devices.len() == 0 {
        panic!("No devices found!!!");
    }
    let context = Context::create(&devices[..]).unwrap();

    println!("creating program...");
    let unbuilt_program: UnbuiltProgram =
        UnbuiltProgram::create_with_source(&context, src).unwrap();

    let names = devices.iter().map(|d| d.low_level_device().name().unwrap());
    println!("building program on devices {:?}...", names);

    let program: Program = unbuilt_program
        .build(&devices[..])
        .unwrap_or_else(|e| panic!("Failed to build program {:?}", e));

    for device in devices[0..1].iter() {
        let program2 = (&program).clone();
        let r_count = program2.low_level_program().reference_count().unwrap();
        let prog_log = program2.low_level_program().get_log(device).unwrap();
        let prog_src = program2.low_level_program().source().unwrap();
        println!("Program log {:?} {:?}, {:?}", r_count, prog_log, prog_src);
        println!("Device {:?}", device);

        let command_queue: CommandQueue = CommandQueue::create(&context, device, None).unwrap();

        let vec_a = vec![1i64, 2, 3];
        let vec_b = vec![0i64, -1, -2];

        let len = vec_a.len();

        let work: Work = Work::new(len);
        let name = device.name().unwrap();
        println!("{}", name);

        let mem_a = Buffer::create_with_len::<i64>(&context, len).unwrap();
        let mem_b = Buffer::create_with_len::<i64>(&context, len).unwrap();
        let mem_c = Buffer::create_with_len::<i64>(&context, len).unwrap();
    
        println!("Creating kernel simple_add");
        let simple_add = Kernel::create(&program2, "simple_add").unwrap();

        println!("writing buffer a...");
        let _write_event_a = command_queue.write_buffer(&mem_a, &vec_a, None).unwrap();

        println!("writing buffer b...");
        let _write_event_b = command_queue.write_buffer(&mem_b, &vec_b, None).unwrap();

        println!("mem_a {:?}", mem_a);

        let mut lock_a = mem_a.write_lock();
        println!("setting simple_add arg 0 as mem_a");
        unsafe { simple_add.set_arg(0, &mut *lock_a).unwrap() };

        let mut lock_b = mem_b.write_lock();
        println!("setting simple_add arg 1 as mem_b");
        unsafe { simple_add.set_arg(1, &mut *lock_b).unwrap() };

        let mut lock_c = mem_c.write_lock();
        println!("setting simple_add mut arg 2 as mem_c");
        unsafe { simple_add.set_arg(2, &mut *lock_c).unwrap() };

        println!("calling enqueue_kernel on simple_add");
        let () = command_queue
            .enqueue_kernel(simple_add, &work, None)
            .unwrap();

        println!("Dropping locks...");
        std::mem::drop(lock_a);
        std::mem::drop(lock_b);
        std::mem::drop(lock_c);

        println!("done putting event into WaitList...");
        let mut vec_c: Vec<i64> = vec![0; len];

        let _read_event = command_queue.read_buffer(&mem_c, &mut vec_c, None).unwrap();

        println!("  {}", string_from_slice(&vec_a[..]));
        println!("+ {}", string_from_slice(&vec_b[..]));
        println!("= {}", string_from_slice(&vec_c[..]));
    }
}

pub fn list_cpu_devices(platform: &Platform) -> Output<Vec<Device>>

pub fn list_gpu_devices(platform: &Platform) -> Output<Vec<Device>>

pub fn list_accelerator_devices(platform: &Platform) -> Output<Vec<Device>>

pub fn list_custom_devices(platform: &Platform) -> Output<Vec<Device>>

Trait Implementations

impl Clone for Device

fn clone(&self) -> Device

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Device

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DevicePtr for Device

unsafe fn device_ptr(&self) -> cl_device_id

fn is_usable(&self) -> bool

fn usability_check(&self) -> Result<(), Error>

fn global_mem_cacheline_size(&self) -> Result<u32, Error>

fn native_vector_width_double(&self) -> Result<u32, Error>

fn native_vector_width_half(&self) -> Result<u32, Error>

fn address_bits(&self) -> Result<u32, Error>

fn max_clock_frequency(&self) -> Result<u32, Error>

fn max_compute_units(&self) -> Result<u32, Error>

fn max_constant_args(&self) -> Result<u32, Error>

fn max_read_image_args(&self) -> Result<u32, Error>

fn max_samplers(&self) -> Result<u32, Error>

fn max_work_item_dimensions(&self) -> Result<u32, Error>

fn max_write_image_args(&self) -> Result<u32, Error>

fn mem_base_addr_align(&self) -> Result<u32, Error>

fn min_data_type_align_size(&self) -> Result<u32, Error>

fn native_vector_width_char(&self) -> Result<u32, Error>

fn native_vector_width_short(&self) -> Result<u32, Error>

fn native_vector_width_int(&self) -> Result<u32, Error>

fn native_vector_width_long(&self) -> Result<u32, Error>

fn native_vector_width_float(&self) -> Result<u32, Error>

fn partition_max_sub_devices(&self) -> Result<u32, Error>

fn preferred_vector_width_char(&self) -> Result<u32, Error>

fn preferred_vector_width_short(&self) -> Result<u32, Error>

fn preferred_vector_width_int(&self) -> Result<u32, Error>

fn preferred_vector_width_long(&self) -> Result<u32, Error>

fn preferred_vector_width_float(&self) -> Result<u32, Error>

fn preferred_vector_width_double(&self) -> Result<u32, Error>

fn preferred_vector_width_half(&self) -> Result<u32, Error>

fn vendor_id(&self) -> Result<u32, Error>

fn available(&self) -> Result<bool, Error>

fn compiler_available(&self) -> Result<bool, Error>

fn endian_little(&self) -> Result<bool, Error>

fn error_correction_support(&self) -> Result<bool, Error>

fn host_unified_memory(&self) -> Result<bool, Error>

fn image_support(&self) -> Result<bool, Error>

fn linker_available(&self) -> Result<bool, Error>

fn preferred_interop_user_sync(&self) -> Result<bool, Error>

fn name(&self) -> Result<String, Error>

fn opencl_c_version(&self) -> Result<String, Error>

fn profile(&self) -> Result<String, Error>

fn vendor(&self) -> Result<String, Error>

fn version(&self) -> Result<String, Error>

fn driver_version(&self) -> Result<String, Error>

fn global_mem_cache_size(&self) -> Result<u64, Error>

fn global_mem_size(&self) -> Result<u64, Error>

fn local_mem_size(&self) -> Result<u64, Error>

fn max_constant_buffer_size(&self) -> Result<u64, Error>

fn max_mem_alloc_size(&self) -> Result<u64, Error>

fn image2d_max_width(&self) -> Result<usize, Error>

fn image2d_max_height(&self) -> Result<usize, Error>

fn image3d_max_width(&self) -> Result<usize, Error>

fn image3d_max_height(&self) -> Result<usize, Error>

fn image3d_max_depth(&self) -> Result<usize, Error>

fn image_max_buffer_size(&self) -> Result<usize, Error>

fn image_max_array_size(&self) -> Result<usize, Error>

fn max_parameter_size(&self) -> Result<usize, Error>

fn max_work_group_size(&self) -> Result<usize, Error>

fn printf_buffer_size(&self) -> Result<usize, Error>

fn profiling_timer_resolution(&self) -> Result<usize, Error>

fn max_work_item_sizes(&self) -> Result<Vec<usize>, Error>

fn local_mem_type(&self) -> Result<DeviceLocalMemType, Error>

fn execution_capabilities(&self) -> Result<DeviceExecCapabilities, Error>

fn global_mem_cache_type(&self) -> Result<DeviceMemCacheType, Error>

fn partition_affinity_domain(&self) -> Result<DeviceAffinityDomain, Error>

fn device_type(&self) -> Result<DeviceType, Error>

impl Drop for Device

fn drop(&mut self)

Executes the destructor for this type.

impl PartialEq for Device

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Device

impl Send for Device

impl Sync for Device