void HeapPage::joinBlocks(std::list<HeapBlock> &newReleasedBlocks, std::list<HeapBlock> &newBlocks)
{
auto current = blocks.begin();
while (current != blocks.end()) {
if (current->isReleased()) {
// Found released blocks, look forward for more
// released blocks.
HeapBlock& head = *current;
uint32 bytes = 0;
while (current != blocks.end() && current->isReleased()) {
bytes += current->getSize();
current++;
}
const uint32 diff = bytes - head.getSize();
head.grow(diff);
newReleasedBlocks.push_back(head);
newBlocks.push_back(head);
} else {
// Just push the block to block list, it is occupied.
newBlocks.push_back(*current);
current++;
}
}
}
PassRefPtr<WebCLBuffer> WebCLContext::createBufferBase(unsigned memFlags, unsigned sizeInBytes, void* hostPtr, ExceptionState& es)
{
if (isReleased()) {
es.throwWebCLException(WebCLException::InvalidContext, WebCLException::invalidContextMessage);
return nullptr;
}
if (!WebCLInputChecker::isValidMemoryObjectFlag(memFlags)) {
es.throwWebCLException(WebCLException::InvalidValue, WebCLException::invalidValueMessage);
return nullptr;
}
unsigned num = 0;
for (size_t i = 0; i < m_devices.size(); ++i) {
unsigned maxMemAllocSize = m_devices[i]->getMaxMemAllocSize();
if (maxMemAllocSize && maxMemAllocSize < sizeInBytes) {
num++;
}
}
if (num != 0 && num == m_devices.size()) {
es.throwWebCLException(WebCLException::InvalidBufferSize, WebCLException::invalidBufferSizeMessage);
return nullptr;
}
if (sizeInBytes == 0) {
es.throwWebCLException(WebCLException::InvalidBufferSize, WebCLException::invalidBufferSizeMessage);
return nullptr;
}
RefPtr<WebCLBuffer> buffer = WebCLBuffer::create(this, memFlags, sizeInBytes, hostPtr, es);
if (!hostPtr && buffer)
m_memoryUtil->bufferCreated(buffer.get(), es);
return buffer.release();
}
ScriptValue WebCLContext::getInfo(ScriptState* scriptState, int paramName, ExceptionState& es)
{
v8::Handle<v8::Object> creationContext = scriptState->context()->Global();
v8::Isolate* isolate = scriptState->isolate();
if (isReleased()) {
es.throwWebCLException(WebCLException::InvalidContext, WebCLException::invalidContextMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
cl_int err = CL_SUCCESS;
cl_uint uintUnits = 0;
Vector<RefPtr<WebCLDevice>> result;
switch (paramName) {
case CL_CONTEXT_NUM_DEVICES:
err = clGetContextInfo(m_clContext, CL_CONTEXT_NUM_DEVICES, sizeof(cl_uint), &uintUnits, nullptr);
if (err == CL_SUCCESS)
return ScriptValue(scriptState, v8::Integer::NewFromUnsigned(isolate, static_cast<unsigned>(uintUnits)));
WebCLException::throwException(err, es);
return ScriptValue(scriptState, v8::Null(isolate));
case CL_CONTEXT_DEVICES:
return ScriptValue(scriptState, toV8(m_devices, creationContext, isolate));
default:
es.throwWebCLException(WebCLException::InvalidValue, WebCLException::invalidValueMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
}
void WebCLKernel::setArg(unsigned index, WebCLSampler* sampler, ExceptionState& es)
{
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_KERNEL, WebCLException::invalidKernelMessage);
return;
}
cl_sampler clSamplerId = nullptr;
if (sampler) {
clSamplerId = sampler->getSampler();
if (!clSamplerId) {
es.throwWebCLException(WebCLException::INVALID_MEM_OBJECT, WebCLException::invalidMemObjectMessage);
return;
}
}
WebCLKernelArgInfo* argInfo = getArgInfo(index, es);
if (!argInfo || argInfo->type() != WebCLKernelArgInfo::SAMPLER) {
es.throwWebCLException(WebCLException::INVALID_ARG_VALUE, WebCLException::invalidArgIndexMessage);
return;
}
cl_int err = clSetKernelArg(m_clKernel, index, sizeof(cl_sampler), &clSamplerId);
if (err != CL_SUCCESS)
WebCLException::throwException(err, es);
else
argInfo->setAssociated(true);
}
void WebCLUserEvent::setStatus(cl_int executionStatus, ExceptionState& es)
{
ASSERT(isUserEvent());
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_EVENT, WebCLException::invalidEventMessage);
return;
}
if (!(executionStatus < 0 || executionStatus == CL_COMPLETE)) {
es.throwWebCLException(WebCLException::INVALID_VALUE, WebCLException::invalidValueMessage);
return;
}
if (m_eventStatusSituation == StatusSet) {
es.throwWebCLException(WebCLException::INVALID_OPERATION, WebCLException::invalidOperationMessage);
return;
}
m_eventStatusSituation = StatusSet;
m_executionStatus = executionStatus;
cl_int err = clSetUserEventStatus(m_clEvent, executionStatus);
if (err != CL_SUCCESS)
WebCLException::throwException(err, es);
}
__USE_CORTEX_NAMESPACE
// ---------------------------------------------------------------- //
// *** deletion
// ---------------------------------------------------------------- //
// clients must call release() rather than deleting,
// to ensure that all observers are notified of the
// object's demise. if the object has already been
// released, return an error.
status_t ObservableLooper::release() {
// +++++ what if I'm not running?
// +++++ is a lock necessary?
if(isReleased())
return B_NOT_ALLOWED;
// send request through proper channels
BMessenger(this).SendMessage(B_QUIT_REQUESTED);
return B_OK;
}
ScriptValue WebCLKernel::getInfo(ScriptState* scriptState, int kernelInfo, ExceptionState& es)
{
v8::Handle<v8::Object> creationContext = scriptState->context()->Global();
v8::Isolate* isolate = scriptState->isolate();
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_KERNEL, WebCLException::invalidKernelMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
cl_int err = CL_SUCCESS;
cl_uint uintUnits = 0;
switch (kernelInfo) {
case CL_KERNEL_FUNCTION_NAME:
return ScriptValue(scriptState, v8String(isolate, m_kernelName));
case CL_KERNEL_NUM_ARGS:
err = clGetKernelInfo(m_clKernel, CL_KERNEL_NUM_ARGS, sizeof(cl_uint), &uintUnits, nullptr);
if (err == CL_SUCCESS)
return ScriptValue(scriptState, v8::Integer::NewFromUnsigned(isolate, static_cast<unsigned>(uintUnits)));
break;
case CL_KERNEL_PROGRAM:
return ScriptValue(scriptState, toV8(m_program, creationContext, isolate));
break;
case CL_KERNEL_CONTEXT:
return ScriptValue(scriptState, toV8(context(), creationContext, isolate));
break;
default:
es.throwWebCLException(WebCLException::INVALID_VALUE, WebCLException::invalidValueMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
WebCLException::throwException(err, es);
return ScriptValue(scriptState, v8::Null(isolate));
}
PassRefPtr<WebCLProgram> WebCLContext::createProgram(const String& kernelSource, ExceptionState& es)
{
if (isReleased()) {
es.throwWebCLException(WebCLException::InvalidContext, WebCLException::invalidContextMessage);
return nullptr;
}
if (!kernelSource.length()) {
es.throwWebCLException(WebCLException::InvalidValue, WebCLException::invalidValueMessage);
return nullptr;
}
const char* source = strdup(kernelSource.utf8().data());
cl_int err = CL_SUCCESS;
cl_program clProgramId = clCreateProgramWithSource(m_clContext, 1, (const char**)&source, nullptr, &err);
if (err != CL_SUCCESS) {
WebCLException::throwException(err, es);
return nullptr;
}
RefPtr<WebCLProgram> program = WebCLProgram::create(clProgramId, this, kernelSource);
if (!program) {
es.throwWebCLException(WebCLException::InvalidProgram, WebCLException::invalidProgramMessage);
return nullptr;
}
return program.release();
}
ScriptValue WebCLProgram::getInfo(ScriptState* scriptState, int paramName, ExceptionState& es)
{
v8::Handle<v8::Object> creationContext = scriptState->context()->Global();
v8::Isolate* isolate = scriptState->isolate();
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_PROGRAM, WebCLException::invalidProgramMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
cl_int err = CL_SUCCESS;
cl_uint uintUnits = 0;
Vector<RefPtr<WebCLDevice>> result = context()->getDevices();
switch(paramName) {
case CL_PROGRAM_NUM_DEVICES:
err = clGetProgramInfo(m_clProgram, CL_PROGRAM_NUM_DEVICES, sizeof(cl_uint), &uintUnits, nullptr);
if (err == CL_SUCCESS)
return ScriptValue(scriptState, v8::Integer::NewFromUnsigned(isolate, static_cast<unsigned>(uintUnits)));
WebCLException::throwException(err, es);
return ScriptValue(scriptState, v8::Null(isolate));
case CL_PROGRAM_SOURCE:
return ScriptValue(scriptState, v8String(isolate, m_programSource));
case CL_PROGRAM_CONTEXT:
return ScriptValue(scriptState, toV8(context(), creationContext, isolate));
case CL_PROGRAM_DEVICES:
return ScriptValue(scriptState, toV8(result, creationContext, isolate));
default:
es.throwWebCLException(WebCLException::INVALID_VALUE, WebCLException::invalidValueMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
}
PassRefPtr<WebCLKernel> WebCLProgram::createKernel(const String& kernelName, ExceptionState& es)
{
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_PROGRAM, WebCLException::invalidProgramMessage);
return nullptr;
}
if (!m_isProgramBuilt) {
es.throwWebCLException(WebCLException::INVALID_PROGRAM_EXECUTABLE, WebCLException::invalidProgramExecutableMessage);
return nullptr;
}
if (!m_programSource.contains(kernelName)) {
es.throwWebCLException(WebCLException::INVALID_KERNEL_NAME, WebCLException::invalidKernelNameMessage);
return nullptr;
}
cl_int err = CL_SUCCESS;
const char* kernelNameStr = strdup(kernelName.utf8().data());
cl_kernel clKernelId = clCreateKernel(m_clProgram, kernelNameStr, &err);
if (err != CL_SUCCESS) {
WebCLException::throwException(err, es);
return nullptr;
}
RefPtr<WebCLKernel> kernel = WebCLKernel::create(clKernelId, context(), this, kernelName);
return kernel;
}
void WebCLKernel::setArg(unsigned index, WebCLMemoryObject* object, ExceptionState& es)
{
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_KERNEL, WebCLException::invalidKernelMessage);
return;
}
cl_mem clObject = nullptr;
if (object) {
clObject = object->getMem();
if (!clObject) {
es.throwWebCLException(WebCLException::INVALID_MEM_OBJECT, WebCLException::invalidMemObjectMessage);
return;
}
}
WebCLKernelArgInfo* argInfo = getArgInfo(index, es);
if (!argInfo || (object->type() == WebCLMemoryObject::IMAGE && argInfo->type() != WebCLKernelArgInfo::IMAGE) || (object->type() == WebCLMemoryObject::BUFFER && (argInfo->addressQualifier().isEmpty() || argInfo->type() != WebCLKernelArgInfo::BUFFER))) {
es.throwWebCLException(WebCLException::INVALID_ARG_VALUE, WebCLException::invalidArgIndexMessage);
return;
}
cl_int err = clSetKernelArg(m_clKernel, index, sizeof(cl_mem), &clObject);
if (err != CL_SUCCESS)
WebCLException::throwException(err, es);
else
argInfo->setAssociated(true);
}
void WebCLEvent::setCallback(unsigned commandExecCallbackType, WebCLCallback* callback, ExceptionState& es)
{
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_EVENT, WebCLException::invalidEventMessage);
return;
}
if (commandExecCallbackType != CL_COMPLETE) {
es.throwWebCLException(WebCLException::INVALID_VALUE, WebCLException::invalidValueMessage);
return;
}
ASSERT(callback);
if (m_callbacks.size()) {
m_callbacks.append(adoptRef(callback));
return;
}
m_callbacks.clear();
m_callbacks.append(adoptRef(callback));
WebCLEventHolder* holder = new WebCLEventHolder;
holder->event = createWeakPtr();
holder->type = commandExecCallbackType;
cl_int err = clSetEventCallback(m_clEvent, commandExecCallbackType, &callbackProxy, holder);
if (err != CL_SUCCESS)
WebCLException::throwException(err, es);
}
/**
* Returns the state of the button
* BUTTON_MONITOR_NOT_PRESSED 0
* BUTTON_MONITOR_DEPRESSED 1
* BUTTON_MONITOR_PRESSED 2
* BUTTON_MONITOR_REPEATING 3
* BUTTON_MONITOR_FAST_REPEATING 4
* BUTTON_MONITOR_RELEASED 5
*/
uint8_t NIButtonMonitor::getState(uint8_t buttonId) {
if (isDepressed(buttonId)) return BUTTON_MONITOR_DEPRESSED;
if (isReleased(buttonId)) return BUTTON_MONITOR_RELEASED;
if (isFastRepeating(buttonId)) return BUTTON_MONITOR_FAST_REPEATING;
if (isRepeating(buttonId)) return BUTTON_MONITOR_REPEATING;
if (isPressed(buttonId)) return BUTTON_MONITOR_PRESSED;
return BUTTON_MONITOR_NOT_PRESSED;
}
void Buttons::update(uint32_t cur_millis) {
if (NULL == _getButtonsBitmaskFunc) return;
uint32_t delta_millis = cur_millis - _old_millis;
bitmask_t buttons_bitmask = _getButtonsBitmaskFunc();
if (_buttons_bitmask) _down_millis += delta_millis;
else _up_millis += delta_millis;
if (isReleased()) {
_buttonsUp();
}
else if (_buttons_state == BUTTONS_STATE_LONG_PULSE) {
_buttons_state = BUTTONS_STATE_LONG_PRESS;
}
if (_buttons_state == BUTTONS_STATE_UP) {
if (buttons_bitmask) {
_down_millis = 0;
_pulse_count = 0;
_buttons_bitmask = buttons_bitmask;
_buttons_state = BUTTONS_STATE_BOUNCE;
}
}
else if (_buttons_state == BUTTONS_STATE_BOUNCE) {
if (_buttons_bitmask != buttons_bitmask) {
_buttonsUp();
}
else if (_down_millis >= _short_press_millis) {
_buttons_state = BUTTONS_STATE_SHORT_PRESS;
_onShortPressFunc();
}
}
else if (_buttons_state == BUTTONS_STATE_SHORT_PRESS) {
if (0 == buttons_bitmask) {
_buttons_state = BUTTONS_STATE_SHORT_RELEASE;
_onShortReleaseFunc();
}
else if (_down_millis >= _long_press_millis) {
setNextPulseMillis(_pulse_press_millis);
_buttons_state = BUTTONS_STATE_LONG_PRESS;
_onLongPressFunc();
}
}
else if (_buttons_state == BUTTONS_STATE_LONG_PRESS) {
if (0 == buttons_bitmask) {
_buttons_state = BUTTONS_STATE_LONG_RELEASE;
_onLongReleaseFunc();
}
else if (_down_millis >= _next_pulse_millis) {
setNextPulseMillis(_pulse_press_millis);
_pulse_count++;
_buttons_state = BUTTONS_STATE_LONG_PULSE;
_onLongPulseFunc();
}
}
_old_millis = cur_millis;
}
PassRefPtr<WebCLUserEvent> WebCLContext::createUserEvent(ExceptionState& es)
{
if (isReleased()) {
es.throwWebCLException(WebCLException::InvalidContext, WebCLException::invalidContextMessage);
return nullptr;
}
RefPtr<WebCLUserEvent> event = WebCLUserEvent::create(this, es);
return event.release();
}
void WebCLKernel::release()
{
if (isReleased())
return;
cl_int err = clReleaseKernel(m_clKernel);
if (err != CL_SUCCESS)
ASSERT_NOT_REACHED();
m_clKernel = 0;
}
void WebCLContext::release()
{
if (isReleased())
return;
cl_int err = clReleaseContext(m_clContext);
if (err != CL_SUCCESS)
ASSERT_NOT_REACHED();
m_clContext = 0;
}
void WebCLProgram::release()
{
if (isReleased())
return;
cl_int err = clReleaseProgram(m_clProgram);
if (err != CL_SUCCESS)
ASSERT_NOT_REACHED();
m_clProgram = 0;
// Release the un-triggered callback.
m_buildCallback.clear();
}
void WebCLEvent::release()
{
if (isReleased())
return;
cl_int err = clReleaseEvent(m_clEvent);
if (err != CL_SUCCESS)
ASSERT_NOT_REACHED();
m_clEvent = 0;
// Release un-triggered callbacks.
m_callbacks.clear();
}
ScriptValue WebCLEvent::getProfilingInfo(ScriptState* scriptState, unsigned paramName, ExceptionState& es)
{
v8::Isolate* isolate = scriptState->isolate();
if (isReleased()) {
es.throwWebCLException(WebCLException::InvalidEvent, WebCLException::invalidEventMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
int status = getStatus();
unsigned properties = m_commandQueue ? m_commandQueue->getProperties() : 0;
if (isUserEvent() || status != CL_COMPLETE || !(properties & CL_QUEUE_PROFILING_ENABLE)) {
es.throwWebCLException(WebCLException::ProfilingInfoNotAvailable, WebCLException::profilingInfoNotAvailableMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
cl_int err = CL_SUCCESS;
cl_ulong ulongUnits = 0;
switch (paramName) {
case CL_PROFILING_COMMAND_QUEUED:
err = clGetEventProfilingInfo(m_clEvent, CL_PROFILING_COMMAND_QUEUED, sizeof(cl_ulong), &ulongUnits, nullptr);
if (err == CL_SUCCESS)
return ScriptValue(scriptState, v8::Number::New(isolate, static_cast<double>(ulongUnits)));
break;
case CL_PROFILING_COMMAND_SUBMIT:
err = clGetEventProfilingInfo(m_clEvent, CL_PROFILING_COMMAND_SUBMIT, sizeof(cl_ulong), &ulongUnits, nullptr);
if (err == CL_SUCCESS)
return ScriptValue(scriptState, v8::Number::New(isolate, static_cast<double>(ulongUnits)));
break;
case CL_PROFILING_COMMAND_START:
err = clGetEventProfilingInfo(m_clEvent, CL_PROFILING_COMMAND_START, sizeof(cl_ulong), &ulongUnits, nullptr);
if (err == CL_SUCCESS)
return ScriptValue(scriptState, v8::Number::New(isolate, static_cast<double>(ulongUnits)));
break;
case CL_PROFILING_COMMAND_END:
err = clGetEventProfilingInfo(m_clEvent, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), &ulongUnits, nullptr);
if (err == CL_SUCCESS)
return ScriptValue(scriptState, v8::Number::New(isolate, static_cast<double>(ulongUnits)));
break;
default:
es.throwWebCLException(WebCLException::InvalidValue, WebCLException::invalidValueMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
WebCLException::throwException(err, es);
return ScriptValue(scriptState, v8::Null(isolate));
}
void WebCLContext::releaseAll()
{
if (isReleased())
return;
if (m_webCLObjects.size()) {
for (int i = m_webCLObjects.size() - 1; i >= 0; i--) {
WebCLObject* object = m_webCLObjects[i].get();
if (!object)
continue;
object->release();
}
m_webCLObjects.clear();
}
release();
}
unsigned WebCLEvent::getProfilingInfo(int paramName, ExceptionState& es)
{
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_EVENT, WebCLException::invalidEventMessage);
return 0;
}
int status = getStatus();
unsigned properties = m_commandQueue ? m_commandQueue->getProperties() : 0;
if (isUserEvent() || status != CL_COMPLETE || !(properties & CL_QUEUE_PROFILING_ENABLE)) {
es.throwWebCLException(WebCLException::PROFILING_INFO_NOT_AVAILABLE, WebCLException::profilingInfoNotAvailableMessage);
return 0;
}
cl_int err = CL_SUCCESS;
cl_ulong ulongUnits = 0;
switch(paramName) {
case CL_PROFILING_COMMAND_QUEUED:
err = clGetEventProfilingInfo(m_clEvent, CL_PROFILING_COMMAND_QUEUED, sizeof(cl_ulong), &ulongUnits, nullptr);
if (err == CL_SUCCESS)
return static_cast<unsigned long long>(ulongUnits);
break;
case CL_PROFILING_COMMAND_SUBMIT:
err = clGetEventProfilingInfo(m_clEvent, CL_PROFILING_COMMAND_SUBMIT, sizeof(cl_ulong), &ulongUnits, nullptr);
if (err == CL_SUCCESS)
return static_cast<unsigned long long>(ulongUnits);
break;
case CL_PROFILING_COMMAND_START:
err = clGetEventProfilingInfo(m_clEvent, CL_PROFILING_COMMAND_START, sizeof(cl_ulong), &ulongUnits, nullptr);
if (err == CL_SUCCESS)
return static_cast<unsigned long long>(ulongUnits);
break;
case CL_PROFILING_COMMAND_END:
err = clGetEventProfilingInfo(m_clEvent, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), &ulongUnits, nullptr);
if (err == CL_SUCCESS)
return static_cast<unsigned long long>(ulongUnits);
break;
default:
es.throwWebCLException(WebCLException::INVALID_VALUE, WebCLException::invalidValueMessage);
return 0;
}
WebCLException::throwException(err, es);
return 0;
}
ScriptValue WebCLUserEvent::getInfo(ScriptState* scriptState, unsigned name, ExceptionState& es)
{
v8::Handle<v8::Object> creationContext = scriptState->context()->Global();
v8::Isolate* isolate = scriptState->isolate();
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_EVENT, WebCLException::invalidEventMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
switch (name) {
case CL_EVENT_CONTEXT:
return ScriptValue(scriptState, toV8(context(), creationContext, isolate));
case CL_EVENT_COMMAND_QUEUE:
return ScriptValue(scriptState, v8::Null(isolate));
}
return WebCLEvent::getInfo(scriptState, name, es);
}
Nullable<HeapVector<WebCLImageDescriptor>> WebCLContext::getSupportedImageFormats(unsigned memFlags, ExceptionState& es)
{
HeapVector<WebCLImageDescriptor> supportedImageDescriptor;
if (isReleased()) {
es.throwWebCLException(WebCLException::InvalidContext, WebCLException::invalidContextMessage);
return supportedImageDescriptor;
}
if (!WebCLInputChecker::isValidMemoryObjectFlag(memFlags)) {
es.throwWebCLException(WebCLException::InvalidValue, WebCLException::invalidValueMessage);
return supportedImageDescriptor;
}
cl_uint numberOfSupportedImageFormats = 0;
cl_int err = clGetSupportedImageFormats(m_clContext, memFlags, CL_MEM_OBJECT_IMAGE2D, 0, 0, &numberOfSupportedImageFormats);
if (err != CL_SUCCESS) {
es.throwWebCLException(WebCLException::InvalidImageSize, WebCLException::invalidImageSizeMessage);
return supportedImageDescriptor;
}
Vector<cl_image_format> supportedImages;
supportedImages.reserveCapacity(numberOfSupportedImageFormats);
supportedImages.resize(numberOfSupportedImageFormats);
err = clGetSupportedImageFormats(m_clContext, memFlags, CL_MEM_OBJECT_IMAGE2D, numberOfSupportedImageFormats, supportedImages.data(), 0);
if (err != CL_SUCCESS) {
WebCLException::throwException(err, es);
} else {
for (size_t i = 0; i < static_cast<unsigned>(numberOfSupportedImageFormats); ++i) {
if (WebCLInputChecker::isValidChannelOrder(supportedImages[i].image_channel_order) && WebCLInputChecker::isValidChannelType(supportedImages[i].image_channel_data_type)) {
WebCLImageDescriptor des;
des.setChannelOrder(supportedImages[i].image_channel_order);
des.setChannelType(supportedImages[i].image_channel_data_type);
supportedImageDescriptor.append(des);
}
}
}
return supportedImageDescriptor;
}
void WebCLKernel::setArg(unsigned index, size_t argSize, const void* argValue, ExceptionState& es)
{
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_KERNEL, WebCLException::invalidKernelMessage);
return;
}
if (!WebCLInputChecker::isValidKernelArgIndex(this, index)) {
es.throwWebCLException(WebCLException::INVALID_ARG_INDEX, WebCLException::invalidArgIndexMessage);
return;
}
cl_int err = CL_SUCCESS;
WebCLKernelArgInfo* argInfo = getArgInfo(index, es);
err = clSetKernelArg(m_clKernel, index, argSize, argValue);
if (err != CL_SUCCESS)
WebCLException::throwException(err, es);
else
argInfo->setAssociated(true);
}
ScriptValue WebCLEvent::getInfo(ScriptState* scriptState, unsigned paramName, ExceptionState& es)
{
v8::Handle<v8::Object> creationContext = scriptState->context()->Global();
v8::Isolate* isolate = scriptState->isolate();
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_EVENT, WebCLException::invalidEventMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
cl_int err = CL_SUCCESS;
cl_int intUnits = 0;
cl_command_type commandType = 0;
switch(paramName) {
case CL_EVENT_COMMAND_EXECUTION_STATUS:
err = clGetEventInfo(m_clEvent, CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(cl_int), &intUnits, nullptr);
if (err == CL_SUCCESS)
return ScriptValue(scriptState, v8::Integer::New(isolate, static_cast<int>(intUnits)));
break;
case CL_EVENT_COMMAND_TYPE:
err = clGetEventInfo(m_clEvent, CL_EVENT_COMMAND_TYPE, sizeof(cl_command_type), &commandType, nullptr);
if (err == CL_SUCCESS)
return ScriptValue(scriptState, v8::Integer::NewFromUnsigned(isolate, static_cast<unsigned>(commandType)));
break;
case CL_EVENT_CONTEXT:
ASSERT(!isUserEvent());
return ScriptValue(scriptState, toV8(context(), creationContext, isolate));
case CL_EVENT_COMMAND_QUEUE:
ASSERT(m_commandQueue);
ASSERT(!isUserEvent());
return ScriptValue(scriptState, toV8(m_commandQueue, creationContext, isolate));
default:
es.throwWebCLException(WebCLException::INVALID_VALUE, WebCLException::invalidValueMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
WebCLException::throwException(err, es);
return ScriptValue(scriptState, v8::Null(isolate));
}
ScriptValue WebCLKernel::getWorkGroupInfo(ScriptState* scriptState, WebCLDevice* device, int paramName, ExceptionState& es)
{
v8::Handle<v8::Object> creationContext = scriptState->context()->Global();
v8::Isolate* isolate = scriptState->isolate();
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_KERNEL, WebCLException::invalidKernelMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
cl_device_id clDevice = nullptr;
Vector<RefPtr<WebCLDevice>> deviceList = context()->getDevices();
if (device) {
clDevice = device->getDeviceId();
if (!clDevice) {
es.throwWebCLException(WebCLException::INVALID_DEVICE, WebCLException::invalidDeviceMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
size_t i;
for (i = 0; i < deviceList.size(); i ++) {
if (clDevice == deviceList[i]->getDeviceId())
break;
}
if (i == deviceList.size()) {
es.throwWebCLException(WebCLException::INVALID_DEVICE, WebCLException::invalidDeviceMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
}
if (!device && deviceList.size() != 1) {
es.throwWebCLException(WebCLException::INVALID_DEVICE, WebCLException::invalidDeviceMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
cl_int err = CL_SUCCESS;
size_t sizetUnits = 0;
size_t workGroupSize[3] = {0};
cl_ulong ulongUnits = 0;
switch (paramName) {
case CL_KERNEL_WORK_GROUP_SIZE:
err = clGetKernelWorkGroupInfo(m_clKernel, clDevice, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &sizetUnits, nullptr);
if (err == CL_SUCCESS)
return ScriptValue(scriptState, v8::Integer::NewFromUnsigned(isolate, static_cast<unsigned>(sizetUnits)));
break;
case CL_KERNEL_PRIVATE_MEM_SIZE:
err = clGetKernelWorkGroupInfo(m_clKernel, clDevice, CL_KERNEL_PRIVATE_MEM_SIZE, sizeof(cl_ulong), &ulongUnits, nullptr);
if (err == CL_SUCCESS)
return ScriptValue(scriptState, v8::Integer::NewFromUnsigned(isolate, static_cast<unsigned long long>(ulongUnits)));
break;
case CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE:
err = clGetKernelWorkGroupInfo(m_clKernel, clDevice, CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, sizeof(size_t), &sizetUnits, nullptr);
if (err == CL_SUCCESS)
return ScriptValue(scriptState, v8::Integer::NewFromUnsigned(isolate, static_cast<unsigned>(sizetUnits)));
break;
case CL_KERNEL_COMPILE_WORK_GROUP_SIZE:
err = clGetKernelWorkGroupInfo(m_clKernel, clDevice, CL_KERNEL_COMPILE_WORK_GROUP_SIZE, sizeof(workGroupSize), &workGroupSize, nullptr);
if (err == CL_SUCCESS) {
Vector<unsigned> values;
for (unsigned i = 0; i < 3; ++i)
values.append((unsigned)workGroupSize[i]);
return ScriptValue(scriptState, toV8(values, creationContext, isolate));
}
break;
case CL_KERNEL_LOCAL_MEM_SIZE:
err = clGetKernelWorkGroupInfo(m_clKernel, clDevice, CL_KERNEL_LOCAL_MEM_SIZE, sizeof(cl_ulong), &ulongUnits, nullptr);
if (err == CL_SUCCESS)
return ScriptValue(scriptState, v8::Integer::NewFromUnsigned(isolate, static_cast<unsigned long long>(ulongUnits)));
break;
default:
es.throwWebCLException(WebCLException::INVALID_VALUE, WebCLException::invalidValueMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
WebCLException::throwException(err, es);
return ScriptValue(scriptState, v8::Null(isolate));
}
void WebCLProgram::build(const Vector<RefPtr<WebCLDevice>>& devices, const String& buildOptions, WebCLCallback* callback, ExceptionState& es)
{
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_PROGRAM, WebCLException::invalidProgramMessage);
return;
}
size_t kernel_label = m_programSource.find("__kernel ", 0);
while (kernel_label != WTF::kNotFound) {
size_t openBrace = m_programSource.find("{", kernel_label);
size_t openBraket = m_programSource.reverseFind("(", openBrace);
size_t space = m_programSource.reverseFind(" ", openBraket);
String kernelName = m_programSource.substring(space + 1, openBraket - space - 1);
if (kernelName.length() > 254) {
// Kernel Name length isn't allowed larger than 255.
es.throwWebCLException(WebCLException::BUILD_PROGRAM_FAILURE, WebCLException::buildProgramFailureMessage);
return;
}
size_t closeBraket = m_programSource.find(")", openBraket);
String arguments = m_programSource.substring(openBraket + 1, closeBraket - openBraket - 1);
if (arguments.contains("struct ") || arguments.contains("image1d_array_t ") || arguments.contains("image1d_buffer_t ") || arguments.contains("image1d_t ") || arguments.contains("image2d_array_t ")) {
// 1. Kernel structure parameters aren't allowed;
// 2. Kernel argument "image1d_t", "image1d_array_t", "image2d_array_t" and "image1d_buffer_t" aren't allowed;
es.throwWebCLException(WebCLException::BUILD_PROGRAM_FAILURE, WebCLException::buildProgramFailureMessage);
return;
}
size_t closeBrace = m_programSource.find("}", openBrace);
String codeString = m_programSource.substring(openBrace + 1, closeBrace - openBrace - 1).removeCharacters(isASCIILineBreakOrWhiteSpaceCharacter);
if (codeString.isEmpty()) {
// Kernel code isn't empty;
es.throwWebCLException(WebCLException::BUILD_PROGRAM_FAILURE, WebCLException::buildProgramFailureMessage);
return;
}
kernel_label = m_programSource.find("__kernel ", closeBrace);
}
if (buildOptions.length() > 0) {
static AtomicString& buildOptionDashD = *new AtomicString("-D", AtomicString::ConstructFromLiteral);
static HashSet<AtomicString>& webCLSupportedBuildOptions = *new HashSet<AtomicString>();
if (webCLSupportedBuildOptions.isEmpty()) {
webCLSupportedBuildOptions.add(AtomicString("-cl-opt-disable", AtomicString::ConstructFromLiteral));
webCLSupportedBuildOptions.add(AtomicString("-cl-single-precision-constant", AtomicString::ConstructFromLiteral));
webCLSupportedBuildOptions.add(AtomicString("-cl-denorms-are-zero", AtomicString::ConstructFromLiteral));
webCLSupportedBuildOptions.add(AtomicString("-cl-mad-enable", AtomicString::ConstructFromLiteral));
webCLSupportedBuildOptions.add(AtomicString("-cl-no-signed-zeros", AtomicString::ConstructFromLiteral));
webCLSupportedBuildOptions.add(AtomicString("-cl-unsafe-math-optimizations", AtomicString::ConstructFromLiteral));
webCLSupportedBuildOptions.add(AtomicString("-cl-finite-math-only", AtomicString::ConstructFromLiteral));
webCLSupportedBuildOptions.add(AtomicString("-cl-fast-relaxed-math", AtomicString::ConstructFromLiteral));
webCLSupportedBuildOptions.add(AtomicString("-w", AtomicString::ConstructFromLiteral));
webCLSupportedBuildOptions.add(AtomicString("-Werror", AtomicString::ConstructFromLiteral));
}
Vector<String> webCLBuildOptionsVector;
buildOptions.split(" ", false, webCLBuildOptionsVector);
for (size_t i = 0; i < webCLBuildOptionsVector.size(); i++) {
// Every build option must start with a hyphen.
if (!webCLBuildOptionsVector[i].startsWith("-")) {
es.throwWebCLException(WebCLException::INVALID_BUILD_OPTIONS, WebCLException::invalidBuildOptionsMessage);
return;
}
if (webCLSupportedBuildOptions.contains(AtomicString(webCLBuildOptionsVector[i])))
continue;
if (webCLBuildOptionsVector[i].startsWith(buildOptionDashD)) {
size_t j;
for (j = i + 1; j < webCLBuildOptionsVector.size() && !webCLBuildOptionsVector[j].startsWith("-"); ++j) {}
if (webCLBuildOptionsVector[i].stripWhiteSpace() == buildOptionDashD && j == i + 1) {
es.throwWebCLException(WebCLException::INVALID_BUILD_OPTIONS, WebCLException::invalidBuildOptionsMessage);
return;
}
i = --j;
continue;
}
es.throwWebCLException(WebCLException::INVALID_BUILD_OPTIONS, WebCLException::invalidBuildOptionsMessage);
return;
}
}
pfnNotify callbackProxyPtr = nullptr;
WebCLProgramHolder* holder = nullptr;
if (callback) {
if (m_buildCallback) {
es.throwWebCLException(WebCLException::INVALID_OPERATION, WebCLException::invalidOperationMessage);
return;
}
// Store the callback, eventList to HashTable and call callbackProxy.
m_buildCallback = adoptRef(callback);
callbackProxyPtr = &callbackProxy;
holder = new WebCLProgramHolder;
holder->program = createWeakPtr();
}
cl_int err = CL_SUCCESS;
Vector<cl_device_id> clDevices;
Vector<RefPtr<WebCLDevice>> contextDevices = context()->getDevices();
if (devices.size()) {
Vector<cl_device_id> inputDevices;
for (auto device : devices)
inputDevices.append(device->getDeviceId());
size_t contextDevicesLength = contextDevices.size();
for (size_t z, i = 0; i < inputDevices.size(); i++) {
// Check if the inputDevices[i] is part of programs WebCLContext.
for (z = 0; z < contextDevicesLength; z++) {
if (contextDevices[z]->getDeviceId() == inputDevices[i]) {
break;
}
}
if (z == contextDevicesLength) {
es.throwWebCLException(WebCLException::INVALID_DEVICE, WebCLException::invalidDeviceMessage);
return;
}
clDevices.append(inputDevices[i]);
}
} else {
for (auto contextDevice : contextDevices)
clDevices.append(contextDevice->getDeviceId());
}
if (!clDevices.size()) {
es.throwWebCLException(WebCLException::INVALID_VALUE, WebCLException::invalidValueMessage);
return;
}
m_isProgramBuilt = true;
err = clBuildProgram(m_clProgram, clDevices.size(), clDevices.data(), buildOptions.utf8().data(), callbackProxyPtr, holder);
if (err != CL_SUCCESS)
es.throwWebCLException(WebCLException::BUILD_PROGRAM_FAILURE, WebCLException::buildProgramFailureMessage);
}
Vector<RefPtr<WebCLKernel>> WebCLProgram::createKernelsInProgram(ExceptionState& es)
{
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_PROGRAM, WebCLException::invalidProgramMessage);
return Vector<RefPtr<WebCLKernel>>();
}
if (!m_isProgramBuilt) {
es.throwWebCLException(WebCLException::INVALID_PROGRAM_EXECUTABLE, WebCLException::invalidProgramExecutableMessage);
return Vector<RefPtr<WebCLKernel>>();
}
cl_uint num = 0;
cl_int err = clCreateKernelsInProgram(m_clProgram, 0, nullptr, &num);
if (err != CL_SUCCESS) {
WebCLException::throwException(err, es);
return Vector<RefPtr<WebCLKernel>>();
}
if (num == 0) {
es.throwWebCLException(WebCLException::FAILURE, WebCLException::failureMessage);
return Vector<RefPtr<WebCLKernel>>();
}
cl_kernel* kernelBuf = (cl_kernel*)malloc (sizeof(cl_kernel) * num);
if (!kernelBuf) {
return Vector<RefPtr<WebCLKernel>>();
}
err = clCreateKernelsInProgram(m_clProgram, num, kernelBuf, nullptr);
if (err != CL_SUCCESS) {
WebCLException::throwException(err, es);
return Vector<RefPtr<WebCLKernel>>();
}
Vector<char> kernelName;
size_t bytesOfKernelName = 0;
Vector<RefPtr<WebCLKernel>> m_kernelList;
for (size_t i = 0 ; i < num; i++) {
err = clGetKernelInfo(kernelBuf[i], CL_KERNEL_FUNCTION_NAME, 0, nullptr, &bytesOfKernelName);
if (err != CL_SUCCESS) {
continue;
}
kernelName.reserveCapacity(bytesOfKernelName);
kernelName.resize(bytesOfKernelName);
err = clGetKernelInfo(kernelBuf[i], CL_KERNEL_FUNCTION_NAME, bytesOfKernelName, kernelName.data(), 0);
if (err != CL_SUCCESS) {
continue;
}
RefPtr<WebCLKernel> kernel = WebCLKernel::create(kernelBuf[i], context(), this, static_cast<const char*>(kernelName.data()));
if (kernel)
m_kernelList.append(kernel);
kernelName.clear();
bytesOfKernelName = 0;
}
return m_kernelList;
}
ScriptValue WebCLProgram::getBuildInfo(ScriptState* scriptState, WebCLDevice* device, int paramName, ExceptionState& es)
{
v8::Isolate* isolate = scriptState->isolate();
if (isReleased()) {
es.throwWebCLException(WebCLException::INVALID_PROGRAM, WebCLException::invalidProgramMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
cl_device_id clDevice = nullptr;
if (device) {
clDevice = device->getDeviceId();
if (!clDevice) {
es.throwWebCLException(WebCLException::INVALID_DEVICE, WebCLException::invalidDeviceMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
size_t i = 0;
Vector<RefPtr<WebCLDevice>> deviceList = context()->getDevices();
for (; i < deviceList.size(); i ++) {
if (clDevice == deviceList[i]->getDeviceId())
break;
}
if (i == deviceList.size()) {
es.throwWebCLException(WebCLException::INVALID_DEVICE, WebCLException::invalidDeviceMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
}
cl_int err = CL_SUCCESS;
char *buffer;
size_t len = 0;
switch (paramName) {
case CL_PROGRAM_BUILD_LOG: {
err = clGetProgramBuildInfo(m_clProgram, clDevice, CL_PROGRAM_BUILD_LOG, 0, nullptr, &len);
if (err != CL_SUCCESS)
break;
buffer = new char[len + 1];
err = clGetProgramBuildInfo(m_clProgram, clDevice, CL_PROGRAM_BUILD_LOG, len, buffer, nullptr);
if (err != CL_SUCCESS)
break;
String result(buffer);
delete [] buffer;
return ScriptValue(scriptState, v8String(isolate, result));
}
case CL_PROGRAM_BUILD_OPTIONS: {
err = clGetProgramBuildInfo(m_clProgram, clDevice, CL_PROGRAM_BUILD_OPTIONS, 0, nullptr, &len);
if (err != CL_SUCCESS)
break;
buffer = new char[len + 1];
err = clGetProgramBuildInfo(m_clProgram, clDevice, CL_PROGRAM_BUILD_OPTIONS, len, buffer, nullptr);
if (err != CL_SUCCESS)
break;
String result(buffer);
delete [] buffer;
return ScriptValue(scriptState, v8String(isolate, result));
}
case CL_PROGRAM_BUILD_STATUS:
cl_build_status buildStatus;
err = clGetProgramBuildInfo(m_clProgram, clDevice, CL_PROGRAM_BUILD_STATUS, sizeof(cl_build_status), &buildStatus, nullptr);
if (err == CL_SUCCESS)
return ScriptValue(scriptState, v8::Integer::NewFromUnsigned(isolate, static_cast<unsigned>(buildStatus)));
break;
default:
es.throwWebCLException(WebCLException::INVALID_VALUE, WebCLException::invalidValueMessage);
return ScriptValue(scriptState, v8::Null(isolate));
}
WebCLException::throwException(err, es);
return ScriptValue(scriptState, v8::Null(isolate));
}
