WebCLGetInfo WebCLEvent::getProfilingInfo(int param_name, ExceptionState& es) {
cl_int err=0;
cl_ulong ulong_units = 0;
if (m_cl_Event == NULL) {
printf("Error: Invalid CL Event\n");
es.throwWebCLException(
WebCLException::INVALID_EVENT,
WebCLException::invalidEventMessage);
return WebCLGetInfo();
}
switch(param_name) {
case WebCL::PROFILING_COMMAND_QUEUED:
err = clGetEventProfilingInfo(m_cl_Event,
CL_PROFILING_COMMAND_QUEUED,
sizeof(cl_ulong), &ulong_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned long>(ulong_units));
break;
case WebCL::PROFILING_COMMAND_SUBMIT:
err = clGetEventProfilingInfo(m_cl_Event,
CL_PROFILING_COMMAND_SUBMIT,
sizeof(cl_ulong), &ulong_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned long>(ulong_units));
break;
case WebCL::PROFILING_COMMAND_START:
err = clGetEventProfilingInfo(m_cl_Event,
CL_PROFILING_COMMAND_START,
sizeof(cl_ulong), &ulong_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned long>(ulong_units));
break;
case WebCL::PROFILING_COMMAND_END:
err = clGetEventProfilingInfo(m_cl_Event, CL_PROFILING_COMMAND_END,
sizeof(cl_ulong), &ulong_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(ulong_units));
break;
default:
printf("Error: Unsupported Profiling Info type\n");
return WebCLGetInfo();
}
WebCLException::throwException(err, es);
return WebCLGetInfo();
}
WebCLGetInfo WebCLEvent::getInfo(int param_name, ExceptionState& es) {
printf("getInfo Called = %d\n", param_name);
cl_int err = 0;
cl_uint uint_units = 0;
cl_command_type command_type = 0;
cl_command_queue command_queue = 0;
RefPtr<WebCLCommandQueue> cqObj = nullptr;
if (m_cl_Event == NULL) {
printf("Error: Invalid CL Event\n");
es.throwWebCLException(
WebCLException::INVALID_EVENT,
WebCLException::invalidEventMessage);
return WebCLGetInfo();
}
switch(param_name) {
case WebCL::EVENT_COMMAND_EXECUTION_STATUS :
err = clGetEventInfo(m_cl_Event, CL_EVENT_COMMAND_EXECUTION_STATUS,
sizeof(cl_uint), &uint_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::EVENT_COMMAND_TYPE:
err = clGetEventInfo(m_cl_Event, CL_EVENT_COMMAND_TYPE,
sizeof(cl_command_type), &command_type, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(command_type));
break;
case WebCL::EVENT_COMMAND_QUEUE:
err = clGetEventInfo(m_cl_Event, CL_EVENT_COMMAND_QUEUE,
sizeof(cl_command_queue), &command_queue,
NULL);
cqObj = WebCLCommandQueue::create(command_queue, m_context,
NULL);
if(cqObj == NULL) {
printf("SUCCESS: Cl Event Command Queue\n");
return WebCLGetInfo();
}
if (err == CL_SUCCESS)
return WebCLGetInfo(PassRefPtr<WebCLCommandQueue>(cqObj));
break;
default:
printf("Error: Unsupported Event Info type\n");
return WebCLGetInfo();
}
WebCLException::throwException(err, es);
return WebCLGetInfo();
}
WebCLGetInfo WebCLProgram::getInfo(int param_name, ExceptionState& es) {
cl_int err = 0;
cl_uint uint_units = 0;
char program_string[4096];
RefPtr<WebCLContext> contextObj = nullptr;
RefPtr<WebCLDeviceList> deviceList = nullptr;
if (m_cl_program == NULL) {
es.throwWebCLException(
WebCLException::INVALID_PROGRAM,
WebCLException::invalidProgramMessage);
printf("Error: Invalid program object\n");
return WebCLGetInfo();
}
switch(param_name) {
case WebCL::PROGRAM_NUM_DEVICES:
err = clGetProgramInfo(m_cl_program, CL_PROGRAM_NUM_DEVICES,
sizeof(cl_uint), &uint_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::PROGRAM_SOURCE:
err = clGetProgramInfo(m_cl_program, CL_PROGRAM_SOURCE,
sizeof(program_string), &program_string,
NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(String(program_string));
break;
case WebCL::PROGRAM_CONTEXT:
return WebCLGetInfo(PassRefPtr<WebCLContext>(m_cl_context.get()));
break;
case WebCL::PROGRAM_DEVICES:
return WebCLGetInfo(m_cl_context->getDevices());
break;
default:
printf("Error: UNSUPPORTED program Info type = %d ",param_name);
es.throwWebCLException(
WebCLException::INVALID_PROGRAM,
WebCLException::invalidProgramMessage);
return WebCLGetInfo();
}
WebCLException::throwException(err, es);
return WebCLGetInfo();
}
WebCLGetInfo WebCLMem::getInfo(int param_name, ExceptionState& ec)
{
cl_int err =0;
cl_uint uint_units = 0;
size_t sizet_units = 0;
RefPtr<WebCLContext> contextObj = NULL;
cl_context cl_context_id = NULL;
cl_mem_object_type mem_type = 0;
void* mem_ptr = NULL;
if (m_cl_mem == NULL) {
ec.throwDOMException(WebCL::INVALID_MEM_OBJECT, "WebCL::INVALID_MEM_OBJECT");
printf("Error: Invalid CLMem\n");
return WebCLGetInfo();
}
switch(param_name)
{
case WebCL::MEM_MAP_COUNT:
err = webcl_clGetMemObjectInfo(webcl_channel_, m_cl_mem, CL_MEM_MAP_COUNT , sizeof(cl_uint), &uint_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::MEM_REFERENCE_COUNT:
err = webcl_clGetMemObjectInfo(webcl_channel_, m_cl_mem, CL_MEM_REFERENCE_COUNT , sizeof(cl_uint), &uint_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::MEM_SIZE:
err = webcl_clGetMemObjectInfo(webcl_channel_, m_cl_mem, CL_MEM_SIZE, sizeof(size_t), &sizet_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(sizet_units));
break;
case WebCL::MEM_TYPE:
err = webcl_clGetMemObjectInfo(webcl_channel_, m_cl_mem, CL_MEM_TYPE, sizeof(cl_mem_object_type), &mem_type, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(mem_type));
break;
case WebCL::MEM_CONTEXT:
err = webcl_clGetMemObjectInfo(webcl_channel_, m_cl_mem, CL_MEM_CONTEXT, sizeof(cl_context), &cl_context_id, NULL);
contextObj = WebCLContext::create(m_context, cl_context_id);
if(contextObj == NULL)
{
printf("Error: CL Mem context not NULL\n");
return WebCLGetInfo();
}
if (err == CL_SUCCESS)
return WebCLGetInfo(PassRefPtr<WebCLContext>(contextObj));
break;
case WebCL::MEM_HOST_PTR:
err = webcl_clGetMemObjectInfo(webcl_channel_, m_cl_mem, CL_MEM_HOST_PTR, sizeof(mem_ptr), &mem_ptr, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(mem_ptr);
break;
default:
printf("Error: Unsupported Mem Info type\n");
return WebCLGetInfo();
}
switch (err) {
case CL_INVALID_VALUE:
ec.throwDOMException(WebCL::INVALID_VALUE, "WebCL::INVALID_VALUE");
printf("Error: CL_INVALID_VALUE \n");
break;
// TODO (siba samal) Handle CL_INVALID_D3D10_RESOURCE_KHR Case
// case CL_INVALID_D
// ec.throwDOMException(WebCL::INVALID_D, "WebCL::INVALID_D");
// printf("CL_INVALID_D3D10_RESOURCE_KHR \n");
// break;
case CL_INVALID_MEM_OBJECT:
ec.throwDOMException(WebCL::INVALID_MEM_OBJECT, "WebCL::INVALID_MEM_OBJECT");
printf("Error: CL_INVALID_MEM_OBJECT \n");
break;
case CL_OUT_OF_RESOURCES:
ec.throwDOMException(WebCL::OUT_OF_RESOURCES, "WebCL::OUT_OF_RESOURCES");
printf("Error: CL_OUT_OF_RESOURCES \n");
break;
case CL_OUT_OF_HOST_MEMORY:
ec.throwDOMException(WebCL::OUT_OF_HOST_MEMORY, "WebCL::OUT_OF_HOST_MEMORY");
printf("Error: CL_OUT_OF_HOST_MEMORY \n");
break;
default:
ec.throwDOMException(WebCL::FAILURE, "WebCL::FAILURE");
printf("Error: Invaild Error Type\n");
break;
}
return WebCLGetInfo();
}
WebCLGetInfo WebCLDevice::getInfo(CCenum infoType, ExceptionObject& exception)
{
if (!WebCLInputChecker::isValidDeviceInfoType(infoType)) {
setExceptionFromComputeErrorCode(ComputeContext::INVALID_VALUE, exception);
return WebCLGetInfo();
}
CCerror err = 0;
switch (infoType) {
case ComputeContext::DEVICE_PROFILE:
return WebCLGetInfo(String("WEBCL_PROFILE"));
case ComputeContext::DEVICE_VERSION:
return WebCLGetInfo(String("WebCL 1.0"));
case ComputeContext::DEVICE_OPENCL_C_VERSION:
return WebCLGetInfo(String("WebCL C 1.0"));
case ComputeContext::DRIVER_VERSION: // Vendor specific. Will return a empty string.
case ComputeContext::DEVICE_NAME:
case ComputeContext::DEVICE_VENDOR:
case ComputeContext::DEVICE_EXTENSIONS:
return WebCLGetInfo(emptyString());
case ComputeContext::DEVICE_VENDOR_ID: // Vendor specific.
return WebCLGetInfo(static_cast<CCuint>(0));
case ComputeContext::DEVICE_IMAGE_SUPPORT:
case ComputeContext::DEVICE_AVAILABLE:
case ComputeContext::DEVICE_COMPILER_AVAILABLE:
return WebCLGetInfo(true);
case ComputeContext::DEVICE_MAX_WORK_ITEM_SIZES: { // size_t[]
Vector<size_t> workItemSizes;
err = platformObject()->getDeviceInfo(infoType, &workItemSizes);
if (err == ComputeContext::SUCCESS) {
Vector<CCuint, 3> values;
for (size_t i = 0; i < workItemSizes.size(); ++i)
values.uncheckedAppend(workItemSizes[i]);
return WebCLGetInfo(values);
}
break;
}
case ComputeContext::DEVICE_MAX_WORK_GROUP_SIZE:
case ComputeContext::DEVICE_MAX_PARAMETER_SIZE:
case ComputeContext::DEVICE_PROFILING_TIMER_RESOLUTION:
case ComputeContext::DEVICE_IMAGE2D_MAX_HEIGHT:
case ComputeContext::DEVICE_IMAGE2D_MAX_WIDTH:
case ComputeContext::DEVICE_IMAGE3D_MAX_HEIGHT:
case ComputeContext::DEVICE_IMAGE3D_MAX_DEPTH:
case ComputeContext::DEVICE_IMAGE3D_MAX_WIDTH: {
size_t infoValue = 0;
err = platformObject()->getDeviceInfo(infoType, &infoValue);
if (err == ComputeContext::SUCCESS)
return WebCLGetInfo(static_cast<CCuint>(infoValue));
break;
}
case ComputeContext::DEVICE_MAX_WORK_ITEM_DIMENSIONS:
case ComputeContext::DEVICE_PREFERRED_VECTOR_WIDTH_CHAR:
case ComputeContext::DEVICE_PREFERRED_VECTOR_WIDTH_SHORT:
case ComputeContext::DEVICE_PREFERRED_VECTOR_WIDTH_INT:
case ComputeContext::DEVICE_PREFERRED_VECTOR_WIDTH_LONG:
case ComputeContext::DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT:
case ComputeContext::DEVICE_NATIVE_VECTOR_WIDTH_CHAR:
case ComputeContext::DEVICE_NATIVE_VECTOR_WIDTH_SHORT:
case ComputeContext::DEVICE_NATIVE_VECTOR_WIDTH_INT:
case ComputeContext::DEVICE_NATIVE_VECTOR_WIDTH_LONG:
case ComputeContext::DEVICE_NATIVE_VECTOR_WIDTH_FLOAT:
case ComputeContext::DEVICE_MAX_CLOCK_FREQUENCY:
case ComputeContext::DEVICE_MAX_READ_IMAGE_ARGS:
case ComputeContext::DEVICE_MAX_WRITE_IMAGE_ARGS:
case ComputeContext::DEVICE_MAX_SAMPLERS:
case ComputeContext::DEVICE_MEM_BASE_ADDR_ALIGN:
case ComputeContext::DEVICE_GLOBAL_MEM_CACHELINE_SIZE:
case ComputeContext::DEVICE_MAX_CONSTANT_ARGS:
case ComputeContext::DEVICE_ADDRESS_BITS:
case ComputeContext::DEVICE_MAX_COMPUTE_UNITS: {
CCuint infoValue = 0;
err = platformObject()->getDeviceInfo(infoType, &infoValue);
if (err == ComputeContext::SUCCESS)
return WebCLGetInfo(static_cast<CCuint>(infoValue));
break;
}
case ComputeContext::DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE:
case ComputeContext::DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE: {
if (!isEnabledExtension("KHR_fp64"))
return WebCLGetInfo(0);
CCuint infoValue = 0;
err = platformObject()->getDeviceInfo(infoType, &infoValue);
if (err == ComputeContext::SUCCESS)
return WebCLGetInfo(static_cast<CCuint>(infoValue));
break;
}
case ComputeContext::DEVICE_NATIVE_VECTOR_WIDTH_HALF:
case ComputeContext::DEVICE_PREFERRED_VECTOR_WIDTH_HALF: {
if (!isEnabledExtension("KHR_fp16"))
return WebCLGetInfo(0);
CCuint infoValue = 0;
err = platformObject()->getDeviceInfo(infoType, &infoValue);
if (err == ComputeContext::SUCCESS)
return WebCLGetInfo(static_cast<CCuint>(infoValue));
break;
}
case ComputeContext::DEVICE_LOCAL_MEM_SIZE:
case ComputeContext::DEVICE_MAX_CONSTANT_BUFFER_SIZE:
case ComputeContext::DEVICE_GLOBAL_MEM_SIZE:
case ComputeContext::DEVICE_GLOBAL_MEM_CACHE_SIZE:
case ComputeContext::DEVICE_MAX_MEM_ALLOC_SIZE: {
CCulong infoValue = 0;
err = platformObject()->getDeviceInfo(infoType, &infoValue);
if (err == ComputeContext::SUCCESS)
return WebCLGetInfo(static_cast<CCulong>(infoValue));
break;
}
case ComputeContext::DEVICE_HOST_UNIFIED_MEMORY:
case ComputeContext::DEVICE_ENDIAN_LITTLE:
case ComputeContext::DEVICE_ERROR_CORRECTION_SUPPORT: {
CCbool infoValue = 0;
err = platformObject()->getDeviceInfo(infoType, &infoValue);
if (err == ComputeContext::SUCCESS)
return WebCLGetInfo(static_cast<bool>(infoValue));
break;
}
case ComputeContext::DEVICE_GLOBAL_MEM_CACHE_TYPE: {
CCDeviceMemCachetype type = 0;
err = platformObject()->getDeviceInfo(infoType, &type);
if (err == ComputeContext::SUCCESS)
return WebCLGetInfo(static_cast<CCenum>(type));
break;
}
case ComputeContext::DEVICE_TYPE: {
CCDeviceType type = 0;
err = platformObject()->getDeviceInfo(infoType, &type);
if (err == ComputeContext::SUCCESS)
return WebCLGetInfo(static_cast<CCenum>(type));
break;
}
case ComputeContext::DEVICE_SINGLE_FP_CONFIG: {
CCDeviceFPConfig deviceFPConfig = 0;
err = platformObject()->getDeviceInfo(infoType, &deviceFPConfig);
if (err == ComputeContext::SUCCESS)
return WebCLGetInfo(static_cast<CCenum>(deviceFPConfig));
break;
}
case ComputeContext::DEVICE_LOCAL_MEM_TYPE: {
CCDeviceLocalMemType localMemoryType = 0;
err = platformObject()->getDeviceInfo(infoType, &localMemoryType);
if (err == ComputeContext::SUCCESS)
return WebCLGetInfo(static_cast<CCenum>(localMemoryType));
break;
}
case ComputeContext::DEVICE_QUEUE_PROPERTIES: {
CCCommandQueueProperties queueProperties = 0;
err = platformObject()->getDeviceInfo(infoType, &queueProperties);
if (err == ComputeContext::SUCCESS)
return WebCLGetInfo(static_cast<CCenum>(queueProperties));
break;
}
case ComputeContext::DEVICE_EXECUTION_CAPABILITIES:
return WebCLGetInfo(static_cast<CCenum>(ComputeContext::EXEC_KERNEL));
case ComputeContext::DEVICE_PLATFORM:
return WebCLGetInfo(m_platform);
default:
setExceptionFromComputeErrorCode(ComputeContext::INVALID_VALUE, exception);
}
ASSERT(err != ComputeContext::SUCCESS);
setExceptionFromComputeErrorCode(err, exception);
return WebCLGetInfo();
}
WebCLGetInfo WebCLKernel::getInfo (int kernel_info, ExceptionState& ec)
{
cl_int err = 0;
char function_name[1024];
cl_uint uint_units = 0;
cl_program cl_program_id = NULL;
cl_context cl_context_id = NULL;
RefPtr<WebCLProgram> programObj = NULL;
RefPtr<WebCLContext> contextObj = NULL;
if (m_cl_kernel == NULL) {
printf("Error: Invalid kernel\n");
ec.throwDOMException(WebCLException::INVALID_KERNEL, "WebCLException::INVALID_KERNEL");
return WebCLGetInfo();
}
switch(kernel_info)
{
case WebCL::KERNEL_FUNCTION_NAME:
err = webcl_clGetKernelInfo(webcl_channel_, m_cl_kernel, CL_KERNEL_FUNCTION_NAME, sizeof(function_name), &function_name, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(String(function_name));
break;
case WebCL::KERNEL_NUM_ARGS:
err = webcl_clGetKernelInfo(webcl_channel_, m_cl_kernel, CL_KERNEL_NUM_ARGS , sizeof(cl_uint), &uint_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::KERNEL_REFERENCE_COUNT:
err = webcl_clGetKernelInfo(webcl_channel_, m_cl_kernel, CL_KERNEL_REFERENCE_COUNT , sizeof(cl_uint), &uint_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::KERNEL_PROGRAM:
err = webcl_clGetKernelInfo(webcl_channel_, m_cl_kernel, CL_KERNEL_PROGRAM, sizeof(cl_program_id), &cl_program_id, NULL);
programObj = WebCLProgram::create(m_context, cl_program_id);
if (err == CL_SUCCESS)
return WebCLGetInfo(PassRefPtr<WebCLProgram>(programObj));
break;
case WebCL::KERNEL_CONTEXT:
err = webcl_clGetKernelInfo(webcl_channel_, m_cl_kernel, CL_KERNEL_CONTEXT, sizeof(cl_context), &cl_context_id, NULL);
contextObj = WebCLContext::create(m_context, cl_context_id);
if (err == CL_SUCCESS)
return WebCLGetInfo(PassRefPtr<WebCLContext>(contextObj));
break;
default:
return WebCLGetInfo();
}
switch (err) {
case CL_INVALID_KERNEL:
ec.throwDOMException(WebCLException::INVALID_KERNEL, "WebCLException::INVALID_KERNEL");
printf("Error: CL_INVALID_KERNEL \n");
break;
case CL_INVALID_VALUE:
ec.throwDOMException(WebCLException::INVALID_VALUE, "WebCLException::INVALID_VALUE");
printf("Error: CL_INVALID_VALUE\n");
break;
case CL_OUT_OF_RESOURCES:
ec.throwDOMException(WebCLException::OUT_OF_RESOURCES, "WebCLException::OUT_OF_RESOURCES");
printf("Error: CL_OUT_OF_RESOURCES \n");
break;
case CL_OUT_OF_HOST_MEMORY:
ec.throwDOMException(WebCLException::OUT_OF_HOST_MEMORY, "WebCLException::OUT_OF_HOST_MEMORY");
printf("Error: CL_OUT_OF_HOST_MEMORY \n");
break;
default:
ec.throwDOMException(WebCLException::FAILURE, "WebCLException::FAILURE");
printf("Error: Invaild Error Type\n");
break;
}
return WebCLGetInfo();
}
WebCLGetInfo WebCLKernel::getWorkGroupInfo( WebCLDevice* device, int param_name, ExceptionState& ec)
{
cl_int err = 0;
cl_device_id cl_device = NULL;
size_t sizet_units = 0;
cl_ulong ulong_units = 0;
if (m_cl_kernel == NULL) {
printf("Error: Invalid kernel\n");
ec.throwDOMException(WebCLException::INVALID_KERNEL, "WebCLException::INVALID_KERNEL");
return WebCLGetInfo();
}
if (device != NULL) {
cl_device = device->getCLDevice();
if (cl_device == NULL) {
printf("Error: cl_device null\n");
ec.throwDOMException(WebCLException::INVALID_DEVICE, "WebCLException::INVALID_DEVICE");
return WebCLGetInfo();
}
}
switch (param_name) {
case WebCL::KERNEL_WORK_GROUP_SIZE:
err = webcl_clGetKernelWorkGroupInfo(webcl_channel_, m_cl_kernel, cl_device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &sizet_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(sizet_units));
break;
case WebCL::KERNEL_COMPILE_WORK_GROUP_SIZE:
err = webcl_clGetKernelWorkGroupInfo(webcl_channel_, m_cl_kernel, cl_device, CL_KERNEL_COMPILE_WORK_GROUP_SIZE, sizeof(size_t), &sizet_units, NULL);
return WebCLGetInfo(static_cast<unsigned int>(sizet_units));
break;
case WebCL::KERNEL_LOCAL_MEM_SIZE:
err = webcl_clGetKernelWorkGroupInfo(webcl_channel_, m_cl_kernel, cl_device, CL_KERNEL_LOCAL_MEM_SIZE, sizeof(cl_ulong), &ulong_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned long>(ulong_units));
break;
default:
printf("Error: Unsupported Kernrl Info type\n");
return WebCLGetInfo();
}
printf("Error: clGetKerelWorkGroupInfo\n");
switch (err) {
case CL_INVALID_DEVICE:
ec.throwDOMException(WebCLException::INVALID_DEVICE, "WebCLException::INVALID_DEVICE");
printf("Error: CL_INVALID_DEVICE\n");
break;
case CL_INVALID_VALUE:
ec.throwDOMException(WebCLException::INVALID_VALUE, "WebCLException::INVALID_VALUE");
printf("Error: CL_INVALID_VALUE\n");
break;
case CL_INVALID_KERNEL:
ec.throwDOMException(WebCLException::INVALID_KERNEL, "WebCLException::INVALID_KERNEL");
printf("Error: CL_INVALID_KERNEL\n");
break;
default:
ec.throwDOMException(WebCLException::FAILURE, "WebCLException::FAILURE");
printf("Error: Invaild Error Type\n");
break;
}
return WebCLGetInfo();
}
WebCLGetInfo WebCLDevice::getInfo(int device_type, ExceptionState& ec)
{
cl_int err = 0;
char device_string[1024];
cl_uint uint_units = 0;
size_t sizet_units = 0;
size_t sizet_array[1024] = {0};
cl_ulong ulong_units = 0;
cl_bool bool_units = false;
cl_device_type type = 0;
cl_device_mem_cache_type global_type = 0;
cl_command_queue_properties queue_properties = 0;
cl_device_exec_capabilities exec = NULL;
cl_device_local_mem_type local_type = 0;
if (m_cl_device_id == NULL) {
printf("Error: Invalid Device ID\n");
ec.throwDOMException(WebCLException::INVALID_DEVICE, "WebCLException::INVALID_DEVICE");
return WebCLGetInfo();
}
switch(device_type)
{
case WebCL::DEVICE_EXTENSIONS:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_EXTENSIONS, sizeof(device_string), &device_string, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(String(device_string));
break;
case WebCL::DEVICE_NAME:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_NAME, sizeof(device_string), &device_string, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(String(device_string));
break;
case WebCL::DEVICE_PROFILE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_PROFILE, sizeof(device_string), &device_string, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(String(device_string));
break;
case WebCL::DEVICE_VENDOR:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_VENDOR, sizeof(device_string), &device_string, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(String(device_string));
break;
case WebCL::DEVICE_VERSION:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_VERSION, sizeof(device_string), &device_string, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(String(device_string));
break;
case WebCL::DRIVER_VERSION:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DRIVER_VERSION, sizeof(device_string), &device_string, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(String(device_string));
break;
case WebCL::DEVICE_ADDRESS_BITS:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_ADDRESS_BITS , sizeof(cl_uint), &uint_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_GLOBAL_MEM_CACHELINE_SIZE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE,sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_MAX_CLOCK_FREQUENCY:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_MAX_CONSTANT_ARGS:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MAX_CONSTANT_ARGS, sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_MAX_READ_IMAGE_ARGS:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MAX_READ_IMAGE_ARGS, sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_MAX_SAMPLERS:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MAX_SAMPLERS, sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_MAX_WRITE_IMAGE_ARGS:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MAX_WRITE_IMAGE_ARGS, sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_MEM_BASE_ADDR_ALIGN:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MEM_BASE_ADDR_ALIGN, sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_MIN_DATA_TYPE_ALIGN_SIZE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_VENDOR_ID:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_VENDOR_ID, sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_PREFERRED_VECTOR_WIDTH_CHAR:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_PREFERRED_VECTOR_WIDTH_SHORT:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_PREFERRED_VECTOR_WIDTH_INT:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_PREFERRED_VECTOR_WIDTH_LONG:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, sizeof(cl_uint), &uint_units,NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_MAX_COMPUTE_UNITS:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MAX_COMPUTE_UNITS , sizeof(cl_uint), &uint_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(uint_units));
break;
case WebCL::DEVICE_IMAGE2D_MAX_HEIGHT:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof(size_t), &sizet_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(sizet_units));
break;
case WebCL::DEVICE_IMAGE2D_MAX_WIDTH:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof(size_t), &sizet_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(sizet_units));
break;
case WebCL::DEVICE_IMAGE3D_MAX_DEPTH:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_IMAGE3D_MAX_DEPTH, sizeof(size_t), &sizet_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(sizet_units));
break;
case WebCL::DEVICE_IMAGE3D_MAX_HEIGHT:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof(size_t), &sizet_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(sizet_units));
break;
case WebCL::DEVICE_IMAGE3D_MAX_WIDTH:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof(size_t), &sizet_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(sizet_units));
break;
case WebCL::DEVICE_MAX_PARAMETER_SIZE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MAX_PARAMETER_SIZE, sizeof(size_t), &sizet_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(sizet_units));
break;
case WebCL::DEVICE_MAX_WORK_GROUP_SIZE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t), &sizet_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(sizet_units));
break;
case WebCL::DEVICE_MAX_WORK_ITEM_SIZES:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof(size_t), &sizet_units, NULL);
if(err == CL_SUCCESS) {
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MAX_WORK_ITEM_SIZES, 1024, &sizet_array, NULL);
// TODO (siba samal) Check support for SizeTArray/Int16Array in WebCLGetInfo
if (err == CL_SUCCESS) {
int values[3] = {0,0,0};
for(int i=0; i<((int)sizet_units); i++)
{
printf("%d\n", values[i]);
values[i] = (int)sizet_array[i];
}
return WebCLGetInfo(Int32Array::create(values, 3));
}
}
break;
case WebCL::DEVICE_PROFILING_TIMER_RESOLUTION:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_PROFILING_TIMER_RESOLUTION, sizeof(size_t), &sizet_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(sizet_units));
break;
case WebCL::DEVICE_MAX_WORK_ITEM_DIMENSIONS:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof(size_t), &sizet_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(sizet_units));
break;
case WebCL::DEVICE_LOCAL_MEM_SIZE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_LOCAL_MEM_SIZE, sizeof(cl_ulong), &ulong_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned long>(ulong_units));
break;
case WebCL::DEVICE_MAX_CONSTANT_BUFFER_SIZE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof(cl_ulong), &ulong_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned long>(ulong_units));
break;
case WebCL::DEVICE_MAX_MEM_ALLOC_SIZE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(cl_ulong), &ulong_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned long>(ulong_units));
break;
case WebCL::DEVICE_GLOBAL_MEM_CACHE_SIZE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, sizeof(cl_ulong), &ulong_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(ulong_units));
break;
case WebCL::DEVICE_GLOBAL_MEM_SIZE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(cl_ulong), &ulong_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(ulong_units));
break;
case WebCL::DEVICE_AVAILABLE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_AVAILABLE , sizeof(cl_bool), &bool_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<bool>(bool_units));
break;
case WebCL::DEVICE_COMPILER_AVAILABLE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_COMPILER_AVAILABLE , sizeof(cl_bool), &bool_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<bool>(bool_units));
break;
case WebCL::DEVICE_ENDIAN_LITTLE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_ENDIAN_LITTLE, sizeof(cl_bool), &bool_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<bool>(bool_units));
break;
case WebCL::DEVICE_ERROR_CORRECTION_SUPPORT:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_ERROR_CORRECTION_SUPPORT, sizeof(cl_bool), &bool_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<bool>(bool_units));
break;
case WebCL::DEVICE_IMAGE_SUPPORT:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_IMAGE_SUPPORT, sizeof(cl_bool), &bool_units, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<bool>(bool_units));
break;
case WebCL::DEVICE_TYPE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_TYPE, sizeof(type), &type, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(type));
break;
case WebCL::DEVICE_QUEUE_PROPERTIES:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_QUEUE_PROPERTIES,
sizeof(cl_command_queue_properties), &queue_properties, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(queue_properties));
break;
//cl_device_fp_config fp_config = 0;
// Part of cl_ext.h (which isn't available in Khronos)
//case WebCL::DEVICE_DOUBLE_FP_CONFIG:
//clGetDeviceInfo(m_cl_device_id, CL_DEVICE_DOUBLE_FP_CONFIG, sizeof(cl_device_fp_config), &fp_config, NULL);
//case WebCL::DEVICE_HALF_FP_CONFIG:
//clGetDeviceInfo(m_cl_device_id, CL_DEVICE_HALF_FP_CONFIG, sizeof(cl_device_fp_config), &fp_config, NULL);
//case vDEVICE_SINGLE_FP_CONFIG:
//clGetDeviceInfo(m_cl_device_id, CL_DEVICE_SINGLE_FP_CONFIG, sizeof(cl_device_fp_config), &fp_config, NULL);
//return WebCLGetInfo(static_cast<unsigned int>(fp_config));
//Platform ID is not Supported
//case WebCL::DEVICE_PLATFORM:
//cl_platform_id platform_id = NULL;
//clGetDeviceInfo(m_cl_device_id, CL_DEVICE_PLATFORM, sizeof(cl_platform_id), &platform_id, NULL);
//return WebCLGetInfo(static_cast<unsigned int>(platform_id));
case WebCL::DEVICE_EXECUTION_CAPABILITIES:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof(cl_device_exec_capabilities), &exec, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(exec));
break;
case WebCL::DEVICE_GLOBAL_MEM_CACHE_TYPE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, sizeof(cl_device_mem_cache_type), &global_type, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(global_type));
break;
case WebCL::DEVICE_LOCAL_MEM_TYPE:
err = webcl_clGetDeviceInfo(webcl_channel_, m_cl_device_id, CL_DEVICE_LOCAL_MEM_TYPE, sizeof(cl_device_local_mem_type), &local_type, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(local_type));
break;
default:
ec.throwDOMException(WebCLException::FAILURE, "WebCLException::FAILURE");
printf("Error:UNSUPPORTED DEVICE TYPE = %d ",device_type);
return WebCLGetInfo();
}
switch (err) {
case CL_INVALID_DEVICE:
ec.throwDOMException(WebCLException::INVALID_DEVICE, "WebCLException::INVALID_DEVICE");
printf("Error: CL_INVALID_DEVICE \n");
break;
case CL_INVALID_VALUE:
ec.throwDOMException(WebCLException::INVALID_VALUE, "WebCLException::INVALID_VALUE");
printf("Error: CL_INVALID_VALUE\n");
break;
case CL_OUT_OF_RESOURCES:
ec.throwDOMException(WebCLException::OUT_OF_RESOURCES, "WebCLException::OUT_OF_RESOURCES");
printf("Error: CL_OUT_OF_RESOURCES \n");
break;
case CL_OUT_OF_HOST_MEMORY:
ec.throwDOMException(WebCLException::OUT_OF_HOST_MEMORY, "WebCLException::OUT_OF_HOST_MEMORY");
printf("Error: CL_OUT_OF_HOST_MEMORY \n");
break;
default:
printf("Error: Invaild Error Type\n");
ec.throwDOMException(WebCLException::FAILURE, "WebCLException::FAILURE");
break;
}
return WebCLGetInfo();
}
WebCLGetInfo WebCLProgram::getBuildInfo(WebCLDevice* device, int param_name,
ExceptionState& es) {
cl_device_id device_id = NULL;
cl_int err = 0;
char buffer[8192];
size_t len = 0;
if (m_cl_program == NULL) {
printf("Error: Invalid program object\n");
es.throwWebCLException(
WebCLException::INVALID_PROGRAM,
WebCLException::invalidProgramMessage);
return WebCLGetInfo();
}
if (device != NULL) {
device_id = device->getCLDevice();
if (device_id == NULL) {
es.throwWebCLException(
WebCLException::INVALID_DEVICE,
WebCLException::invalidDeviceMessage);
printf("Error: device_id null\n");
return WebCLGetInfo();
}
}
switch (param_name) {
case WebCL::PROGRAM_BUILD_LOG:
err = clGetProgramBuildInfo(m_cl_program, device_id,
CL_PROGRAM_BUILD_LOG, sizeof(buffer),
buffer, &len);
if (err == CL_SUCCESS)
return WebCLGetInfo(String(buffer));
break;
case WebCL::PROGRAM_BUILD_OPTIONS:
err = clGetProgramBuildInfo(m_cl_program, device_id,
CL_PROGRAM_BUILD_OPTIONS,
sizeof(buffer), &buffer, NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(String(buffer));
break;
case WebCL::PROGRAM_BUILD_STATUS:
cl_build_status build_status;
err = clGetProgramBuildInfo(m_cl_program, device_id,
CL_PROGRAM_BUILD_STATUS,
sizeof(cl_build_status), &build_status,
NULL);
if (err == CL_SUCCESS)
return WebCLGetInfo(static_cast<unsigned int>(build_status));
break;
default:
es.throwWebCLException(
WebCLException::INVALID_PROGRAM,
WebCLException::invalidProgramMessage);
printf("Error: UNSUPPORTED Program Build Info Type = %d ",
param_name);
return WebCLGetInfo();
}
WebCLException::throwException(err, es);
return WebCLGetInfo();
}
