Commit f314c210 authored by Joseph Noir's avatar Joseph Noir

Rename spawn_config to nd_range

parent 522e26e3
...@@ -54,7 +54,7 @@ struct dummy_size_calculator { ...@@ -54,7 +54,7 @@ struct dummy_size_calculator {
} }
}; };
/// Mark an a spawn_cl template argument as input only /// Mark an a spawn template argument as input only
template <class Arg, class Tag = val> template <class Arg, class Tag = val>
struct in { struct in {
static_assert(std::is_same<Tag,val>::value || std::is_same<Tag,mref>::value, static_assert(std::is_same<Tag,val>::value || std::is_same<Tag,mref>::value,
...@@ -63,7 +63,7 @@ struct in { ...@@ -63,7 +63,7 @@ struct in {
using arg_type = typename std::decay<Arg>::type; using arg_type = typename std::decay<Arg>::type;
}; };
/// Mark an a spawn_cl template argument as input and output /// Mark an a spawn template argument as input and output
template <class Arg, class TagIn = val, class TagOut = val> template <class Arg, class TagIn = val, class TagOut = val>
struct in_out { struct in_out {
static_assert( static_assert(
......
...@@ -37,7 +37,7 @@ ...@@ -37,7 +37,7 @@
#include "caf/opencl/arguments.hpp" #include "caf/opencl/arguments.hpp"
#include "caf/opencl/smart_ptr.hpp" #include "caf/opencl/smart_ptr.hpp"
#include "caf/opencl/opencl_err.hpp" #include "caf/opencl/opencl_err.hpp"
#include "caf/opencl/spawn_config.hpp" #include "caf/opencl/nd_range.hpp"
namespace caf { namespace caf {
namespace opencl { namespace opencl {
...@@ -60,7 +60,7 @@ public: ...@@ -60,7 +60,7 @@ public:
std::vector<size_t> lengths, std::vector<size_t> lengths,
message msg, message msg,
std::tuple<Ts...> output_tuple, std::tuple<Ts...> output_tuple,
spawn_config config) nd_range range)
: lengths_(std::move(lengths)), : lengths_(std::move(lengths)),
promise_(std::move(promise)), promise_(std::move(promise)),
cl_actor_(std::move(parent)), cl_actor_(std::move(parent)),
...@@ -70,7 +70,7 @@ public: ...@@ -70,7 +70,7 @@ public:
scratch_buffers_(std::move(scratches)), scratch_buffers_(std::move(scratches)),
results_(output_tuple), results_(output_tuple),
msg_(std::move(msg)), msg_(std::move(msg)),
config_(std::move(config)) { range_(std::move(range)) {
// nop // nop
} }
...@@ -107,10 +107,10 @@ public: ...@@ -107,10 +107,10 @@ public:
mem_out_events_.emplace_back(); mem_out_events_.emplace_back();
cl_int err = clEnqueueNDRangeKernel( cl_int err = clEnqueueNDRangeKernel(
parent->queue_.get(), parent->kernel_.get(), parent->queue_.get(), parent->kernel_.get(),
static_cast<unsigned int>(config_.dimensions().size()), static_cast<unsigned int>(range_.dimensions().size()),
data_or_nullptr(config_.offsets()), data_or_nullptr(range_.offsets()),
data_or_nullptr(config_.dimensions()), data_or_nullptr(range_.dimensions()),
data_or_nullptr(config_.local_dimensions()), data_or_nullptr(range_.local_dimensions()),
static_cast<unsigned int>(mem_in_events_.size()), static_cast<unsigned int>(mem_in_events_.size()),
(mem_in_events_.empty() ? nullptr : mem_in_events_.data()), (mem_in_events_.empty() ? nullptr : mem_in_events_.data()),
&mem_out_events_.back() &mem_out_events_.back()
...@@ -183,10 +183,10 @@ public: ...@@ -183,10 +183,10 @@ public:
cl_event execution_event; cl_event execution_event;
cl_int err = clEnqueueNDRangeKernel( cl_int err = clEnqueueNDRangeKernel(
parent->queue_.get(), parent->kernel_.get(), parent->queue_.get(), parent->kernel_.get(),
static_cast<cl_uint>(config_.dimensions().size()), static_cast<cl_uint>(range_.dimensions().size()),
data_or_nullptr(config_.offsets()), data_or_nullptr(range_.offsets()),
data_or_nullptr(config_.dimensions()), data_or_nullptr(range_.dimensions()),
data_or_nullptr(config_.local_dimensions()), data_or_nullptr(range_.local_dimensions()),
static_cast<unsigned int>(mem_in_events_.size()), static_cast<unsigned int>(mem_in_events_.size()),
(mem_in_events_.empty() ? nullptr : mem_in_events_.data()), (mem_in_events_.empty() ? nullptr : mem_in_events_.data()),
&execution_event &execution_event
...@@ -274,7 +274,7 @@ private: ...@@ -274,7 +274,7 @@ private:
std::vector<cl_mem_ptr> scratch_buffers_; std::vector<cl_mem_ptr> scratch_buffers_;
std::tuple<Ts...> results_; std::tuple<Ts...> results_;
message msg_; // keeps the argument buffers alive for async copy to device message msg_; // keeps the argument buffers alive for async copy to device
spawn_config config_; nd_range range_;
}; };
} // namespace opencl } // namespace opencl
......
...@@ -35,28 +35,28 @@ struct cl_spawn_helper { ...@@ -35,28 +35,28 @@ struct cl_spawn_helper {
using map_out_fun = typename impl::output_mapping; using map_out_fun = typename impl::output_mapping;
actor operator()(actor_config actor_cfg, const opencl::program_ptr p, actor operator()(actor_config actor_cfg, const opencl::program_ptr p,
const char* fn, const opencl::spawn_config& spawn_cfg, const char* fn, const opencl::nd_range& range,
Ts&&... xs) const { Ts&&... xs) const {
return actor_cast<actor>(impl::create(std::move(actor_cfg), return actor_cast<actor>(impl::create(std::move(actor_cfg),
p, fn, spawn_cfg, p, fn, range,
map_in_fun{}, map_out_fun{}, map_in_fun{}, map_out_fun{},
std::move(xs)...)); std::move(xs)...));
} }
actor operator()(actor_config actor_cfg, const opencl::program_ptr p, actor operator()(actor_config actor_cfg, const opencl::program_ptr p,
const char* fn, const opencl::spawn_config& spawn_cfg, const char* fn, const opencl::nd_range& range,
map_in_fun map_input, Ts&&... xs) const { map_in_fun map_input, Ts&&... xs) const {
return actor_cast<actor>(impl::create(std::move(actor_cfg), return actor_cast<actor>(impl::create(std::move(actor_cfg),
p, fn, spawn_cfg, p, fn, range,
std::move(map_input), std::move(map_input),
map_out_fun{}, map_out_fun{},
std::move(xs)...)); std::move(xs)...));
} }
actor operator()(actor_config actor_cfg, const opencl::program_ptr p, actor operator()(actor_config actor_cfg, const opencl::program_ptr p,
const char* fn, const opencl::spawn_config& spawn_cfg, const char* fn, const opencl::nd_range& range,
map_in_fun map_input, map_out_fun map_output, map_in_fun map_input, map_out_fun map_output,
Ts&&... xs) const { Ts&&... xs) const {
return actor_cast<actor>(impl::create(std::move(actor_cfg), return actor_cast<actor>(impl::create(std::move(actor_cfg),
p, fn, spawn_cfg, p, fn, range,
std::move(map_input), std::move(map_input),
std::move(map_output), std::move(map_output),
std::move(xs)...)); std::move(xs)...));
......
...@@ -113,9 +113,9 @@ public: ...@@ -113,9 +113,9 @@ public:
actor actor
>::type >::type
spawn(const opencl::program_ptr prog, const char* fname, spawn(const opencl::program_ptr prog, const char* fname,
const opencl::spawn_config& config, T x, Ts... xs) { const opencl::nd_range& range, T x, Ts... xs) {
detail::cl_spawn_helper<false, T, Ts...> f; detail::cl_spawn_helper<false, T, Ts...> f;
return f(actor_config{system_.dummy_execution_unit()}, prog, fname, config, return f(actor_config{system_.dummy_execution_unit()}, prog, fname, range,
std::move(x), std::move(xs)...); std::move(x), std::move(xs)...);
} }
...@@ -130,10 +130,10 @@ public: ...@@ -130,10 +130,10 @@ public:
actor actor
>::type >::type
spawn(const char* source, const char* fname, spawn(const char* source, const char* fname,
const opencl::spawn_config& config, T x, Ts... xs) { const opencl::nd_range& range, T x, Ts... xs) {
detail::cl_spawn_helper<false, T, Ts...> f; detail::cl_spawn_helper<false, T, Ts...> f;
return f(actor_config{system_.dummy_execution_unit()}, return f(actor_config{system_.dummy_execution_unit()},
create_program(source), fname, config, create_program(source), fname, range,
std::move(x), std::move(xs)...); std::move(x), std::move(xs)...);
} }
...@@ -143,11 +143,11 @@ public: ...@@ -143,11 +143,11 @@ public:
/// `dims.empty()`, or `clCreateKernel` failed. /// `dims.empty()`, or `clCreateKernel` failed.
template <class Fun, class... Ts> template <class Fun, class... Ts>
actor spawn(const opencl::program_ptr prog, const char* fname, actor spawn(const opencl::program_ptr prog, const char* fname,
const opencl::spawn_config& config, const opencl::nd_range& range,
std::function<optional<message> (message&)> map_args, std::function<optional<message> (message&)> map_args,
Fun map_result, Ts... xs) { Fun map_result, Ts... xs) {
detail::cl_spawn_helper<false, Ts...> f; detail::cl_spawn_helper<false, Ts...> f;
return f(actor_config{system_.dummy_execution_unit()}, prog, fname, config, return f(actor_config{system_.dummy_execution_unit()}, prog, fname, range,
std::move(map_args), std::move(map_result), std::move(map_args), std::move(map_result),
std::forward<Ts>(xs)...); std::forward<Ts>(xs)...);
} }
...@@ -159,12 +159,12 @@ public: ...@@ -159,12 +159,12 @@ public:
/// occured, or @p clCreateKernel failed. /// occured, or @p clCreateKernel failed.
template <class Fun, class... Ts> template <class Fun, class... Ts>
actor spawn(const char* source, const char* fname, actor spawn(const char* source, const char* fname,
const opencl::spawn_config& config, const opencl::nd_range& range,
std::function<optional<message> (message&)> map_args, std::function<optional<message> (message&)> map_args,
Fun map_result, Ts... xs) { Fun map_result, Ts... xs) {
detail::cl_spawn_helper<false, Ts...> f; detail::cl_spawn_helper<false, Ts...> f;
return f(actor_config{system_.dummy_execution_unit()}, return f(actor_config{system_.dummy_execution_unit()},
create_program(source), fname, config, create_program(source), fname, range,
std::move(map_args), std::move(map_result), std::move(map_args), std::move(map_result),
std::forward<Ts>(xs)...); std::forward<Ts>(xs)...);
} }
...@@ -181,11 +181,11 @@ public: ...@@ -181,11 +181,11 @@ public:
actor actor
>::type >::type
spawn(const opencl::program_ptr prog, const char* fname, spawn(const opencl::program_ptr prog, const char* fname,
const opencl::spawn_config& config, const opencl::nd_range& range,
std::function<optional<message> (message&)> map_args, std::function<optional<message> (message&)> map_args,
T x, Ts... xs) { T x, Ts... xs) {
detail::cl_spawn_helper<false, Ts...> f; detail::cl_spawn_helper<false, Ts...> f;
return f(actor_config{system_.dummy_execution_unit()}, prog, fname, config, return f(actor_config{system_.dummy_execution_unit()}, prog, fname, range,
std::move(map_args), std::forward<T>(x), std::forward<Ts>(xs)...); std::move(map_args), std::forward<T>(x), std::forward<Ts>(xs)...);
} }
...@@ -200,12 +200,12 @@ public: ...@@ -200,12 +200,12 @@ public:
actor actor
>::type >::type
spawn(const char* source, const char* fname, spawn(const char* source, const char* fname,
const opencl::spawn_config& config, const opencl::nd_range& range,
std::function<optional<message> (message&)> map_args, std::function<optional<message> (message&)> map_args,
T x, Ts... xs) { T x, Ts... xs) {
detail::cl_spawn_helper<false, Ts...> f; detail::cl_spawn_helper<false, Ts...> f;
return f(actor_config{system_.dummy_execution_unit()}, return f(actor_config{system_.dummy_execution_unit()},
create_program(source), fname, config, create_program(source), fname, range,
std::move(map_args), std::forward<T>(x), std::forward<Ts>(xs)...); std::move(map_args), std::forward<T>(x), std::forward<Ts>(xs)...);
} }
...@@ -222,11 +222,11 @@ public: ...@@ -222,11 +222,11 @@ public:
actor actor
>::type >::type
spawn(const opencl::program_ptr prog, const char* fname, spawn(const opencl::program_ptr prog, const char* fname,
const opencl::spawn_config& config, const opencl::nd_range& range,
std::function<optional<message> (spawn_config&, message&)> map_args, std::function<optional<message> (nd_range&, message&)> map_args,
Fun map_result, Ts... xs) { Fun map_result, Ts... xs) {
detail::cl_spawn_helper<true, Ts...> f; detail::cl_spawn_helper<true, Ts...> f;
return f(actor_config{system_.dummy_execution_unit()}, prog, fname, config, return f(actor_config{system_.dummy_execution_unit()}, prog, fname, range,
std::move(map_args), std::move(map_result), std::move(map_args), std::move(map_result),
std::forward<Ts>(xs)...); std::forward<Ts>(xs)...);
} }
...@@ -242,12 +242,12 @@ public: ...@@ -242,12 +242,12 @@ public:
actor actor
>::type >::type
spawn(const char* source, const char* fname, spawn(const char* source, const char* fname,
const opencl::spawn_config& config, const opencl::nd_range& range,
std::function<optional<message> (spawn_config&, message&)> map_args, std::function<optional<message> (nd_range&, message&)> map_args,
Fun map_result, Ts... xs) { Fun map_result, Ts... xs) {
detail::cl_spawn_helper<true, Ts...> f; detail::cl_spawn_helper<true, Ts...> f;
return f(actor_config{system_.dummy_execution_unit()}, return f(actor_config{system_.dummy_execution_unit()},
create_program(source), fname, config, create_program(source), fname, range,
std::move(map_args), std::move(map_result), std::move(map_args), std::move(map_result),
std::forward<Ts>(xs)...); std::forward<Ts>(xs)...);
} }
...@@ -262,11 +262,11 @@ public: ...@@ -262,11 +262,11 @@ public:
actor actor
>::type >::type
spawn(const opencl::program_ptr prog, const char* fname, spawn(const opencl::program_ptr prog, const char* fname,
const opencl::spawn_config& config, const opencl::nd_range& range,
std::function<optional<message> (spawn_config&, message&)> map_args, std::function<optional<message> (nd_range&, message&)> map_args,
T x, Ts... xs) { T x, Ts... xs) {
detail::cl_spawn_helper<true, T, Ts...> f; detail::cl_spawn_helper<true, T, Ts...> f;
return f(actor_config{system_.dummy_execution_unit()}, prog, fname, config, return f(actor_config{system_.dummy_execution_unit()}, prog, fname, range,
std::move(map_args), std::forward<T>(x), std::forward<Ts>(xs)...); std::move(map_args), std::forward<T>(x), std::forward<Ts>(xs)...);
} }
...@@ -281,12 +281,12 @@ public: ...@@ -281,12 +281,12 @@ public:
actor actor
>::type >::type
spawn(const char* source, const char* fname, spawn(const char* source, const char* fname,
const opencl::spawn_config& config, const opencl::nd_range& range,
std::function<optional<message> (spawn_config&, message&)> map_args, std::function<optional<message> (nd_range&, message&)> map_args,
T x, Ts... xs) { T x, Ts... xs) {
detail::cl_spawn_helper<true, T, Ts...> f; detail::cl_spawn_helper<true, T, Ts...> f;
return f(actor_config{system_.dummy_execution_unit()}, return f(actor_config{system_.dummy_execution_unit()},
create_program(source), fname, config, create_program(source), fname, range,
std::move(map_args), std::forward<T>(x), std::forward<Ts>(xs)...); std::move(map_args), std::forward<T>(x), std::forward<Ts>(xs)...);
} }
......
...@@ -17,39 +17,39 @@ ...@@ -17,39 +17,39 @@
* http://www.boost.org/LICENSE_1_0.txt. * * http://www.boost.org/LICENSE_1_0.txt. *
******************************************************************************/ ******************************************************************************/
#ifndef CAF_OPENCL_SPAWN_CONFIG_HPP #ifndef CAF_OPENCL_ND_RANGE_HPP
#define CAF_OPENCL_SPAWN_CONFIG_HPP #define CAF_OPENCL_ND_RANGE_HPP
#include "caf/opencl/global.hpp" #include "caf/opencl/global.hpp"
namespace caf { namespace caf {
namespace opencl { namespace opencl {
class spawn_config { class nd_range {
public: public:
spawn_config(const opencl::dim_vec& dims, nd_range(const opencl::dim_vec& dimensions,
const opencl::dim_vec& offset = {}, const opencl::dim_vec& offsets = {},
const opencl::dim_vec& local_dims = {}) const opencl::dim_vec& local_dimensions = {})
: dims_{dims}, : dims_{dimensions},
offset_{offset}, offset_{offsets},
local_dims_{local_dims} { local_dims_{local_dimensions} {
// nop // nop
} }
spawn_config(opencl::dim_vec&& dims, nd_range(opencl::dim_vec&& dimensions,
opencl::dim_vec&& offset = {}, opencl::dim_vec&& offsets = {},
opencl::dim_vec&& local_dims = {}) opencl::dim_vec&& local_dimensions = {})
: dims_{std::move(dims)}, : dims_{std::move(dimensions)},
offset_{std::move(offset)}, offset_{std::move(offsets)},
local_dims_{std::move(local_dims)} { local_dims_{std::move(local_dimensions)} {
// nop // nop
} }
spawn_config(const spawn_config&) = default; nd_range(const nd_range&) = default;
spawn_config(spawn_config&&) = default; nd_range(nd_range&&) = default;
spawn_config& operator=(const spawn_config&) = default; nd_range& operator=(const nd_range&) = default;
spawn_config& operator=(spawn_config&&) = default; nd_range& operator=(nd_range&&) = default;
const opencl::dim_vec& dimensions() const { const opencl::dim_vec& dimensions() const {
return dims_; return dims_;
...@@ -72,4 +72,4 @@ private: ...@@ -72,4 +72,4 @@ private:
} // namespace opencl } // namespace opencl
} // namespace caf } // namespace caf
#endif // CAF_OPENCL_SPAWN_CONFIG_HPP #endif // CAF_OPENCL_ND_RANGE_HPP
...@@ -40,7 +40,7 @@ ...@@ -40,7 +40,7 @@
#include "caf/opencl/arguments.hpp" #include "caf/opencl/arguments.hpp"
#include "caf/opencl/smart_ptr.hpp" #include "caf/opencl/smart_ptr.hpp"
#include "caf/opencl/opencl_err.hpp" #include "caf/opencl/opencl_err.hpp"
#include "caf/opencl/spawn_config.hpp" #include "caf/opencl/nd_range.hpp"
namespace caf { namespace caf {
namespace opencl { namespace opencl {
...@@ -101,7 +101,7 @@ public: ...@@ -101,7 +101,7 @@ public:
using input_types = using input_types =
typename detail::tl_map<input_wrapped_types, extract_input_type>::type; typename detail::tl_map<input_wrapped_types, extract_input_type>::type;
using input_mapping = typename std::conditional<PassConfig, using input_mapping = typename std::conditional<PassConfig,
std::function<optional<message> (spawn_config&, message&)>, std::function<optional<message> (nd_range&, message&)>,
std::function<optional<message> (message&)> std::function<optional<message> (message&)>
>::type; >::type;
...@@ -127,16 +127,16 @@ public: ...@@ -127,16 +127,16 @@ public:
} }
static actor create(actor_config actor_conf, const program_ptr prog, static actor create(actor_config actor_conf, const program_ptr prog,
const char* kernel_name, const spawn_config& spawn_conf, const char* kernel_name, const nd_range& range,
input_mapping map_args, output_mapping map_result, input_mapping map_args, output_mapping map_result,
Ts&&... xs) { Ts&&... xs) {
if (spawn_conf.dimensions().empty()) { if (range.dimensions().empty()) {
auto str = "OpenCL kernel needs at least 1 global dimension."; auto str = "OpenCL kernel needs at least 1 global dimension.";
CAF_LOG_ERROR(str); CAF_LOG_ERROR(str);
throw std::runtime_error(str); throw std::runtime_error(str);
} }
auto check_vec = [&](const dim_vec& vec, const char* name) { auto check_vec = [&](const dim_vec& vec, const char* name) {
if (! vec.empty() && vec.size() != spawn_conf.dimensions().size()) { if (! vec.empty() && vec.size() != range.dimensions().size()) {
std::ostringstream oss; std::ostringstream oss;
oss << name << " vector is not empty, but " oss << name << " vector is not empty, but "
<< "its size differs from global dimensions vector's size"; << "its size differs from global dimensions vector's size";
...@@ -144,8 +144,8 @@ public: ...@@ -144,8 +144,8 @@ public:
throw std::runtime_error(oss.str()); throw std::runtime_error(oss.str());
} }
}; };
check_vec(spawn_conf.offsets(), "offsets"); check_vec(range.offsets(), "offsets");
check_vec(spawn_conf.local_dimensions(), "local dimensions"); check_vec(range.local_dimensions(), "local dimensions");
auto& sys = actor_conf.host->system(); auto& sys = actor_conf.host->system();
auto itr = prog->available_kernels_.find(kernel_name); auto itr = prog->available_kernels_.find(kernel_name);
if (itr == prog->available_kernels_.end()) { if (itr == prog->available_kernels_.end()) {
...@@ -155,14 +155,14 @@ public: ...@@ -155,14 +155,14 @@ public:
false); false);
return make_actor<opencl_actor, actor>(sys.next_actor_id(), sys.node(), return make_actor<opencl_actor, actor>(sys.next_actor_id(), sys.node(),
&sys, std::move(actor_conf), &sys, std::move(actor_conf),
prog, kernel, spawn_conf, prog, kernel, range,
std::move(map_args), std::move(map_args),
std::move(map_result), std::move(map_result),
std::forward_as_tuple(xs...)); std::forward_as_tuple(xs...));
} }
return make_actor<opencl_actor, actor>(sys.next_actor_id(), sys.node(), return make_actor<opencl_actor, actor>(sys.next_actor_id(), sys.node(),
&sys, std::move(actor_conf), &sys, std::move(actor_conf),
prog, itr->second, spawn_conf, prog, itr->second, range,
std::move(map_args), std::move(map_args),
std::move(map_result), std::move(map_result),
std::forward_as_tuple(xs...)); std::forward_as_tuple(xs...));
...@@ -203,7 +203,7 @@ public: ...@@ -203,7 +203,7 @@ public:
std::move(result_lengths), std::move(result_lengths),
std::move(content), std::move(content),
std::move(result), std::move(result),
config_ range_
); );
cmd->enqueue(); cmd->enqueue();
} }
...@@ -223,7 +223,7 @@ public: ...@@ -223,7 +223,7 @@ public:
} }
opencl_actor(actor_config actor_conf, const program_ptr prog, opencl_actor(actor_config actor_conf, const program_ptr prog,
cl_kernel_ptr kernel, spawn_config spawn_conf, cl_kernel_ptr kernel, nd_range range,
input_mapping map_args, output_mapping map_result, input_mapping map_args, output_mapping map_result,
std::tuple<Ts...> xs) std::tuple<Ts...> xs)
: monitorable_actor(actor_conf), : monitorable_actor(actor_conf),
...@@ -231,13 +231,13 @@ public: ...@@ -231,13 +231,13 @@ public:
program_(prog->program_), program_(prog->program_),
context_(prog->context_), context_(prog->context_),
queue_(prog->queue_), queue_(prog->queue_),
config_(std::move(spawn_conf)), range_(std::move(range)),
map_args_(std::move(map_args)), map_args_(std::move(map_args)),
map_results_(std::move(map_result)), map_results_(std::move(map_result)),
kernel_signature_(std::move(xs)) { kernel_signature_(std::move(xs)) {
CAF_LOG_TRACE(CAF_ARG(this->id())); CAF_LOG_TRACE(CAF_ARG(this->id()));
default_length_ = std::accumulate(std::begin(config_.dimensions()), default_length_ = std::accumulate(std::begin(range_.dimensions()),
std::end(config_.dimensions()), std::end(range_.dimensions()),
size_t{1}, size_t{1},
std::multiplies<size_t>{}); std::multiplies<size_t>{});
} }
...@@ -489,7 +489,7 @@ public: ...@@ -489,7 +489,7 @@ public:
template <bool Q = PassConfig> template <bool Q = PassConfig>
typename std::enable_if<Q, bool>::type map_arguments(message& content) { typename std::enable_if<Q, bool>::type map_arguments(message& content) {
if (map_args_) { if (map_args_) {
auto mapped = map_args_(config_, content); auto mapped = map_args_(range_, content);
if (!mapped) { if (!mapped) {
CAF_LOG_ERROR("Mapping argumentes failed."); CAF_LOG_ERROR("Mapping argumentes failed.");
return false; return false;
...@@ -503,7 +503,7 @@ public: ...@@ -503,7 +503,7 @@ public:
cl_program_ptr program_; cl_program_ptr program_;
cl_context_ptr context_; cl_context_ptr context_;
cl_command_queue_ptr queue_; cl_command_queue_ptr queue_;
spawn_config config_; nd_range range_;
input_mapping map_args_; input_mapping map_args_;
output_mapping map_results_; output_mapping map_results_;
std::tuple<Ts...> kernel_signature_; std::tuple<Ts...> kernel_signature_;
......
...@@ -176,7 +176,7 @@ void multiplier(event_based_actor* self) { ...@@ -176,7 +176,7 @@ void multiplier(event_based_actor* self) {
// arguments for global memory to be contained in vectors, // arguments for global memory to be contained in vectors,
// the vector is omitted here. // the vector is omitted here.
auto worker = mngr.spawn(kernel_source, kernel_name, auto worker = mngr.spawn(kernel_source, kernel_name,
spawn_config{dim_vec{matrix_size, matrix_size}}, nd_range{dim_vec{matrix_size, matrix_size}},
unbox_args, box_res, unbox_args, box_res,
in<float>{}, in<float>{}, out<float>{}); in<float>{}, in<float>{}, out<float>{});
......
...@@ -227,22 +227,22 @@ int main() { ...@@ -227,22 +227,22 @@ int main() {
return round_up((n + 1) / 2, half_block); return round_up((n + 1) / 2, half_block);
}; };
auto nd_conf = [half_block, get_size](size_t dim) { auto nd_conf = [half_block, get_size](size_t dim) {
return spawn_config{dim_vec{get_size(dim)}, {}, dim_vec{half_block}}; return nd_range{dim_vec{get_size(dim)}, {}, dim_vec{half_block}};
}; };
auto reduced_ref = [&](const uref&, uval n) { auto reduced_ref = [&](const uref&, uval n) {
// calculate number of groups from the group size from the values size // calculate number of groups from the group size from the values size
return size_t{get_size(n) / half_block}; return size_t{get_size(n) / half_block};
}; };
// default nd-range // default nd-range
auto ndr = spawn_config{dim_vec{half_block}, {}, dim_vec{half_block}}; auto ndr = nd_range{dim_vec{half_block}, {}, dim_vec{half_block}};
// ---- scan actors ---- // ---- scan actors ----
auto phase1 = mngr.spawn( auto phase1 = mngr.spawn(
prog, kernel_name_1, ndr, prog, kernel_name_1, ndr,
[nd_conf](spawn_config& conf, message& msg) -> optional<message> { [nd_conf](nd_range& range, message& msg) -> optional<message> {
return msg.apply([&](uvec& vec) { return msg.apply([&](uvec& vec) {
auto size = vec.size(); auto size = vec.size();
conf = nd_conf(size); range = nd_conf(size);
return make_message(std::move(vec), static_cast<uval>(size)); return make_message(std::move(vec), static_cast<uval>(size));
}); });
}, },
...@@ -253,10 +253,10 @@ int main() { ...@@ -253,10 +253,10 @@ int main() {
); );
auto phase2 = mngr.spawn( auto phase2 = mngr.spawn(
prog, kernel_name_2, ndr, prog, kernel_name_2, ndr,
[nd_conf](spawn_config& conf, message& msg) -> optional<message> { [nd_conf](nd_range& range, message& msg) -> optional<message> {
return msg.apply([&](uref& data, uref& incs) { return msg.apply([&](uref& data, uref& incs) {
auto size = incs.size(); auto size = incs.size();
conf = nd_conf(size); range = nd_conf(size);
return make_message(move(data), move(incs), static_cast<uval>(size)); return make_message(move(data), move(incs), static_cast<uval>(size));
}); });
}, },
...@@ -266,10 +266,10 @@ int main() { ...@@ -266,10 +266,10 @@ int main() {
); );
auto phase3 = mngr.spawn( auto phase3 = mngr.spawn(
prog, kernel_name_3, ndr, prog, kernel_name_3, ndr,
[nd_conf](spawn_config& conf, message& msg) -> optional<message> { [nd_conf](nd_range& range, message& msg) -> optional<message> {
return msg.apply([&](uref& data, uref& incs) { return msg.apply([&](uref& data, uref& incs) {
auto size = incs.size(); auto size = incs.size();
conf = nd_conf(size); range = nd_conf(size);
return make_message(move(data), move(incs), static_cast<uval>(size)); return make_message(move(data), move(incs), static_cast<uval>(size));
}); });
}, },
......
...@@ -96,7 +96,7 @@ void multiplier(event_based_actor* self) { ...@@ -96,7 +96,7 @@ void multiplier(event_based_actor* self) {
// the vector type is omitted for brevity. // the vector type is omitted for brevity.
auto worker = self->system().opencl_manager().spawn( auto worker = self->system().opencl_manager().spawn(
kernel_source, kernel_name, kernel_source, kernel_name,
spawn_config{dim_vec{matrix_size, matrix_size}}, nd_range{dim_vec{matrix_size, matrix_size}},
in<float>{}, in<float>{}, out<float>{} in<float>{}, in<float>{}, out<float>{}
); );
// send both matrices to the actor and wait for a result // send both matrices to the actor and wait for a result
......
This diff is collapsed.
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