/* 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; }