Commit 699869d9 authored by Joseph Noir's avatar Joseph Noir

Cleanup error handling to use opencl_err header

parent 2a44eee1
...@@ -40,6 +40,7 @@ ...@@ -40,6 +40,7 @@
#include "caf/opencl/command.hpp" #include "caf/opencl/command.hpp"
#include "caf/opencl/program.hpp" #include "caf/opencl/program.hpp"
#include "caf/opencl/smart_ptr.hpp" #include "caf/opencl/smart_ptr.hpp"
#include "caf/opencl/opencl_err.hpp"
namespace caf { namespace caf {
namespace opencl { namespace opencl {
...@@ -82,15 +83,9 @@ class actor_facade<Ret(Args...)> : public abstract_actor { ...@@ -82,15 +83,9 @@ class actor_facade<Ret(Args...)> : public abstract_actor {
}; };
check_vec(offsets, "offsets"); check_vec(offsets, "offsets");
check_vec(local_dims, "local dimensions"); check_vec(local_dims, "local dimensions");
cl_int err{0};
kernel_ptr kernel; kernel_ptr kernel;
kernel.adopt(clCreateKernel(prog.m_program.get(), kernel_name, &err)); kernel.adopt(v2get(CAF_CLF(clCreateKernel), prog.m_program.get(),
if (err != CL_SUCCESS) { kernel_name));
std::ostringstream oss;
oss << "clCreateKernel: " << get_opencl_error(err);
CAF_LOGM_ERROR("caf::opencl::actor_facade", oss.str());
throw std::runtime_error(oss.str());
}
if (result_size == 0) { if (result_size == 0) {
result_size = std::accumulate(global_dims.begin(), global_dims.end(), result_size = std::accumulate(global_dims.begin(), global_dims.end(),
size_t{1}, std::multiplies<size_t>{}); size_t{1}, std::multiplies<size_t>{});
...@@ -159,14 +154,11 @@ class actor_facade<Ret(Args...)> : public abstract_actor { ...@@ -159,14 +154,11 @@ class actor_facade<Ret(Args...)> : public abstract_actor {
size_t m_result_size; size_t m_result_size;
void add_arguments_to_kernel_rec(evnt_vec&, args_vec& arguments) { void add_arguments_to_kernel_rec(evnt_vec&, args_vec& arguments) {
cl_int err{0};
// rotate left (output buffer to the end) // rotate left (output buffer to the end)
rotate(begin(arguments), begin(arguments) + 1, end(arguments)); rotate(begin(arguments), begin(arguments) + 1, end(arguments));
for (cl_uint i = 0; i < arguments.size(); ++i) { for (cl_uint i = 0; i < arguments.size(); ++i) {
err = clSetKernelArg(m_kernel.get(), i, sizeof(cl_mem), v1callcl(CAF_CLF(clSetKernelArg), m_kernel.get(), i,
static_cast<void*>(&arguments[i])); sizeof(cl_mem), static_cast<void*>(&arguments[i]));
CAF_LOG_ERROR_IF(err != CL_SUCCESS,
"clSetKernelArg: " << get_opencl_error(err));
} }
clFlush(m_queue.get()); clFlush(m_queue.get());
} }
...@@ -174,21 +166,12 @@ class actor_facade<Ret(Args...)> : public abstract_actor { ...@@ -174,21 +166,12 @@ class actor_facade<Ret(Args...)> : public abstract_actor {
template <typename T0, typename... Ts> template <typename T0, typename... Ts>
void add_arguments_to_kernel_rec(evnt_vec& events, args_vec& arguments, void add_arguments_to_kernel_rec(evnt_vec& events, args_vec& arguments,
T0& arg0, Ts&... args) { T0& arg0, Ts&... args) {
cl_int err{0};
size_t buffer_size = sizeof(typename T0::value_type) * arg0.size(); size_t buffer_size = sizeof(typename T0::value_type) * arg0.size();
auto buffer = clCreateBuffer(m_context.get(), CL_MEM_READ_ONLY, buffer_size, auto buffer = v2get(CAF_CLF(clCreateBuffer), m_context.get(),
nullptr, &err); CL_MEM_READ_ONLY, buffer_size, nullptr);
if (err != CL_SUCCESS) { cl_event event = v1get<cl_event>(CAF_CLF(clEnqueueWriteBuffer),
CAF_LOGMF(CAF_ERROR, "clCreateBuffer: " << get_opencl_error(err)); m_queue.get(), buffer, CL_FALSE,
return; 0,buffer_size, arg0.data());
}
cl_event event;
err = clEnqueueWriteBuffer(m_queue.get(), buffer, CL_FALSE, 0, buffer_size,
arg0.data(), 0, nullptr, &event);
if (err != CL_SUCCESS) {
CAF_LOGMF(CAF_ERROR, "clEnqueueWriteBuffer: " << get_opencl_error(err));
return;
}
events.push_back(std::move(event)); events.push_back(std::move(event));
mem_ptr tmp; mem_ptr tmp;
tmp.adopt(std::move(buffer)); tmp.adopt(std::move(buffer));
...@@ -200,14 +183,8 @@ class actor_facade<Ret(Args...)> : public abstract_actor { ...@@ -200,14 +183,8 @@ class actor_facade<Ret(Args...)> : public abstract_actor {
void add_arguments_to_kernel(evnt_vec& events, args_vec& arguments, void add_arguments_to_kernel(evnt_vec& events, args_vec& arguments,
size_t ret_size, Ts&&... args) { size_t ret_size, Ts&&... args) {
arguments.clear(); arguments.clear();
cl_int err{0}; auto buf = v2get(CAF_CLF(clCreateBuffer), m_context.get(), CL_MEM_WRITE_ONLY,
auto buf = sizeof(typename R::value_type) * ret_size, nullptr);
clCreateBuffer(m_context.get(), CL_MEM_WRITE_ONLY,
sizeof(typename R::value_type) * ret_size, nullptr, &err);
if (err != CL_SUCCESS) {
CAF_LOGMF(CAF_ERROR, "clCreateBuffer: " << get_opencl_error(err));
return;
}
mem_ptr tmp; mem_ptr tmp;
tmp.adopt(std::move(buf)); tmp.adopt(std::move(buf));
arguments.push_back(tmp); arguments.push_back(tmp);
......
...@@ -30,6 +30,7 @@ ...@@ -30,6 +30,7 @@
#include "caf/abstract_actor.hpp" #include "caf/abstract_actor.hpp"
#include "caf/response_promise.hpp" #include "caf/response_promise.hpp"
#include "caf/opencl/smart_ptr.hpp" #include "caf/opencl/smart_ptr.hpp"
#include "caf/opencl/opencl_err.hpp"
#include "caf/detail/scope_guard.hpp" #include "caf/detail/scope_guard.hpp"
namespace caf { namespace caf {
...@@ -52,25 +53,22 @@ class command : public ref_counted { ...@@ -52,25 +53,22 @@ class command : public ref_counted {
m_msg(msg) {} m_msg(msg) {}
~command() { ~command() {
cl_int err{0};
for (auto& e : m_events) { for (auto& e : m_events) {
err = clReleaseEvent(e); v1callcl(CAF_CLF(clReleaseEvent),e);
if (err != CL_SUCCESS) {
CAF_LOGMF(CAF_ERROR, "clReleaseEvent: " << get_opencl_error(err));
}
} }
} }
void enqueue() { void enqueue() {
// Errors in this function can not be handled by opencl_err.hpp
// because they require non-standard error handling
CAF_LOG_TRACE("command::enqueue()"); CAF_LOG_TRACE("command::enqueue()");
this->ref(); // reference held by the OpenCL comand queue this->ref(); // reference held by the OpenCL comand queue
cl_int err{0};
cl_event event_k; cl_event event_k;
auto data_or_nullptr = [](const dim_vec& vec) { auto data_or_nullptr = [](const dim_vec& vec) {
return vec.empty() ? nullptr : vec.data(); return vec.empty() ? nullptr : vec.data();
}; };
// OpenCL expects cl_uint (unsigned int), hence the cast // OpenCL expects cl_uint (unsigned int), hence the cast
err = clEnqueueNDRangeKernel( cl_int err = clEnqueueNDRangeKernel(
m_queue.get(), m_actor_facade->m_kernel.get(), m_queue.get(), m_actor_facade->m_kernel.get(),
static_cast<cl_uint>(m_actor_facade->m_global_dimensions.size()), static_cast<cl_uint>(m_actor_facade->m_global_dimensions.size()),
data_or_nullptr(m_actor_facade->m_global_offsets), data_or_nullptr(m_actor_facade->m_global_offsets),
......
...@@ -23,7 +23,9 @@ ...@@ -23,7 +23,9 @@
#include <iostream> #include <iostream>
#include "caf/detail/singletons.hpp" #include "caf/detail/singletons.hpp"
#include "caf/opencl/program.hpp" #include "caf/opencl/program.hpp"
#include "caf/opencl/opencl_err.hpp"
#include "caf/opencl/opencl_metainfo.hpp" #include "caf/opencl/opencl_metainfo.hpp"
using namespace std; using namespace std;
...@@ -52,20 +54,16 @@ program program::create(const char* kernel_source, const char* options, ...@@ -52,20 +54,16 @@ program program::create(const char* kernel_source, const char* options,
throw runtime_error(oss.str()); throw runtime_error(oss.str());
} }
cl_int err{0};
// create program object from kernel source // create program object from kernel source
size_t kernel_source_length = strlen(kernel_source); size_t kernel_source_length = strlen(kernel_source);
program_ptr pptr; program_ptr pptr;
pptr.adopt(clCreateProgramWithSource(context.get(), 1, &kernel_source, pptr.adopt(v2get(CAF_CLF(clCreateProgramWithSource),context.get(), 1,
&kernel_source_length, &err)); &kernel_source, &kernel_source_length));
if (err != CL_SUCCESS) {
throw runtime_error("clCreateProgramWithSource: " + get_opencl_error(err));
}
// build programm from program object // build programm from program object
auto dev_tmp = devices[device_id].m_device.get(); auto dev_tmp = devices[device_id].m_device.get();
err = clBuildProgram(pptr.get(), 1, &dev_tmp, options, nullptr, nullptr); cl_int err = clBuildProgram(pptr.get(), 1, &dev_tmp,
options,nullptr, nullptr);
if (err != CL_SUCCESS) { if (err != CL_SUCCESS) {
ostringstream oss; ostringstream oss;
oss << "clBuildProgram: " << get_opencl_error(err); oss << "clBuildProgram: " << get_opencl_error(err);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment