index 2e0b0bd2775f40d4e10e6835a12318585acf1633..ab0bf26034ed20027296344542d463ecfc973cc5 100644 (file)
{
TRACE::print("\tOCL Device: %s created\n",
device_type_m == CL_DEVICE_TYPE_ACCELERATOR ? "DSP" :
- device_type_m == CL_DEVICE_TYPE_CUSTOM ? "DLA" : "Unknown");
+ device_type_m == CL_DEVICE_TYPE_CUSTOM ? "EVE" : "Unknown");
for (int i = 0; i < MAX_DEVICES; i++)
queue_m[i] = nullptr;
// Queue 0 on device 0
queue_m[0] = clCreateCommandQueue(context_m,
device_ids[0],
- 0,
+ CL_QUEUE_PROFILING_ENABLE|
+ CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE,
&errcode);
errorCheck(errcode, __LINE__);
BuildProgramFromBinary(binary_filename, device_ids, 1);
int index = static_cast<int>(id);
queue_m[index] = clCreateCommandQueue(context_m,
sub_devices[index],
- 0,
+ CL_QUEUE_PROFILING_ENABLE|
+ CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE,
&errcode);
errorCheck(errcode, __LINE__);
}
int index = static_cast<int>(id);
queue_m[index] = clCreateCommandQueue(context_m,
all_device_ids[index],
- 0,
+ CL_QUEUE_PROFILING_ENABLE|
+ CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE,
&errcode);
errorCheck(errcode, __LINE__);
}
Kernel::Kernel(Device* device, const std::string& name,
const KernelArgs& args, uint8_t device_index):
- name_m(name), device_m(device), device_index_m(device_index),
- is_running_m(false)
+ name_m(name), device_m(device), device_index_m(device_index)
{
TRACE::print("Creating kernel %s\n", name.c_str());
cl_int err;
kernel_m = clCreateKernel(device_m->program_m, name_m.c_str(), &err);
errorCheck(err, __LINE__);
+ for (int i=0; i < tidl::internal::NUM_CONTEXTS; i++)
+ event_m[i] = nullptr;
+
int arg_index = 0;
- for (auto arg : args)
+ for (const auto& arg : args)
{
if (!arg.isLocal())
{
- if (arg.kind() == ArgInfo::Kind::BUFFER)
+ if (arg.kind() == DeviceArgInfo::Kind::BUFFER)
{
cl_mem buffer = device_m->CreateBuffer(arg);
- clSetKernelArg(kernel_m, arg_index++, sizeof(cl_mem), &buffer);
- TRACE::print(" Arg[%d]: %p\n", arg_index-1, buffer);
+ clSetKernelArg(kernel_m, arg_index, sizeof(cl_mem), &buffer);
+ TRACE::print(" Arg[%d]: %p\n", arg_index, buffer);
- if (buffer != nullptr) buffers_m.push_back(buffer);
+ if (buffer)
+ buffers_m.push_back(buffer);
}
- else if (arg.kind() == ArgInfo::Kind::SCALAR)
+ else if (arg.kind() == DeviceArgInfo::Kind::SCALAR)
{
- clSetKernelArg(kernel_m, arg_index++, arg.size(), arg.ptr());
- TRACE::print(" Arg[%d]: %p\n", arg_index-1, arg.ptr());
+ clSetKernelArg(kernel_m, arg_index, arg.size(), arg.ptr());
+ TRACE::print(" Arg[%d]: %p\n", arg_index, arg.ptr());
}
else
{
- assert ("ArgInfo kind not supported");
+ assert ("DeviceArgInfo kind not supported");
}
}
else
{
- clSetKernelArg(kernel_m, arg_index++, arg.size(), NULL);
- TRACE::print(" Arg[%d]: local, %d\n", arg_index-1, arg.size());
+ clSetKernelArg(kernel_m, arg_index, arg.size(), NULL);
+ TRACE::print(" Arg[%d]: local, %d\n", arg_index, arg.size());
}
+ arg_index++;
}
}
-Kernel& Kernel::RunAsync()
+bool Kernel::UpdateScalarArg(uint32_t index, size_t size, const void *value)
+{
+ cl_int ret = clSetKernelArg(kernel_m, index, size, value);
+ return ret == CL_SUCCESS;
+}
+
+Kernel& Kernel::RunAsync(uint32_t context_idx)
{
// Execute kernel
- TRACE::print("\tKernel: device %d executing %s\n", device_index_m,
- name_m.c_str());
+ TRACE::print("\tKernel: device %d executing %s, context %d\n",
+ device_index_m, name_m.c_str(), context_idx);
cl_int ret = clEnqueueTask(device_m->queue_m[device_index_m],
- kernel_m, 0, 0, &event_m);
+ kernel_m, 0, 0, &event_m[context_idx]);
errorCheck(ret, __LINE__);
- is_running_m = true;
return *this;
}
-
-bool Kernel::Wait()
+bool Kernel::Wait(uint32_t context_idx)
{
// Wait called without a corresponding RunAsync
- if (!is_running_m)
+ if (event_m[context_idx] == nullptr)
return false;
- TRACE::print("\tKernel: waiting...\n");
- cl_int ret = clWaitForEvents(1, &event_m);
+ TRACE::print("\tKernel: waiting context %d...\n", context_idx);
+ cl_int ret = clWaitForEvents(1, &event_m[context_idx]);
errorCheck(ret, __LINE__);
- ret = clReleaseEvent(event_m);
+
+ ret = clReleaseEvent(event_m[context_idx]);
errorCheck(ret, __LINE__);
+ event_m[context_idx] = nullptr;
+
TRACE::print("\tKernel: finished execution\n");
- is_running_m = false;
return true;
}
+extern void CallbackWrapper(void *user_data) __attribute__((weak));
+
+static
+void EventCallback(cl_event event, cl_int exec_status, void *user_data)
+{
+ if (exec_status != CL_SUCCESS || user_data == nullptr) return;
+ if (CallbackWrapper) CallbackWrapper(user_data);
+}
+
+bool Kernel::AddCallback(void *user_data, uint32_t context_idx)
+{
+ if (event_m[context_idx] == nullptr)
+ return false;
+
+ return clSetEventCallback(event_m[context_idx], CL_COMPLETE, EventCallback,
+ user_data) == CL_SUCCESS;
+}
+
Kernel::~Kernel()
{
for (auto b : buffers_m)
clReleaseKernel(kernel_m);
}
-cl_mem Device::CreateBuffer(const ArgInfo &Arg)
+cl_mem Device::CreateBuffer(const DeviceArgInfo &Arg)
{
size_t size = Arg.size();
void *host_ptr = Arg.ptr();
Device::Ptr p(nullptr);
if (core_type == DeviceType::DSP)
p.reset(new DspDevice(ids, name));
- else if (core_type == DeviceType::DLA)
+ else if (core_type == DeviceType::EVE)
p.reset(new EveDevice(ids, name));
return p;
}
+// Minimum version of OpenCL required for this version of TIDL API
+#define MIN_OCL_VERSION "01.01.18.00"
+static bool CheckOpenCLVersion(cl_platform_id id)
+{
+ cl_int err;
+ size_t length;
+ err = clGetPlatformInfo(id, CL_PLATFORM_VERSION, 0, nullptr, &length);
+ if (err != CL_SUCCESS) return false;
+
+ std::unique_ptr<char> version(new char[length]);
+ err = clGetPlatformInfo(id, CL_PLATFORM_VERSION, length, version.get(),
+ nullptr);
+ if (err != CL_SUCCESS) return false;
+
+ std::string v(version.get());
+
+ if (v.substr(v.find("01."), sizeof(MIN_OCL_VERSION)) >= MIN_OCL_VERSION)
+ return true;
+
+ std::cerr << "TIDL API Error: OpenCL " << MIN_OCL_VERSION
+ << " or higher required." << std::endl;
+
+ return false;
+}
+
static bool PlatformIsAM57()
{
cl_platform_id id;
err = clGetPlatformIDs(1, &id, nullptr);
if (err != CL_SUCCESS) return false;
+ if (!CheckOpenCLVersion(id))
+ return false;
+
// Check if the device name is AM57
size_t length;
err = clGetPlatformInfo(id, CL_PLATFORM_NAME, 0, nullptr, &length);
if (!PlatformIsAM57()) return 0;
// Convert DeviceType to OpenCL device type
- cl_device_type t = (device_type == DeviceType::DLA) ?
+ cl_device_type t = (device_type == DeviceType::EVE) ?
CL_DEVICE_TYPE_CUSTOM :
CL_DEVICE_TYPE_ACCELERATOR;