allock

5 files changed, 92 insertions, 92 deletions

diff --git a/libclapi/cl_command_queue.c b/libclapi/cl_command_queue.c
index 4e1fcaea..fc625a1c 100644
--- a/libclapi/cl_command_queue.c
+++ b/libclapi/cl_command_queue.c
@@ -32,7 +32,7 @@ static cl_command_queue cl_command_queue_new(cl_context ctx, cl_device_id device
     cl_command_queue_properties properties)
 {
   cl_command_queue queue = NULL;
-  queue = CALLOC(struct _cl_command_queue);
+  queue = CL_CALLOC(1, sizeof(_cl_command_queue));
   if (queue == NULL)
     return NULL;
 
@@ -74,9 +74,9 @@ static void cl_command_queue_delete(cl_command_queue queue)
 
   cl_release_context(queue->ctx);
   cl_release_device_id(queue->device);
-  cl_free(queue->wait_events);
+  CL_FREE(queue->wait_events);
   queue->magic = CL_MAGIC_DEAD_HEADER; /* For safety */
-  cl_free(queue);
+  CL_FREE(queue);
 
 }
 
diff --git a/libclapi/cl_kernel.c b/libclapi/cl_kernel.c
index 3093d283..446dff8a 100644
--- a/libclapi/cl_kernel.c
+++ b/libclapi/cl_kernel.c
@@ -39,37 +39,37 @@ static cl_argument cl_argument_new(cl_kernel kernel, cl_uint index, size_t size,
                                    cl_kernel_arg_type_qualifier type_qualifier)
 {
   cl_argument arg = NULL;
-  arg = CALLOC(struct _cl_argument);
+  arg = CL_CALLOC(1, sizeof(_cl_argument));
   if (arg == NULL)
     return NULL;
 
   if (type == CL_KERNEL_ARG_VALUE && size > sizeof(arg->val)) {
     /* Big value, we need extra space. */
-    arg->pstruct = cl_calloc(1, size);
+    arg->pstruct = CL_CALLOC(1, size);
     type = CL_KERNEL_ARG_STRUCT;
     if (arg->pstruct == NULL) {
-      cl_free(arg);
+      CL_FREE(arg);
       return NULL;
     }
   }
 
   if (name) {
-    arg->name = cl_malloc((strlen(name) + 1) * sizeof(char));
+    arg->name = CL_MALLOC((strlen(name) + 1) * sizeof(char));
     if (arg->name == NULL) {
-      cl_free(arg);
+      CL_FREE(arg);
       if (arg->pstruct)
-        cl_free(arg->pstruct);
+        CL_FREE(arg->pstruct);
       return NULL;
     }
   }
   if (type_name) {
-    arg->type_name = cl_malloc((strlen(type_name) + 1) * sizeof(char));
+    arg->type_name = CL_MALLOC((strlen(type_name) + 1) * sizeof(char));
     if (arg->type_name == NULL) {
       if (arg->name)
-        cl_free(arg->name);
+        CL_FREE(arg->name);
       if (arg->pstruct)
-        cl_free(arg->pstruct);
-      cl_free(arg);
+        CL_FREE(arg->pstruct);
+      CL_FREE(arg);
       return NULL;
     }
   }
@@ -92,42 +92,42 @@ static void cl_argument_delete(cl_argument arg)
   assert(arg);
 
   if (arg->name)
-    cl_free(arg->name);
+    CL_FREE(arg->name);
   if (arg->type_name)
-    cl_free(arg->type_name);
+    CL_FREE(arg->type_name);
   if (arg->type == CL_KERNEL_ARG_STRUCT) {
     assert(arg->pstruct);
-    cl_free(arg->pstruct);
+    CL_FREE(arg->pstruct);
   }
-  cl_free(arg);
+  CL_FREE(arg);
 }
 
 static cl_kernel cl_kernel_new(cl_program p, const char* name)
 {
   cl_kernel k = NULL;
-  k = CALLOC(struct _cl_kernel);
+  k = CL_CALLOC(1, sizeof(_cl_kernel));
   if (k == NULL)
     return NULL;
 
-  k->name = cl_malloc((strlen(name) + 1) * sizeof(char));
+  k->name = CL_MALLOC((strlen(name) + 1) * sizeof(char));
   if (k->name == NULL) {
-    cl_free(k);
+    CL_FREE(k);
     return NULL;
   }
 
-  k->wg_info = CALLOC_ARRAY(_cl_kernel_workgroup_info, p->ctx->device_num);
+  k->wg_info = CL_CALLOC(p->ctx->device_num, sizeof(_cl_kernel_workgroup_info));
   if (k->wg_info == NULL) {
-    cl_free(k->name);
-    cl_free(k);
+    CL_FREE(k->name);
+    CL_FREE(k);
     return NULL;
   }
 
   if (p->ctx->device_num > 1) {
-    k->pdata = CALLOC_ARRAY(void*, p->ctx->device_num);
+    k->pdata = CL_CALLOC(p->ctx->device_num, sizeof(void*));
     if (k->pdata == NULL) {
-      cl_free(k->name);
-      cl_free(k->wg_info);
-      cl_free(k);
+      CL_FREE(k->name);
+      CL_FREE(k->wg_info);
+      CL_FREE(k);
       return NULL;
     }
   }
@@ -172,22 +172,22 @@ static void cl_kernel_delete(cl_kernel k)
     for (i = 0; i < k->arg_num; ++i)
       cl_argument_delete(k->args[i]);
 
-    cl_free(k->args);
+    CL_FREE(k->args);
   }
 
   assert(k->name);
