src/gallium/state_trackers/clover/core/kernel.cpp

   1 //
   2 // Copyright 2012 Francisco Jerez
   3 //
   4 // Permission is hereby granted, free of charge, to any person obtaining a
   5 // copy of this software and associated documentation files (the "Software"),
   6 // to deal in the Software without restriction, including without limitation
   7 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 // and/or sell copies of the Software, and to permit persons to whom the
   9 // Software is furnished to do so, subject to the following conditions:
  10 //
  11 // The above copyright notice and this permission notice shall be included in
  12 // all copies or substantial portions of the Software.
  13 //
  14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18 // OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20 // OTHER DEALINGS IN THE SOFTWARE.
  21 //
  22
  23 #include "core/kernel.hpp"
  24 #include "core/resource.hpp"
  25 #include "pipe/p_context.h"
  26
  27 using namespace clover;
  28
  29 _cl_kernel::_cl_kernel(clover::program &prog,
  30                        const std::string &name,
  31                        const std::vector<clover::module::argument> &args) :
  32    prog(prog), __name(name), exec(*this) {
  33    for (auto arg : args) {
  34       if (arg.type == module::argument::scalar)
  35          this->args.emplace_back(new scalar_argument(arg.size));
  36       else if (arg.type == module::argument::global)
  37          this->args.emplace_back(new global_argument(arg.size));
  38       else if (arg.type == module::argument::local)
  39          this->args.emplace_back(new local_argument());
  40       else if (arg.type == module::argument::constant)
  41          this->args.emplace_back(new constant_argument());
  42       else if (arg.type == module::argument::image2d_rd ||
  43                arg.type == module::argument::image3d_rd)
  44          this->args.emplace_back(new image_rd_argument());
  45       else if (arg.type == module::argument::image2d_wr ||
  46                arg.type == module::argument::image3d_wr)
  47          this->args.emplace_back(new image_wr_argument());
  48       else if (arg.type == module::argument::sampler)
  49          this->args.emplace_back(new sampler_argument());
  50       else
  51          throw error(CL_INVALID_KERNEL_DEFINITION);
  52    }
  53 }
  54
  55 template<typename T, typename V>
  56 static inline std::vector<T>
  57 pad_vector(clover::command_queue &q, const V &v, T x) {
  58    std::vector<T> w { v.begin(), v.end() };
  59    w.resize(q.dev.max_block_size().size(), x);
  60    return w;
  61 }
  62
  63 void
  64 _cl_kernel::launch(clover::command_queue &q,
  65                    const std::vector<size_t> &grid_offset,
  66                    const std::vector<size_t> &grid_size,
  67                    const std::vector<size_t> &block_size) {
  68    void *st = exec.bind(&q);
  69    auto g_handles = map([&](size_t h) { return (uint32_t *)&exec.input[h]; },
  70                         exec.g_handles.begin(), exec.g_handles.end());
  71
  72    q.pipe->bind_compute_state(q.pipe, st);
  73    q.pipe->bind_compute_sampler_states(q.pipe, 0, exec.samplers.size(),
  74                                        exec.samplers.data());
  75    q.pipe->set_compute_sampler_views(q.pipe, 0, exec.sviews.size(),
  76                                      exec.sviews.data());
  77    q.pipe->set_compute_resources(q.pipe, 0, exec.resources.size(),
  78                                      exec.resources.data());
  79    q.pipe->set_global_binding(q.pipe, 0, exec.g_buffers.size(),
  80                               exec.g_buffers.data(), g_handles.data());
  81
  82    q.pipe->launch_grid(q.pipe,
  83                        pad_vector<uint>(q, block_size, 1).data(),
  84                        pad_vector<uint>(q, grid_size, 1).data(),
  85                        module(q).sym(__name).offset,
  86                        exec.input.data());
  87
  88    q.pipe->set_global_binding(q.pipe, 0, exec.g_buffers.size(), NULL, NULL);
  89    q.pipe->set_compute_resources(q.pipe, 0, exec.resources.size(), NULL);
  90    q.pipe->set_compute_sampler_views(q.pipe, 0, exec.sviews.size(), NULL);
  91    q.pipe->bind_compute_sampler_states(q.pipe, 0, exec.samplers.size(), NULL);
  92    exec.unbind();
  93 }
  94
  95 size_t
  96 _cl_kernel::mem_local() const {
  97    size_t sz = 0;
  98
  99    for (auto &arg : args) {
 100       if (dynamic_cast<local_argument *>(arg.get()))
 101          sz += arg->storage();
 102    }
 103
 104    return sz;
 105 }
 106
 107 size_t
 108 _cl_kernel::mem_private() const {
 109    return 0;
 110 }
 111
 112 size_t
 113 _cl_kernel::max_block_size() const {
 114    return SIZE_MAX;
 115 }
 116
 117 const std::string &
 118 _cl_kernel::name() const {
 119    return __name;
 120 }
 121
 122 std::vector<size_t>
 123 _cl_kernel::block_size() const {
 124    return { 0, 0, 0 };
 125 }
 126
 127 const clover::module &
 128 _cl_kernel::module(const clover::command_queue &q) const {
 129    return prog.binaries().find(&q.dev)->second;
 130 }
 131
 132
 133 _cl_kernel::exec_context::exec_context(clover::kernel &kern) :
 134    kern(kern), q(NULL), mem_local(0), st(NULL) {
 135 }
 136
 137 _cl_kernel::exec_context::~exec_context() {
 138    if (st)
 139       q->pipe->delete_compute_state(q->pipe, st);
 140 }
 141
 142 void *
 143 _cl_kernel::exec_context::bind(clover::command_queue *__q) {
 144    std::swap(q, __q);
 145
 146    for (auto &arg : kern.args)
 147       arg->bind(*this);
 148
 149    // Create a new compute state if anything changed.
 150    if (!st || q != __q ||
 151        cs.req_local_mem != mem_local ||
 152        cs.req_input_mem != input.size()) {
 153       if (st)
 154          __q->pipe->delete_compute_state(__q->pipe, st);
 155
 156       cs.prog = kern.module(*q).sec(module::section::text).data.begin();
 157       cs.req_local_mem = mem_local;
 158       cs.req_input_mem = input.size();
 159       st = q->pipe->create_compute_state(q->pipe, &cs);
 160    }
 161
 162    return st;
 163 }
 164
 165 void
 166 _cl_kernel::exec_context::unbind() {
 167    for (auto &arg : kern.args)
 168       arg->unbind(*this);
 169
 170    input.clear();
 171    samplers.clear();
 172    sviews.clear();
 173    resources.clear();
 174    g_buffers.clear();
 175    g_handles.clear();
 176    mem_local = 0;
 177 }
 178
 179 _cl_kernel::argument::argument(size_t size) :
 180    __size(size), __set(false) {
 181 }
 182
 183 bool
 184 _cl_kernel::argument::set() const {
 185    return __set;
 186 }
 187
 188 size_t
 189 _cl_kernel::argument::storage() const {
 190    return 0;
 191 }
 192
 193 _cl_kernel::scalar_argument::scalar_argument(size_t size) :
 194    argument(size) {
 195 }
 196
 197 void
 198 _cl_kernel::scalar_argument::set(size_t size, const void *value) {
 199    if (size != __size)
 200       throw error(CL_INVALID_ARG_SIZE);
 201
 202    v = { (uint8_t *)value, (uint8_t *)value + size };
 203    __set = true;
 204 }
 205
 206 void
 207 _cl_kernel::scalar_argument::bind(exec_context &ctx) {
 208    ctx.input.insert(ctx.input.end(), v.begin(), v.end());
 209 }
 210
 211 void
 212 _cl_kernel::scalar_argument::unbind(exec_context &ctx) {
 213 }
 214
 215 _cl_kernel::global_argument::global_argument(size_t size) :
 216    argument(size) {
 217 }
 218
 219 void
 220 _cl_kernel::global_argument::set(size_t size, const void *value) {
 221    if (size != sizeof(cl_mem))
 222       throw error(CL_INVALID_ARG_SIZE);
 223
 224    obj = dynamic_cast<clover::buffer *>(*(cl_mem *)value);
 225    if (!obj)
 226       throw error(CL_INVALID_MEM_OBJECT);
 227
 228    __set = true;
 229 }
 230
 231 void
 232 _cl_kernel::global_argument::bind(exec_context &ctx) {
 233    size_t offset = ctx.input.size();
 234    size_t idx = ctx.g_buffers.size();
 235
 236    ctx.input.resize(offset + __size);
 237
 238    ctx.g_buffers.resize(idx + 1);
 239    ctx.g_buffers[idx] = obj->resource(ctx.q).pipe;
 240
 241    ctx.g_handles.resize(idx + 1);
 242    ctx.g_handles[idx] = offset;
 243 }
 244
 245 void
 246 _cl_kernel::global_argument::unbind(exec_context &ctx) {
 247 }
 248
 249 _cl_kernel::local_argument::local_argument() :
 250    argument(sizeof(uint32_t)) {
 251 }
 252
 253 size_t
 254 _cl_kernel::local_argument::storage() const {
 255    return __storage;
 256 }
 257
 258 void
 259 _cl_kernel::local_argument::set(size_t size, const void *value) {
 260    if (value)
 261       throw error(CL_INVALID_ARG_VALUE);
 262
 263    __storage = size;
 264    __set = true;
 265 }
 266
 267 void
 268 _cl_kernel::local_argument::bind(exec_context &ctx) {
 269    size_t offset = ctx.input.size();
 270    size_t ptr = ctx.mem_local;
 271
 272    ctx.input.resize(offset + sizeof(uint32_t));
 273    *(uint32_t *)&ctx.input[offset] = ptr;
 274
 275    ctx.mem_local += __storage;
 276 }
 277
 278 void
 279 _cl_kernel::local_argument::unbind(exec_context &ctx) {
 280 }
 281
 282 _cl_kernel::constant_argument::constant_argument() :
 283    argument(sizeof(uint32_t)) {
 284 }
 285
 286 void
 287 _cl_kernel::constant_argument::set(size_t size, const void *value) {
 288    if (size != sizeof(cl_mem))
 289       throw error(CL_INVALID_ARG_SIZE);
 290
 291    obj = dynamic_cast<clover::buffer *>(*(cl_mem *)value);
 292    if (!obj)
 293       throw error(CL_INVALID_MEM_OBJECT);
 294
 295    __set = true;
 296 }
 297
 298 void
 299 _cl_kernel::constant_argument::bind(exec_context &ctx) {
 300    size_t offset = ctx.input.size();
 301    size_t idx = ctx.resources.size();
 302
 303    ctx.input.resize(offset + sizeof(uint32_t));
 304    *(uint32_t *)&ctx.input[offset] = idx << 24;
 305
 306    ctx.resources.resize(idx + 1);
 307    ctx.resources[idx] = st = obj->resource(ctx.q).bind_surface(*ctx.q, false);
 308 }
 309
 310 void
 311 _cl_kernel::constant_argument::unbind(exec_context &ctx) {
 312    obj->resource(ctx.q).unbind_surface(*ctx.q, st);
 313 }
 314
 315 _cl_kernel::image_rd_argument::image_rd_argument() :
 316    argument(sizeof(uint32_t)) {
 317 }
 318
 319 void
 320 _cl_kernel::image_rd_argument::set(size_t size, const void *value) {
 321    if (size != sizeof(cl_mem))
 322       throw error(CL_INVALID_ARG_SIZE);
 323
 324    obj = dynamic_cast<clover::image *>(*(cl_mem *)value);
 325    if (!obj)
 326       throw error(CL_INVALID_MEM_OBJECT);
 327
 328    __set = true;
 329 }
 330
 331 void
 332 _cl_kernel::image_rd_argument::bind(exec_context &ctx) {
 333    size_t offset = ctx.input.size();
 334    size_t idx = ctx.sviews.size();
 335
 336    ctx.input.resize(offset + sizeof(uint32_t));
 337    *(uint32_t *)&ctx.input[offset] = idx;
 338
 339    ctx.sviews.resize(idx + 1);
 340    ctx.sviews[idx] = st = obj->resource(ctx.q).bind_sampler_view(*ctx.q);
 341 }
 342
 343 void
 344 _cl_kernel::image_rd_argument::unbind(exec_context &ctx) {
 345    obj->resource(ctx.q).unbind_sampler_view(*ctx.q, st);
 346 }
 347
 348 _cl_kernel::image_wr_argument::image_wr_argument() :
 349    argument(sizeof(uint32_t)) {
 350 }
 351
 352 void
 353 _cl_kernel::image_wr_argument::set(size_t size, const void *value) {
 354    if (size != sizeof(cl_mem))
 355       throw error(CL_INVALID_ARG_SIZE);
 356
 357    obj = dynamic_cast<clover::image *>(*(cl_mem *)value);
 358    if (!obj)
 359       throw error(CL_INVALID_MEM_OBJECT);
 360
 361    __set = true;
 362 }
 363
 364 void
 365 _cl_kernel::image_wr_argument::bind(exec_context &ctx) {
 366    size_t offset = ctx.input.size();
 367    size_t idx = ctx.resources.size();
 368
 369    ctx.input.resize(offset + sizeof(uint32_t));
 370    *(uint32_t *)&ctx.input[offset] = idx;
 371
 372    ctx.resources.resize(idx + 1);
 373    ctx.resources[idx] = st = obj->resource(ctx.q).bind_surface(*ctx.q, true);
 374 }
 375
 376 void
 377 _cl_kernel::image_wr_argument::unbind(exec_context &ctx) {
 378    obj->resource(ctx.q).unbind_surface(*ctx.q, st);
 379 }
 380
 381 _cl_kernel::sampler_argument::sampler_argument() :
 382    argument(0) {
 383 }
 384
 385 void
 386 _cl_kernel::sampler_argument::set(size_t size, const void *value) {
 387    if (size != sizeof(cl_sampler))
 388       throw error(CL_INVALID_ARG_SIZE);
 389
 390    obj = *(cl_sampler *)value;
 391    __set = true;
 392 }
 393
 394 void
 395 _cl_kernel::sampler_argument::bind(exec_context &ctx) {
 396    size_t idx = ctx.samplers.size();
 397
 398    ctx.samplers.resize(idx + 1);
 399    ctx.samplers[idx] = st = obj->bind(*ctx.q);
 400 }
 401
 402 void
 403 _cl_kernel::sampler_argument::unbind(exec_context &ctx) {
 404    obj->unbind(*ctx.q, st);
 405 }