create image

4 files changed, 76 insertions, 66 deletions

diff --git a/libclapi/cl_image.c b/libclapi/cl_image.c
index 57730d31..54ecadb1 100644
--- a/libclapi/cl_image.c
+++ b/libclapi/cl_image.c
@@ -203,10 +203,10 @@ cl_image_byte_per_pixel(const cl_image_format *fmt, uint32_t *bpp)
   return CL_SUCCESS;
 }
 
-static cl_mem _cl_mem_new_image(cl_context ctx, cl_mem_flags flags, const cl_image_format *fmt,
-                                const cl_mem_object_type image_type, size_t w, size_t h, size_t depth,
-                                size_t pitch, size_t slice_pitch, void *data, /* pointer from application */
-                                cl_mem buffer, /* for image2D from buffer */ cl_int *errcode_ret)
+static cl_mem _cl_mem_create_image(cl_context ctx, cl_mem_flags flags, const cl_image_format *fmt,
+                                   const cl_mem_object_type image_type, size_t w, size_t h, size_t depth,
+                                   size_t pitch, size_t slice_pitch, void *data, /* pointer from application */
+                                   cl_mem buffer, /* for image2D from buffer */ cl_int *errcode_ret)
 {
   cl_int err = CL_SUCCESS;
   cl_mem mem = NULL;
@@ -362,12 +362,12 @@ exit:
     *errcode_ret = err;
   return mem;
 error:
-  cl_mem_release(mem);
+  cl_release_mem(mem);
   mem = NULL;
   goto exit;
 }
 
