The execution of a PL kernel is associated with a class called
that implements methods to start and wait for kernel execution. Most interaction with
kernel objects are accomplished through
objects, created from a kernel to represent an execution of the kernel.
The run object can be explicitly constructed from a kernel object, or implicitly constructed by starting a kernel execution as shown below.
std::cout << "Execution of the kernel\n"; auto run = krnl(bo0, bo1, bo_out, DATA_SIZE); run.wait();
The above code example demonstrates launching the kernel execution using
xrt::kernel() operator with the list of arguments
for the kernel that returns an
xrt::run object. This is
an asynchronous operator that returns after starting the run. The
xrt::run::wait() member function is used to block the
current thread until the run is complete.
xrt::runobject can be used to relaunch the same kernel function if desired.
auto run = xrt::run(krnl); run.set_arg(0,bo0); // Arguments are specified starting from 0 run.set_arg(0,bo1); run.set_arg(0,bo_out); run.start(); run.wait();
In this example, the run object is explicitly constructed from the kernel
object, the kernel arguments are specified with
run.set_args(), and the run execution is launched by the
run.start() command. Finally, the current thread is blocked
as it waits for the kernel to finish.
After the kernel has completed its execution, you can sync the kernel results back to the host application using code similar to the following example:
// Get the output; bo_out.sync(XCL_BO_SYNC_BO_FROM_DEVICE); // Validate our results if (std::memcmp(bo_out_map, bufReference, DATA_SIZE)) throw std::runtime_error("Value read back does not match reference");