mot.lib package¶
Submodules¶
mot.lib.cl_data_type module¶
mot.lib.cl_environments module¶
-
class
mot.lib.cl_environments.
CLEnvironment
(platform, device)[source]¶ Bases:
object
Storage unit for an OpenCL environment.
Parameters: - platform (pyopencl platform) – An PyOpenCL platform.
- device (pyopencl device) – An PyOpenCL device
-
context
¶ Get a CL context containing this device.
Returns: a PyOpenCL device context Return type: cl.Context
-
device
¶ Get the device associated with this environment.
Returns: The device associated with this environment. Return type: pyopencl device
-
device_type
¶ Get the device type of the device in this environment.
Returns: the device type of this device.
-
is_cpu
¶ Check if the device associated with this environment is a CPU.
Returns: True if the device is an CPU, false otherwise. Return type: boolean
-
is_gpu
¶ Check if the device associated with this environment is a GPU.
Returns: True if the device is an GPU, false otherwise. Return type: boolean
-
platform
¶ Get the platform associated with this environment.
Returns: The platform associated with this environment. Return type: pyopencl platform
-
queue
¶ Get a CL queue for this device and context.
Returns: a PyOpenCL queue Return type: cl.Queue
-
supports_double
¶ Check if the device listed by this environment supports double
Returns: True if the device supports double, false otherwise. Return type: boolean
-
class
mot.lib.cl_environments.
CLEnvironmentFactory
[source]¶ Bases:
object
-
static
all_devices
(cl_device_type=None, platform=None)[source]¶ Get multiple device environments, optionally only of the indicated type.
This will only fetch devices that support double point precision.
Parameters: - cl_device_type (cl.device_type.* or string) – The type of the device we want, can be a opencl device type or a string matching ‘GPU’ or ‘CPU’.
- platform (opencl platform) – The opencl platform to select the devices from
Returns: List with the CL device environments.
Return type: list of CLEnvironment
-
static
single_device
(cl_device_type='GPU', platform=None, fallback_to_any_device_type=False)[source]¶ Get a list containing a single device environment, for a device of the given type on the given platform.
This will only fetch devices that support double (possibly only double with a pragma defined, but still, it should support double).
Parameters: - cl_device_type (cl.device_type.* or string) – The type of the device we want, can be a opencl device type or a string matching ‘GPU’, ‘CPU’ or ‘ALL’.
- platform (opencl platform) – The opencl platform to select the devices from
- fallback_to_any_device_type (boolean) – If True, try to fallback to any possible device in the system.
Returns: List with one element, the CL runtime environment requested.
Return type: list of CLEnvironment
-
static
smart_device_selection
(preferred_device_type=None)[source]¶ Get a list of device environments that is suitable for use in MOT.
Basically this gets the total list of devices using all_devices() and applies a filter on it.
- This filter does the following:
- if the ‘AMD Accelerated Parallel Processing’ is available remove all environments using the ‘Clover’
- platform.
More things may be implemented in the future.
Parameters: preferred_device_type (str) – the preferred device type, one of ‘CPU’, ‘GPU’ or ‘APU’. If no devices of this type can be found, we will use any other device available. Returns: List with the CL device environments. Return type: list of CLEnvironment
-
static
mot.lib.cl_function module¶
-
class
mot.lib.cl_function.
CLFunction
[source]¶ Bases:
mot.lib.cl_function.CLCodeObject
Interface for a basic CL function.
-
evaluate
(inputs, nmr_instances, use_local_reduction=False, cl_runtime_info=None)[source]¶ Evaluate this function for each set of given parameters.
Given a set of input parameters, this model will be evaluated for every parameter set. This function will convert possible dots in the parameter names to underscores for use in the CL kernel.
Parameters: - inputs (Iterable[Union(ndarray, mot.lib.utils.KernelData) – or Mapping[str: Union(ndarray, mot.lib.utils.KernelData)]): for each CL function parameter the input data. Each of these input datasets must either be a scalar or be of equal length in the first dimension. The elements can either be raw ndarrays or KernelData objects. If an ndarray is given we will load it read/write by default. You can provide either an iterable with one value per parameter, or a mapping with for every parameter a corresponding value.
- nmr_instances (int) – the number of parallel processes to run.
- use_local_reduction (boolean) – set this to True if you want to use local memory reduction in evaluating this function. If this is set to True we will multiply the global size (given by the nmr_instances) by the work group sizes.
- cl_runtime_info (mot.configuration.CLRuntimeInfo) – the runtime information for execution
Returns: the return values of the function, which can be None if this function has a void return type.
Return type: ndarray
-
get_cl_body
()[source]¶ Get the CL code for the body of this function.
Returns: the CL code of this function body Return type: str
-
get_cl_code
()[source]¶ Get the function code for this function and all its dependencies, with include guards.
Returns: The CL code for inclusion in a kernel. Return type: str
-
get_cl_function_name
()[source]¶ Return the calling name of the implemented CL function
Returns: The name of this CL function Return type: str
-
get_dependencies
()[source]¶ Get the list of dependencies this function depends on.
Returns: the list of dependencies for this function. Return type: list[CLFunction]
-
get_parameters
()[source]¶ Return the list of parameters from this CL function.
Returns: - list of the parameters in this
- model in the same order as in the CL function
Return type: list of mot.lib.cl_function.CLFunctionParameter
-
-
class
mot.lib.cl_function.
CLFunctionParameter
[source]¶ Bases:
object
-
address_space
¶ Get the address space of this data declaration.
Returns: the data type address space, one of global
,local
,constant
orprivate
.Return type: str
-
array_sizes
¶ Get the dimension of this array type.
This returns for example (10, 5) for the data type float[10][5].
Returns: the sizes of the arrays Return type: Tuple[int]
-
basic_ctype
¶ Get the basic data type without the vector and pointer additions.
For example, if the full data ctype is
float4*
, we will only returnfloat
here.Returns: the raw CL data type Return type: str
-
ctype
¶ Get the ctype of this data type.
For example, if the data type is float4*, we will return float4 here.
Returns: the full ctype of this data type Return type: str
-
get_declaration
()[source]¶ Get the complete CL declaration for this parameter.
Returns: the declaration for this data type. Return type: str
-
get_renamed
(name)[source]¶ Get a copy of the current parameter but then with a new name.
Parameters: name (str) – the new name for this parameter Returns: a copy of the current type but with a new name Return type: cls
-
is_array_type
¶ Check if this parameter is an array type (like float[3] or int[10][5]).
Returns: True if this is an array type, false otherwise Return type: boolean
-
is_pointer_type
¶ Check if this parameter is a pointer type (appended by a
*
)Returns: True if it is a pointer type, false otherwise Return type: boolean
-
is_vector_type
¶ Check if this data type is a vector type (like for example double4, float2, int8, etc.).
Returns: True if it is a vector type, false otherwise Return type: boolean
-
name
¶ The name of this parameter.
Returns: the name of this parameter Return type: str
-
nmr_pointers
¶ Get the number of asterisks / pointer references of this data type.
If the data type is float**, we return 2 here.
Returns: the number of pointer asterisks in the data type. Return type: int
-
vector_length
¶ Get the length of this vector, returns None if not a vector type.
Returns: the length of the vector type (for example, if the data type is float4, this returns 4). Return type: int
-
-
class
mot.lib.cl_function.
SimpleCLCodeObject
(cl_code)[source]¶ Bases:
mot.lib.cl_function.CLCodeObject
Simple code object for including type definitions in the kernel.
Parameters: cl_code (str) – CL code to be included in the kernel
-
class
mot.lib.cl_function.
SimpleCLFunction
(return_type, cl_function_name, parameter_list, cl_body, dependencies=None)[source]¶ Bases:
mot.lib.cl_function.CLFunction
A simple implementation of a CL function.
Parameters: - return_type (str) – the CL return type of the function
- cl_function_name (string) – The name of the CL function
- parameter_list (list or tuple) – This either contains instances of
CLFunctionParameter
or strings from which to form the function parameters. - cl_body (str) – the body of the CL code for this function.
- dependencies (Iterable[CLCodeObject]) – The CL code objects this function depends on, these will be prepended to the CL code generated by this function.
-
evaluate
(inputs, nmr_instances, use_local_reduction=False, cl_runtime_info=None)[source]¶ Evaluate this function for each set of given parameters.
Given a set of input parameters, this model will be evaluated for every parameter set. This function will convert possible dots in the parameter names to underscores for use in the CL kernel.
Parameters: - inputs (Iterable[Union(ndarray, mot.lib.utils.KernelData) – or Mapping[str: Union(ndarray, mot.lib.utils.KernelData)]): for each CL function parameter the input data. Each of these input datasets must either be a scalar or be of equal length in the first dimension. The elements can either be raw ndarrays or KernelData objects. If an ndarray is given we will load it read/write by default. You can provide either an iterable with one value per parameter, or a mapping with for every parameter a corresponding value.
- nmr_instances (int) – the number of parallel processes to run.
- use_local_reduction (boolean) – set this to True if you want to use local memory reduction in evaluating this function. If this is set to True we will multiply the global size (given by the nmr_instances) by the work group sizes.
- cl_runtime_info (mot.configuration.CLRuntimeInfo) – the runtime information for execution
Returns: the return values of the function, which can be None if this function has a void return type.
Return type: ndarray
-
classmethod
from_string
(cl_function, dependencies=())[source]¶ Parse the given CL function into a SimpleCLFunction object.
Parameters: - cl_function (str) – the function we wish to turn into an object
- dependencies (list or tuple of CLLibrary) – The list of CL libraries this function depends on
Returns: the CL data type for this parameter declaration
Return type:
-
get_cl_body
()[source]¶ Get the CL code for the body of this function.
Returns: the CL code of this function body Return type: str
-
get_cl_code
()[source]¶ Get the function code for this function and all its dependencies, with include guards.
Returns: The CL code for inclusion in a kernel. Return type: str
-
get_cl_function_name
()[source]¶ Return the calling name of the implemented CL function
Returns: The name of this CL function Return type: str
-
get_dependencies
()[source]¶ Get the list of dependencies this function depends on.
Returns: the list of dependencies for this function. Return type: list[CLFunction]
-
get_parameters
()[source]¶ Return the list of parameters from this CL function.
Returns: - list of the parameters in this
- model in the same order as in the CL function
Return type: list of mot.lib.cl_function.CLFunctionParameter
-
class
mot.lib.cl_function.
SimpleCLFunctionParameter
(declaration)[source]¶ Bases:
mot.lib.cl_function.CLFunctionParameter
Creates a new function parameter for the CL functions.
Parameters: declaration (str) – the declaration of this parameter. For example global int foo
.-
address_space
¶ Get the address space of this data declaration.
Returns: the data type address space, one of global
,local
,constant
orprivate
.Return type: str
-
array_sizes
¶ Get the dimension of this array type.
This returns for example (10, 5) for the data type float[10][5].
Returns: the sizes of the arrays Return type: Tuple[int]
-
basic_ctype
¶ Get the basic data type without the vector and pointer additions.
For example, if the full data ctype is
float4*
, we will only returnfloat
here.Returns: the raw CL data type Return type: str
-
ctype
¶ Get the ctype of this data type.
For example, if the data type is float4*, we will return float4 here.
Returns: the full ctype of this data type Return type: str
-
get_declaration
()[source]¶ Get the complete CL declaration for this parameter.
Returns: the declaration for this data type. Return type: str
-
get_renamed
(name)[source]¶ Get a copy of the current parameter but then with a new name.
Parameters: name (str) – the new name for this parameter Returns: a copy of the current type but with a new name Return type: cls
-
is_array_type
¶ Check if this parameter is an array type (like float[3] or int[10][5]).
Returns: True if this is an array type, false otherwise Return type: boolean
-
is_pointer_type
¶ Check if this parameter is a pointer type (appended by a
*
)Returns: True if it is a pointer type, false otherwise Return type: boolean
-
is_vector_type
¶ Check if this data type is a vector type (like for example double4, float2, int8, etc.).
Returns: True if it is a vector type, false otherwise Return type: boolean
-
name
¶ The name of this parameter.
Returns: the name of this parameter Return type: str
-
nmr_pointers
¶ Get the number of asterisks / pointer references of this data type.
If the data type is float**, we return 2 here.
Returns: the number of pointer asterisks in the data type. Return type: int
-
vector_length
¶ Get the length of this vector, returns None if not a vector type.
Returns: the length of the vector type (for example, if the data type is float4, this returns 4). Return type: int
-
-
mot.lib.cl_function.
apply_cl_function
(cl_function, kernel_data, nmr_instances, use_local_reduction=False, cl_runtime_info=None)[source]¶ Run the given function/procedure on the given set of data.
This class will wrap the given CL function in a kernel call and execute that that for every data instance using the provided kernel data. This class will respect the read write setting of the kernel data elements such that output can be written back to the according kernel data elements.
Parameters: - cl_function (mot.lib.cl_function.CLFunction) – the function to run on the datasets. Either a name function tuple or an actual CLFunction object.
- (dict[str (kernel_data) – mot.lib.kernel_data.KernelData]): the data to use as input to the function.
- nmr_instances (int) – the number of parallel threads to run (used as
global_size
) - use_local_reduction (boolean) – set this to True if you want to use local memory reduction in your CL procedure. If this is set to True we will multiply the global size (given by the nmr_instances) by the work group sizes.
- cl_runtime_info (mot.configuration.CLRuntimeInfo) – the runtime information
mot.lib.kernel_data module¶
-
class
mot.lib.kernel_data.
Array
(data, ctype=None, mode='r', offset_str=None, ensure_zero_copy=False, as_scalar=False)[source]¶ Bases:
mot.lib.kernel_data.KernelData
Loads the given array as a buffer into the kernel.
By default, this will try to offset the data in the kernel by the stride of the first dimension multiplied with the problem id by the kernel. For example, if a (n, m) matrix is provided, this will offset the data by
{problem_id} * m
.This class will adapt the data to match the ctype (if necessary) and it might copy the data as a consecutive array for direct memory access by the CL environment. Depending on those transformations, a copy of the original array may be made. As such, if
is_writable
would have been set, the return values might be written to a different array. To retrieve the output data after kernel execution, use the methodget_data()
. Alternatively, setensure_zero_copy
to True, this ensures that the return values are written to the same reference by raising a ValueError if the data has to be copied to be used in the kernel.Parameters: - data (ndarray) – the data to load in the kernel
- ctype (str) – the desired c-type for in use in the kernel, like
int
,float
ormot_float_type
. If None it is implied from the provided data. - mode (str) – one of ‘r’, ‘w’ or ‘rw’, for respectively read, write or read and write. This sets the mode of how the data is loaded into the compute device’s memory.
- offset_str (str) – the offset definition, can use
{problem_id}
for multiplication purposes. Set to 0 for no offset. - ensure_zero_copy (boolean) – only used if
is_writable
is set to True. If set, we guarantee that the return values are written to the same input array. This allows the user of this class to user their reference to the underlying data, relieving the user of having to useget_data()
. - as_scalar (boolean) – if given and if the data is only a 1d, we will load the value as a scalar in the data struct. As such, one does not need to evaluate as a pointer.
-
enqueue_readouts
(queue, buffers, range_start, range_end)[source]¶ Enqueue readouts for this kernel input data object.
This should add non-blocking readouts to the given queue.
Parameters: - queue (opencl queue) – the queue on which to add the unmap buffer command
- buffers (List[pyopencl._cl.Buffer.Buffer]) – the list of buffers corresponding to this kernel data.
These buffers are obtained earlier from the method
get_kernel_inputs()
. - range_start (int) – the start of the range to read out (in the first dimension)
- range_end (int) – the end of the range to read out (in the first dimension)
-
get_data
()[source]¶ Get the underlying data of this kernel data object.
Returns: the underlying data object, can return None if this input data has no actual data. Return type: dict, ndarray, scalar
-
get_function_call_input
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ How this kernel data is used as input to the function that operates on the data.
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: a single string representing how this kernel data is used as input to the function we are applying
Return type: str
-
get_kernel_inputs
(cl_context, workgroup_size)[source]¶ Get the kernel input data matching the list of parameters of
get_kernel_parameters()
.Since the kernels follow the map/unmap paradigm make sure to use the
USE_HOST_PTR
when making writable data objects.Parameters: - cl_context (pyopencl.Context) – the CL context in which we are working.
- workgroup_size (int) – the workgroup size the kernel will use.
Returns: - a list of buffers, local memory objects, scalars, etc., anything that can be loaded into the kernel.
If no data should be entered, return an empty list.
Return type: List
-
get_kernel_parameters
(kernel_param_name)[source]¶ Get the kernel argument declarations for this kernel data.
Parameters: kernel_param_name (str) – the parameter name for the parameter in the kernel function call Returns: a list of kernel parameter declarations, or an empty list Return type: List[str]
-
get_nmr_kernel_inputs
()[source]¶ Get the number of kernel inputs this input data object has.
Returns: the number of kernel inputs Return type: int
-
get_scalar_arg_dtypes
()[source]¶ Get the numpy data types we should report in the kernel call for scalar elements.
If we are inserting scalars in the kernel we need to provide the CL runtime with the correct data type of the function. If the kernel parameter is not a scalar, we should return None. If the kernel data does not require a kernel input parameter, return an empty list.
This list should match the list of parameters of
get_kernel_parameters()
.Returns: the numpy data type for this element, or None if this is not a scalar. Return type: List[Union[dtype, None]]
-
get_struct_declaration
(name)[source]¶ Get the variable declaration of this data object for use in a Struct.
Parameters: name (str) – the name for this data Returns: the variable declaration of this kernel data object Return type: str
-
get_struct_initialization
(variable_name, kernel_param_name, problem_id_substitute)[source]¶ Initialize the variable inside a struct.
This should initialize the variable for use in a struct (should correspond to
get_struct_declaration()
).Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: the necessary CL code to initialize this variable
Return type: str
-
get_type_definitions
()[source]¶ Get possible type definitions needed to load this data into the kernel.
These types are defined at the head of the CL script, before any functions.
Returns: - a CL compatible type declaration. This can for example be used for defining struct types.
- If no extra types are needed, this function should return the empty string.
Return type: str
-
initialize_variable
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ Initialize the variable inside the kernel function.
This should initialize the variable as such that we can use it when calling the function acting on this data.
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: the necessary CL code to initialize this variable
Return type: str
-
post_function_callback
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ A callback to update or change data after the function has been applied
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: CL code that needs to be run after the function has been applied.
Return type: str
-
set_mot_float_dtype
(mot_float_dtype)[source]¶ Set the numpy data type corresponding to the
mot_float_type
ctype.This is set just prior to using this kernel data in the kernel.
Parameters: mot_float_dtype (dtype) – the numpy data type that is to correspond with the mot_float_type
used in the kernels.
-
class
mot.lib.kernel_data.
CompositeArray
(elements, ctype, address_space='private')[source]¶ Bases:
mot.lib.kernel_data.KernelData
An array filled with the given kernel data elements.
Each of the given elements should be a
Scalar
or anArray
with the property as_scalar set to True. We will load each value of the given elements into a private array.Parameters: - elements (List[KernelData]) – the kernel data elements to load into the private array
- ctype (str) – the data type of this structure
- address_space (str) – the address space for the allocation of the main array
-
enqueue_readouts
(queue, buffers, range_start, range_end)[source]¶ Enqueue readouts for this kernel input data object.
This should add non-blocking readouts to the given queue.
Parameters: - queue (opencl queue) – the queue on which to add the unmap buffer command
- buffers (List[pyopencl._cl.Buffer.Buffer]) – the list of buffers corresponding to this kernel data.
These buffers are obtained earlier from the method
get_kernel_inputs()
. - range_start (int) – the start of the range to read out (in the first dimension)
- range_end (int) – the end of the range to read out (in the first dimension)
-
get_data
()[source]¶ Get the underlying data of this kernel data object.
Returns: the underlying data object, can return None if this input data has no actual data. Return type: dict, ndarray, scalar
-
get_function_call_input
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ How this kernel data is used as input to the function that operates on the data.
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: a single string representing how this kernel data is used as input to the function we are applying
Return type: str
-
get_kernel_inputs
(cl_context, workgroup_size)[source]¶ Get the kernel input data matching the list of parameters of
get_kernel_parameters()
.Since the kernels follow the map/unmap paradigm make sure to use the
USE_HOST_PTR
when making writable data objects.Parameters: - cl_context (pyopencl.Context) – the CL context in which we are working.
- workgroup_size (int) – the workgroup size the kernel will use.
Returns: - a list of buffers, local memory objects, scalars, etc., anything that can be loaded into the kernel.
If no data should be entered, return an empty list.
Return type: List
-
get_kernel_parameters
(kernel_param_name)[source]¶ Get the kernel argument declarations for this kernel data.
Parameters: kernel_param_name (str) – the parameter name for the parameter in the kernel function call Returns: a list of kernel parameter declarations, or an empty list Return type: List[str]
-
get_nmr_kernel_inputs
()[source]¶ Get the number of kernel inputs this input data object has.
Returns: the number of kernel inputs Return type: int
-
get_scalar_arg_dtypes
()[source]¶ Get the numpy data types we should report in the kernel call for scalar elements.
If we are inserting scalars in the kernel we need to provide the CL runtime with the correct data type of the function. If the kernel parameter is not a scalar, we should return None. If the kernel data does not require a kernel input parameter, return an empty list.
This list should match the list of parameters of
get_kernel_parameters()
.Returns: the numpy data type for this element, or None if this is not a scalar. Return type: List[Union[dtype, None]]
-
get_struct_declaration
(name)[source]¶ Get the variable declaration of this data object for use in a Struct.
Parameters: name (str) – the name for this data Returns: the variable declaration of this kernel data object Return type: str
-
get_struct_initialization
(variable_name, kernel_param_name, problem_id_substitute)[source]¶ Initialize the variable inside a struct.
This should initialize the variable for use in a struct (should correspond to
get_struct_declaration()
).Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: the necessary CL code to initialize this variable
Return type: str
-
get_type_definitions
()[source]¶ Get possible type definitions needed to load this data into the kernel.
These types are defined at the head of the CL script, before any functions.
Returns: - a CL compatible type declaration. This can for example be used for defining struct types.
- If no extra types are needed, this function should return the empty string.
Return type: str
-
initialize_variable
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ Initialize the variable inside the kernel function.
This should initialize the variable as such that we can use it when calling the function acting on this data.
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: the necessary CL code to initialize this variable
Return type: str
-
post_function_callback
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ A callback to update or change data after the function has been applied
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: CL code that needs to be run after the function has been applied.
Return type: str
-
set_mot_float_dtype
(mot_float_dtype)[source]¶ Set the numpy data type corresponding to the
mot_float_type
ctype.This is set just prior to using this kernel data in the kernel.
Parameters: mot_float_dtype (dtype) – the numpy data type that is to correspond with the mot_float_type
used in the kernels.
-
class
mot.lib.kernel_data.
KernelData
[source]¶ Bases:
object
-
enqueue_readouts
(queue, buffers, range_start, range_end)[source]¶ Enqueue readouts for this kernel input data object.
This should add non-blocking readouts to the given queue.
Parameters: - queue (opencl queue) – the queue on which to add the unmap buffer command
- buffers (List[pyopencl._cl.Buffer.Buffer]) – the list of buffers corresponding to this kernel data.
These buffers are obtained earlier from the method
get_kernel_inputs()
. - range_start (int) – the start of the range to read out (in the first dimension)
- range_end (int) – the end of the range to read out (in the first dimension)
-
get_data
()[source]¶ Get the underlying data of this kernel data object.
Returns: the underlying data object, can return None if this input data has no actual data. Return type: dict, ndarray, scalar
-
get_function_call_input
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ How this kernel data is used as input to the function that operates on the data.
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: a single string representing how this kernel data is used as input to the function we are applying
Return type: str
-
get_kernel_inputs
(cl_context, workgroup_size)[source]¶ Get the kernel input data matching the list of parameters of
get_kernel_parameters()
.Since the kernels follow the map/unmap paradigm make sure to use the
USE_HOST_PTR
when making writable data objects.Parameters: - cl_context (pyopencl.Context) – the CL context in which we are working.
- workgroup_size (int) – the workgroup size the kernel will use.
Returns: - a list of buffers, local memory objects, scalars, etc., anything that can be loaded into the kernel.
If no data should be entered, return an empty list.
Return type: List
-
get_kernel_parameters
(kernel_param_name)[source]¶ Get the kernel argument declarations for this kernel data.
Parameters: kernel_param_name (str) – the parameter name for the parameter in the kernel function call Returns: a list of kernel parameter declarations, or an empty list Return type: List[str]
-
get_nmr_kernel_inputs
()[source]¶ Get the number of kernel inputs this input data object has.
Returns: the number of kernel inputs Return type: int
-
get_scalar_arg_dtypes
()[source]¶ Get the numpy data types we should report in the kernel call for scalar elements.
If we are inserting scalars in the kernel we need to provide the CL runtime with the correct data type of the function. If the kernel parameter is not a scalar, we should return None. If the kernel data does not require a kernel input parameter, return an empty list.
This list should match the list of parameters of
get_kernel_parameters()
.Returns: the numpy data type for this element, or None if this is not a scalar. Return type: List[Union[dtype, None]]
-
get_struct_declaration
(name)[source]¶ Get the variable declaration of this data object for use in a Struct.
Parameters: name (str) – the name for this data Returns: the variable declaration of this kernel data object Return type: str
-
get_struct_initialization
(variable_name, kernel_param_name, problem_id_substitute)[source]¶ Initialize the variable inside a struct.
This should initialize the variable for use in a struct (should correspond to
get_struct_declaration()
).Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: the necessary CL code to initialize this variable
Return type: str
-
get_type_definitions
()[source]¶ Get possible type definitions needed to load this data into the kernel.
These types are defined at the head of the CL script, before any functions.
Returns: - a CL compatible type declaration. This can for example be used for defining struct types.
- If no extra types are needed, this function should return the empty string.
Return type: str
-
initialize_variable
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ Initialize the variable inside the kernel function.
This should initialize the variable as such that we can use it when calling the function acting on this data.
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: the necessary CL code to initialize this variable
Return type: str
-
post_function_callback
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ A callback to update or change data after the function has been applied
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: CL code that needs to be run after the function has been applied.
Return type: str
-
set_mot_float_dtype
(mot_float_dtype)[source]¶ Set the numpy data type corresponding to the
mot_float_type
ctype.This is set just prior to using this kernel data in the kernel.
Parameters: mot_float_dtype (dtype) – the numpy data type that is to correspond with the mot_float_type
used in the kernels.
-
-
class
mot.lib.kernel_data.
LocalMemory
(ctype, nmr_items=None)[source]¶ Bases:
mot.lib.kernel_data.KernelData
Indicates that a local memory array of the indicated size must be loaded as kernel input data.
By default, this will create a local memory object the size of the local work group.
Parameters: - ctype (str) – the desired c-type for this local memory object, like
int
,float
ormot_float_type
. - nmr_items (int or Callable[[int], int]) – either the size directly or a function that can calculate the required local memory size given the work group size. This will independently be multiplied with the item size of the ctype for the final size in bytes.
-
enqueue_readouts
(queue, buffers, range_start, range_end)[source]¶ Enqueue readouts for this kernel input data object.
This should add non-blocking readouts to the given queue.
Parameters: - queue (opencl queue) – the queue on which to add the unmap buffer command
- buffers (List[pyopencl._cl.Buffer.Buffer]) – the list of buffers corresponding to this kernel data.
These buffers are obtained earlier from the method
get_kernel_inputs()
. - range_start (int) – the start of the range to read out (in the first dimension)
- range_end (int) – the end of the range to read out (in the first dimension)
-
get_data
()[source]¶ Get the underlying data of this kernel data object.
Returns: the underlying data object, can return None if this input data has no actual data. Return type: dict, ndarray, scalar
-
get_function_call_input
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ How this kernel data is used as input to the function that operates on the data.
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: a single string representing how this kernel data is used as input to the function we are applying
Return type: str
-
get_kernel_inputs
(cl_context, workgroup_size)[source]¶ Get the kernel input data matching the list of parameters of
get_kernel_parameters()
.Since the kernels follow the map/unmap paradigm make sure to use the
USE_HOST_PTR
when making writable data objects.Parameters: - cl_context (pyopencl.Context) – the CL context in which we are working.
- workgroup_size (int) – the workgroup size the kernel will use.
Returns: - a list of buffers, local memory objects, scalars, etc., anything that can be loaded into the kernel.
If no data should be entered, return an empty list.
Return type: List
-
get_kernel_parameters
(kernel_param_name)[source]¶ Get the kernel argument declarations for this kernel data.
Parameters: kernel_param_name (str) – the parameter name for the parameter in the kernel function call Returns: a list of kernel parameter declarations, or an empty list Return type: List[str]
-
get_nmr_kernel_inputs
()[source]¶ Get the number of kernel inputs this input data object has.
Returns: the number of kernel inputs Return type: int
-
get_scalar_arg_dtypes
()[source]¶ Get the numpy data types we should report in the kernel call for scalar elements.
If we are inserting scalars in the kernel we need to provide the CL runtime with the correct data type of the function. If the kernel parameter is not a scalar, we should return None. If the kernel data does not require a kernel input parameter, return an empty list.
This list should match the list of parameters of
get_kernel_parameters()
.Returns: the numpy data type for this element, or None if this is not a scalar. Return type: List[Union[dtype, None]]
-
get_struct_declaration
(name)[source]¶ Get the variable declaration of this data object for use in a Struct.
Parameters: name (str) – the name for this data Returns: the variable declaration of this kernel data object Return type: str
-
get_struct_initialization
(variable_name, kernel_param_name, problem_id_substitute)[source]¶ Initialize the variable inside a struct.
This should initialize the variable for use in a struct (should correspond to
get_struct_declaration()
).Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: the necessary CL code to initialize this variable
Return type: str
-
get_type_definitions
()[source]¶ Get possible type definitions needed to load this data into the kernel.
These types are defined at the head of the CL script, before any functions.
Returns: - a CL compatible type declaration. This can for example be used for defining struct types.
- If no extra types are needed, this function should return the empty string.
Return type: str
-
initialize_variable
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ Initialize the variable inside the kernel function.
This should initialize the variable as such that we can use it when calling the function acting on this data.
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: the necessary CL code to initialize this variable
Return type: str
-
post_function_callback
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ A callback to update or change data after the function has been applied
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: CL code that needs to be run after the function has been applied.
Return type: str
-
set_mot_float_dtype
(mot_float_dtype)[source]¶ Set the numpy data type corresponding to the
mot_float_type
ctype.This is set just prior to using this kernel data in the kernel.
Parameters: mot_float_dtype (dtype) – the numpy data type that is to correspond with the mot_float_type
used in the kernels.
- ctype (str) – the desired c-type for this local memory object, like
-
class
mot.lib.kernel_data.
PrivateMemory
(nmr_items, ctype)[source]¶ Bases:
mot.lib.kernel_data.KernelData
Adds a private memory array of the indicated size to the kernel data elements.
This is useful if you want to have private memory arrays in kernel data structs.
Parameters: - nmr_items (int) – the size of the private memory array
- ctype (str) – the desired c-type for this local memory object, like
int
,float
ormot_float_type
.
-
enqueue_readouts
(queue, buffers, range_start, range_end)[source]¶ Enqueue readouts for this kernel input data object.
This should add non-blocking readouts to the given queue.
Parameters: - queue (opencl queue) – the queue on which to add the unmap buffer command
- buffers (List[pyopencl._cl.Buffer.Buffer]) – the list of buffers corresponding to this kernel data.
These buffers are obtained earlier from the method
get_kernel_inputs()
. - range_start (int) – the start of the range to read out (in the first dimension)
- range_end (int) – the end of the range to read out (in the first dimension)
-
get_data
()[source]¶ Get the underlying data of this kernel data object.
Returns: the underlying data object, can return None if this input data has no actual data. Return type: dict, ndarray, scalar
-
get_function_call_input
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ How this kernel data is used as input to the function that operates on the data.
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: a single string representing how this kernel data is used as input to the function we are applying
Return type: str
-
get_kernel_inputs
(cl_context, workgroup_size)[source]¶ Get the kernel input data matching the list of parameters of
get_kernel_parameters()
.Since the kernels follow the map/unmap paradigm make sure to use the
USE_HOST_PTR
when making writable data objects.Parameters: - cl_context (pyopencl.Context) – the CL context in which we are working.
- workgroup_size (int) – the workgroup size the kernel will use.
Returns: - a list of buffers, local memory objects, scalars, etc., anything that can be loaded into the kernel.
If no data should be entered, return an empty list.
Return type: List
-
get_kernel_parameters
(kernel_param_name)[source]¶ Get the kernel argument declarations for this kernel data.
Parameters: kernel_param_name (str) – the parameter name for the parameter in the kernel function call Returns: a list of kernel parameter declarations, or an empty list Return type: List[str]
-
get_nmr_kernel_inputs
()[source]¶ Get the number of kernel inputs this input data object has.
Returns: the number of kernel inputs Return type: int
-
get_scalar_arg_dtypes
()[source]¶ Get the numpy data types we should report in the kernel call for scalar elements.
If we are inserting scalars in the kernel we need to provide the CL runtime with the correct data type of the function. If the kernel parameter is not a scalar, we should return None. If the kernel data does not require a kernel input parameter, return an empty list.
This list should match the list of parameters of
get_kernel_parameters()
.Returns: the numpy data type for this element, or None if this is not a scalar. Return type: List[Union[dtype, None]]
-
get_struct_declaration
(name)[source]¶ Get the variable declaration of this data object for use in a Struct.
Parameters: name (str) – the name for this data Returns: the variable declaration of this kernel data object Return type: str
-
get_struct_initialization
(variable_name, kernel_param_name, problem_id_substitute)[source]¶ Initialize the variable inside a struct.
This should initialize the variable for use in a struct (should correspond to
get_struct_declaration()
).Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: the necessary CL code to initialize this variable
Return type: str
-
get_type_definitions
()[source]¶ Get possible type definitions needed to load this data into the kernel.
These types are defined at the head of the CL script, before any functions.
Returns: - a CL compatible type declaration. This can for example be used for defining struct types.
- If no extra types are needed, this function should return the empty string.
Return type: str
-
initialize_variable
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ Initialize the variable inside the kernel function.
This should initialize the variable as such that we can use it when calling the function acting on this data.
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: the necessary CL code to initialize this variable
Return type: str
-
post_function_callback
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ A callback to update or change data after the function has been applied
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: CL code that needs to be run after the function has been applied.
Return type: str
-
set_mot_float_dtype
(mot_float_dtype)[source]¶ Set the numpy data type corresponding to the
mot_float_type
ctype.This is set just prior to using this kernel data in the kernel.
Parameters: mot_float_dtype (dtype) – the numpy data type that is to correspond with the mot_float_type
used in the kernels.
-
class
mot.lib.kernel_data.
Scalar
(value, ctype=None)[source]¶ Bases:
mot.lib.kernel_data.KernelData
A kernel input scalar.
This will insert the given value directly into the kernel’s source code, and will not load it as a buffer.
Parameters: - value (number) – the number to insert into the kernel as a scalar.
- ctype (str) – the desired c-type for in use in the kernel, like
int
,float
ormot_float_type
. If None it is implied from the value.
-
enqueue_readouts
(queue, buffers, range_start, range_end)[source]¶ Enqueue readouts for this kernel input data object.
This should add non-blocking readouts to the given queue.
Parameters: - queue (opencl queue) – the queue on which to add the unmap buffer command
- buffers (List[pyopencl._cl.Buffer.Buffer]) – the list of buffers corresponding to this kernel data.
These buffers are obtained earlier from the method
get_kernel_inputs()
. - range_start (int) – the start of the range to read out (in the first dimension)
- range_end (int) – the end of the range to read out (in the first dimension)
-
get_data
()[source]¶ Get the underlying data of this kernel data object.
Returns: the underlying data object, can return None if this input data has no actual data. Return type: dict, ndarray, scalar
-
get_function_call_input
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ How this kernel data is used as input to the function that operates on the data.
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: a single string representing how this kernel data is used as input to the function we are applying
Return type: str
-
get_kernel_inputs
(cl_context, workgroup_size)[source]¶ Get the kernel input data matching the list of parameters of
get_kernel_parameters()
.Since the kernels follow the map/unmap paradigm make sure to use the
USE_HOST_PTR
when making writable data objects.Parameters: - cl_context (pyopencl.Context) – the CL context in which we are working.
- workgroup_size (int) – the workgroup size the kernel will use.
Returns: - a list of buffers, local memory objects, scalars, etc., anything that can be loaded into the kernel.
If no data should be entered, return an empty list.
Return type: List
-
get_kernel_parameters
(kernel_param_name)[source]¶ Get the kernel argument declarations for this kernel data.
Parameters: kernel_param_name (str) – the parameter name for the parameter in the kernel function call Returns: a list of kernel parameter declarations, or an empty list Return type: List[str]
-
get_nmr_kernel_inputs
()[source]¶ Get the number of kernel inputs this input data object has.
Returns: the number of kernel inputs Return type: int
-
get_scalar_arg_dtypes
()[source]¶ Get the numpy data types we should report in the kernel call for scalar elements.
If we are inserting scalars in the kernel we need to provide the CL runtime with the correct data type of the function. If the kernel parameter is not a scalar, we should return None. If the kernel data does not require a kernel input parameter, return an empty list.
This list should match the list of parameters of
get_kernel_parameters()
.Returns: the numpy data type for this element, or None if this is not a scalar. Return type: List[Union[dtype, None]]
-
get_struct_declaration
(name)[source]¶ Get the variable declaration of this data object for use in a Struct.
Parameters: name (str) – the name for this data Returns: the variable declaration of this kernel data object Return type: str
-
get_struct_initialization
(variable_name, kernel_param_name, problem_id_substitute)[source]¶ Initialize the variable inside a struct.
This should initialize the variable for use in a struct (should correspond to
get_struct_declaration()
).Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: the necessary CL code to initialize this variable
Return type: str
-
get_type_definitions
()[source]¶ Get possible type definitions needed to load this data into the kernel.
These types are defined at the head of the CL script, before any functions.
Returns: - a CL compatible type declaration. This can for example be used for defining struct types.
- If no extra types are needed, this function should return the empty string.
Return type: str
-
initialize_variable
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ Initialize the variable inside the kernel function.
This should initialize the variable as such that we can use it when calling the function acting on this data.
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: the necessary CL code to initialize this variable
Return type: str
-
post_function_callback
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ A callback to update or change data after the function has been applied
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: CL code that needs to be run after the function has been applied.
Return type: str
-
set_mot_float_dtype
(mot_float_dtype)[source]¶ Set the numpy data type corresponding to the
mot_float_type
ctype.This is set just prior to using this kernel data in the kernel.
Parameters: mot_float_dtype (dtype) – the numpy data type that is to correspond with the mot_float_type
used in the kernels.
-
class
mot.lib.kernel_data.
Struct
(elements, ctype, anonymous=False)[source]¶ Bases:
mot.lib.kernel_data.KernelData
A kernel data element for structs.
Please be aware that structs will always be passed as a pointer to the calling function.
Parameters: - elements (Dict[str, Union[Dict, KernelData]]) – the kernel data elements to load into the kernel Can be a nested dictionary, in which case we load the nested elements as anonymous structs. Alternatively, you can nest Structs in Structs, yielding named structs.
- ctype (str) – the name of this structure
- anonymous (boolean) – if this struct is to be loaded anonymously, this is only meant for nested Structs.
-
enqueue_readouts
(queue, buffers, range_start, range_end)[source]¶ Enqueue readouts for this kernel input data object.
This should add non-blocking readouts to the given queue.
Parameters: - queue (opencl queue) – the queue on which to add the unmap buffer command
- buffers (List[pyopencl._cl.Buffer.Buffer]) – the list of buffers corresponding to this kernel data.
These buffers are obtained earlier from the method
get_kernel_inputs()
. - range_start (int) – the start of the range to read out (in the first dimension)
- range_end (int) – the end of the range to read out (in the first dimension)
-
get_data
()[source]¶ Get the underlying data of this kernel data object.
Returns: the underlying data object, can return None if this input data has no actual data. Return type: dict, ndarray, scalar
-
get_function_call_input
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ How this kernel data is used as input to the function that operates on the data.
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: a single string representing how this kernel data is used as input to the function we are applying
Return type: str
-
get_kernel_inputs
(cl_context, workgroup_size)[source]¶ Get the kernel input data matching the list of parameters of
get_kernel_parameters()
.Since the kernels follow the map/unmap paradigm make sure to use the
USE_HOST_PTR
when making writable data objects.Parameters: - cl_context (pyopencl.Context) – the CL context in which we are working.
- workgroup_size (int) – the workgroup size the kernel will use.
Returns: - a list of buffers, local memory objects, scalars, etc., anything that can be loaded into the kernel.
If no data should be entered, return an empty list.
Return type: List
-
get_kernel_parameters
(kernel_param_name)[source]¶ Get the kernel argument declarations for this kernel data.
Parameters: kernel_param_name (str) – the parameter name for the parameter in the kernel function call Returns: a list of kernel parameter declarations, or an empty list Return type: List[str]
-
get_nmr_kernel_inputs
()[source]¶ Get the number of kernel inputs this input data object has.
Returns: the number of kernel inputs Return type: int
-
get_scalar_arg_dtypes
()[source]¶ Get the numpy data types we should report in the kernel call for scalar elements.
If we are inserting scalars in the kernel we need to provide the CL runtime with the correct data type of the function. If the kernel parameter is not a scalar, we should return None. If the kernel data does not require a kernel input parameter, return an empty list.
This list should match the list of parameters of
get_kernel_parameters()
.Returns: the numpy data type for this element, or None if this is not a scalar. Return type: List[Union[dtype, None]]
-
get_struct_declaration
(name)[source]¶ Get the variable declaration of this data object for use in a Struct.
Parameters: name (str) – the name for this data Returns: the variable declaration of this kernel data object Return type: str
-
get_struct_initialization
(variable_name, kernel_param_name, problem_id_substitute)[source]¶ Initialize the variable inside a struct.
This should initialize the variable for use in a struct (should correspond to
get_struct_declaration()
).Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: the necessary CL code to initialize this variable
Return type: str
-
get_type_definitions
()[source]¶ Get possible type definitions needed to load this data into the kernel.
These types are defined at the head of the CL script, before any functions.
Returns: - a CL compatible type declaration. This can for example be used for defining struct types.
- If no extra types are needed, this function should return the empty string.
Return type: str
-
initialize_variable
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ Initialize the variable inside the kernel function.
This should initialize the variable as such that we can use it when calling the function acting on this data.
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: the necessary CL code to initialize this variable
Return type: str
-
post_function_callback
(variable_name, kernel_param_name, problem_id_substitute, address_space)[source]¶ A callback to update or change data after the function has been applied
Parameters: - variable_name (str) – the name for this variable
- kernel_param_name (str) – the kernel parameter name (given in
get_kernel_parameters()
). - problem_id_substitute (str) – the substitute for the
{problem_id}
in the kernel data info elements. - address_space (str) – the desired address space for this variable, defined by the parameter of the called function.
Returns: CL code that needs to be run after the function has been applied.
Return type: str
-
set_mot_float_dtype
(mot_float_dtype)[source]¶ Set the numpy data type corresponding to the
mot_float_type
ctype.This is set just prior to using this kernel data in the kernel.
Parameters: mot_float_dtype (dtype) – the numpy data type that is to correspond with the mot_float_type
used in the kernels.
-
class
mot.lib.kernel_data.
Zeros
(shape, ctype, offset_str=None, mode='w')[source]¶ Bases:
mot.lib.kernel_data.Array
Allocate an output buffer of the given shape.
This is meant to quickly allocate a buffer large enough to hold the data requested. After running an OpenCL kernel you can get the written data using the method
get_data()
.Parameters: - shape (int or tuple) – the shape of the output array
- offset_str (str) – the offset definition, can use
{problem_id}
for multiplication purposes. Set to 0 for no offset. - mode (str) – one of ‘r’, ‘w’ or ‘rw’, for respectively read, write or read and write. This sets the mode of how the data is loaded into the compute device’s memory.
mot.lib.load_balance_strategies module¶
mot.lib.utils module¶
-
mot.lib.utils.
add_include_guards
(cl_str, guard_name=None)[source]¶ Add include guards to the given string.
If you are including the same body of CL code multiple times in a Kernel, it is important to add include guards (https://en.wikipedia.org/wiki/Include_guard) around them to prevent the kernel from registering the function twice.
Parameters: - cl_str (str) – the piece of CL code as a string to which we add the include guards
- guard_name (str) – the name of the C pre-processor guard. If not given we use the MD5 hash of the given cl string.
Returns: the same string but then with include guards around them.
Return type: str
-
mot.lib.utils.
all_elements_equal
(value)[source]¶ Checks if all elements in the given value are equal to each other.
If the input is a single value the result is trivial. If not, we compare all the values to see if they are exactly the same.
Parameters: value (ndarray or number) – a numpy array or a single number. Returns: true if all elements are equal to each other, false otherwise Return type: bool
-
mot.lib.utils.
all_logging_disabled
(highest_level=50)[source]¶ Disable all logging temporarily.
A context manager that will prevent any logging messages triggered during the body from being processed.
Parameters: highest_level – the maximum logging level that is being blocked
-
mot.lib.utils.
cartesian
(arrays, out=None)[source]¶ Generate a cartesian product of input arrays.
Parameters: - arrays (list of array-like) – 1-D arrays to form the cartesian product of.
- out (ndarray) – Array to place the cartesian product in.
Returns: 2-D array of shape (M, len(arrays)) containing cartesian products formed of input arrays.
Return type: ndarray
Examples
>>> cartesian(([1, 2, 3], [4, 5], [6, 7])) array([[1, 4, 6], [1, 4, 7], [1, 5, 6], [1, 5, 7], [2, 4, 6], [2, 4, 7], [2, 5, 6], [2, 5, 7], [3, 4, 6], [3, 4, 7], [3, 5, 6], [3, 5, 7]])
-
mot.lib.utils.
convert_data_to_dtype
(data, data_type, mot_float_type='float')[source]¶ Convert the given input data to the correct numpy type.
Parameters: - data (ndarray) – The value to convert to the correct numpy type
- data_type (str) – the data type we need to convert the data to
- mot_float_type (str) – the data type of the current
mot_float_type
Returns: the input data but then converted to the desired numpy data type
Return type: ndarray
-
mot.lib.utils.
covariance_to_correlations
(covariance)[source]¶ Transform a covariance matrix into a correlations matrix.
This can be seen as dividing a covariance matrix by the outer product of the diagonal.
As post processing we replace the infinities and the NaNs with zeros and clip the result to [-1, 1].
Parameters: covariance (ndarray) – a matrix of shape (n, p, p) with for n problems the covariance matrix of shape (p, p). Returns: the correlations matrix Return type: ndarray
-
mot.lib.utils.
ctype_to_dtype
(cl_type, mot_float_type='float')[source]¶ Get the numpy dtype of the given cl_type string.
Parameters: - cl_type (str) – the CL data type to match, for example ‘float’ or ‘float4’.
- mot_float_type (str) – the C name of the
mot_float_type
. The dtype will be looked up recursively.
Returns: the numpy datatype
Return type: dtype
-
mot.lib.utils.
device_supports_double
(cl_device)[source]¶ Check if the given CL device supports double
Parameters: cl_device (pyopencl cl device) – The device to check if it supports double. Returns: True if the given cl_device supports double, false otherwise. Return type: boolean
-
mot.lib.utils.
device_type_from_string
(cl_device_type_str)[source]¶ Converts values like
gpu
to a pyopencl device type string.Supported values are:
accelerator
,cpu
,custom
,gpu
. Ifall
is given, None is returned.Parameters: cl_device_type_str (str) – The string we want to convert to a device type. Returns: the pyopencl device type. Return type: cl.device_type
-
mot.lib.utils.
dtype_to_ctype
(dtype)[source]¶ Get the CL type of the given numpy data type.
Parameters: dtype (np.dtype) – the numpy data type Returns: the CL type string for the corresponding type Return type: str
-
mot.lib.utils.
get_float_type_def
(double_precision, include_complex=True)[source]¶ Get the model floating point type definition.
Parameters: - double_precision (boolean) – if True we will use the double type for the mot_float_type type. Else, we will use the single precision float type for the mot_float_type type.
- include_complex (boolean) – if we include support for complex numbers
Returns: defines the mot_float_type types, the epsilon and the MIN and MAX values.
Return type: str
-
mot.lib.utils.
get_single_value
(value)[source]¶ Get a single value out of the given value.
This is meant to be used after a call to
all_elements_equal()
that returned True. With this function we return a single number from the input value.Parameters: value (ndarray or number) – a numpy array or a single number. Returns: a single number from the input Return type: number Raises: ValueError
– if not all elements are equal
-
mot.lib.utils.
hessian_to_covariance
(hessian, output_singularity=False)[source]¶ Calculate a covariance matrix from a Hessian by inverting the Hessian.
Mathematically we can calculate the covariance matrix from the Hessian (the Hessian at the Maximum Likelihood Estimator), by a simple matrix inversion. However, round-off errors can make the Hessian singular, making an exact inverse impossible. This method uses an exact inverse if possible with a fall back on a pseudo inverse. If also the pseudo inverse fails, this function returns zeros as covariance for that Hessian.
Important: Before the matrix inversion it will set NaN’s to 0. After the inversion we make the diagonal (representing the variances of each parameter) positive where needed by taking the absolute.
Parameters: - hessian (ndarray) – a matrix of shape (n, p, p) where for n problems we have a matrix of shape (p, p) for p parameters and we take the inverse for every (p, p) matrix.
- output_singularity (boolean) – if set to True, we additionally output a boolean matrix with the location of singular Hessians.
Returns: - if
output_singularity
is set to False, only output the inverse of the Hessians as the covariance matrix. If
output_singularity
is set to True this function returns a tuple with: (covariance_matrix
,is_singular
).
Return type: ndarray or tuple
-
mot.lib.utils.
is_scalar
(value)[source]¶ Test if the given value is a scalar.
This function also works with memory mapped array values, in contrast to the numpy is_scalar method.
Parameters: value – the value to test for being a scalar value Returns: if the given value is a scalar or not Return type: boolean
-
mot.lib.utils.
is_vector_ctype
(ctype)[source]¶ Test if the given ctype is a vector type. That is, if it ends with 2, 3, 4, 8 or 16.
Parameters: ctype (str) – the ctype to test if it is an OpenCL vector type Returns: if it is a vector type or not Return type: bool
-
mot.lib.utils.
multiprocess_mapping
(func, iterable)[source]¶ Multiprocess mapping the given function on the given iterable.
This only works in Linux and Mac systems since Windows has no forking capability. On Windows we fall back on single processing. Also, if we reach memory limits we fall back on single cpu processing.
Parameters: - func (func) – the function to apply
- iterable (iterable) – the iterable with the elements we want to apply the function on
-
mot.lib.utils.
parse_cl_function
(cl_code, dependencies=())[source]¶ Parse the given OpenCL string to a single SimpleCLFunction.
If the string contains more than one function, we will return only the last, with all the other added as a dependency.
Parameters: - cl_code (str) – the input string containing one or more functions.
- dependencies (Iterable[CLCodeObject]) – The list of CL libraries this function depends on
Returns: the CL function for the last function in the given strings.
Return type:
-
mot.lib.utils.
split_cl_function
(cl_str)[source]¶ Split an CL function into a return type, function name, parameters list and the body.
Parameters: cl_str (str) – the CL code to parse and plit into components Returns: string elements for the return type, function name, parameter list and the body Return type: tuple
-
mot.lib.utils.
split_in_batches
(nmr_elements, max_batch_size)[source]¶ Split the total number of elements into batches of the specified maximum size.
- Examples::
split_in_batches(30, 8) -> [(0, 8), (8, 15), (16, 23), (24, 29)]
- for batch_start, batch_end in split_in_batches(2000, 100):
- array[batch_start:batch_end]
Yields: tuple – the start and end point of the next batch
-
mot.lib.utils.
split_vector_ctype
(ctype)[source]¶ Split a vector ctype into a raw ctype and the vector length.
If the given ctype is not a vector type, we raise an error. I
Parameters: ctype (str) – the ctype to possibly split into a raw ctype and the vector length Returns: the raw ctype and the vector length Return type: tuple