def _build_plan(self, plan_factory, _device_params, *args):
plan = plan_factory()
# Using root_parameters to avoid duplicated names
# (can happen if this computation is nested and
# the same arrays are passed to it as arguments)
arglist = ", ".join(self._root_parameters)
idxs = Indices(self._guiding_shape)
template = helpers.template_def(
['kernel_declaration'] + self._root_parameters,
"""
${kernel_declaration}
{
VIRTUAL_SKIP_THREADS;
%for i, idx in enumerate(idxs):
VSIZE_T ${idx} = virtual_global_id(${i});
%endfor
${snippet(idxs, """ + arglist + """)}
}
""")
plan.kernel_call(
template, args,
kernel_name="kernel_pure_parallel",
global_size=(1,) if len(self._guiding_shape) == 0 else self._guiding_shape,
render_kwds=dict(
idxs=idxs,
product=helpers.product,
snippet=self._snippet))
return plan
def __init__(self, parameters, code, render_kwds=None, connectors=None):
for param in parameters:
if param.annotation.input and param.annotation.output:
raise ValueError(
"Transformation cannot have 'io' parameters ('" +
param.name + "')")
self.signature = Signature(parameters)
for param in self.signature.parameters.values():
setattr(
self, param.name,
TransformationParameter(self, param.name,
param.annotation.type))
if connectors is not None:
self.connectors = connectors
else:
self.connectors = [
param.name for param in parameters if param.annotation.array
]
tr_param_names = ['idxs'] + [
param.name for param in self.signature.parameters.values()
]
self.snippet = Snippet(template_def(tr_param_names, code),
render_kwds=render_kwds)
def _build_plan(self, plan_factory, _device_params, *args):
plan = plan_factory()
# Using root_parameters to avoid duplicated names
# (can happen if this computation is nested and
# the same arrays are passed to it as arguments)
arglist = ", ".join(self._root_parameters)
idxs = Indices(self._guiding_shape)
template = helpers.template_def(['kernel_declaration'] +
self._root_parameters, """
${kernel_declaration}
{
VIRTUAL_SKIP_THREADS;
%for i, idx in enumerate(idxs):
VSIZE_T ${idx} = virtual_global_id(${i});
%endfor
${snippet(idxs, """ + arglist + """)}
}
""")
plan.kernel_call(template,
args,
kernel_name="kernel_pure_parallel",
global_size=(1, ) if len(self._guiding_shape) == 0
else self._guiding_shape,
render_kwds=dict(idxs=idxs,
product=helpers.product,
snippet=self._snippet))
return plan
def create(cls, func_or_str, render_kwds=None):
"""
Creates a snippet from the ``Mako`` def:
* if ``func_or_str`` is a function, then the def has the same signature as ``func_or_str``,
and the body equal to the string it returns;
* if ``func_or_str`` is a string, then the def has empty signature.
"""
signature, code = extract_signature_and_value(func_or_str)
return cls(template_def(signature, code), render_kwds=render_kwds)
def create(cls, func_or_str, render_kwds=None):
"""
Creates a snippet from the ``Mako`` def:
* if ``func_or_str`` is a function, then the def has the same signature as ``func_or_str``,
and the body equal to the string it returns;
* if ``func_or_str`` is a string, then the def has empty signature.
"""
signature, code = extract_signature_and_value(func_or_str)
return cls(template_def(signature, code), render_kwds=render_kwds)
def create(cls, func_or_str, render_kwds=None):
"""
Creates a module from the ``Mako`` def:
* if ``func_or_str`` is a function, then the def has the same signature as ``func_or_str``
(prefix will be passed as the first positional parameter),
and the body equal to the string it returns;
* if ``func_or_str`` is a string, then the def has a single positional argument ``prefix``.
and the body ``code``.
"""
signature, code = extract_signature_and_value(func_or_str, default_parameters=["prefix"])
return cls(template_def(signature, code), render_kwds=render_kwds)
def create(cls, func_or_str, render_kwds=None):
"""
Creates a module from the ``Mako`` def:
* if ``func_or_str`` is a function, then the def has the same signature as ``func_or_str``
(prefix will be passed as the first positional parameter),
and the body equal to the string it returns;
* if ``func_or_str`` is a string, then the def has a single positional argument ``prefix``.
and the body ``code``.
"""
signature, code = extract_signature_and_value(
func_or_str, default_parameters=['prefix'])
return cls(template_def(signature, code), render_kwds=render_kwds)
def __init__(self, parameters, code, guiding_array=None, render_kwds=None):
Computation.__init__(self, parameters)
self._root_parameters = list(self.signature.parameters.keys())
if isinstance(code, Snippet):
self._snippet = code
else:
self._snippet = Snippet(helpers.template_def(
['idxs'] + self._root_parameters, code), render_kwds=render_kwds)
if guiding_array is None:
guiding_array = self._root_parameters[0]
if isinstance(guiding_array, str):
self._guiding_shape = self.signature.parameters[guiding_array].annotation.type.shape
else:
self._guiding_shape = guiding_array
def __init__(self, parameters, code, guiding_array=None, render_kwds=None):
Computation.__init__(self, parameters)
self._root_parameters = list(self.signature.parameters.keys())
if isinstance(code, Snippet):
self._snippet = code
else:
self._snippet = Snippet(helpers.template_def(
['idxs'] + self._root_parameters, code),
render_kwds=render_kwds)
if guiding_array is None:
guiding_array = self._root_parameters[0]
if isinstance(guiding_array, str):
self._guiding_shape = self.signature.parameters[
guiding_array].annotation.type.shape
else:
self._guiding_shape = guiding_array
def __init__(self, parameters, code, render_kwds=None, connectors=None):
for param in parameters:
if param.annotation.input and param.annotation.output:
raise ValueError(
"Transformation cannot have 'io' parameters ('" + param.name + "')")
self.signature = Signature(parameters)
for param in self.signature.parameters.values():
setattr(
self, param.name,
TransformationParameter(self, param.name, param.annotation.type))
if connectors is not None:
self.connectors = connectors
else:
self.connectors = [param.name for param in parameters if param.annotation.array]
tr_param_names = ['idxs'] + [param.name for param in self.signature.parameters.values()]
self.snippet = Snippet(template_def(tr_param_names, code), render_kwds=render_kwds)
ctype = param.annotation.type.ctype
if param.annotation.array:
qualifier = ("CONSTANT_MEM" if param.annotation.constant else "GLOBAL_MEM")
return qualifier + " " + str(ctype) + " *" + name
else:
return str(ctype) + " " + name
else:
return name
def param_cnames_seq(parameters, qualified=False):
return [param_cname(p, qualified=qualified) for p in parameters]
_snippet_kernel_declaration = helpers.template_def(
[],
"KERNEL void ${kernel_name}(${', '.join(param_cnames_seq(parameters, qualified=True))})")
def kernel_declaration(kernel_name, parameters):
return Snippet(
_snippet_kernel_declaration,
render_kwds=dict(
param_cnames_seq=param_cnames_seq,
kernel_name=kernel_name,
parameters=parameters))
def node_connector(output):
if output:
return VALUE_NAME
else:
if qualified:
ctype = param.annotation.type.ctype
if param.annotation.array:
return "GLOBAL_MEM " + str(ctype) + " *" + name
else:
return str(ctype) + " " + name
else:
return name
def param_cnames_seq(parameters, qualified=False):
return [param_cname(p, qualified=qualified) for p in parameters]
_snippet_kernel_declaration = helpers.template_def(
[],
"KERNEL void ${kernel_name}(${', '.join(param_cnames_seq(parameters, qualified=True))})"
)
def kernel_declaration(kernel_name, parameters):
return Snippet(_snippet_kernel_declaration,
render_kwds=dict(param_cnames_seq=param_cnames_seq,
kernel_name=kernel_name,
parameters=parameters))
def node_connector(output):
if output:
return VALUE_NAME
else:
return VALUE_NAME + " ="