-static cl_mem _cl_mem_new_image_from_buffer(cl_context ctx, cl_mem_flags flags,
+static cl_mem _cl_mem_create_image_from_buffer(cl_context ctx, cl_mem_flags flags,
     const cl_image_format* image_format, const cl_image_desc *image_desc,
     cl_int *errcode_ret)
 {
@@ -448,9 +448,9 @@ static cl_mem _cl_mem_new_image_from_buffer(cl_context ctx, cl_mem_flags flags,
   }
 
   if(image_desc->image_type == CL_MEM_OBJECT_IMAGE2D || image_desc->image_type == CL_MEM_OBJECT_IMAGE1D_BUFFER) {
-    image = _cl_mem_new_image(ctx, flags, image_format, image_desc->image_type, image_desc->image_width,
-                              image_desc->image_height, image_desc->image_depth, image_desc->image_row_pitch,
-                              image_desc->image_slice_pitch, NULL, image_desc->buffer, errcode_ret);
+    image = _cl_mem_create_image(ctx, flags, image_format, image_desc->image_type, image_desc->image_width,
+                                 image_desc->image_height, image_desc->image_depth, image_desc->image_row_pitch,
+                                 image_desc->image_slice_pitch, NULL, image_desc->buffer, errcode_ret);
   } else
     assert(0);
 
@@ -472,7 +472,7 @@ static cl_mem _cl_mem_new_image_from_buffer(cl_context ctx, cl_mem_flags flags,
 
 error:
   if (image)
-    cl_mem_release(image);
+    cl_release_mem(image);
 
   image = NULL;
   if (errcode_ret)
@@ -481,8 +481,8 @@ error:
   return image;
 }
 
-static cl_mem cl_mem_new_image(cl_context context, cl_mem_flags flags, const cl_image_format *image_format,
-                               const cl_image_desc *image_desc, void *host_ptr, cl_int *errcode_ret)
+static cl_mem cl_mem_create_image(cl_context context, cl_mem_flags flags, const cl_image_format *image_format,
+                                  const cl_image_desc *image_desc, void *host_ptr, cl_int *errcode_ret)
 {
   cl_mem image = NULL;
   cl_int err = CL_SUCCESS;
@@ -491,26 +491,26 @@ static cl_mem cl_mem_new_image(cl_context context, cl_mem_flags flags, const cl_
   switch (image_desc->image_type) {
     case CL_MEM_OBJECT_IMAGE1D:
     case CL_MEM_OBJECT_IMAGE3D:
-      image = _cl_mem_new_image(context, flags, image_format, image_desc->image_type,
-                                image_desc->image_width, image_desc->image_height, image_desc->image_depth,
-                                image_desc->image_row_pitch, image_desc->image_slice_pitch,
-                                host_ptr, NULL, &err);
+      image = _cl_mem_create_image(context, flags, image_format, image_desc->image_type,
+                                   image_desc->image_width, image_desc->image_height, image_desc->image_depth,
+                                   image_desc->image_row_pitch, image_desc->image_slice_pitch,
+                                   host_ptr, NULL, &err);
     case CL_MEM_OBJECT_IMAGE2D:
       if(image_desc->buffer)
-        image = _cl_mem_new_image_from_buffer(context, flags, image_format, image_desc, &err);
+        image = _cl_mem_create_image_from_buffer(context, flags, image_format, image_desc, &err);
       else
-        image = _cl_mem_new_image(context, flags, image_format, image_desc->image_type,
-                                  image_desc->image_width, image_desc->image_height, image_desc->image_depth,
-                                  image_desc->image_row_pitch, image_desc->image_slice_pitch,
-                                  host_ptr, NULL, &err);
+        image = _cl_mem_create_image(context, flags, image_format, image_desc->image_type,
+                                     image_desc->image_width, image_desc->image_height, image_desc->image_depth,
+                                     image_desc->image_row_pitch, image_desc->image_slice_pitch,
+                                     host_ptr, NULL, &err);
     case CL_MEM_OBJECT_IMAGE1D_ARRAY:
     case CL_MEM_OBJECT_IMAGE2D_ARRAY:
-      image = _cl_mem_new_image(context, flags, image_format, image_desc->image_type,
-                                image_desc->image_width, image_desc->image_height, image_desc->image_array_size,
-                                image_desc->image_row_pitch, image_desc->image_slice_pitch,
-                                host_ptr, NULL, &err);
+      image = _cl_mem_create_image(context, flags, image_format, image_desc->image_type,
+                                   image_desc->image_width, image_desc->image_height, image_desc->image_array_size,
+                                   image_desc->image_row_pitch, image_desc->image_slice_pitch,
+                                   host_ptr, NULL, &err);
     case CL_MEM_OBJECT_IMAGE1D_BUFFER:
-      image = _cl_mem_new_image_from_buffer(context, flags, image_format, image_desc, &err);
+      image = _cl_mem_create_image_from_buffer(context, flags, image_format, image_desc, &err);
       break;
     case CL_MEM_OBJECT_BUFFER:
     default:
@@ -527,7 +527,7 @@ static cl_mem cl_mem_new_image(cl_context context, cl_mem_flags flags, const cl_
   }
 
   if (err != CL_SUCCESS) {
-    cl_mem_release(image);
+    cl_release_mem(image);
     image = NULL;
   }
 
@@ -606,8 +606,8 @@ clCreateImage(cl_context context,
   }
 
   /* Other details check for image_desc will leave to image create. */
-  mem = cl_mem_new_image(context, flags, image_format, image_desc,
-                         host_ptr, &err);
+  mem = cl_mem_create_image(context, flags, image_format, image_desc,
+                            host_ptr, &err);
 error:
   if (errcode_ret)
     *errcode_ret = err;
diff --git a/libclapi/cl_internals.h b/libclapi/cl_internals.h
index e39f22ac..d5ec194d 100644
--- a/libclapi/cl_internals.h
+++ b/libclapi/cl_internals.h
@@ -364,7 +364,7 @@ extern void cl_release_device_id(cl_device_id device);
 extern cl_int cl_get_device_info(cl_device_id device, cl_device_info param_name,
     size_t param_value_size, void *param_value, size_t *param_value_size_ret);
 extern cl_mem cl_mem_new(cl_mem_object_type type, cl_context ctx, cl_mem_flags flags, size_t sz);
-extern void cl_mem_release(cl_mem mem);
+extern void cl_release_mem(cl_mem mem);
 extern void cl_retain_mem(cl_mem mem);
 extern void cl_retain_program(cl_program p);
 extern void cl_release_program(cl_program p);
diff --git a/libclapi/cl_kernel.c b/libclapi/cl_kernel.c
index be3d52c2..c4b1adaf 100644
--- a/libclapi/cl_kernel.c
+++ b/libclapi/cl_kernel.c
@@ -88,6 +88,8 @@ static cl_argument cl_argument_new(cl_kernel kernel, cl_uint index, size_t size,
 
 static void cl_argument_delete(cl_argument arg)
 {
+  assert(arg);
+
   if (arg->name)
     cl_free(arg->name);
   if (arg->type_name)
diff --git a/libclapi/cl_mem.c b/libclapi/cl_mem.c
index c9f540d1..97688162 100644
--- a/libclapi/cl_mem.c
+++ b/libclapi/cl_mem.c
@@ -159,8 +159,37 @@ LOCAL cl_mem cl_mem_new(cl_mem_object_type type, cl_context ctx, cl_mem_flags fl
   return mem;
 }
 
+static void cl_mem_delete(cl_mem mem)
+{
+  assert(mem);
+  /* Remove it from the list */
+  if (mem->ctx) {
+    pthread_mutex_lock(&mem->ctx->lock);
+    if (mem->prev)
+      mem->prev->next = mem->next;
+    if (mem->next)
+      mem->next->prev = mem->prev;
+    if (mem->ctx->buffers == mem)
+      mem->ctx->buffers = mem->next;
+    pthread_mutex_unlock(&mem->ctx->lock);
+    cl_release_context(mem->ctx);
+  } else {
+    assert((mem->prev == 0) && (mem->next == 0));
+  }
+
+  if (mem->mapped_ptr)
+    free(mem->mapped_ptr); // Allocated by users
 
-LOCAL void cl_mem_release(cl_mem mem)
+  if (mem->dstr_cb)
+    cl_free(mem->dstr_cb);
+
+  if (mem->ctx->device_num > 1) {
+    cl_free(mem->pdata);
+  }
+  cl_free(mem);
+}
+
+LOCAL void cl_release_mem(cl_mem mem)
 {
   cl_uint i;
 
@@ -177,33 +206,15 @@ LOCAL void cl_mem_release(cl_mem mem)
   if (IS_IMAGE(mem)) {
     if (cl_mem_to_image(mem)->buffer_from) {
       assert(mem->type == CL_MEM_OBJECT_IMAGE1D_BUFFER || mem->type == CL_MEM_OBJECT_IMAGE2D);
-      cl_mem_release(cl_mem_to_image(mem)->buffer_from);
+      cl_release_mem(cl_mem_to_image(mem)->buffer_from);
     }
   }
 
-  /* Remove it from the list */
-  if (mem->ctx) {
-    pthread_mutex_lock(&mem->ctx->lock);
-    if (mem->prev)
-      mem->prev->next = mem->next;
-    if (mem->next)
-      mem->next->prev = mem->prev;
-    if (mem->ctx->buffers == mem)
-      mem->ctx->buffers = mem->next;
-    pthread_mutex_unlock(&mem->ctx->lock);
-    cl_release_context(mem->ctx);
-  } else {
-    assert((mem->prev == 0) && (mem->next == 0));
-  }
-
   /* Someone still mapped? Assert */
   if (mem->map_ref != 0) {
     FATAL("Free the mem %p, while there are still %d user mapping it\n", mem, mem->map_ref);
   }
 
-  if (mem->mapped_ptr)
-    free(mem->mapped_ptr);
-
   /* Call the user callback. */
   if (mem->dstr_cb) {
     cl_mem_dstr_cb *cb = mem->dstr_cb;
@@ -211,7 +222,6 @@ LOCAL void cl_mem_release(cl_mem mem)
       cb = mem->dstr_cb;
       cb->pfn_notify(mem, cb->user_data);
       mem->dstr_cb = cb->next;
-      free(cb);
     }
   }
 
@@ -227,17 +237,14 @@ LOCAL void cl_mem_release(cl_mem mem)
     if (buffer->parent->subs == buffer)
       buffer->parent->subs = buffer->sub_next;
     pthread_mutex_unlock(&buffer->parent->sub_lock);
-    cl_mem_release((cl_mem )(buffer->parent));
+    cl_release_mem((cl_mem )(buffer->parent));
   }
 
-  if (mem->ctx->device_num > 1) {
-    cl_free(mem->pdata);
-  }
-  cl_free(mem);
+  cl_mem_delete(mem);
 }
 
-static cl_mem cl_mem_new_buffer(cl_context ctx, cl_mem_flags flags, size_t sz,
-                                void *data, cl_int *errcode_ret)
+static cl_mem cl_mem_create_buffer(cl_context ctx, cl_mem_flags flags, size_t sz,
+                                   void *data, cl_int *errcode_ret)
 {
   /* Possible mem type combination:
        CL_MEM_ALLOC_HOST_PTR
@@ -318,14 +325,15 @@ exit:
   if (errcode_ret)
     *errcode_ret = err;
   return mem;
+
 error:
-  cl_mem_release(mem);
+  cl_release_mem(mem);
   mem = NULL;
   goto exit;
 }
 
-static cl_mem cl_mem_new_sub_buffer(cl_mem buffer, cl_mem_flags flags, cl_buffer_create_type create_type,
-                                    const void *create_info, cl_int *errcode_ret)
+static cl_mem cl_mem_create_sub_buffer(cl_mem buffer, cl_mem_flags flags, cl_buffer_create_type create_type,
+                                       const void *create_info, cl_int *errcode_ret)
 {
   cl_int err = CL_SUCCESS;
   cl_mem mem = NULL;
@@ -427,7 +435,7 @@ exit:
     *errcode_ret = err;
   return mem;
 error:
-  cl_mem_release(mem);
+  cl_release_mem(mem);
   mem = NULL;
   goto exit;
 }
@@ -446,7 +454,7 @@ clCreateBuffer(cl_context    context,
   cl_int err = CL_SUCCESS;
   CHECK_CONTEXT (context);
 
-  mem = cl_mem_new_buffer(context, flags, size, host_ptr, &err);
+  mem = cl_mem_create_buffer(context, flags, size, host_ptr, &err);
 error:
   if (errcode_ret)
     *errcode_ret = err;
@@ -465,8 +473,8 @@ clCreateSubBuffer(cl_mem                buffer,
 
   CHECK_MEM(buffer);
 
-  mem = cl_mem_new_sub_buffer(buffer, flags, buffer_create_type,
-                              buffer_create_info, &err);
+  mem = cl_mem_create_sub_buffer(buffer, flags, buffer_create_type,
+                                 buffer_create_info, &err);
 error:
   if (errcode_ret)
     *errcode_ret = err;
@@ -488,7 +496,7 @@ clReleaseMemObject(cl_mem memobj)
 {
   cl_int err = CL_SUCCESS;
   CHECK_MEM(memobj);
-  cl_mem_release(memobj);
+  cl_release_mem(memobj);
 error:
   return err;
 }