if (!name)
throw error(CL_INVALID_VALUE);
- if (prog.binaries().empty())
- throw error(CL_INVALID_PROGRAM_EXECUTABLE);
-
- auto sym = prog.binaries().begin()->second.sym(name);
+ auto &sym = find(name_equals(name), prog.symbols());
ret_error(r_errcode, CL_SUCCESS);
return new kernel(prog, name, range(sym.args));
-} catch (module::noent_error &e) {
+} catch (std::out_of_range &e) {
ret_error(r_errcode, CL_INVALID_KERNEL_NAME);
return NULL;
clCreateKernelsInProgram(cl_program d_prog, cl_uint count,
cl_kernel *rd_kerns, cl_uint *r_count) try {
auto &prog = obj(d_prog);
-
- if (prog.binaries().empty())
- throw error(CL_INVALID_PROGRAM_EXECUTABLE);
-
- auto &syms = prog.binaries().begin()->second.syms;
+ auto &syms = prog.symbols();
if (rd_kerns && count < syms.size())
throw error(CL_INVALID_VALUE);
PUBLIC cl_int
clSetKernelArg(cl_kernel d_kern, cl_uint idx, size_t size,
const void *value) try {
- auto &kern = obj(d_kern);
-
- if (idx >= kern.args.size())
- throw error(CL_INVALID_ARG_INDEX);
-
- kern.args[idx]->set(size, value);
-
+ obj(d_kern).args().at(idx).set(size, value);
return CL_SUCCESS;
+} catch (std::out_of_range &e) {
+ return CL_INVALID_ARG_INDEX;
+
} catch (error &e) {
return e.get();
}
break;
case CL_KERNEL_NUM_ARGS:
- buf.as_scalar<cl_uint>() = kern.args.size();
+ buf.as_scalar<cl_uint>() = kern.args().size();
break;
case CL_KERNEL_REFERENCE_COUNT:
auto &kern = obj(d_kern);
auto pdev = pobj(d_dev);
- if ((!pdev && kern.prog.binaries().size() != 1) ||
- (pdev && !kern.prog.binaries().count(pdev)))
+ if ((!pdev && kern.prog.devices().size() != 1) ||
+ (pdev && !count(*pdev, kern.prog.devices())))
throw error(CL_INVALID_DEVICE);
switch (param) {
if (any_of([](kernel::argument &arg) {
return !arg.set();
- }, map(derefs(), kern.args)))
+ }, kern.args()))
throw error(CL_INVALID_KERNEL_ARGS);
- if (!kern.prog.binaries().count(&q.dev))
+ if (!count(q.dev, kern.prog.devices()))
throw error(CL_INVALID_PROGRAM_EXECUTABLE);
}
break;
case CL_PROGRAM_NUM_DEVICES:
- buf.as_scalar<cl_uint>() = prog.binaries().size();
+ buf.as_scalar<cl_uint>() = prog.devices().size();
break;
case CL_PROGRAM_DEVICES:
- buf.as_vector<cl_device_id>() = map(keys(), prog.binaries());
+ buf.as_vector<cl_device_id>() = descs(prog.devices());
break;
case CL_PROGRAM_SOURCE:
break;
case CL_PROGRAM_BINARY_SIZES:
- buf.as_vector<size_t>() =
- map([](const std::pair<device *, module> &ent) {
- compat::ostream::buffer_t bin;
- compat::ostream s(bin);
- ent.second.serialize(s);
- return bin.size();
- },
- prog.binaries());
+ buf.as_vector<size_t>() = map([&](const device &dev) {
+ compat::ostream::buffer_t bin;
+ compat::ostream s(bin);
+ prog.binary(dev).serialize(s);
+ return bin.size();
+ },
+ prog.devices());
break;
case CL_PROGRAM_BINARIES:
- buf.as_matrix<unsigned char>() =
- map([](const std::pair<device *, module> &ent) {
- compat::ostream::buffer_t bin;
- compat::ostream s(bin);
- ent.second.serialize(s);
- return bin;
- },
- prog.binaries());
+ buf.as_matrix<unsigned char>() = map([&](const device &dev) {
+ compat::ostream::buffer_t bin;
+ compat::ostream s(bin);
+ prog.binary(dev).serialize(s);
+ return bin;
+ },
+ prog.devices());
break;
default:
auto &prog = obj(d_prog);
auto &dev = obj(d_dev);
- if (!count(dev, prog.ctx.devs()))
+ if (!count(dev, prog.devices()))
return CL_INVALID_DEVICE;
switch (param) {
using namespace clover;
-kernel::kernel(program &prog,
- const std::string &name,
+kernel::kernel(program &prog, const std::string &name,
const std::vector<module::argument> &margs) :
prog(prog), _name(name), exec(*this) {
- for (auto marg : margs) {
+ for (auto &marg : margs) {
if (marg.type == module::argument::scalar)
- args.emplace_back(new scalar_argument(marg.size));
+ _args.emplace_back(new scalar_argument(marg.size));
else if (marg.type == module::argument::global)
- args.emplace_back(new global_argument);
+ _args.emplace_back(new global_argument);
else if (marg.type == module::argument::local)
- args.emplace_back(new local_argument);
+ _args.emplace_back(new local_argument);
else if (marg.type == module::argument::constant)
- args.emplace_back(new constant_argument);
+ _args.emplace_back(new constant_argument);
else if (marg.type == module::argument::image2d_rd ||
marg.type == module::argument::image3d_rd)
- args.emplace_back(new image_rd_argument);
+ _args.emplace_back(new image_rd_argument);
else if (marg.type == module::argument::image2d_wr ||
marg.type == module::argument::image3d_wr)
- args.emplace_back(new image_wr_argument);
+ _args.emplace_back(new image_wr_argument);
else if (marg.type == module::argument::sampler)
- args.emplace_back(new sampler_argument);
+ _args.emplace_back(new sampler_argument);
else
throw error(CL_INVALID_KERNEL_DEFINITION);
}
}
-template<typename T, typename V>
-static inline std::vector<T>
-pad_vector(command_queue &q, const V &v, T x) {
- std::vector<T> w { v.begin(), v.end() };
+template<typename V>
+static inline std::vector<uint>
+pad_vector(command_queue &q, const V &v, uint x) {
+ std::vector<uint> w { v.begin(), v.end() };
w.resize(q.dev.max_block_size().size(), x);
return w;
}
const std::vector<size_t> &grid_offset,
const std::vector<size_t> &grid_size,
const std::vector<size_t> &block_size) {
+ const auto m = prog.binary(q.dev);
+ const auto reduced_grid_size =
+ map(divides(), grid_size, block_size);
void *st = exec.bind(&q);
+
+ // The handles are created during exec_context::bind(), so we need make
+ // sure to call exec_context::bind() before retrieving them.
std::vector<uint32_t *> g_handles = map([&](size_t h) {
return (uint32_t *)&exec.input[h];
}, exec.g_handles);
exec.g_buffers.data(), g_handles.data());
q.pipe->launch_grid(q.pipe,
- pad_vector<uint>(q, block_size, 1).data(),
- pad_vector<uint>(q, grid_size, 1).data(),
- module(q).sym(_name).offset,
+ pad_vector(q, block_size, 1).data(),
+ pad_vector(q, reduced_grid_size, 1).data(),
+ find(name_equals(_name), m.syms).offset,
exec.input.data());
q.pipe->set_global_binding(q.pipe, 0, exec.g_buffers.size(), NULL, NULL);
kernel::mem_local() const {
size_t sz = 0;
- for (auto &arg : args) {
- if (dynamic_cast<local_argument *>(arg.get()))
- sz += arg->storage();
+ for (auto &arg : args()) {
+ if (dynamic_cast<local_argument *>(&arg))
+ sz += arg.storage();
}
return sz;
return { 0, 0, 0 };
}
+kernel::argument_range
+kernel::args() {
+ return map(derefs(), _args);
+}
+
+kernel::const_argument_range
+kernel::args() const {
+ return map(derefs(), _args);
+}
+
const module &
kernel::module(const command_queue &q) const {
- return prog.binaries().find(&q.dev)->second;
+ return prog.binary(q.dev);
}
kernel::exec_context::exec_context(kernel &kern) :
- kern(kern), q(NULL), mem_local(0), st(NULL) {
+ kern(kern), q(NULL), mem_local(0), st(NULL), cs() {
}
kernel::exec_context::~exec_context() {
std::swap(q, _q);
// Bind kernel arguments.
- auto margs = kern.module(*q).sym(kern.name()).args;
- for_each([=](std::unique_ptr<kernel::argument> &karg,
- const module::argument &marg) {
- karg->bind(*this, marg);
- }, kern.args, margs);
+ auto &m = kern.prog.binary(q->dev);
+ auto margs = find(name_equals(kern.name()), m.syms).args;
+ auto msec = find(type_equals(module::section::text), m.secs);
+
+ for_each([=](kernel::argument &karg, const module::argument &marg) {
+ karg.bind(*this, marg);
+ }, kern.args(), margs);
// Create a new compute state if anything changed.
if (!st || q != _q ||
if (st)
_q->pipe->delete_compute_state(_q->pipe, st);
- cs.prog = kern.module(*q).sec(module::section::text).data.begin();
+ cs.prog = msec.data.begin();
cs.req_local_mem = mem_local;
cs.req_input_mem = input.size();
st = q->pipe->create_compute_state(q->pipe, &cs);
void
kernel::exec_context::unbind() {
- for (auto &arg : kern.args)
- arg->unbind(*this);
+ for (auto &arg : kern.args())
+ arg.unbind(*this);
input.clear();
samplers.clear();
bool _set;
};
- kernel(program &prog,
- const std::string &name,
- const std::vector<module::argument> &margs);
+ private:
+ typedef adaptor_range<
+ derefs, std::vector<std::unique_ptr<argument>> &
+ > argument_range;
+
+ typedef adaptor_range<
+ derefs, const std::vector<std::unique_ptr<argument>> &
+ > const_argument_range;
+
+ public:
+ kernel(program &prog, const std::string &name,
+ const std::vector<clover::module::argument> &margs);
kernel(const kernel &kern) = delete;
kernel &
const std::string &name() const;
std::vector<size_t> block_size() const;
+ argument_range args();
+ const_argument_range args() const;
+
program &prog;
- std::vector<std::unique_ptr<argument>> args;
private:
- const clover::module &
- module(const command_queue &q) const;
+ const clover::module &module(const command_queue &q) const;
class scalar_argument : public argument {
public:
void *st;
};
+ std::vector<std::unique_ptr<argument>> _args;
std::string _name;
exec_context exec;
};
//
#include <type_traits>
-#include <algorithm>
#include "core/module.hpp"
module::deserialize(compat::istream &is) {
return _proc<module>(is);
}
-
- const module::symbol &
- module::sym(compat::string name) const {
- auto it = std::find_if(syms.begin(), syms.end(), [&](const symbol &x) {
- return compat::string(x.name) == name;
- });
-
- if (it == syms.end())
- throw noent_error();
-
- return *it;
- }
-
- const module::section &
- module::sec(typename section::type type) const {
- auto it = std::find_if(secs.begin(), secs.end(), [&](const section &x) {
- return x.type == type;
- });
-
- if (it == secs.end())
- throw noent_error();
-
- return *it;
- }
}
namespace clover {
struct module {
- class noent_error {
- public:
- virtual ~noent_error() {}
- };
-
typedef uint32_t resource_id;
typedef uint32_t size_t;
};
section(resource_id id, enum type type, size_t size,
- const clover::compat::vector<char> &data) :
+ const compat::vector<char> &data) :
id(id), type(type), size(size), data(data) { }
section() : id(0), type(text), size(0), data() { }
resource_id id;
type type;
size_t size;
- clover::compat::vector<char> data;
+ compat::vector<char> data;
};
struct argument {
};
struct symbol {
- symbol(const clover::compat::vector<char> &name, resource_id section,
- size_t offset, const c
lover::compat::vector<argument> &args) :
+ symbol(const compat::vector<char> &name, resource_id section,
+ size_t offset, const compat::vector<argument> &args) :
name(name), section(section), offset(offset), args(args) { }
symbol() : name(), section(0), offset(0), args() { }
- clover::compat::vector<char> name;
+ compat::vector<char> name;
resource_id section;
size_t offset;
- c
lover::compat::vector<argument> args;
+ compat::vector<argument> args;
};
void serialize(compat::ostream &os) const;
static module deserialize(compat::istream &is);
- /// Look up a symbol by name. Throws module::noent_error if not
- /// found.
- const symbol &sym(compat::string name) const;
-
- /// Look up a section by type. Throws module::noent_error if not
- /// found.
- const section &sec(typename section::type type) const;
-
- clover::compat::vector<symbol> syms;
- clover::compat::vector<section> secs;
+ compat::vector<symbol> syms;
+ compat::vector<section> secs;
};
}
return _source;
}
-const std::map<device *, module> &
-program::binaries() const {
- return _binaries;
+program::device_range
+program::devices() const {
+ return map(derefs(), map(keys(), _binaries));
+}
+
+const module &
+program::binary(const device &dev) const {
+ return _binaries.find(const_cast<device *>(&dev))->second;
}
cl_build_status
-program::build_status(device &dev) const {
- return _binaries.count(&dev) ? CL_BUILD_SUCCESS : CL_BUILD_NONE;
+program::build_status(const device &dev) const {
+ if (_binaries.count(const_cast<device *>(&dev)))
+ return CL_BUILD_SUCCESS;
+ else
+ return CL_BUILD_NONE;
}
std::string
-program::build_opts(device &dev) const {
+program::build_opts(const device &dev) const {
return _opts.count(&dev) ? _opts.find(&dev)->second : "";
}
std::string
-program::build_log(device &dev) const {
+program::build_log(const device &dev) const {
return _logs.count(&dev) ? _logs.find(&dev)->second : "";
}
+
+const compat::vector<module::symbol> &
+program::symbols() const {
+ if (_binaries.empty())
+ throw error(CL_INVALID_PROGRAM_EXECUTABLE);
+
+ return _binaries.begin()->second.syms;
+}
namespace clover {
class program : public ref_counter, public _cl_program {
+ private:
+ typedef adaptor_range<
+ derefs, adaptor_range<
+ keys, const std::map<device *, module> &>> device_range;
+
public:
program(context &ctx,
const std::string &source);
void build(const ref_vector<device> &devs, const char *opts);
const std::string &source() const;
- const std::map<device *, module> &binaries() const;
- cl_build_status build_status(device &dev) const;
- std::string build_opts(device &dev) const;
- std::string build_log(device &dev) const;
+ device_range devices() const;
+
+ const module &binary(const device &dev) const;
+ cl_build_status build_status(const device &dev) const;
+ std::string build_opts(const device &dev) const;
+ std::string build_log(const device &dev) const;
+
+ const compat::vector<module::symbol> &symbols() const;
context &ctx;
private:
std::map<device *, module> _binaries;
- std::map<device *, std::string> _logs;
- std::map<device *, std::string> _opts;
+ std::map<const device *, std::string> _logs;
+ std::map<const device *, std::string> _opts;
std::string _source;
};
}
projects / mesa.git / commitdiff