/* [implicit_jscontext] dpoIData allocateData (in jsval templ, [optional] in uint32_t length); */
NS_IMETHODIMP dpoCContext::AllocateData(const jsval & templ, uint32_t length, JSContext *cx, dpoIData **_retval)
{
cl_int err_code;
nsresult result;
JSObject *tArray;
size_t bytePerElements;
nsCOMPtr<dpoCData> data;
result = ExtractArray( templ, &tArray, cx);
if (NS_FAILED(result)) {
return result;
}
data = new dpoCData( this);
if (data == NULL) {
DEBUG_LOG_STATUS("AllocateData", "Cannot create new dpoCData object");
return NS_ERROR_OUT_OF_MEMORY;
}
if (length == 0) {
DEBUG_LOG_STATUS("AllocateData", "size not provided, assuming template's size");
length = JS_GetTypedArrayLength(tArray);
}
bytePerElements = JS_GetTypedArrayByteLength(tArray) / JS_GetTypedArrayLength(tArray);
DEBUG_LOG_STATUS("AllocateData", "length " << length << " bytePerElements " << bytePerElements);
#ifdef PREALLOCATE_IN_JS_HEAP
JSObject *jsArray;
if (NS_FAILED(CreateAlignedTA(JS_GetTypedArrayType(tArray, cx), length, &jsArray, cx))) {
return NS_ERROR_NOT_AVAILABLE;
}
if (!jsArray) {
DEBUG_LOG_STATUS("AllocateData", "Cannot create typed array");
return NS_ERROR_OUT_OF_MEMORY;
}
cl_mem memObj = CreateBuffer( CL_MEM_USE_HOST_PTR | CL_MEM_READ_WRITE,
JS_GetTypedArrayByteLength(jsArray, cx), GetPointerFromTA(jsArray, cx), &err_code);
#else /* PREALLOCATE_IN_JS_HEAP */
JSObject *jsArray = nullptr;
cl_mem memObj = CreateBuffer(cx, CL_MEM_READ_WRITE, length * bytePerElements, NULL, &err_code);
#endif /* PREALLOCATE_IN_JS_HEAP */
if (err_code != CL_SUCCESS) {
DEBUG_LOG_ERROR("AllocateData", err_code);
return NS_ERROR_NOT_AVAILABLE;
}
result = data->InitCData(cx, cmdQueue, memObj, JS_GetArrayBufferViewType(tArray), length, length * bytePerElements, jsArray);
if (NS_SUCCEEDED(result)) {
data.forget((dpoCData **) _retval);
}
return result;
}
/* [implicit_jscontext] uint32_t getAlignmentOffset (in jsval source); */
NS_IMETHODIMP dpoCContext::GetAlignmentOffset(const JS::Value & source, JSContext* cx, uint32_t *_retval)
{
JSObject *object;
uint8_t *data;
if (JSVAL_IS_PRIMITIVE(source)) {
return NS_ERROR_INVALID_ARG;
}
object = JSVAL_TO_OBJECT(source);
if (JS_IsTypedArrayObject(object)) {
data = GetPointerFromTA(object, cx);
} else if (JS_IsArrayBufferObject(object)) {
data = JS_GetArrayBufferData(object);
} else {
return NS_ERROR_INVALID_ARG;
}
*_retval = (((uintptr_t) data) + alignment_size) / alignment_size * alignment_size - ((uintptr_t) data);
return NS_OK;
}
/* [implicit_jscontext] dpoIData mapData (in jsval source); */
NS_IMETHODIMP dpoCContext::MapData(const jsval & source, JSContext *cx, dpoIData **_retval)
{
cl_int err_code;
nsresult result;
JSObject *tArray;
nsCOMPtr<dpoCData> data;
result = ExtractArray( source, &tArray, cx);
if (NS_SUCCEEDED(result)) {
// we have a typed array
data = new dpoCData( this);
if (data == NULL) {
DEBUG_LOG_STATUS("MapData", "Cannot create new dpoCData object");
return NS_ERROR_OUT_OF_MEMORY;
}
// USE_HOST_PTR is save as the CData object will keep the associated typed array alive as long as the
// memory buffer lives
cl_mem_flags flags = CL_MEM_READ_ONLY;
void *tArrayBuffer = NULL;
size_t arrayByteLength = JS_GetTypedArrayByteLength(tArray, cx);
if(arrayByteLength == 0) {
arrayByteLength = 1;
}
else {
tArrayBuffer = GetPointerFromTA(tArray, cx);
flags |= CL_MEM_USE_HOST_PTR;
}
cl_mem memObj = CreateBuffer(flags, arrayByteLength, tArrayBuffer , &err_code);
if (err_code != CL_SUCCESS) {
DEBUG_LOG_ERROR("MapData", err_code);
return NS_ERROR_NOT_AVAILABLE;
}
result = data->InitCData(cx, cmdQueue, memObj, JS_GetTypedArrayType(tArray, cx), JS_GetTypedArrayLength(tArray, cx),
JS_GetTypedArrayByteLength(tArray, cx), tArray);
#ifdef SUPPORT_MAPPING_ARRAYS
} else if (JSVAL_IS_OBJECT(source)) {
// maybe it is a regular array.
//
// WARNING: We map a pointer to the actual array here. All this works on CPU only
// and only of the OpenCL compiler knows what to do! For the current Intel OpenCL SDK
// this works but your milage may vary.
const jsval *elems = UnsafeDenseArrayElements(cx, JSVAL_TO_OBJECT(source));
if (elems != NULL) {
data = new dpoCData( this);
if (data == NULL) {
DEBUG_LOG_STATUS("MapData", "Cannot create new dpoCData object");
return NS_ERROR_OUT_OF_MEMORY;
}
cl_mem memObj = CreateBuffer(CL_MEM_COPY_HOST_PTR | CL_MEM_READ_ONLY, sizeof(double *), &elems, &err_code);
if (err_code != CL_SUCCESS) {
DEBUG_LOG_ERROR("MapData", err_code);
return NS_ERROR_NOT_AVAILABLE;
}
result = data->InitCData(cx, cmdQueue, memObj, 0 /* bogus type */, 1, sizeof(double *), JSVAL_TO_OBJECT(source));
#ifndef DEBUG_OFF
} else {
DEBUG_LOG_STATUS("MapData", "No elements returned!");
#endif /* DEBUG_OFF */
}
#endif /* SUPPORT_MAPPING_ARRAYS */
}
if (NS_SUCCEEDED(result)) {
data.forget((dpoCData **)_retval);
}
return result;
}