def __call__(self, kernel, codegen_result):
"""
Generates the wrapping python invoker for this execution target
:arg kernel: the loopy :class:`LoopKernel`(s) to be executued
:codegen_result: the loopy :class:`CodeGenerationResult` created
by code generation
:returns: A python callable that handles execution of this
kernel
"""
options = kernel.options
implemented_data_info = codegen_result.implemented_data_info
from loopy.kernel.data import KernelArgument
gen = PythonFunctionGenerator(
"invoke_%s_loopy_kernel" % kernel.name, self.system_args + [
"%s=None" % idi.name for idi in implemented_data_info
if issubclass(idi.arg_class, KernelArgument)
])
gen.add_to_preamble("from __future__ import division")
gen.add_to_preamble("")
self.target_specific_preamble(gen)
gen.add_to_preamble("")
self.generate_host_code(gen, codegen_result)
gen.add_to_preamble("")
self.initialize_system_args(gen)
self.generate_integer_arg_finding_from_shapes(gen, kernel,
implemented_data_info)
self.generate_integer_arg_finding_from_offsets(gen, kernel,
implemented_data_info)
self.generate_integer_arg_finding_from_strides(gen, kernel,
implemented_data_info)
self.generate_value_arg_check(gen, kernel, implemented_data_info)
args = self.generate_arg_setup(gen, kernel, implemented_data_info,
options)
self.generate_invocation(gen, codegen_result.host_program.name, args,
kernel, implemented_data_info)
self.generate_output_handler(gen, options, kernel,
implemented_data_info)
if options.write_wrapper:
output = gen.get()
if options.highlight_wrapper:
output = get_highlighted_python_code(output)
if options.write_wrapper is True:
print(output)
else:
with open(options.write_wrapper, "w") as outf:
outf.write(output)
return gen.get_picklable_function()
def generate_invoker(kernel, cl_kernel, impl_arg_info, options):
system_args = [
"cl_kernel", "queue", "allocator=None", "wait_for=None",
# ignored if options.no_numpy
"out_host=None"
]
gen = PythonFunctionGenerator(
"invoke_%s_loopy_kernel" % kernel.name,
system_args + ["%s=None" % iai.name for iai in impl_arg_info])
gen.add_to_preamble("from __future__ import division")
gen.add_to_preamble("")
gen.add_to_preamble("import pyopencl as _lpy_cl")
gen.add_to_preamble("import pyopencl.array as _lpy_cl_array")
gen.add_to_preamble("import pyopencl.tools as _lpy_cl_tools")
gen.add_to_preamble("import numpy as _lpy_np")
gen.add_to_preamble("from struct import pack as _lpy_pack")
gen.add_to_preamble("")
gen("if allocator is None:")
with Indentation(gen):
gen("allocator = _lpy_cl_tools.DeferredAllocator(queue.context)")
gen("")
generate_integer_arg_finding_from_shapes(gen, kernel, impl_arg_info, options)
generate_integer_arg_finding_from_offsets(gen, kernel, impl_arg_info, options)
generate_integer_arg_finding_from_strides(gen, kernel, impl_arg_info, options)
arg_idx_to_cl_arg_idx = \
generate_value_arg_setup(gen, kernel, cl_kernel, impl_arg_info, options)
generate_array_arg_setup(gen, kernel, impl_arg_info, options,
arg_idx_to_cl_arg_idx)
# {{{ generate invocation
from loopy.symbolic import StringifyMapper
strify = StringifyMapper()
gsize_expr, lsize_expr = kernel.get_grid_sizes_as_exprs()
if not gsize_expr:
gsize_expr = (1,)
if not lsize_expr:
lsize_expr = (1,)
def strify_tuple(t):
return "(%s,)" % (
", ".join("int(%s)" % strify(t_i) for t_i in t))
gen("_lpy_evt = _lpy_cl.enqueue_nd_range_kernel(queue, cl_kernel, "
"%(gsize)s, %(lsize)s, wait_for=wait_for, g_times_l=True)"
% dict(
gsize=strify_tuple(gsize_expr),
lsize=strify_tuple(lsize_expr)))
gen("")
# }}}
# {{{ output
if not options.no_numpy:
gen("if out_host is None and (_lpy_encountered_numpy "
"and not _lpy_encountered_dev):")
with Indentation(gen):
gen("out_host = True")
gen("if out_host:")
with Indentation(gen):
gen("pass") # if no outputs (?!)
for arg_idx, arg in enumerate(impl_arg_info):
is_written = arg.base_name in kernel.get_written_variables()
if is_written:
gen("%s = %s.get(queue=queue)" % (arg.name, arg.name))
gen("")
if options.return_dict:
gen("return _lpy_evt, {%s}"
% ", ".join("\"%s\": %s" % (arg.name, arg.name)
for arg in impl_arg_info
if arg.base_name in kernel.get_written_variables()))
else:
out_args = [arg
for arg in impl_arg_info
if arg.base_name in kernel.get_written_variables()]
if out_args:
gen("return _lpy_evt, (%s,)"
% ", ".join(arg.name for arg in out_args))
else:
gen("return _lpy_evt, ()")
# }}}
if options.write_wrapper:
output = gen.get()
if options.highlight_wrapper:
output = get_highlighted_python_code(output)
if options.write_wrapper is True:
print(output)
else:
with open(options.write_wrapper, "w") as outf:
outf.write(output)
return gen.get_function()
def generate_invoker(kernel, codegen_result):
options = kernel.options
implemented_data_info = codegen_result.implemented_data_info
host_code = codegen_result.host_code()
system_args = [
"_lpy_cl_kernels",
"queue",
"allocator=None",
"wait_for=None",
# ignored if options.no_numpy
"out_host=None"
]
from loopy.kernel.data import KernelArgument
gen = PythonFunctionGenerator(
"invoke_%s_loopy_kernel" % kernel.name, system_args + [
"%s=None" % idi.name for idi in implemented_data_info
if issubclass(idi.arg_class, KernelArgument)
])
gen.add_to_preamble("from __future__ import division")
gen.add_to_preamble("")
gen.add_to_preamble("import pyopencl as _lpy_cl")
gen.add_to_preamble("import pyopencl.array as _lpy_cl_array")
gen.add_to_preamble("import pyopencl.tools as _lpy_cl_tools")
gen.add_to_preamble("import numpy as _lpy_np")
gen.add_to_preamble("")
gen.add_to_preamble(host_code)
gen.add_to_preamble("")
gen("if allocator is None:")
with Indentation(gen):
gen("allocator = _lpy_cl_tools.DeferredAllocator(queue.context)")
gen("")
generate_integer_arg_finding_from_shapes(gen, kernel,
implemented_data_info)
generate_integer_arg_finding_from_offsets(gen, kernel,
implemented_data_info)
generate_integer_arg_finding_from_strides(gen, kernel,
implemented_data_info)
generate_value_arg_check(gen, kernel, implemented_data_info)
args = generate_arg_setup(gen, kernel, implemented_data_info, options)
# {{{ generate invocation
gen("_lpy_evt = {kernel_name}({args})".format(
kernel_name=codegen_result.host_program.name,
args=", ".join(["_lpy_cl_kernels", "queue"] + args +
["wait_for=wait_for"])))
# }}}
# {{{ output
if not options.no_numpy:
gen("if out_host is None and (_lpy_encountered_numpy "
"and not _lpy_encountered_dev):")
with Indentation(gen):
gen("out_host = True")
gen("if out_host:")
with Indentation(gen):
gen("pass") # if no outputs (?!)
for arg in implemented_data_info:
if not issubclass(arg.arg_class, KernelArgument):
continue
is_written = arg.base_name in kernel.get_written_variables()
if is_written:
gen("%s = %s.get(queue=queue)" % (arg.name, arg.name))
gen("")
if options.return_dict:
gen("return _lpy_evt, {%s}" %
", ".join("\"%s\": %s" % (arg.name, arg.name)
for arg in implemented_data_info
if issubclass(arg.arg_class, KernelArgument)
if arg.base_name in kernel.get_written_variables()))
else:
out_args = [
arg for arg in implemented_data_info
if issubclass(arg.arg_class, KernelArgument)
if arg.base_name in kernel.get_written_variables()
]
if out_args:
gen("return _lpy_evt, (%s,)" % ", ".join(arg.name
for arg in out_args))
else:
gen("return _lpy_evt, ()")
# }}}
if options.write_wrapper:
output = gen.get()
if options.highlight_wrapper:
output = get_highlighted_python_code(output)
if options.write_wrapper is True:
print(output)
else:
with open(options.write_wrapper, "w") as outf:
outf.write(output)
return gen.get_function()
def generate_invoker(kernel, codegen_result):
options = kernel.options
implemented_data_info = codegen_result.implemented_data_info
host_code = codegen_result.host_code()
system_args = [
"_lpy_cl_kernels", "queue", "allocator=None", "wait_for=None",
# ignored if options.no_numpy
"out_host=None"
]
from loopy.kernel.data import KernelArgument
gen = PythonFunctionGenerator(
"invoke_%s_loopy_kernel" % kernel.name,
system_args + [
"%s=None" % idi.name
for idi in implemented_data_info
if issubclass(idi.arg_class, KernelArgument)
])
gen.add_to_preamble("from __future__ import division")
gen.add_to_preamble("")
gen.add_to_preamble("import pyopencl as _lpy_cl")
gen.add_to_preamble("import pyopencl.array as _lpy_cl_array")
gen.add_to_preamble("import pyopencl.tools as _lpy_cl_tools")
gen.add_to_preamble("import numpy as _lpy_np")
gen.add_to_preamble("")
gen.add_to_preamble(host_code)
gen.add_to_preamble("")
gen("if allocator is None:")
with Indentation(gen):
gen("allocator = _lpy_cl_tools.DeferredAllocator(queue.context)")
gen("")
generate_integer_arg_finding_from_shapes(gen, kernel, implemented_data_info)
generate_integer_arg_finding_from_offsets(gen, kernel, implemented_data_info)
generate_integer_arg_finding_from_strides(gen, kernel, implemented_data_info)
generate_value_arg_check(gen, kernel, implemented_data_info)
args = generate_arg_setup(gen, kernel, implemented_data_info, options)
# {{{ generate invocation
gen("_lpy_evt = {kernel_name}({args})"
.format(
kernel_name=codegen_result.host_program.name,
args=", ".join(
["_lpy_cl_kernels", "queue"]
+ args
+ ["wait_for=wait_for"])))
# }}}
# {{{ output
if not options.no_numpy:
gen("if out_host is None and (_lpy_encountered_numpy "
"and not _lpy_encountered_dev):")
with Indentation(gen):
gen("out_host = True")
gen("if out_host:")
with Indentation(gen):
gen("pass") # if no outputs (?!)
for arg in implemented_data_info:
if not issubclass(arg.arg_class, KernelArgument):
continue
is_written = arg.base_name in kernel.get_written_variables()
if is_written:
gen("%s = %s.get(queue=queue)" % (arg.name, arg.name))
gen("")
if options.return_dict:
gen("return _lpy_evt, {%s}"
% ", ".join("\"%s\": %s" % (arg.name, arg.name)
for arg in implemented_data_info
if issubclass(arg.arg_class, KernelArgument)
if arg.base_name in kernel.get_written_variables()))
else:
out_args = [arg
for arg in implemented_data_info
if issubclass(arg.arg_class, KernelArgument)
if arg.base_name in kernel.get_written_variables()]
if out_args:
gen("return _lpy_evt, (%s,)"
% ", ".join(arg.name for arg in out_args))
else:
gen("return _lpy_evt, ()")
# }}}
if options.write_wrapper:
output = gen.get()
if options.highlight_wrapper:
output = get_highlighted_python_code(output)
if options.write_wrapper is True:
print(output)
else:
with open(options.write_wrapper, "w") as outf:
outf.write(output)
return gen.get_function()
def __call__(self, kernel, codegen_result):
"""
Generates the wrapping python invoker for this execution target
:arg kernel: the loopy :class:`LoopKernel`(s) to be executued
:codegen_result: the loopy :class:`CodeGenerationResult` created
by code generation
:returns: A python callable that handles execution of this
kernel
"""
options = kernel.options
implemented_data_info = codegen_result.implemented_data_info
from loopy.kernel.data import KernelArgument
gen = PythonFunctionGenerator(
"invoke_%s_loopy_kernel" % kernel.name,
self.system_args + [
"%s=None" % idi.name
for idi in implemented_data_info
if issubclass(idi.arg_class, KernelArgument)
])
gen.add_to_preamble("from __future__ import division")
gen.add_to_preamble("")
self.target_specific_preamble(gen)
gen.add_to_preamble("")
self.generate_host_code(gen, codegen_result)
gen.add_to_preamble("")
self.initialize_system_args(gen)
self.generate_integer_arg_finding_from_shapes(
gen, kernel, implemented_data_info)
self.generate_integer_arg_finding_from_offsets(
gen, kernel, implemented_data_info)
self.generate_integer_arg_finding_from_strides(
gen, kernel, implemented_data_info)
self.generate_value_arg_check(
gen, kernel, implemented_data_info)
args = self.generate_arg_setup(
gen, kernel, implemented_data_info, options)
self.generate_invocation(gen, codegen_result.host_program.name, args,
kernel, implemented_data_info)
self.generate_output_handler(gen, options, kernel, implemented_data_info)
if options.write_wrapper:
output = gen.get()
if options.highlight_wrapper:
output = get_highlighted_python_code(output)
if options.write_wrapper is True:
print(output)
else:
with open(options.write_wrapper, "w") as outf:
outf.write(output)
return gen.get_picklable_function()
