[Beignet] [PATCH V2 2/6] Add a struct and a function to handle all implemented enqueue api.
Yang Rong
rong.r.yang at intel.com
Mon Aug 12 01:07:17 PDT 2013
Event and non-blocking enqueue api may use this function.
Signed-off-by: Yang Rong <rong.r.yang at intel.com>
---
src/cl_enqueue.c | 318 +++++++++++-------------------------------------------
1 file changed, 64 insertions(+), 254 deletions(-)
diff --git a/src/cl_enqueue.c b/src/cl_enqueue.c
index 5cf00ed..cfc7355 100644
--- a/src/cl_enqueue.c
+++ b/src/cl_enqueue.c
@@ -30,128 +30,47 @@
cl_int cl_enqueue_read_buffer(enqueue_data* data)
{
cl_int err = CL_SUCCESS;
- /*void* src_ptr;
+ void* src_ptr;
- CHECK_QUEUE(command_queue);
- CHECK_MEM(buffer);
- if (command_queue->ctx != buffer->ctx) {
- err = CL_INVALID_CONTEXT;
- goto error;
- }
-
- if (blocking_read != CL_TRUE)
- NOT_IMPLEMENTED;
-
- if (!ptr || !size || offset + size > buffer->size) {
- err = CL_INVALID_VALUE;
- goto error;
- }
-
- if (buffer->flags & (CL_MEM_HOST_WRITE_ONLY | CL_MEM_HOST_NO_ACCESS)) {
- err = CL_INVALID_OPERATION;
- goto error;
- }
-
- if (!(src_ptr = cl_mem_map_auto(buffer))) {
+ if (!(src_ptr = cl_mem_map_auto(data->mem_obj))) {
err = CL_MAP_FAILURE;
goto error;
}
- memcpy(ptr, (char*)src_ptr + offset, size);
+ memcpy(data->ptr, (char*)src_ptr + data->offset, data->size);
- err = cl_mem_unmap_auto(buffer);
+ err = cl_mem_unmap_auto(data->mem_obj);
-error: */
+error:
return err;
}
cl_int cl_enqueue_write_buffer(enqueue_data *data)
{
cl_int err = CL_SUCCESS;
- /*void* dst_ptr;
-
- CHECK_QUEUE(command_queue);
- CHECK_MEM(buffer);
- if (command_queue->ctx != buffer->ctx) {
- err = CL_INVALID_CONTEXT;
- goto error;
- }
-
- if (blocking_write != CL_TRUE)
- NOT_IMPLEMENTED;
+ void* dst_ptr;
- if (!ptr || !size || offset + size > buffer->size) {
- err = CL_INVALID_VALUE;
- goto error;
- }
-
- if (buffer->flags & (CL_MEM_HOST_READ_ONLY | CL_MEM_HOST_NO_ACCESS)) {
- err = CL_INVALID_OPERATION;
- goto error;
- }
-
- if (!(dst_ptr = cl_mem_map_auto(buffer))) {
+ if (!(dst_ptr = cl_mem_map_auto(data->mem_obj))) {
err = CL_MAP_FAILURE;
goto error;
}
- memcpy((char*)dst_ptr + offset, ptr, size);
+ memcpy((char*)dst_ptr + data->offset, data->const_ptr, data->size);
- err = cl_mem_unmap_auto(buffer);
+ err = cl_mem_unmap_auto(data->mem_obj);
-error: */
+error:
return err;
}
cl_int cl_enqueue_read_image(enqueue_data *data)
{
cl_int err = CL_SUCCESS;
- /* void* src_ptr;
-
- CHECK_QUEUE(command_queue);
- CHECK_IMAGE(image);
- if (command_queue->ctx != image->ctx) {
- err = CL_INVALID_CONTEXT;
- goto error;
- }
-
- if (blocking_read != CL_TRUE)
- NOT_IMPLEMENTED;
-
- if (!origin || !region || origin[0] + region[0] > image->w || origin[1] + region[1] > image->h || origin[2] + region[2] > image->depth) {
- err = CL_INVALID_VALUE;
- goto error;
- }
+ void* src_ptr;
- if (!row_pitch)
- row_pitch = image->bpp*region[0];
- else if (row_pitch < image->bpp*region[0]) {
- err = CL_INVALID_VALUE;
- goto error;
- }
-
- if (image->slice_pitch) {
- if (!slice_pitch)
- slice_pitch = row_pitch*region[1];
- else if (slice_pitch < row_pitch*region[1]) {
- err = CL_INVALID_VALUE;
- goto error;
- }
- }
- else if (slice_pitch) {
- err = CL_INVALID_VALUE;
- goto error;
- }
-
- if (!ptr) {
- err = CL_INVALID_VALUE;
- goto error;
- }
-
- if (image->flags & (CL_MEM_HOST_WRITE_ONLY | CL_MEM_HOST_NO_ACCESS)) {
- err = CL_INVALID_OPERATION;
- goto error;
- }
+ cl_mem image = data->mem_obj;
+ const size_t* origin = data->origin;
+ const size_t* region = data->region;
if (!(src_ptr = cl_mem_map_auto(image))) {
err = CL_MAP_FAILURE;
@@ -161,29 +80,29 @@ cl_int cl_enqueue_read_image(enqueue_data *data)
size_t offset = image->bpp*origin[0] + image->row_pitch*origin[1] + image->slice_pitch*origin[2];
src_ptr = (char*)src_ptr + offset;
- if (!origin[0] && region[0] == image->w && row_pitch == image->row_pitch &&
- (region[2] == 1 || (!origin[1] && region[1] == image->h && slice_pitch == image->slice_pitch)))
+ if (!origin[0] && region[0] == image->w && data->row_pitch == image->row_pitch &&
+ (region[2] == 1 || (!origin[1] && region[1] == image->h && data->slice_pitch == image->slice_pitch)))
{
- memcpy(ptr, src_ptr, region[2] == 1 ? row_pitch*region[1] : slice_pitch*region[2]);
+ memcpy(data->ptr, src_ptr, region[2] == 1 ? data->row_pitch*region[1] : data->slice_pitch*region[2]);
}
else {
cl_uint y, z;
for (z = 0; z < region[2]; z++) {
const char* src = src_ptr;
- char* dst = ptr;
+ char* dst = data->ptr;
for (y = 0; y < region[1]; y++) {
- memcpy(dst, src, image->bpp*region[0]);
- src += image->row_pitch;
- dst += row_pitch;
+ memcpy(dst, src, image->bpp*region[0]);
+ src += image->row_pitch;
+ dst += data->row_pitch;
}
src_ptr = (char*)src_ptr + image->slice_pitch;
- ptr = (char*)ptr + slice_pitch;
+ data->ptr = (char*)data->ptr + data->slice_pitch;
}
}
- err = cl_mem_unmap_auto(image);
+ err = cl_mem_unmap_auto(image);
-error: */
+error:
return err;
}
@@ -191,52 +110,11 @@ error: */
cl_int cl_enqueue_write_image(enqueue_data *data)
{
cl_int err = CL_SUCCESS;
- /*void* dst_ptr;
+ void* dst_ptr;
- CHECK_QUEUE(command_queue);
- CHECK_IMAGE(image);
- if (command_queue->ctx != image->ctx) {
- err = CL_INVALID_CONTEXT;
- goto error;
- }
-
- if (blocking_write != CL_TRUE)
- NOT_IMPLEMENTED;
-
- if (!origin || !region || origin[0] + region[0] > image->w || origin[1] + region[1] > image->h || origin[2] + region[2] > image->depth) {
- err = CL_INVALID_VALUE;
- goto error;
- }
-
- if (!row_pitch)
- row_pitch = image->bpp*region[0];
- else if (row_pitch < image->bpp*region[0]) {
- err = CL_INVALID_VALUE;
- goto error;
- }
-
- if (image->slice_pitch) {
- if (!slice_pitch)
- slice_pitch = row_pitch*region[1];
- else if (slice_pitch < row_pitch*region[1]) {
- err = CL_INVALID_VALUE;
- goto error;
- }
- }
- else if (slice_pitch) {
- err = CL_INVALID_VALUE;
- goto error;
- }
-
- if (!ptr) {
- err = CL_INVALID_VALUE;
- goto error;
- }
-
- if (image->flags & (CL_MEM_HOST_READ_ONLY | CL_MEM_HOST_NO_ACCESS)) {
- err = CL_INVALID_OPERATION;
- goto error;
- }
+ cl_mem image = data->mem_obj;
+ const size_t *origin = data->origin;
+ const size_t *region = data->region;
if (!(dst_ptr = cl_mem_map_auto(image))) {
err = CL_MAP_FAILURE;
@@ -246,81 +124,57 @@ cl_int cl_enqueue_write_image(enqueue_data *data)
size_t offset = image->bpp*origin[0] + image->row_pitch*origin[1] + image->slice_pitch*origin[2];
dst_ptr = (char*)dst_ptr + offset;
- if (!origin[0] && region[0] == image->w && row_pitch == image->row_pitch &&
- (region[2] == 1 || (!origin[1] && region[1] == image->h && slice_pitch == image->slice_pitch)))
+ if (!origin[0] && region[0] == image->w && data->row_pitch == image->row_pitch &&
+ (region[2] == 1 || (!origin[1] && region[1] == image->h && data->slice_pitch == image->slice_pitch)))
{
- memcpy(dst_ptr, ptr, region[2] == 1 ? row_pitch*region[1] : slice_pitch*region[2]);
+ memcpy(dst_ptr, data->ptr, region[2] == 1 ? data->row_pitch*region[1] : data->slice_pitch*region[2]);
}
else {
cl_uint y, z;
for (z = 0; z < region[2]; z++) {
- const char* src = ptr;
+ const char* src = data->const_ptr;
char* dst = dst_ptr;
for (y = 0; y < region[1]; y++) {
- memcpy(dst, src, image->bpp*region[0]);
- src += row_pitch;
- dst += image->row_pitch;
+ memcpy(dst, src, image->bpp*region[0]);
+ src += data->row_pitch;
+ dst += image->row_pitch;
}
- ptr = (char*)ptr + slice_pitch;
+ data->ptr = (char*)data->ptr + data->slice_pitch;
dst_ptr = (char*)dst_ptr + image->slice_pitch;
}
}
err = cl_mem_unmap_auto(image);
-error: */
+error:
return err;
}
cl_int cl_enqueue_map_buffer(enqueue_data *data)
{
+
+ void *ptr = NULL;
cl_int err = CL_SUCCESS;
- /* void *ptr = NULL;
void *mem_ptr = NULL;
- cl_int err = CL_SUCCESS;
- int slot = -1;
-
- CHECK_QUEUE(command_queue);
- CHECK_MEM(buffer);
- if (command_queue->ctx != buffer->ctx) {
- err = CL_INVALID_CONTEXT;
- goto error;
- }
-
- if (blocking_map != CL_TRUE)
- NOT_IMPLEMENTED;
-
- if (!size || offset + size > buffer->size) {
- err = CL_INVALID_VALUE;
- goto error;
- }
-
- if ((map_flags & CL_MAP_READ &&
- buffer->flags & (CL_MEM_HOST_WRITE_ONLY | CL_MEM_HOST_NO_ACCESS)) ||
- (map_flags & (CL_MAP_WRITE | CL_MAP_WRITE_INVALIDATE_REGION) &&
- buffer->flags & (CL_MEM_HOST_READ_ONLY | CL_MEM_HOST_NO_ACCESS)))
- {
- err = CL_INVALID_OPERATION;
- goto error;
- }
+ cl_int slot = -1;
+ cl_mem buffer = data->mem_obj;
if (!(ptr = cl_mem_map_auto(buffer))) {
err = CL_MAP_FAILURE;
- goto error;
}
- ptr = (char*)ptr + offset;
+ ptr = (char*)ptr + data->offset;
if(buffer->flags & CL_MEM_USE_HOST_PTR) {
assert(buffer->host_ptr);
- memcpy(buffer->host_ptr + offset, ptr, size);
- mem_ptr = buffer->host_ptr + offset;
+ memcpy(buffer->host_ptr + data->offset, ptr, data->size);
+ mem_ptr = buffer->host_ptr + data->offset;
} else {
mem_ptr = ptr;
}
- //Record the mapped address.
+ /* Record the mapped address. */
if (!buffer->mapped_ptr_sz) {
buffer->mapped_ptr_sz = 16;
buffer->mapped_ptr = (cl_mapped_ptr *)malloc(
@@ -335,19 +189,19 @@ cl_int cl_enqueue_map_buffer(enqueue_data *data)
memset(buffer->mapped_ptr, 0, buffer->mapped_ptr_sz * sizeof(cl_mapped_ptr));
slot = 0;
} else {
- int i = 0;
+ int i = 0;
for (; i < buffer->mapped_ptr_sz; i++) {
if (buffer->mapped_ptr[i].ptr == NULL) {
slot = i;
break;
}
- }
+ }
if (i == buffer->mapped_ptr_sz) {
cl_mapped_ptr *new_ptr = (cl_mapped_ptr *)malloc(
sizeof(cl_mapped_ptr) * buffer->mapped_ptr_sz * 2);
if (!new_ptr) {
- cl_mem_unmap_auto (buffer);
+ cl_mem_unmap_auto (buffer);
err = CL_OUT_OF_HOST_MEMORY;
ptr = NULL;
goto error;
@@ -365,56 +219,22 @@ cl_int cl_enqueue_map_buffer(enqueue_data *data)
assert(slot != -1);
buffer->mapped_ptr[slot].ptr = mem_ptr;
buffer->mapped_ptr[slot].v_ptr = ptr;
- buffer->mapped_ptr[slot].size = size;
+ buffer->mapped_ptr[slot].size = data->size;
buffer->map_ref++;
-error:
- if (errcode_ret)
- *errcode_ret = err;
- return mem_ptr;
+ data->ptr = mem_ptr;
-error: */
+error:
return err;
}
cl_int cl_enqueue_map_image(enqueue_data *data)
{
+ void *ptr = NULL;
cl_int err = CL_SUCCESS;
- /*void *ptr = NULL;
- cl_int err = CL_SUCCESS;
-
- CHECK_QUEUE(command_queue);
- CHECK_IMAGE(image);
- if (command_queue->ctx != image->ctx) {
- err = CL_INVALID_CONTEXT;
- goto error;
- }
-
- if (blocking_map != CL_TRUE)
- NOT_IMPLEMENTED;
- if (!origin || !region || origin[0] + region[0] > image->w || origin[1] + region[1] > image->h || origin[2] + region[2] > image->depth) {
- err = CL_INVALID_VALUE;
- goto error;
- }
-
- if (!image_row_pitch || (image->slice_pitch && !image_slice_pitch)) {
- err = CL_INVALID_VALUE;
- goto error;
- }
-
- *image_row_pitch = image->row_pitch;
- if (image_slice_pitch)
- *image_slice_pitch = image->slice_pitch;
-
- if ((map_flags & CL_MAP_READ &&
- image->flags & (CL_MEM_HOST_WRITE_ONLY | CL_MEM_HOST_NO_ACCESS)) ||
- (map_flags & (CL_MAP_WRITE | CL_MAP_WRITE_INVALIDATE_REGION) &&
- image->flags & (CL_MEM_HOST_READ_ONLY | CL_MEM_HOST_NO_ACCESS)))
- {
- err = CL_INVALID_OPERATION;
- goto error;
- }
+ cl_mem image = data->mem_obj;
+ const size_t *origin = data->origin;
if (!(ptr = cl_mem_map_auto(image))) {
err = CL_MAP_FAILURE;
@@ -422,30 +242,20 @@ cl_int cl_enqueue_map_image(enqueue_data *data)
}
size_t offset = image->bpp*origin[0] + image->row_pitch*origin[1] + image->slice_pitch*origin[2];
- ptr = (char*)ptr + offset;
+ data->ptr = (char*)ptr + offset;
error:
- if (errcode_ret)
- *errcode_ret = err;
- return ptr;
-
-error: */
return err;
}
cl_int cl_enqueue_unmap_mem_object(enqueue_data *data)
{
cl_int err = CL_SUCCESS;
- /*int i;
+ int i;
size_t mapped_size = 0;
void * v_ptr = NULL;
-
- CHECK_QUEUE(command_queue);
- CHECK_MEM(memobj);
- if (command_queue->ctx != memobj->ctx) {
- err = CL_INVALID_CONTEXT;
- goto error;
- }
+ void * mapped_ptr = data->ptr;
+ cl_mem memobj = data->mem_obj;
assert(memobj->mapped_ptr_sz >= memobj->map_ref);
INVALID_VALUE_IF(!mapped_ptr);
@@ -460,13 +270,13 @@ cl_int cl_enqueue_unmap_mem_object(enqueue_data *data)
break;
}
}
- // can not find a mapped address?
+ /* can not find a mapped address? */
INVALID_VALUE_IF(i == memobj->mapped_ptr_sz);
if (memobj->flags & CL_MEM_USE_HOST_PTR) {
assert(mapped_ptr >= memobj->host_ptr &&
mapped_ptr + mapped_size <= memobj->host_ptr + memobj->size);
- //Sync the data.
+ /* Sync the data. */
memcpy(v_ptr, mapped_ptr, mapped_size);
} else {
assert(v_ptr == mapped_ptr);
@@ -474,13 +284,13 @@ cl_int cl_enqueue_unmap_mem_object(enqueue_data *data)
cl_mem_unmap_auto(memobj);
- //shrink the mapped slot.
+ /* shrink the mapped slot. */
if (memobj->mapped_ptr_sz/2 > memobj->map_ref) {
int j = 0;
cl_mapped_ptr *new_ptr = (cl_mapped_ptr *)malloc(
- sizeof(cl_mapped_ptr) * (memobj->mapped_ptr_sz/2));
+ sizeof(cl_mapped_ptr) * (memobj->mapped_ptr_sz/2));
if (!new_ptr) {
- //Just do nothing.
+ /* Just do nothing. */
goto error;
}
memset(new_ptr, 0, (memobj->mapped_ptr_sz/2) * sizeof(cl_mapped_ptr));
@@ -497,7 +307,7 @@ cl_int cl_enqueue_unmap_mem_object(enqueue_data *data)
memobj->mapped_ptr = new_ptr;
}
-error: */
+error:
return err;
}
--
1.7.10.4
More information about the Beignet
mailing list