-  cl_free(k->name);
-  cl_free(k->wg_info);
+  CL_FREE(k->name);
+  CL_FREE(k->wg_info);
   if (k->attr)
-    cl_free(k->attr);
+    CL_FREE(k->attr);
 
   if (k->program->ctx->device_num > 1) {
-    cl_free(k->pdata);
+    CL_FREE(k->pdata);
   }
 
   pthread_mutex_destroy(&k->lock);
   k->magic = CL_MAGIC_DEAD_HEADER; /* For safety */
-  cl_free(k);
+  CL_FREE(k);
 }
 
 static cl_int cl_retain_kernel(cl_kernel k)
@@ -209,7 +209,7 @@ LOCAL void cl_release_kernel(cl_kernel k)
   if (cl_ref_dec(&k->ref_n) > 1)
     return;
 
-  build_status = CALLOC_ARRAY(int32_t, k->program->ctx->device_num);
+  build_status = CL_CALLOC(k->program->ctx->device_num, sizeof(int32_t));
   assert(build_status != NULL);
   pthread_mutex_lock(&k->program->lock);
   for (i = 0; i < k->program->ctx->device_num; i++)
@@ -385,7 +385,7 @@ LOCAL cl_kernel cl_create_kernel(cl_program p, const char* kernel_name, cl_int*
   if (err != CL_SUCCESS)
     goto error;
 
-  build_status = CALLOC_ARRAY(int32_t, p->ctx->device_num);
+  build_status = CL_CALLOC(p->ctx->device_num, sizeof(int32_t));
   if (UNLIKELY(build_status == NULL)) {
     err = CL_OUT_OF_HOST_MEMORY;
     goto error;
@@ -434,7 +434,7 @@ LOCAL cl_kernel cl_create_kernel(cl_program p, const char* kernel_name, cl_int*
     if (attr_sz == 0) // Still no attr
       continue;
 
-    attr = cl_realloc(attr, attr_sz);
+    attr = CL_REALLOC(attr, attr_sz);
     if (attr == NULL) {
       err = CL_OUT_OF_HOST_MEMORY;
       goto error;
@@ -491,7 +491,7 @@ LOCAL cl_kernel cl_create_kernel(cl_program p, const char* kernel_name, cl_int*
     }
   }
 
-  k->args = CALLOC_ARRAY(cl_argument, k->arg_num);
+  k->args = CL_CALLOC(k->arg_num, sizeof(cl_argument));
   if (UNLIKELY(k->args == NULL)) {
     err = CL_OUT_OF_HOST_MEMORY;
     goto error;
@@ -513,7 +513,7 @@ LOCAL cl_kernel cl_create_kernel(cl_program p, const char* kernel_name, cl_int*
            but that have no effect for kernel run. */
         err = p->ctx->devices[i]->driver->get_kernel_arg_name(k, p->ctx->devices[i], j, NULL, 0, &name_sz);
         if (err == CL_SUCCESS && name_sz != 0) {
-          name = cl_malloc(name_sz * sizeof(char));
+          name = CL_MALLOC(name_sz * sizeof(char));
           if (UNLIKELY(name == NULL)) {
             err = CL_OUT_OF_HOST_MEMORY;
             goto error;
@@ -532,7 +532,7 @@ LOCAL cl_kernel cl_create_kernel(cl_program p, const char* kernel_name, cl_int*
            but that have no effect for kernel run. */
         err = p->ctx->devices[i]->driver->get_kernel_arg_type_name(k, p->ctx->devices[i], j, NULL, 0, &type_name_sz);
         if (err == CL_SUCCESS && type_name_sz != 0) {
-          type_name = cl_malloc(type_name_sz * sizeof(char));
+          type_name = CL_MALLOC(type_name_sz * sizeof(char));
           if (UNLIKELY(type_name == NULL)) {
             err = CL_OUT_OF_HOST_MEMORY;
             goto error;
@@ -578,11 +578,11 @@ LOCAL cl_kernel cl_create_kernel(cl_program p, const char* kernel_name, cl_int*
     }
 
     if (name)
-      cl_free(name);
+      CL_FREE(name);
     name = NULL;
     name_sz = 0;
     if (type_name)
-      cl_free(type_name);
+      CL_FREE(type_name);
     type_name = NULL;
     type_name_sz = 0;
     qualifier= 0;
@@ -592,13 +592,13 @@ LOCAL cl_kernel cl_create_kernel(cl_program p, const char* kernel_name, cl_int*
   }
 
   if (attr)
-    cl_free(attr);
+    CL_FREE(attr);
   if (name)
-    cl_free(name);
+    CL_FREE(name);
   if (type_name)
-    cl_free(type_name);
+    CL_FREE(type_name);
   if (build_status)
-    cl_free(build_status);
+    CL_FREE(build_status);
 
   if (errcode_ret)
     *errcode_ret = err;
@@ -606,13 +606,13 @@ LOCAL cl_kernel cl_create_kernel(cl_program p, const char* kernel_name, cl_int*
 
 error:
   if (attr)
-    cl_free(attr);
+    CL_FREE(attr);
   if (build_status)
-    cl_free(build_status);
+    CL_FREE(build_status);
   if (name)
-    cl_free(name);
+    CL_FREE(name);
   if (type_name)
-    cl_free(type_name);
+    CL_FREE(type_name);
   if (k)
     cl_release_kernel(k);
   if (errcode_ret)
diff --git a/libclapi/cl_mem.c b/libclapi/cl_mem.c
index 862f7a37..3c9842d5 100644
--- a/libclapi/cl_mem.c
+++ b/libclapi/cl_mem.c
@@ -125,29 +125,29 @@ LOCAL cl_mem cl_mem_new(cl_mem_object_type type, cl_context ctx, cl_mem_flags fl
       || type == CL_MEM_OBJECT_IMAGE2D_ARRAY || type == CL_MEM_OBJECT_IMAGE1D
       || type == CL_MEM_OBJECT_IMAGE1D_ARRAY || type == CL_MEM_OBJECT_IMAGE1D_BUFFER) {
     struct _cl_mem_image *image = NULL;
-    image = CALLOC(struct _cl_mem_image);
+    image = CL_CALLOC(1, sizeof(struct _cl_mem_image));
     mem = &image->base;
   } else {
     struct _cl_mem_buffer *buffer = NULL;
-    buffer = CALLOC(struct _cl_mem_buffer);
+    buffer = CL_CALLOC(1, sizeof(struct _cl_mem_buffer));
     mem = &buffer->base;
   }
 
   if (mem == NULL)
     return NULL;
 
-  mem->enqueued_devices = CALLOC_ARRAY(cl_bool, ctx->device_num);
+  mem->enqueued_devices = CL_CALLOC(ctx->device_num, sizeof(cl_bool));
   if (mem->enqueued_devices == NULL) {
-    cl_free(mem);
+    CL_FREE(mem);
     return NULL;
   }
 
   /* Create the private pointer array if device > 1 */
   if (ctx->device_num > 1) {
-    mem->pdata = CALLOC_ARRAY(void*, ctx->device_num);
+    mem->pdata = CL_CALLOC(ctx->device_num, sizeof(void*));
     if (mem->pdata == NULL) {
-      cl_free(mem->enqueued_devices);
-      cl_free(mem);
+      CL_FREE(mem->enqueued_devices);
+      CL_FREE(mem);
       return NULL;
     }
   }
@@ -189,24 +189,24 @@ static void cl_mem_delete(cl_mem mem)
   cl_release_context(mem->ctx);
 
   if (mem->mapped_ptr)
-    cl_free(mem->mapped_ptr);
+    CL_FREE(mem->mapped_ptr);
 
   if (mem->dstr_cb) {
     cl_mem_dstr_cb *cb = NULL;
     while (mem->dstr_cb) {
       cb = mem->dstr_cb;
       mem->dstr_cb = cb->next;
-      cl_free(cb);
+      CL_FREE(cb);
     }
   }
 
   pthread_mutex_destroy(&mem->lock);
 
   if (mem->ctx->device_num > 1) {
-    cl_free(mem->pdata);
+    CL_FREE(mem->pdata);
   }
-  cl_free(mem->enqueued_devices);
-  cl_free(mem);
+  CL_FREE(mem->enqueued_devices);
+  CL_FREE(mem);
 }
 
 LOCAL void cl_release_mem(cl_mem mem)
@@ -463,7 +463,7 @@ static cl_int cl_record_mapped(cl_mem mem, void *ptr, size_t offset,
   /* Record the mapped address. */
   if (!mem->mapped_ptr_sz) {
     mem->mapped_ptr_sz = 16;
-    mem->mapped_ptr = (cl_mapped_ptr *)cl_malloc(
+    mem->mapped_ptr = (cl_mapped_ptr *)CL_MALLOC(
                         sizeof(cl_mapped_ptr) * mem->mapped_ptr_sz);
     if (!mem->mapped_ptr) {
       pthread_mutex_unlock(&mem->lock);
@@ -480,7 +480,7 @@ static cl_int cl_record_mapped(cl_mem mem, void *ptr, size_t offset,
       }
     }
     if (i == mem->mapped_ptr_sz) {
-      cl_mapped_ptr *new_ptr = (cl_mapped_ptr *)cl_malloc(sizeof(cl_mapped_ptr) * mem->mapped_ptr_sz * 2);
+      cl_mapped_ptr *new_ptr = (cl_mapped_ptr *)CL_MALLOC(sizeof(cl_mapped_ptr) * mem->mapped_ptr_sz * 2);
       if (!new_ptr) {
         pthread_mutex_unlock(&mem->lock);
         return CL_OUT_OF_HOST_MEMORY;
@@ -490,7 +490,7 @@ static cl_int cl_record_mapped(cl_mem mem, void *ptr, size_t offset,
              mem->mapped_ptr_sz * sizeof(cl_mapped_ptr));
       slot = mem->mapped_ptr_sz;
       mem->mapped_ptr_sz *= 2;
-      cl_free(mem->mapped_ptr);
+      CL_FREE(mem->mapped_ptr);
       mem->mapped_ptr = new_ptr;
     }
   }
@@ -627,7 +627,7 @@ static cl_int cl_enqueue_unmap_mem(cl_command_queue queue, cl_mem memobj, void *
       }
     }
     memobj->mapped_ptr_sz = memobj->mapped_ptr_sz/2;
-    cl_free(memobj->mapped_ptr);
+    CL_FREE(memobj->mapped_ptr);
     memobj->mapped_ptr = new_ptr;
   }
   pthread_mutex_unlock(&memobj->lock);
diff --git a/libclapi/cl_program.c b/libclapi/cl_program.c
index 78febc27..25031e20 100644
--- a/libclapi/cl_program.c
+++ b/libclapi/cl_program.c
@@ -84,27 +84,27 @@ static void cl_program_delete(cl_program p)
   for (i = 0; i < p->ctx->device_num; i++) {
     /* Release the build options. */
     if (p->device_status[i].build_opts) {
-      cl_free(p->device_status[i].build_opts);
+      CL_FREE(p->device_status[i].build_opts);
       p->device_status[i].build_opts = NULL;
     }
   }
 
   if (p->kernel_names)
-    cl_free(p->kernel_names);
+    CL_FREE(p->kernel_names);
 
   /* Destroy the sources if still allocated */
   if (p->source) {
-    cl_free(p->source);
+    CL_FREE(p->source);
     p->source = NULL;
   }
 
   if (p->ctx->device_num > 1) {
-    cl_free(p->pdata);
+    CL_FREE(p->pdata);
   }
 
   pthread_mutex_destroy(&p->lock);
   p->magic = CL_MAGIC_DEAD_HEADER; /* For safety */
-  cl_free(p);
+  CL_FREE(p);
 }
 
 LOCAL void cl_release_program(cl_program p)
@@ -139,14 +139,14 @@ static cl_program cl_program_new(cl_context ctx)
   int i;
 
   /* Allocate the structure */
-  TRY_ALLOC_NO_ERR(p, CALLOC(struct _cl_program));
+  TRY_ALLOC_NO_ERR(p, CL_CALLOC(1, sizeof(struct _cl_program)));
   /* Create the private pointer array if device > 1 */
   if (ctx->device_num > 1) {
-    TRY_ALLOC_NO_ERR(p->pdata, CALLOC_ARRAY(void*, ctx->device_num));
+    TRY_ALLOC_NO_ERR(p->pdata, CL_CALLOC(ctx->device_num, sizeof(void*)));
   }
 
   TRY_ALLOC_NO_ERR(p->device_status,
-                   CALLOC_ARRAY(_cl_program_device_status, ctx->device_num));
+                   CL_CALLOC(ctx->device_num, sizeof(_cl_program_device_status)));
 
   for (i = 0; i < ctx->device_num; i++) {
     p->device_status[i].build_status = CL_BUILD_NONE;
@@ -174,13 +174,13 @@ error:
 
   if (p->ctx->device_num > 1) {
     if (p->pdata)
-      cl_free(p->pdata);
+      CL_FREE(p->pdata);
   }
 
   if (p->device_status)
-    cl_free(p->device_status);
+    CL_FREE(p->device_status);
 
-  cl_free(p);
+  CL_FREE(p);
   return NULL;
 }
 
@@ -203,7 +203,7 @@ static cl_program cl_program_create_from_source(cl_context ctx, cl_uint count,
     goto exit;
   }
 
-  TRY_ALLOC(lens, cl_calloc(count, sizeof(int32_t)));
+  TRY_ALLOC(lens, CL_CALLOC(count, sizeof(int32_t)));
   for (i = 0; i < (int) count; ++i) {
     size_t len;
     if (lengths == NULL || lengths[i] == 0)
@@ -213,7 +213,7 @@ static cl_program cl_program_create_from_source(cl_context ctx, cl_uint count,
     lens[i] = len;
     len_total += len;
   }
-  TRY_ALLOC(program->source, cl_calloc(len_total+1, sizeof(char)));
+  TRY_ALLOC(program->source, CL_CALLOC(len_total+1, sizeof(char)));
   p = program->source;
   for (i = 0; i < (int) count; ++i) {
     memcpy(p, strings[i], lens[i]);
@@ -224,7 +224,7 @@ static cl_program cl_program_create_from_source(cl_context ctx, cl_uint count,
   program->source_type = FROM_SOURCE;
 
 exit:
-  cl_free(lens);
+  CL_FREE(lens);
   lens = NULL;
   if (errcode_ret)
     *errcode_ret = err;
@@ -315,7 +315,7 @@ static cl_int cl_get_kernel_names(cl_program p, const cl_device_id device)
     goto error;
   }
 
-  kernel_names = cl_calloc(1, kernel_names_sz);
+  kernel_names = CL_CALLOC(1, kernel_names_sz);
   if (kernel_names == NULL) {
     err = CL_OUT_OF_HOST_MEMORY;
     goto error;
@@ -375,7 +375,7 @@ static cl_int cl_get_kernel_names(cl_program p, const cl_device_id device)
 
 error:
   if (kernel_names)
-    cl_free(kernel_names);
+    CL_FREE(kernel_names);
   return err;
 }
 
@@ -448,14 +448,14 @@ static cl_int cl_program_build(cl_program p, const char *options,
       if(p->device_status[index].build_opts == NULL ||
           strcmp(options, p->device_status[index].build_opts) != 0) {
         if(p->device_status[index].build_opts) {
-          cl_free(p->device_status[index].build_opts);
+          CL_FREE(p->device_status[index].build_opts);
           p->device_status[index].build_opts = NULL;
         }
-        TRY_ALLOC(p->device_status[index].build_opts, cl_calloc(strlen(options) + 1, sizeof(char)));
+        TRY_ALLOC(p->device_status[index].build_opts, CL_CALLOC(strlen(options) + 1, sizeof(char)));
         memcpy(p->device_status[index].build_opts, options, strlen(options));
       }
     } else if (options == NULL && p->device_status[index].build_opts) {
-      cl_free(p->device_status[index].build_opts);
+      CL_FREE(p->device_status[index].build_opts);
       p->device_status[index].build_opts = NULL;
     }
   }
@@ -562,14 +562,14 @@ static cl_int cl_program_compile(cl_program p, cl_uint num_devices, const cl_dev
       if(p->device_status[index].build_opts == NULL ||
           strcmp(options, p->device_status[index].build_opts) != 0) {
         if(p->device_status[index].build_opts) {
-          cl_free(p->device_status[index].build_opts);
+          CL_FREE(p->device_status[index].build_opts);
           p->device_status[index].build_opts = NULL;
         }
-        TRY_ALLOC(p->device_status[index].build_opts, cl_calloc(strlen(options) + 1, sizeof(char)));
+        TRY_ALLOC(p->device_status[index].build_opts, CL_CALLOC(strlen(options) + 1, sizeof(char)));
         memcpy(p->device_status[index].build_opts, options, strlen(options));
       }
     } else if (options == NULL && p->device_status[index].build_opts) {
-      cl_free(p->device_status[index].build_opts);
+      CL_FREE(p->device_status[index].build_opts);
       p->device_status[index].build_opts = NULL;
     }
   }
diff --git a/libclapi/cl_sampler.c b/libclapi/cl_sampler.c
index 8f932b25..8fb87985 100644
--- a/libclapi/cl_sampler.c
+++ b/libclapi/cl_sampler.c
@@ -41,9 +41,9 @@ static void cl_sampler_delete(cl_sampler sampler)
   cl_release_context(sampler->ctx);
 
   if (sampler->ctx->device_num > 1) {
-    cl_free(sampler->pdata);
+    CL_FREE(sampler->pdata);
   }
-  cl_free(sampler);
+  CL_FREE(sampler);
 }
 
 static void cl_release_sampler(cl_sampler sampler)
@@ -69,7 +69,7 @@ static cl_sampler cl_sampler_new(cl_context ctx, cl_bool normalized_coords,
   cl_sampler sampler = NULL;
 
   /* Allocate and inialize the structure itself */
-  sampler = CALLOC(struct _cl_sampler);
+  sampler = CL_CALLOC(1, sizeof(_cl_sampler));
   if (sampler == NULL)
     return NULL;
 
@@ -80,9 +80,9 @@ static cl_sampler cl_sampler_new(cl_context ctx, cl_bool normalized_coords,
   sampler->filter = filter;
   /* Create the private pointer array if device > 1 */
   if (ctx->device_num > 1) {
-    sampler->pdata = CALLOC_ARRAY(void*, ctx->device_num);
+    sampler->pdata = CL_CALLOC(ctx->device_num, sizeof(void*));
     if (sampler->pdata == NULL) {
-      cl_free(sampler);
+      CL_FREE(sampler);
       return NULL;
     }
   }