From: Yang Rong <rong.r.yang@intel.com>
Date: Mon, 12 Aug 2013 08:07:17 +0000 (+0800)
Subject: Add a struct and a function to handle all implemented enqueue api.
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=b2eca34b8ba3318ffae6dac40e824ea0f35d25ec;p=contrib%2Fbeignet.git

Add a struct and a function to handle all implemented enqueue api.

Event and non-blocking enqueue api may use this function.

Signed-off-by: Yang Rong <rong.r.yang@intel.com>
Reviewed-by: Zhigang Gong <zhigang.gong@linux.intel.com>
---

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