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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
use crate::api::device::get_devs_for_type;
use crate::api::icd::*;
use crate::api::types::*;
use crate::api::util::*;
use crate::cl_closure;
use crate::core::context::*;
use crate::core::platform::*;
use mesa_rust_util::properties::Properties;
use rusticl_opencl_gen::*;
use std::collections::HashSet;
use std::iter::FromIterator;
use std::slice;
use std::sync::Arc;
impl CLInfo<cl_context_info> for cl_context {
fn query(&self, q: cl_context_info, _: &[u8]) -> CLResult<Vec<u8>> {
let ctx = self.get_ref()?;
Ok(match q {
CL_CONTEXT_DEVICES => {
cl_prop::<&Vec<cl_device_id>>(
&ctx.devs
.iter()
.map(|d| {
// Note we use as_ptr here which doesn't increase the reference count.
cl_device_id::from_ptr(Arc::as_ptr(d))
})
.collect(),
)
}
CL_CONTEXT_NUM_DEVICES => cl_prop::<cl_uint>(ctx.devs.len() as u32),
CL_CONTEXT_PROPERTIES => cl_prop::<&Properties<cl_context_properties>>(&ctx.properties),
CL_CONTEXT_REFERENCE_COUNT => cl_prop::<cl_uint>(self.refcnt()?),
// CL_INVALID_VALUE if param_name is not one of the supported values
_ => return Err(CL_INVALID_VALUE),
})
}
}
pub fn create_context(
properties: *const cl_context_properties,
num_devices: cl_uint,
devices: *const cl_device_id,
pfn_notify: Option<CreateContextCB>,
user_data: *mut ::std::os::raw::c_void,
) -> CLResult<cl_context> {
check_cb(&pfn_notify, user_data)?;
// CL_INVALID_VALUE if devices is NULL.
if devices.is_null() {
return Err(CL_INVALID_VALUE);
}
// CL_INVALID_VALUE if num_devices is equal to zero.
if num_devices == 0 {
return Err(CL_INVALID_VALUE);
}
// CL_INVALID_PROPERTY [...] if the same property name is specified more than once.
let props = Properties::from_ptr(properties).ok_or(CL_INVALID_PROPERTY)?;
for p in &props.props {
match p.0 as u32 {
// CL_INVALID_PLATFORM [...] if platform value specified in properties is not a valid platform.
CL_CONTEXT_PLATFORM => {
(p.1 as cl_platform_id).get_ref()?;
}
CL_CONTEXT_INTEROP_USER_SYNC => {
check_cl_bool(p.1).ok_or(CL_INVALID_PROPERTY)?;
}
// CL_INVALID_PROPERTY if context property name in properties is not a supported property name
_ => return Err(CL_INVALID_PROPERTY),
}
}
// Duplicate devices specified in devices are ignored.
let set: HashSet<_> =
HashSet::from_iter(unsafe { slice::from_raw_parts(devices, num_devices as usize) }.iter());
let devs: Result<_, _> = set.into_iter().map(cl_device_id::get_arc).collect();
Ok(cl_context::from_arc(Context::new(devs?, props)))
}
pub fn create_context_from_type(
properties: *const cl_context_properties,
device_type: cl_device_type,
pfn_notify: Option<CreateContextCB>,
user_data: *mut ::std::os::raw::c_void,
) -> CLResult<cl_context> {
// CL_INVALID_DEVICE_TYPE if device_type is not a valid value.
check_cl_device_type(device_type)?;
let devs: Vec<_> = get_devs_for_type(device_type)
.iter()
.map(|d| cl_device_id::from_ptr(Arc::as_ptr(d)))
.collect();
// CL_DEVICE_NOT_FOUND if no devices that match device_type and property values specified in properties were found.
if devs.is_empty() {
return Err(CL_DEVICE_NOT_FOUND);
}
// errors are essentially the same and we will always pass in a valid
// device list, so that's fine as well.
create_context(
properties,
devs.len() as u32,
devs.as_ptr(),
pfn_notify,
user_data,
)
}
pub fn set_context_destructor_callback(
context: cl_context,
pfn_notify: ::std::option::Option<DeleteContextCB>,
user_data: *mut ::std::os::raw::c_void,
) -> CLResult<()> {
let c = context.get_ref()?;
// CL_INVALID_VALUE if pfn_notify is NULL.
if pfn_notify.is_none() {
return Err(CL_INVALID_VALUE);
}
c.dtors
.lock()
.unwrap()
.push(cl_closure!(|c| pfn_notify(c, user_data)));
Ok(())
}
|
