parenchyma 0.0.33

A high-performance computing (HPC) framework
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use {Context, Device, Error, ErrorKind, ExtensionPackage, Result};
use std::marker::Unsize;
use super::OpenCLDevice;
use super::super::high;
use utility::Uninitialized;

/// Represents an OpenCL context.
///
/// A context is responsible for managing OpenCL objects and resources (command-queues, program 
/// objects, kernel objects, executing kernels, etc.). The usual configuration is a single context 
/// encapsulating multiple devices. The resources, such as [buffers][buffer] and [events][event], 
/// can be shared across multiple devices in a single context. Other possible setups include:
///
/// * a single context for multiple devices
/// * a single context for a single device
/// * a context for each device
///
/// note: multi-platform contexts are not supported in OpenCL.
///
/// ## Programs
///
/// An OpenCL context can have multiple programs associated with it. Programs can be compiled
/// individually to avoid possible name clashes due to using packages from multiple package 
/// authors.
///
/// [buffer]: ./frameworks/opencl/struct.Memory.html
/// [event]: ./frameworks/opencl/struct.Event.html
#[derive(Debug)]
pub struct OpenCLContext<X> {
    /// The high-level context.
    pub(super) context: high::Context,
    /// Holds the extension package implementation.
    pub(super) package: X,
    /// A list of devices associated with the context.
    pub(super) selection: Vec<OpenCLDevice>,
    /// The index of the _active_ device.
    pub(super) active: usize,
    // TODO
    // work_dim must be greater than zero and less than or equal 
    // to CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS.
    // max_work_item_dims: u32,
}

impl<X> OpenCLContext<X> {

    /// Returns the `package`.
    ///
    /// [package author]
    pub fn package(&self) -> &X {
        &self.package
    }

    /// Returns the _active_ OpenCL device.
    ///
    /// [package author]
    pub fn device(&self) -> &OpenCLDevice {
        &self.selection[self.active]
    }
}

impl OpenCLContext<Uninitialized> {
    /// Creates and returns a program.
    pub fn create_program<I>(&mut self, src: &[I]) -> Result<high::Program> where I: AsRef<str> {
        let program = self.context.create_program_with_source(src)?;
        let raw_devices: Vec<_> = self.selection.iter().map(|d| d.device.clone()).collect();
        program.build(&raw_devices, None /* TODO */)?;
        Ok(program)
    }
}

impl<X> Context for OpenCLContext<X> 
    where X: ExtensionPackage, 
          OpenCLContext<X>: Unsize<X::Extension> {

    type Package = X;

    fn active_device(&self) -> &Device {

        &self.selection[self.active]
    }

    fn set_active(&mut self, idx: usize) -> Result {
        if idx >= self.selection.len() {
            return Err(Error::new(ErrorKind::Other, "device index out of range"));
        }

        self.active = idx;

        Ok(())
    }

    fn extension(&self) -> &X::Extension {

        self
    }
}