/* void setKernelArgLocal (in long aIndex, in unsigned long aSize); */
NS_IMETHODIMP WebCLKernel::SetKernelArgLocal(PRInt32 aIndex, PRUint32 aSize, JSContext *cx)
{
D_METHOD_START;
nsresult rv = NS_OK;
NS_ENSURE_ARG_POINTER (cx);
cl_int err = mWrapper->setKernelArg (mInternal, aIndex, aSize, 0);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (err);
return rv;
}
/* nsIVariant getDevices (in T_WebCLDeviceType aType); */
NS_IMETHODIMP WebCLPlatform::GetDevices(T_WebCLDeviceType aType, JSContext *cx, nsIVariant **_retval)
{
D_METHOD_START;
NS_ENSURE_ARG_POINTER (_retval);
nsresult rv;
nsTArray<cl_device_id> devices;
cl_int err = mWrapper->getDeviceIDs (mInternal, aType, devices);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (err);
nsCOMPtr<nsIVariant> res;
rv = WebCL_convertVectorToJSArrayInVariant (cx, devices, types::DEVICE_V,
getter_AddRefs (res), mWrapper);
NS_ENSURE_SUCCESS (rv, rv);
NS_ADDREF (*_retval = res);
return NS_OK;
}
/* IWebCLKernel createKernel (in string aKernelName); */
NS_IMETHODIMP WebCLProgram::CreateKernel(const char *aKernelName, JSContext *cx, IWebCLKernel **_retval)
{
D_METHOD_START;
NS_ENSURE_ARG_POINTER (cx);
NS_ENSURE_ARG_POINTER (_retval);
nsresult rv;
cl_int err = CL_SUCCESS;
cl_kernel kernel = mWrapper->createKernel (mInternal, nsCString(aKernelName), &err);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (err);
nsCOMPtr<WebCLKernel> xpcObj;
rv = WebCLKernel::getInstance (kernel, getter_AddRefs(xpcObj), mWrapper);
NS_ENSURE_SUCCESS (rv, rv);
NS_ADDREF (*_retval = xpcObj);
return NS_OK;
}
/* nsIVariant createKernelsInProgram (); */
NS_IMETHODIMP WebCLProgram::CreateKernelsInProgram(JSContext *cx, nsIVariant **_retval)
{
D_METHOD_START;
NS_ENSURE_ARG_POINTER (cx);
NS_ENSURE_ARG_POINTER (_retval);
nsresult rv;
nsTArray<cl_kernel> kernels;
cl_int err = mWrapper->createKernelsInProgram (mInternal, kernels);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (err);
nsCOMPtr<nsIVariant> value;
rv = WebCL_convertVectorToJSArrayInVariant (cx, kernels,
types::KERNEL_V,
getter_AddRefs (value),
mWrapper);
NS_ENSURE_SUCCESS (rv, rv);
NS_ADDREF (*_retval = value);
return NS_OK;
}
/* void buildProgram (in nsIVariant aDevices, in string aOptions); */
NS_IMETHODIMP WebCLProgram::BuildProgram(nsIVariant *aDevices, const char *aOptions, JSContext *cx)
{
D_METHOD_START;
NS_ENSURE_ARG_POINTER (aDevices);
NS_ENSURE_ARG_POINTER (cx);
nsresult rv;
nsTArray<nsIVariant*> deviceVariants;
rv = WebCL_getVariantsFromJSArray (cx, aDevices, deviceVariants);
NS_ENSURE_SUCCESS (rv, rv);
nsTArray<cl_device_id> devices;
rv = WebCL_convertVariantVectorToInternalVector<WebCLDevice, cl_device_id> (deviceVariants,
devices);
WebCL_releaseVariantVector (deviceVariants);
NS_ENSURE_SUCCESS (rv, rv);
cl_int err = mWrapper->buildProgram (mInternal, devices, nsCString(aOptions), 0, 0);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (err);
return NS_OK;
}
/* void setKernelArg (in long aIndex, in nsIVariant aValue, [optional] in long aType); */
NS_IMETHODIMP WebCLKernel::SetKernelArg(PRInt32 aIndex, nsIVariant *aValue, PRInt32 aType, JSContext *cx)
{
D_METHOD_START;
NS_ENSURE_ARG_POINTER (aValue);
NS_ENSURE_ARG_POINTER (cx);
nsresult rv = NS_OK;
if (aType == types::UNKNOWN)
{
PRUint16 variantType = 0;
rv = aValue->GetDataType (&variantType);
// If the type is unknown or user chose not to use explicit type, we'll try
// to guess it based on the type of the variant.
switch (variantType)
{
case nsIDataType::VTYPE_INT8: return SetKernelArg (aIndex, aValue, types::CHAR, cx);
case nsIDataType::VTYPE_INT16: return SetKernelArg (aIndex, aValue, types::SHORT, cx);
case nsIDataType::VTYPE_INT32: return SetKernelArg (aIndex, aValue, types::INT, cx);
case nsIDataType::VTYPE_INT64: return SetKernelArg (aIndex, aValue, types::LONG, cx);
case nsIDataType::VTYPE_UINT8: return SetKernelArg (aIndex, aValue, types::UCHAR, cx);
case nsIDataType::VTYPE_UINT16: return SetKernelArg (aIndex, aValue, types::USHORT, cx);
case nsIDataType::VTYPE_UINT32: return SetKernelArg (aIndex, aValue, types::UINT, cx);
case nsIDataType::VTYPE_UINT64: return SetKernelArg (aIndex, aValue, types::ULONG, cx);
case nsIDataType::VTYPE_FLOAT: return SetKernelArg (aIndex, aValue, types::FLOAT, cx);
case nsIDataType::VTYPE_DOUBLE: return SetKernelArg (aIndex, aValue, types::DOUBLE, cx);
case nsIDataType::VTYPE_BOOL: return SetKernelArg (aIndex, aValue, types::BOOL, cx);
case nsIDataType::VTYPE_CHAR:
case nsIDataType::VTYPE_WCHAR: return SetKernelArg (aIndex, aValue, types::CHAR, cx);
case nsIDataType::VTYPE_CHAR_STR:
case nsIDataType::VTYPE_WCHAR_STR:
case nsIDataType::VTYPE_UTF8STRING:
case nsIDataType::VTYPE_ASTRING:
case nsIDataType::VTYPE_CSTRING: return SetKernelArg (aIndex, aValue, types::STRING, cx);
case nsIDataType::VTYPE_INTERFACE:
case nsIDataType::VTYPE_INTERFACE_IS:
{
// Try conversions to supported WebCL interfaces.
nsCOMPtr<IWebCLMemoryObject> memObj;
rv = aValue->GetAsISupports (getter_AddRefs(memObj));
if (NS_SUCCEEDED (rv)) return SetKernelArg (aIndex, aValue, types::MEMORY_OBJECT, cx);
nsCOMPtr<IWebCLSampler> samplerObj;
rv = aValue->GetAsISupports (getter_AddRefs(samplerObj));
if (NS_SUCCEEDED (rv)) return SetKernelArg (aIndex, aValue, types::SAMPLER, cx);
// None found, intentional leak to default
}
case nsIDataType::VTYPE_ARRAY:
case nsIDataType::VTYPE_EMPTY_ARRAY:
D_LOG (LOG_LEVEL_ERROR, "Array support not implemented.");
WebCL_reportJSError (cx, "WebCLKernel::setKernelArg: Array support not implemented.");
return WEBCL_XPCOM_ERROR; //NS_ERROR_INVALID_ARG;
case nsIDataType::VTYPE_EMPTY:
case nsIDataType::VTYPE_VOID:
case nsIDataType::VTYPE_ID:
default:
D_LOG (LOG_LEVEL_ERROR,
"Unable to guess type from variant (type %u) and no type given by the user.",
variantType);
WebCL_reportJSError (cx, "WebCLKernel::setKernelArg: Unable to guess type from variant (type %u) and no type given by the user.",
variantType);
return WEBCL_XPCOM_ERROR; //NS_ERROR_INVALID_ARG;
}
}
size_t sze = 0;
void* value = 0;
switch (aType)
{
case types::BYTE:
case types::CHAR:
value = (void*)malloc (sze = sizeof (cl_char));
if (value)
rv = variantToCLChar (aValue, (cl_char*)value);
break;
case types::UCHAR:
value = (void*)malloc (sze = sizeof (cl_uchar));
if (value)
rv = variantToCLUChar (aValue, (cl_uchar*)value);
break;
case types::SHORT:
value = (void*)malloc (sze = sizeof (cl_short));
if (value)
rv = variantToCLShort (aValue, (cl_short*)value);
break;
case types::USHORT:
value = (void*)malloc (sze = sizeof (cl_ushort));
if (value)
rv = variantToCLUShort (aValue, (cl_ushort*)value);
break;
case types::BUILD_STATUS:
case types::INT:
value = (void*)malloc (sze = sizeof (cl_int));
if (value)
rv = variantToCLInt (aValue, (cl_int*)value);
break;
case types::ADRESSING_MODE:
case types::CHANNEL_ORDER:
case types::CHANNEL_TYPE:
case types::COMMAND_TYPE:
case types::DEVICE_LOCAL_MEM_TYPE:
case types::DEVICE_MEM_CACHE_TYPE:
case types::FILTER_MODE:
case types::GL_OBJECT_TYPE:
case types::MEM_OBJECT_TYPE:
case types::UINT:
value = (void*)malloc (sze = sizeof (cl_uint));
if (value)
rv = variantToCLUInt (aValue, (cl_uint*)value);
break;
case types::LONG:
value = (void*)malloc (sze = sizeof (cl_long));
if (value)
rv = variantToCLLong (aValue, (cl_long*)value);
break;
case types::COMMAND_QUEUE_PROPERTIES: // bitfield
case types::DEVICE_EXEC_CAPABILITIES: // bitfield
case types::DEVICE_FP_CONFIG: // bitfield
case types::DEVICE_TYPE: // bitfield
case types::MAP_FLAGS: // bitfield
case types::MEM_FLAGS: // bitfield
case types::ULONG:
value = (void*)malloc (sze = sizeof (cl_ulong));
if (value)
rv = variantToCLULong (aValue, (cl_ulong*)value);
break;
case types::BOOL:
value = (void*)malloc (sze = sizeof (cl_bool));
if (value)
rv = variantToCLBool (aValue, (cl_bool*)value);
break;
case types::SIZE_T:
value = (void*)malloc (sze = sizeof (size_t));
if (value)
rv = variantToCLSizeT (aValue, (size_t*)value);
break;
case types::HALF:
value = (void*)malloc (sze = sizeof (cl_half));
if (value)
rv = variantToCLHalf (aValue, (cl_half*)value);
break;
case types::FLOAT:
value = (void*)malloc (sze = sizeof (cl_float));
if (value)
rv = variantToCLFloat (aValue, (cl_float*)value);
break;
case types::DOUBLE:
value = (void*)malloc (sze = sizeof (cl_double));
if (value)
rv = variantToCLDouble (aValue, (cl_double*)value);
break;
case types::STRING:
{
nsCString str;
rv = aValue->GetAsACString (str);
if (NS_SUCCEEDED (rv))
{
cl_int err = mWrapper->setKernelArg (mInternal, aIndex, str.Length () + 1,
(void*)str.get ());
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (err);
}
break;
}
case types::BYTE_V:
case types::CHAR_V:
case types::UCHAR_V:
case types::SHORT_V:
case types::USHORT_V:
case types::CONTEXT_PROPERTIES:
case types::INT_V:
case types::UINT_V:
case types::LONG_V:
case types::ULONG_V:
case types::BOOL_V:
case types::SIZE_T_V:
case types::HALF_V:
case types::FLOAT_V:
case types::DOUBLE_V:
case types::STRING_V:
D_LOG (LOG_LEVEL_ERROR, "Array types are not supported.");
WebCL_reportJSError (cx, "WebCLKernel::setKernelArg: Array types are not supported.");
return WEBCL_XPCOM_ERROR; //NS_ERROR_NOT_IMPLEMENTED;
case types::MEMORY_OBJECT:
{
nsCOMPtr<nsISupports> isu;
rv = aValue->GetAsISupports (getter_AddRefs(isu));
if (NS_FAILED (rv)) break;
nsCOMPtr<WebCLMemoryObject> memObject = do_QueryInterface (isu, &rv);
if (NS_FAILED (rv)) break;
cl_mem wrapped = memObject->getInternal ();
cl_int wrErr = mWrapper->setKernelArg (mInternal, aIndex, sizeof(cl_mem),
(void*)&wrapped);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (wrErr);
return NS_OK;
}
case types::SAMPLER:
{
nsCOMPtr<nsISupports> isu;
rv = aValue->GetAsISupports (getter_AddRefs(isu));
if (NS_FAILED (rv)) break;
nsCOMPtr<WebCLSampler> sampler = do_QueryInterface (isu, &rv);
if (NS_FAILED (rv)) break;
cl_sampler wrapped = sampler->getInternal ();
cl_int wrErr = mWrapper->setKernelArg (mInternal, aIndex, sizeof(cl_sampler),
(void*)&wrapped);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (wrErr);
return NS_OK;
}
case types::PLATFORM:
{
nsCOMPtr<nsISupports> isu;
rv = aValue->GetAsISupports (getter_AddRefs(isu));
if (NS_FAILED (rv)) break;
nsCOMPtr<WebCLPlatform> platform = do_QueryInterface (isu, &rv);
if (NS_FAILED (rv)) break;
cl_platform_id wrapped = platform->getInternal ();
cl_int wrErr = mWrapper->setKernelArg (mInternal, aIndex, sizeof(cl_platform_id),
(void*)&wrapped);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (wrErr);
return NS_OK;
}
case types::DEVICE:
{
nsCOMPtr<nsISupports> isu;
rv = aValue->GetAsISupports (getter_AddRefs(isu));
if (NS_FAILED (rv)) break;
nsCOMPtr<WebCLDevice> device = do_QueryInterface (isu, &rv);
if (NS_FAILED (rv)) break;
cl_device_id wrapped = device->getInternal ();
cl_int wrErr = mWrapper->setKernelArg (mInternal, aIndex, sizeof(cl_device_id),
(void*)&wrapped);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (wrErr);
return NS_OK;
}
case types::CONTEXT:
{
nsCOMPtr<nsISupports> isu;
rv = aValue->GetAsISupports (getter_AddRefs(isu));
if (NS_FAILED (rv)) break;
nsCOMPtr<WebCLContext> context = do_QueryInterface (isu, &rv);
if (NS_FAILED (rv)) break;
cl_context wrapped = context->getInternal ();
cl_int wrErr = mWrapper->setKernelArg (mInternal, aIndex, sizeof(cl_context),
(void*)&wrapped);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (wrErr);
return NS_OK;
}
case types::COMMAND_QUEUE:
{
nsCOMPtr<nsISupports> isu;
rv = aValue->GetAsISupports (getter_AddRefs(isu));
if (NS_FAILED (rv)) break;
nsCOMPtr<WebCLCommandQueue> cmdQueue = do_QueryInterface (isu, &rv);
if (NS_FAILED (rv)) break;
cl_command_queue wrapped = cmdQueue->getInternal ();
cl_int wrErr = mWrapper->setKernelArg (mInternal, aIndex, sizeof(cl_command_queue),
(void*)&wrapped);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (wrErr);
return NS_OK;
}
case types::PROGRAM:
{
nsCOMPtr<nsISupports> isu;
rv = aValue->GetAsISupports (getter_AddRefs(isu));
if (NS_FAILED (rv)) break;
nsCOMPtr<WebCLProgram> program = do_QueryInterface (isu, &rv);
if (NS_FAILED (rv)) break;
cl_program wrapped = program->getInternal ();
cl_int wrErr = mWrapper->setKernelArg (mInternal, aIndex, sizeof(cl_program),
(void*)&wrapped);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (wrErr);
return NS_OK;
}
case types::KERNEL:
{
nsCOMPtr<nsISupports> isu;
rv = aValue->GetAsISupports (getter_AddRefs(isu));
if (NS_FAILED (rv)) break;
nsCOMPtr<WebCLKernel> kernel = do_QueryInterface (isu, &rv);
if (NS_FAILED (rv)) break;
cl_kernel wrapped = kernel->getInternal ();
cl_int wrErr = mWrapper->setKernelArg (mInternal, aIndex, sizeof(cl_kernel),
(void*)&wrapped);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (wrErr);
return NS_OK;
}
case types::EVENT:
{
nsCOMPtr<nsISupports> isu;
rv = aValue->GetAsISupports (getter_AddRefs(isu));
if (NS_FAILED (rv)) break;
nsCOMPtr<WebCLEvent> event = do_QueryInterface (isu, &rv);
if (NS_FAILED (rv)) break;
cl_event wrapped = event->getInternal ();
cl_int wrErr = mWrapper->setKernelArg (mInternal, aIndex, sizeof(cl_event),
(void*)&wrapped);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (wrErr);
return NS_OK;
}
default:
D_LOG (LOG_LEVEL_ERROR, "Unsupported type %d at argument index %u", aType, aIndex);
WebCL_reportJSError (cx, "WebCLKernel::setKernelArg: Unsupported type %d at argument index %u.", aType, aIndex);
//rv = NS_ERROR_INVALID_ARG;
return WEBCL_XPCOM_ERROR;
}
if (NS_SUCCEEDED (rv))
{
if (value)
{
cl_int err = mWrapper->setKernelArg (mInternal, aIndex, sze, value);
ENSURE_LIB_WRAPPER_SUCCESS (mWrapper);
ENSURE_CL_OP_SUCCESS (err);
}
else
{
D_LOG (LOG_LEVEL_ERROR, "Memory allocation failed for kernel argument at index %d.", aIndex);
WebCL_reportJSError (cx, "WebCLKernel::setKernelArg: Memory allocation failed for kernel argument at index %d.", aIndex);
rv = WEBCL_XPCOM_ERROR; //NS_ERROR_OUT_OF_MEMORY;
}
}
else
{
D_LOG (LOG_LEVEL_ERROR, "Failed to convert kernel argument at index %d.", aIndex);
WebCL_reportJSError (cx, "WebCLKernel::setKernelArg: Failed to convert kernel argument at index %d.", aIndex);
rv = WEBCL_XPCOM_ERROR;
}
if (value)
free (value);
return rv;
}
