Method OpenclKernelCommand

platforms/example/hal/src/opencl_command.cpp:5–45

using namespace xsched::opencl;

OpenclKernelCommand::OpenclKernelCommand(cl_kernel kernel, cl_uint work_dim,
                                         const size_t *global_work_offset,
                                         const size_t *global_work_size,
                                         const size_t *local_work_size,
                                         cl_uint num_events_in_wait_list,
                                         const cl_event *event_wait_list,
                                         cl_event *event,
                                         size_t num_args, KernelArgument *args)
    : kernel_(kernel), work_dim_(work_dim),
      num_events_in_wait_list_(num_events_in_wait_list), event_wait_list_(event_wait_list),
      event_(event), num_args_(num_args)
{
    if (work_dim_ <= 0) return;
    
    const size_t buf_size = work_dim_ * sizeof(size_t);
    global_work_size_ = (size_t *)malloc(buf_size);
    memcpy(global_work_size_, global_work_size, buf_size);

    // local_work_size is optional and can be nullptr
    if (local_work_size != nullptr) {
        local_work_size_ = (size_t *)malloc(buf_size);
        memcpy(local_work_size_, local_work_size, buf_size);
    }

    // global_work_offset is optional and can be nullptr
    if (global_work_offset != nullptr) {
        global_work_offset_ = (size_t *)malloc(buf_size);
        memcpy(global_work_offset_, global_work_offset, buf_size);
    }

    if (num_args_ <= 0) return;
    args_ = (KernelArgument *)malloc(num_args_ * sizeof(KernelArgument));
    for (size_t i = 0; i < num_args_; i++) {
        args_[i].index = args[i].index;
        args_[i].size = args[i].size;
        args_[i].value = nullptr;
        if (args[i].size == 0 || args[i].value == nullptr) continue;
        args_[i].value = malloc(args[i].size);
        memcpy(args_[i].value, args[i].value, args[i].size);
    }
}

OpenclKernelCommand::~OpenclKernelCommand()
{