def _set_up_default_target():
try:
import pyopencl # noqa
except ImportError:
from loopy.target.opencl import OpenCLTarget
target = OpenCLTarget()
else:
from loopy.target.pyopencl import PyOpenCLTarget
target = PyOpenCLTarget()
set_default_target(target)
def __init__(self, context, kernel):
"""
:arg context: a :class:`pyopencl.Context`
:arg kernel: may be a loopy.LoopKernel, a generator returning kernels
(a warning will be issued if more than one is returned). If the
kernel has not yet been loop-scheduled, that is done, too, with no
specific arguments.
"""
super(PyOpenCLKernelExecutor, self).__init__(kernel)
self.context = context
from loopy.target.pyopencl import PyOpenCLTarget
if isinstance(kernel.target, PyOpenCLTarget):
self.kernel = kernel.copy(target=PyOpenCLTarget(context.devices[0]))
def __init__(self, context, kernel):
"""
:arg context: a :class:`pyopencl.Context`
:arg kernel: may be a loopy.LoopKernel, a generator returning kernels
(a warning will be issued if more than one is returned). If the
kernel has not yet been loop-scheduled, that is done, too, with no
specific arguments.
"""
self.context = context
from loopy.target.pyopencl import PyOpenCLTarget
self.kernel = kernel.copy(target=PyOpenCLTarget(context.devices[0]))
self.packing_controller = SeparateArrayPackingController(kernel)
self.output_names = tuple(arg.name for arg in self.kernel.args
if arg.name in self.kernel.get_written_variables())
def auto_test_vs_ref(ref_knl,
ctx,
test_knl=None,
op_count=[],
op_label=[],
parameters={},
print_ref_code=False,
print_code=True,
warmup_rounds=2,
dump_binary=False,
fills_entire_output=None,
do_check=True,
check_result=None,
max_test_kernel_count=1,
quiet=False,
blacklist_ref_vendors=[]):
"""Compare results of `ref_knl` to the kernels generated by
scheduling *test_knl*.
:arg check_result: a callable with :class:`numpy.ndarray` arguments
*(result, reference_result)* returning a a tuple (class:`bool`,
message) indicating correctness/acceptability of the result
:arg max_test_kernel_count: Stop testing after this many *test_knl*
"""
import pyopencl as cl
if test_knl is None:
test_knl = ref_knl
do_check = False
if len(ref_knl.args) != len(test_knl.args):
raise LoopyError("ref_knl and test_knl do not have the same number "
"of arguments")
for i, (ref_arg, test_arg) in enumerate(zip(ref_knl.args, test_knl.args)):
if ref_arg.name != test_arg.name:
raise LoopyError(
"ref_knl and test_knl argument lists disagree at index "
"%d (1-based)" % (i + 1))
if ref_arg.dtype != test_arg.dtype:
raise LoopyError(
"ref_knl and test_knl argument lists disagree at index "
"%d (1-based)" % (i + 1))
from loopy.compiled import CompiledKernel
from loopy.target.execution import get_highlighted_code
if isinstance(op_count, (int, float)):
warn("op_count should be a list", stacklevel=2)
op_count = [op_count]
if isinstance(op_label, str):
warn("op_label should be a list", stacklevel=2)
op_label = [op_label]
from time import time
if check_result is None:
check_result = _default_check_result
if fills_entire_output is not None:
warn("fills_entire_output is deprecated",
DeprecationWarning,
stacklevel=2)
# {{{ compile and run reference code
from loopy.type_inference import infer_unknown_types
ref_knl = infer_unknown_types(ref_knl, expect_completion=True)
found_ref_device = False
ref_errors = []
from loopy.kernel.data import ImageArg
need_ref_image_support = any(
isinstance(arg, ImageArg) for arg in ref_knl.args)
for dev in _enumerate_cl_devices_for_ref_test(blacklist_ref_vendors,
need_ref_image_support):
ref_ctx = cl.Context([dev])
ref_queue = cl.CommandQueue(
ref_ctx, properties=cl.command_queue_properties.PROFILING_ENABLE)
pp_ref_knl = lp.preprocess_kernel(ref_knl)
for knl in lp.generate_loop_schedules(pp_ref_knl):
ref_sched_kernel = knl
break
logger.info("{} (ref): trying {} for the reference calculation".format(
ref_knl.name, dev))
ref_compiled = CompiledKernel(ref_ctx, ref_sched_kernel)
if not quiet and print_ref_code:
print(75 * "-")
print("Reference Code:")
print(75 * "-")
print(get_highlighted_code(ref_compiled.get_code()))
print(75 * "-")
ref_kernel_info = ref_compiled.kernel_info(frozenset())
try:
ref_args, ref_arg_data = \
make_ref_args(ref_sched_kernel,
ref_kernel_info.implemented_data_info,
ref_queue, parameters)
ref_args["out_host"] = False
except cl.RuntimeError as e:
if e.code == cl.status_code.IMAGE_FORMAT_NOT_SUPPORTED:
import traceback
ref_errors.append("\n".join([
75 * "-",
"On %s:" % dev, 75 * "-",
traceback.format_exc(), 75 * "-"
]))
continue
else:
raise
found_ref_device = True
if not do_check:
break
ref_queue.finish()
logger.info("{} (ref): using {} for the reference calculation".format(
ref_knl.name, dev))
logger.info("%s (ref): run" % ref_knl.name)
ref_start = time()
if not AUTO_TEST_SKIP_RUN:
ref_evt, _ = ref_compiled(ref_queue, **ref_args)
else:
ref_evt = cl.enqueue_marker(ref_queue)
ref_queue.finish()
ref_stop = time()
ref_elapsed_wall = ref_stop - ref_start
logger.info("%s (ref): run done" % ref_knl.name)
ref_evt.wait()
ref_elapsed_event = 1e-9 * (ref_evt.profile.END -
ref_evt.profile.START)
break
if not found_ref_device:
raise LoopyError("could not find a suitable device for the "
"reference computation.\n"
"These errors were encountered:\n" +
"\n".join(ref_errors))
# }}}
# {{{ compile and run parallel code
need_check = do_check
queue = cl.CommandQueue(
ctx, properties=cl.command_queue_properties.PROFILING_ENABLE)
from loopy.kernel import KernelState
from loopy.target.pyopencl import PyOpenCLTarget
if test_knl.state not in [
KernelState.PREPROCESSED, KernelState.LINEARIZED
]:
if isinstance(test_knl.target, PyOpenCLTarget):
test_knl = test_knl.copy(target=PyOpenCLTarget(ctx.devices[0]))
test_knl = lp.preprocess_kernel(test_knl)
if not test_knl.schedule:
test_kernels = lp.generate_loop_schedules(test_knl)
else:
test_kernels = [test_knl]
test_kernel_count = 0
from loopy.type_inference import infer_unknown_types
for i, kernel in enumerate(test_kernels):
test_kernel_count += 1
if test_kernel_count > max_test_kernel_count:
break
kernel = infer_unknown_types(kernel, expect_completion=True)
compiled = CompiledKernel(ctx, kernel)
kernel_info = compiled.kernel_info(frozenset())
args = make_args(kernel, kernel_info.implemented_data_info, queue,
ref_arg_data, parameters)
args["out_host"] = False
if not quiet:
print(75 * "-")
print("Kernel #%d:" % i)
print(75 * "-")
if print_code:
print(compiled.get_highlighted_code())
print(75 * "-")
if dump_binary:
# {{{ find cl program
for name in dir(kernel_info.cl_kernels):
if name.startswith("__"):
continue
cl_kernel = getattr(kernel_info.cl_kernels, name)
cl_program = cl_kernel.get_info(cl.kernel_info.PROGRAM)
break
else:
assert False, "could not find cl_program"
# }}}
print(type(cl_program))
if hasattr(cl_program, "binaries"):
print(cl_program.binaries[0])
print(75 * "-")
logger.info("%s: run warmup" % (knl.name))
for i in range(warmup_rounds):
if not AUTO_TEST_SKIP_RUN:
compiled(queue, **args)
if need_check and not AUTO_TEST_SKIP_RUN:
for arg_desc in ref_arg_data:
if arg_desc is None:
continue
if not arg_desc.needs_checking:
continue
from pyopencl.compyte.array import as_strided
ref_ary = as_strided(
arg_desc.ref_storage_array.get(),
shape=arg_desc.ref_shape,
strides=arg_desc.ref_numpy_strides).flatten()
test_ary = as_strided(
arg_desc.test_storage_array.get(),
shape=arg_desc.test_shape,
strides=arg_desc.test_numpy_strides).flatten()
common_len = min(len(ref_ary), len(test_ary))
ref_ary = ref_ary[:common_len]
test_ary = test_ary[:common_len]
error_is_small, error = check_result(test_ary, ref_ary)
if not error_is_small:
raise AutomaticTestFailure(error)
need_check = False
events = []
queue.finish()
logger.info("%s: warmup done" % (knl.name))
logger.info("%s: timing run" % (knl.name))
timing_rounds = max(warmup_rounds, 1)
while True:
from time import time
start_time = time()
evt_start = cl.enqueue_marker(queue)
for i in range(timing_rounds):
if not AUTO_TEST_SKIP_RUN:
evt, _ = compiled(queue, **args)
events.append(evt)
else:
events.append(cl.enqueue_marker(queue))
evt_end = cl.enqueue_marker(queue)
queue.finish()
stop_time = time()
for evt in events:
evt.wait()
evt_start.wait()
evt_end.wait()
elapsed_event = (1e-9*events[-1].profile.END
- 1e-9*events[0].profile.START) \
/ timing_rounds
try:
elapsed_event_marker = ((1e-9 * evt_end.profile.START -
1e-9 * evt_start.profile.START) /
timing_rounds)
except cl.RuntimeError:
elapsed_event_marker = None
elapsed_wall = (stop_time - start_time) / timing_rounds
if elapsed_wall * timing_rounds < 0.3:
timing_rounds *= 4
else:
break
logger.info("%s: timing run done" % (knl.name))
rates = ""
for cnt, lbl in zip(op_count, op_label):
rates += " {:g} {}/s".format(cnt / elapsed_wall, lbl)
if not quiet:
def format_float_or_none(v):
if v is None:
return "<unavailable>"
else:
return "%g" % v
print("elapsed: %s s event, %s s marker-event %s s wall "
"(%d rounds)%s" %
(format_float_or_none(elapsed_event),
format_float_or_none(elapsed_event_marker),
format_float_or_none(elapsed_wall), timing_rounds, rates))
if do_check:
ref_rates = ""
for cnt, lbl in zip(op_count, op_label):
ref_rates += " {:g} {}/s".format(cnt / ref_elapsed_event, lbl)
if not quiet:
print("ref: elapsed: {:g} s event, {:g} s wall{}".format(
ref_elapsed_event, ref_elapsed_wall, ref_rates))
# }}}
result_dict = {}
result_dict["elapsed_event"] = elapsed_event
result_dict["elapsed_event_marker"] = elapsed_event_marker
result_dict["elapsed_wall"] = elapsed_wall
result_dict["timing_rounds"] = timing_rounds
if do_check:
result_dict["ref_elapsed_event"] = ref_elapsed_event
result_dict["ref_elapsed_wall"] = ref_elapsed_wall
return result_dict
