cl_command_queue clCreateCommandQueueFCL (cl_context context,
cl_device_id device,
cl_command_queue_properties properties,
cl_int *errcode_ret)
{
MSG(clCreateCommandQueueFCL);
if (properties & ~(CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_PROFILING_ENABLE))
{
SET_RET(CL_INVALID_VALUE);
return 0;
}
FreeOCL::unlocker unlock;
if (!FreeOCL::is_valid(context))
{
SET_RET(CL_INVALID_CONTEXT);
return 0;
}
unlock.handle(context);
if (!FreeOCL::is_valid(device))
{
SET_RET(CL_INVALID_DEVICE);
return 0;
}
cl_command_queue q = new _cl_command_queue(context);
q->device = device;
q->properties = properties;
SET_RET(CL_SUCCESS);
return q;
}
void trap_kernel_handler(struct user_context *user_ctx)
{
_debug("...... in %s, code = %p\n",
__func__, user_ctx->code & ~YALNIX_PREFIX);
switch (user_ctx->code) {
case YALNIX_FORK:
SET_RET(user_ctx, sys_fork(user_ctx));
break;
case YALNIX_EXEC:
sys_exec((char *)user_ctx->regs[0], (char **)user_ctx->regs[1],
user_ctx);
break;
case YALNIX_EXIT:
sys_exit(user_ctx->regs[0], user_ctx);
break;
case YALNIX_WAIT:
if (!FROM_USER_SPACE(user_ctx->regs[0])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_wait((int *)user_ctx->regs[0], user_ctx));
break;
case YALNIX_GETPID:
SET_RET(user_ctx, sys_getpid());
break;
case YALNIX_BRK:
SET_RET(user_ctx, sys_brk(user_ctx->regs[0]));
break;
case YALNIX_DELAY:
SET_RET(user_ctx, sys_delay(user_ctx->regs[0], user_ctx));
break;
case YALNIX_TTY_READ:
if (!FROM_USER_SPACE(user_ctx->regs[1])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_tty_read(user_ctx->regs[0],
(char *)user_ctx->regs[1],
user_ctx->regs[2],
user_ctx));
break;
case YALNIX_TTY_WRITE:
if (!FROM_USER_SPACE(user_ctx->regs[1])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_tty_write(user_ctx->regs[0],
(char *)user_ctx->regs[1],
user_ctx->regs[2],
user_ctx));
break;
case YALNIX_PIPE_INIT:
if (!FROM_USER_SPACE(user_ctx->regs[0])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_pipe_init((unsigned int *)
user_ctx->regs[0]));
break;
case YALNIX_PIPE_READ:
if (!FROM_USER_SPACE(user_ctx->regs[1])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_pipe_read(user_ctx->regs[0],
(char *)user_ctx->regs[1],
user_ctx->regs[2],
user_ctx));
break;
case YALNIX_PIPE_WRITE:
if (!FROM_USER_SPACE(user_ctx->regs[1])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_pipe_write(user_ctx->regs[0],
(char *)user_ctx->regs[1],
user_ctx->regs[2],
user_ctx));
break;
case YALNIX_LOCK_INIT:
if (!FROM_USER_SPACE(user_ctx->regs[0])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_lock_init((unsigned int *)
user_ctx->regs[0]));
break;
case YALNIX_LOCK_ACQUIRE:
SET_RET(user_ctx, sys_lock_acquire(user_ctx->regs[0],
user_ctx));
break;
case YALNIX_LOCK_RELEASE:
SET_RET(user_ctx, sys_lock_release(user_ctx->regs[0]));
break;
case YALNIX_CVAR_INIT:
if (!FROM_USER_SPACE(user_ctx->regs[0])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_cvar_init((unsigned int *)
user_ctx->regs[0]));
break;
case YALNIX_CVAR_WAIT:
SET_RET(user_ctx, sys_cvar_wait(user_ctx->regs[0],
user_ctx->regs[1],
user_ctx));
break;
case YALNIX_CVAR_SIGNAL:
SET_RET(user_ctx, sys_cvar_signal(user_ctx->regs[0]));
break;
case YALNIX_CVAR_BROADCAST:
SET_RET(user_ctx, sys_cvar_broadcast(user_ctx->regs[0]));
break;
case YALNIX_RECLAIM:
SET_RET(user_ctx, sys_reclaim(user_ctx->regs[0]));
break;
case YALNIX_CUSTOM_0:
SET_RET(user_ctx, sys_fork_share(user_ctx));
break;
}
return;
}
cl_mem clCreateBufferFCL (cl_context context,
cl_mem_flags flags,
size_t size,
void *host_ptr,
cl_int *errcode_ret)
{
MSG(clCreateBufferFCL);
if (size == 0)
{
SET_RET(CL_INVALID_BUFFER_SIZE);
return 0;
}
if (((flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR))
&& host_ptr == NULL)
|| (host_ptr != NULL && !(flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR))))
{
SET_RET(CL_INVALID_HOST_PTR);
return 0;
}
if ((flags & CL_MEM_USE_HOST_PTR) && (flags & (CL_MEM_ALLOC_HOST_PTR | CL_MEM_COPY_HOST_PTR)))
{
SET_RET(CL_INVALID_VALUE);
return 0;
}
if (((flags & CL_MEM_READ_WRITE) && (flags & (CL_MEM_WRITE_ONLY | CL_MEM_READ_ONLY)))
|| ((flags & CL_MEM_WRITE_ONLY) && (flags & CL_MEM_READ_ONLY)))
{
SET_RET(CL_INVALID_VALUE);
return 0;
}
if (((flags & CL_MEM_HOST_NO_ACCESS) && (flags & (CL_MEM_HOST_READ_ONLY | CL_MEM_HOST_WRITE_ONLY)))
|| ((flags & CL_MEM_HOST_READ_ONLY) && (flags & CL_MEM_HOST_WRITE_ONLY)))
{
SET_RET(CL_INVALID_VALUE);
return 0;
}
FreeOCL::unlocker unlock;
if (!FreeOCL::is_valid(context))
{
SET_RET(CL_INVALID_CONTEXT);
return 0;
}
unlock.handle(context);
cl_mem mem = new _cl_mem(context);
mem->flags = flags;
mem->size = size;
mem->mem_type = CL_MEM_OBJECT_BUFFER;
mem->host_ptr = host_ptr;
mem->parent = NULL;
mem->offset = 0;
if (flags & CL_MEM_USE_HOST_PTR)
mem->ptr = host_ptr;
#ifdef FREEOCL_OS_WINDOWS
else if ((mem->ptr = __mingw_aligned_malloc(size, 256)) == NULL)
#else
else if (posix_memalign(&(mem->ptr), 256, size) == ENOMEM)
#endif
{
SET_RET(CL_OUT_OF_RESOURCES);
delete mem;
return 0;
}
if (flags & CL_MEM_COPY_HOST_PTR)
memcpy(mem->ptr, host_ptr, size);
SET_RET(CL_SUCCESS);
return mem;
}
void * clEnqueueMapBufferFCL (cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_map,
cl_map_flags map_flags,
size_t offset,
size_t cb,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event,
cl_int *errcode_ret)
{
MSG(clEnqueueMapBufferFCL);
if (map_flags & ~(CL_MAP_READ | CL_MAP_WRITE | CL_MAP_WRITE_INVALIDATE_REGION))
{
SET_RET(CL_INVALID_VALUE);
return NULL;
}
FreeOCL::unlocker unlock;
if (!FreeOCL::is_valid(command_queue))
{
SET_RET(CL_INVALID_COMMAND_QUEUE);
return NULL;
}
unlock.handle(command_queue);
if (!FreeOCL::is_valid(command_queue->context))
{
SET_RET(CL_INVALID_CONTEXT);
return NULL;
}
command_queue->context->unlock();
if (!FreeOCL::is_valid(buffer))
{
SET_RET(CL_INVALID_MEM_OBJECT);
return NULL;
}
unlock.handle(buffer);
if (buffer->size < offset + cb)
{
SET_RET(CL_INVALID_VALUE);
return NULL;
}
void *p = (char*)buffer->ptr + offset;
if ((num_events_in_wait_list == 0 || event_wait_list == NULL) && blocking_map == CL_FALSE)
{
buffer->mapped.insert(p);
if (event)
{
cl_event e = new _cl_event(command_queue->context);
*event = e;
e->command_queue = command_queue;
e->command_type = CL_COMMAND_MAP_BUFFER;
e->status = CL_QUEUED;
e->change_status(CL_QUEUED);
e->change_status(CL_SUBMITTED);
e->change_status(CL_RUNNING);
e->change_status(CL_COMPLETE);
}
}
else
{
FreeOCL::smartptr<FreeOCL::command_map_buffer> cmd = new FreeOCL::command_map_buffer;
cmd->num_events_in_wait_list = num_events_in_wait_list;
cmd->event_wait_list = event_wait_list;
cmd->event = (blocking_map == CL_TRUE || event) ? new _cl_event(command_queue->context) : NULL;
if (cmd->event)
{
cmd->event->command_queue = command_queue;
cmd->event->command_type = CL_COMMAND_MAP_BUFFER;
cmd->event->status = CL_QUEUED;
if (event)
*event = cmd->event.weak();
}
cmd->buffer = buffer;
cmd->ptr = p;
unlock.forget(command_queue);
command_queue->enqueue(cmd);
unlock.unlockall();
if (blocking_map == CL_TRUE)
{
clWaitForEventsFCL(1, &cmd->event.weak());
if (event == NULL)
clReleaseEventFCL(cmd->event.weak());
}
}
SET_RET(CL_SUCCESS);
return p;
}
cl_mem clCreateSubBufferFCL (cl_mem buffer,
cl_mem_flags flags,
cl_buffer_create_type buffer_create_type,
const void *buffer_create_info,
cl_int *errcode_ret)
{
MSG(clCreateSubBufferFCL);
FreeOCL::unlocker unlock;
if (!FreeOCL::is_valid(buffer))
{
SET_RET(CL_INVALID_MEM_OBJECT);
return 0;
}
unlock.handle(buffer);
if (buffer->parent)
{
SET_RET(CL_INVALID_MEM_OBJECT);
return 0;
}
if (((buffer->flags & CL_MEM_WRITE_ONLY) && ((flags & CL_MEM_READ_WRITE) || (flags & CL_MEM_READ_ONLY)))
|| ((buffer->flags & CL_MEM_READ_ONLY) && ((flags & CL_MEM_READ_WRITE) || (flags & CL_MEM_WRITE_ONLY)))
|| (flags & CL_MEM_USE_HOST_PTR)
|| (flags & CL_MEM_ALLOC_HOST_PTR)
|| (flags & CL_MEM_COPY_HOST_PTR))
{
SET_RET(CL_INVALID_VALUE);
return 0;
}
if (buffer_create_info == NULL)
{
SET_RET(CL_INVALID_VALUE);
return 0;
}
switch(buffer_create_type)
{
case CL_BUFFER_CREATE_TYPE_REGION:
{
const _cl_buffer_region *p_info = (const _cl_buffer_region *)buffer_create_info;
if (p_info->size == 0)
{
SET_RET(CL_INVALID_BUFFER_SIZE);
return 0;
}
if (p_info->size + p_info->origin > buffer->size)
{
SET_RET(CL_INVALID_VALUE);
return 0;
}
if ((p_info->origin % FreeOCL::device->mem_base_addr_align) != 0)
{
SET_RET(CL_MISALIGNED_SUB_BUFFER_OFFSET);
return 0;
}
cl_mem mem = new _cl_mem(buffer->context);
mem->flags = flags;
mem->size = p_info->size;
mem->mem_type = CL_MEM_OBJECT_BUFFER;
mem->host_ptr = NULL;
mem->parent = buffer;
mem->offset = p_info->origin;
mem->ptr = (char*)buffer->ptr + p_info->origin;
SET_RET(CL_SUCCESS);
return mem;
}
break;
default:
SET_RET(CL_INVALID_VALUE);
return 0;
}
SET_RET(CL_INVALID_VALUE);
return 0;
}
