[Beignet] [PATCH newRT] Wrap all memory allocate functions.
He Junyan
junyan.he at inbox.com
Thu Mar 30 14:31:33 UTC 2017
I have already tried glibc's hsearch and tsearch.
tsearch using binary tree, but you can only have one search tree within one
program, which is unacceptible.
hsearch using hash table, but you can just insert the element but can not
delete the element. For our case, the point address is the key and there
hundred of thoundred of them, so this is also unacceptible.
On Thu, Mar 30, 2017 at 07:35:20AM +0000, Yang, Rong R wrote:
> Date: Thu, 30 Mar 2017 07:35:20 +0000
> From: "Yang, Rong R" <rong.r.yang at intel.com>
> To: "junyan.he at inbox.com" <junyan.he at inbox.com>,
> "beignet at lists.freedesktop.org" <beignet at lists.freedesktop.org>
> Cc: "He, Junyan" <junyan.he at intel.com>
> Subject: Re: [Beignet] [PATCH newRT] Wrap all memory allocate functions.
>
> Actually, you implement a hash table with insert/delete operations, does linux has these apis?
>
> > -----Original Message-----
> > From: Beignet [mailto:beignet-bounces at lists.freedesktop.org] On Behalf Of
> > junyan.he at inbox.com
> > Sent: Thursday, March 23, 2017 15:46
> > To: beignet at lists.freedesktop.org
> > Cc: He, Junyan <junyan.he at intel.com>
> > Subject: [Beignet] [PATCH newRT] Wrap all memory allocate functions.
> >
> > From: Junyan He <junyan.he at intel.com>
> >
> > We modify all memory allocated functions in cl_alloc file, make it
> > easy to debug all the memory leak point.
> >
> > Signed-off-by: Junyan He <junyan.he at intel.com>
> > ---
> > src/cl_accelerator_intel.c | 4 +-
> > src/cl_alloc.c | 197 ++++++++++++++++++++++++++++++++++------
> > -
> > src/cl_alloc.h | 43 +++++++--
> > src/cl_api.c | 3 +-
> > src/cl_api_context.c | 4 +-
> > src/cl_api_kernel.c | 12 +--
> > src/cl_command_queue.c | 12 +--
> > src/cl_command_queue_enqueue.c | 6 +-
> > src/cl_command_queue_gen7.c | 2 +-
> > src/cl_context.c | 14 +--
> > src/cl_device_enqueue.c | 2 +-
> > src/cl_enqueue.c | 6 +-
> > src/cl_event.c | 20 ++---
> > src/cl_kernel.c | 30 +++----
> > src/cl_mem.c | 28 +++---
> > src/cl_program.c | 54 +++++------
> > src/cl_sampler.c | 4 +-
> > src/cl_utils.h | 3 -
> > src/gen/cl_command_queue_gen.c | 12 +--
> > src/gen/cl_kernel_gen.c | 28 +++---
> > src/gen/cl_program_gen.c | 12 +--
> > src/intel/intel_batchbuffer.c | 4 +-
> > src/intel/intel_driver.c | 8 +-
> > src/intel/intel_gpgpu.c | 18 ++--
> > src/x11/dricommon.c | 6 +-
> > 25 files changed, 342 insertions(+), 190 deletions(-)
> >
> > diff --git a/src/cl_accelerator_intel.c b/src/cl_accelerator_intel.c
> > index ae08184..62700b2 100644
> > --- a/src/cl_accelerator_intel.c
> > +++ b/src/cl_accelerator_intel.c
> > @@ -18,7 +18,7 @@ cl_accelerator_intel_new(cl_context ctx,
> > cl_int err = CL_SUCCESS;
> >
> > /* Allocate and inialize the structure itself */
> > - TRY_ALLOC(accel, CALLOC(struct _cl_accelerator_intel));
> > + TRY_ALLOC(accel, CL_CALLOC(1, sizeof(struct _cl_accelerator_intel)));
> > CL_OBJECT_INIT_BASE(accel, CL_OBJECT_ACCELERATOR_INTEL_MAGIC);
> >
> > if (accel_type != CL_ACCELERATOR_TYPE_MOTION_ESTIMATION_INTEL) {
> > @@ -81,5 +81,5 @@ cl_accelerator_intel_delete(cl_accelerator_intel accel)
> >
> > cl_context_delete(accel->ctx);
> > CL_OBJECT_DESTROY_BASE(accel);
> > - cl_free(accel);
> > + CL_FREE(accel);
> > }
> > diff --git a/src/cl_alloc.c b/src/cl_alloc.c
> > index e532569..b9ac853 100644
> > --- a/src/cl_alloc.c
> > +++ b/src/cl_alloc.c
> > @@ -1,4 +1,4 @@
> > -/*
> > +/*
> > * Copyright © 2012 Intel Corporation
> > *
> > * This library is free software; you can redistribute it and/or
> > @@ -14,75 +14,204 @@
> > * You should have received a copy of the GNU Lesser General Public
> > * License along with this library. If not, see <http://www.gnu.org/licenses/>.
> > *
> > - * Author: Benjamin Segovia <benjamin.segovia at intel.com>
> > */
> > -
> > #include "cl_alloc.h"
> > #include "cl_utils.h"
> > -
> > +#include "cl_device_id.h"
> > #include <stdlib.h>
> > #include <assert.h>
> > #include <malloc.h>
> > +#include <pthread.h>
> > +#include <string.h>
> > +
> > +#ifdef CL_ALLOC_DEBUG
> > +
> > +static pthread_mutex_t cl_alloc_log_lock;
> > +#define MAX_ALLOC_LOG_NUM 1024 * 1024
> > +static unsigned int cl_alloc_log_num;
> > +
> > +typedef struct _cl_alloc_log_item {
> > + void *ptr;
> > + size_t size;
> > + char *file;
> > + int line;
> > +} _cl_alloc_log_item;
> > +typedef struct _cl_alloc_log_item *cl_alloc_log_item;
> > +
> > +#define ALLOC_LOG_BUCKET_SZ 128
> > +static cl_alloc_log_item *cl_alloc_log_map[ALLOC_LOG_BUCKET_SZ];
> > +static int cl_alloc_log_map_size[ALLOC_LOG_BUCKET_SZ];
> > +
> > +LOCAL void cl_alloc_debug_init(void)
> > +{
> > + static int inited = 0;
> > + int i;
> > + if (inited)
> > + return;
> > +
> > + pthread_mutex_init(&cl_alloc_log_lock, NULL);
> > +
> > + for (i = 0; i < ALLOC_LOG_BUCKET_SZ; i++) {
> > + cl_alloc_log_map_size[i] = 128;
> > + cl_alloc_log_map[i] = malloc(cl_alloc_log_map_size[i] *
> > sizeof(cl_alloc_log_item));
> > + memset(cl_alloc_log_map[i], 0, cl_alloc_log_map_size[i] *
> > sizeof(cl_alloc_log_item));
> > + }
> > + cl_alloc_log_num = 0;
> >
> > -static volatile int32_t cl_alloc_n = 0;
> > + atexit(cl_alloc_report_unfreed);
> > + inited = 1;
> > +}
> >
> > -LOCAL void*
> > -cl_malloc(size_t sz)
> > +static void insert_alloc_log_item(void *ptr, size_t sz, char *file, int line)
> > {
> > - void * p = NULL;
> > - atomic_inc(&cl_alloc_n);
> > - p = malloc(sz);
> > + cl_long slot;
> > + int i;
> > +
> > + if (cl_alloc_log_num > MAX_ALLOC_LOG_NUM) {
> > + // To many alloc without free. We consider already leaks a lot.
> > + cl_alloc_report_unfreed();
> > + assert(0);
> > + }
> > +
> > + slot = (cl_long)ptr;
> > + slot = (slot >> 5) & 0x07f;
> > + assert(slot < ALLOC_LOG_BUCKET_SZ);
> > +
> > + cl_alloc_log_item it = malloc(sizeof(_cl_alloc_log_item));
> > + assert(it);
> > + it->ptr = ptr;
> > + it->size = sz;
> > + it->file = file;
> > + it->line = line;
> > +
> > + pthread_mutex_lock(&cl_alloc_log_lock);
> > + for (i = 0; i < cl_alloc_log_map_size[slot]; i++) {
> > + if (cl_alloc_log_map[slot][i] == NULL) {
> > + break;
> > + }
> > + }
> > +
> > + if (i == cl_alloc_log_map_size[slot]) {
> > + cl_alloc_log_map[slot] =
> > + realloc(cl_alloc_log_map[slot], 2 * cl_alloc_log_map_size[slot] *
> > sizeof(cl_alloc_log_item));
> > + memset(cl_alloc_log_map[slot] + cl_alloc_log_map_size[slot], 0,
> > + cl_alloc_log_map_size[slot] * sizeof(cl_alloc_log_item));
> > + cl_alloc_log_map_size[slot] = cl_alloc_log_map_size[slot] * 2;
> > + }
> > +
> > + cl_alloc_log_map[slot][i] = it;
> > + cl_alloc_log_num++;
> > + pthread_mutex_unlock(&cl_alloc_log_lock);
> > +}
> > +
> > +static void delete_alloc_log_item(void *ptr, char *file, int line)
> > +{
> > + cl_long slot;
> > + int i;
> > +
> > + slot = (cl_long)ptr;
> > + slot = (slot >> 5) & 0x07f;
> > + assert(slot < ALLOC_LOG_BUCKET_SZ);
> > +
> > + pthread_mutex_lock(&cl_alloc_log_lock);
> > + for (i = 0; i < cl_alloc_log_map_size[slot]; i++) {
> > + if (cl_alloc_log_map[slot][i] && cl_alloc_log_map[slot][i]->ptr == ptr) {
> > + break;
> > + }
> > + }
> > +
> > + if (i == cl_alloc_log_map_size[slot]) {
> > + printf("Free at file: %s, line: %d, We can not find the malloc log for this
> > ptr:%p, fatal\n",
> > + file, line, ptr);
> > + assert(0);
> > + }
> > +
> > + free(cl_alloc_log_map[slot][i]);
> > + cl_alloc_log_map[slot][i] = NULL;
> > +
> > + cl_alloc_log_num--;
> > + pthread_mutex_unlock(&cl_alloc_log_lock);
> > +}
> > +
> > +LOCAL void cl_register_alloc_ptr(void *ptr, size_t sz, char *file, int line)
> > +{
> > + assert(ptr);
> > + insert_alloc_log_item(ptr, sz, file, line);
> > +}
> > +
> > +LOCAL void *cl_malloc(size_t sz, char *file, int line)
> > +{
> > + void *p = malloc(sz);
> > assert(p);
> > + insert_alloc_log_item(p, sz, file, line);
> > return p;
> > }
> >
> > -LOCAL void*
> > -cl_aligned_malloc(size_t sz, size_t align)
> > +LOCAL void *cl_memalign(size_t align, size_t sz, char *file, int line)
> > {
> > - void * p = NULL;
> > - atomic_inc(&cl_alloc_n);
> > + void *p = NULL;
> > p = memalign(align, sz);
> > assert(p);
> > + insert_alloc_log_item(p, ((sz + align - 1) / align) * align, file, line);
> > return p;
> > }
> >
> > -LOCAL void*
> > -cl_calloc(size_t n, size_t elem_size)
> > +LOCAL void *cl_calloc(size_t n, size_t elem_size, char *file, int line)
> > {
> > void *p = NULL;
> > - atomic_inc(&cl_alloc_n);
> > p = calloc(n, elem_size);
> > assert(p);
> > + insert_alloc_log_item(p, n * elem_size, file, line);
> > return p;
> > }
> >
> > -LOCAL void*
> > -cl_realloc(void *ptr, size_t sz)
> > +LOCAL void *cl_realloc(void *ptr, size_t sz, char *file, int line)
> > {
> > - if (ptr == NULL)
> > - atomic_inc(&cl_alloc_n);
> > - return realloc(ptr, sz);
> > + void *p = NULL;
> > +
> > + if (ptr != NULL) {
> > + delete_alloc_log_item(ptr, file, line);
> > + }
> > +
> > + p = realloc(ptr, sz);
> > + assert(p);
> > + insert_alloc_log_item(p, sz, file, line);
> > + return p;
> > }
> >
> > -LOCAL void
> > -cl_free(void *ptr)
> > +LOCAL void cl_free(void *ptr, char *file, int line)
> > {
> > if (ptr == NULL)
> > return;
> > - atomic_dec(&cl_alloc_n);
> > +
> > + delete_alloc_log_item(ptr, file, line);
> > free(ptr);
> > - ptr = NULL;
> > }
> >
> > -LOCAL size_t
> > -cl_report_unfreed(void)
> > +void cl_alloc_report_unfreed(void)
> > {
> > - return cl_alloc_n;
> > -}
> > + int i, slot, num;
> > + pthread_mutex_lock(&cl_alloc_log_lock);
> > + if (cl_alloc_log_num == 0) {
> > + pthread_mutex_unlock(&cl_alloc_log_lock);
> > + return;
> > + }
> >
> > -LOCAL void
> > -cl_report_set_all_freed(void)
> > -{
> > - cl_alloc_n = 0;
> > + printf("-------------------------------------------------------------------\n");
> > + num = 0;
> > + for (slot = 0; slot < ALLOC_LOG_BUCKET_SZ; slot++) {
> > + for (i = 0; i < cl_alloc_log_map_size[slot]; i++) {
> > + if (cl_alloc_log_map[slot][i]) {
> > + printf("Leak point at file:%s, line: %d, ptr is %p, alloc size is %ld\n",
> > + cl_alloc_log_map[slot][i]->file, cl_alloc_log_map[slot][i]->line,
> > + cl_alloc_log_map[slot][i]->ptr, cl_alloc_log_map[slot][i]->size);
> > + num++;
> > + }
> > + }
> > + }
> > + printf("-------------------------------------------------------------------\n");
> > + assert(num == cl_alloc_log_num);
> > + pthread_mutex_unlock(&cl_alloc_log_lock);
> > }
> >
> > +#endif
> > diff --git a/src/cl_alloc.h b/src/cl_alloc.h
> > index 433ffc6..61a904e 100644
> > --- a/src/cl_alloc.h
> > +++ b/src/cl_alloc.h
> > @@ -1,4 +1,4 @@
> > -/*
> > +/*
> > * Copyright © 2012 Intel Corporation
> > *
> > * This library is free software; you can redistribute it and/or
> > @@ -20,28 +20,53 @@
> > #ifndef __CL_ALLOC_H__
> > #define __CL_ALLOC_H__
> >
> > -#include "cl_internals.h"
> > #include <stdlib.h>
> > +#include <malloc.h>
> > +
> > +//#define CL_ALLOC_DEBUG 1
> > +#ifdef CL_ALLOC_DEBUG
> > +
> > +/* Register some ptr allocated by other part */
> > +extern void cl_register_alloc_ptr(void *ptr, size_t sz, char *file, int line);
> > +#define CL_REGISTER_ALLOC_PTR(PTR, SZ) cl_register_alloc_ptr(PTR, SZ,
> > __FILE__, __LINE__)
> >
> > /* Return a valid pointer for the requested memory block size */
> > -extern void *cl_malloc(size_t sz);
> > +extern void *cl_malloc(size_t sz, char *file, int line);
> > +#define CL_MALLOC(SZ) cl_malloc(SZ, __FILE__, __LINE__)
> >
> > /* Aligned malloc */
> > -extern void* cl_aligned_malloc(size_t sz, size_t align);
> > +extern void *cl_memalign(size_t align, size_t sz, char *file, int line);
> > +#define CL_MEMALIGN(ALIGN, SZ) cl_memalign(ALIGN, SZ, __FILE__,
> > __LINE__)
> >
> > /* malloc + memzero */
> > -extern void *cl_calloc(size_t n, size_t elem_size);
> > +extern void *cl_calloc(size_t n, size_t elem_size, char *file, int line);
> > +#define CL_CALLOC(N, ELEM_SIZE) cl_calloc(N, ELEM_SIZE, __FILE__,
> > __LINE__)
> >
> > /* Regular realloc */
> > -extern void *cl_realloc(void *ptr, size_t sz);
> > +extern void *cl_realloc(void *ptr, size_t sz, char *file, int line);
> > +#define CL_REALLOC(PTR, SZ) cl_realloc(PTR, SZ, __FILE__, __LINE__)
> >
> > /* Free a pointer allocated with cl_*alloc */
> > -extern void cl_free(void *ptr);
> > +extern void cl_free(void *ptr, char *file, int line);
> > +#define CL_FREE(PTR) cl_free(PTR, __FILE__, __LINE__)
> >
> > /* We count the number of allocation. This function report the number of
> > * allocation still unfreed
> > */
> > -extern size_t cl_report_unfreed(void);
> > +extern void cl_alloc_report_unfreed(void);
> > +#define CL_ALLOC_REPORT_UNFREED() cl_alloc_report_unfreed()
> >
> > -#endif /* __CL_ALLOC_H__ */
> > +extern void cl_alloc_debug_init(void);
> > +#define CL_ALLOC_DEBUG_INIT() cl_alloc_debug_init()
> >
> > +#else
> > +#define CL_REGISTER_ALLOC_PTR(PTR, SZ)
> > +#define CL_MALLOC(SZ) malloc(SZ)
> > +#define CL_MEMALIGN(ALIGN, SZ) memalign(ALIGN, SZ)
> > +#define CL_CALLOC(N, ELEM_SIZE) calloc(N, ELEM_SIZE)
> > +#define CL_REALLOC(PTR, SZ) realloc(PTR, SZ)
> > +#define CL_FREE(PTR) free(PTR)
> > +#define CL_ALLOC_REPORT_UNFREED()
> > +#define CL_ALLOC_DEBUG_INIT()
> > +#endif /* end of CL_ALLOC_DEBUG */
> > +#endif /* __CL_ALLOC_H__ */
> > diff --git a/src/cl_api.c b/src/cl_api.c
> > index 24b8b3d..f72533f 100644
> > --- a/src/cl_api.c
> > +++ b/src/cl_api.c
> > @@ -1280,7 +1280,8 @@
> > clGetExtensionFunctionAddressForPlatform(cl_platform_id platform,
> > cl_int
> > clReportUnfreedIntel(void)
> > {
> > - return cl_report_unfreed();
> > + return CL_SUCCESS;
> > + //return cl_report_unfreed();
> > }
> >
> > void*
> > diff --git a/src/cl_api_context.c b/src/cl_api_context.c
> > index e8184b1..fa1be08 100644
> > --- a/src/cl_api_context.c
> > +++ b/src/cl_api_context.c
> > @@ -92,7 +92,7 @@ clCreateContextFromType(const cl_context_properties
> > *properties,
> > break;
> >
> > assert(num_devices > 0);
> > - devices = cl_malloc(num_devices * sizeof(cl_device_id));
> > + devices = CL_MALLOC(num_devices * sizeof(cl_device_id));
> > err = cl_get_device_ids(NULL, device_type, num_devices, &devices[0],
> > &num_devices);
> > if (err != CL_SUCCESS)
> > break;
> > @@ -101,7 +101,7 @@ clCreateContextFromType(const
> > cl_context_properties *properties,
> > } while (0);
> >
> > if (devices)
> > - cl_free(devices);
> > + CL_FREE(devices);
> > if (errcode_ret)
> > *errcode_ret = err;
> > return context;
> > diff --git a/src/cl_api_kernel.c b/src/cl_api_kernel.c
> > index 13ea8c0..ce4d7b8 100644
> > --- a/src/cl_api_kernel.c
> > +++ b/src/cl_api_kernel.c
> > @@ -341,10 +341,10 @@ clEnqueueNativeKernel(cl_command_queue
> > command_queue,
> >
> > //Per spec, need copy args
> > if (cb_args) {
> > - new_args = cl_malloc(cb_args);
> > + new_args = CL_MALLOC(cb_args);
> > if (num_mem_objects) {
> > - new_args_mem_loc = cl_malloc(sizeof(void *) * num_mem_objects);
> > - new_mem_list = cl_malloc(sizeof(cl_mem) * num_mem_objects);
> > + new_args_mem_loc = CL_MALLOC(sizeof(void *) *
> > num_mem_objects);
> > + new_mem_list = CL_MALLOC(sizeof(cl_mem) * num_mem_objects);
> > memcpy(new_mem_list, mem_list, sizeof(cl_mem) *
> > num_mem_objects);
> > }
> >
> > @@ -405,11 +405,11 @@ clEnqueueNativeKernel(cl_command_queue
> > command_queue,
> >
> > if (err != CL_SUCCESS) {
> > if (new_args)
> > - cl_free(new_args);
> > + CL_FREE(new_args);
> > if (new_mem_list)
> > - cl_free(new_mem_list);
> > + CL_FREE(new_mem_list);
> > if (new_args_mem_loc)
> > - cl_free(new_args_mem_loc);
> > + CL_FREE(new_args_mem_loc);
> > }
> >
> > if (err == CL_SUCCESS && event) {
> > diff --git a/src/cl_command_queue.c b/src/cl_command_queue.c
> > index 55b1a23..1b21375 100644
> > --- a/src/cl_command_queue.c
> > +++ b/src/cl_command_queue.c
> > @@ -42,13 +42,13 @@ cl_command_queue_new(cl_context ctx)
> > cl_command_queue queue = NULL;
> >
> > assert(ctx);
> > - queue = cl_calloc(1, sizeof(_cl_command_queue));
> > + queue = CL_CALLOC(1, sizeof(_cl_command_queue));
> > if (queue == NULL)
> > return NULL;
> >
> > CL_OBJECT_INIT_BASE(queue, CL_OBJECT_COMMAND_QUEUE_MAGIC);
> > if (cl_command_queue_init_enqueue(queue) != CL_SUCCESS) {
> > - cl_free(queue);
> > + CL_FREE(queue);
> > return NULL;
> > }
> >
> > @@ -91,10 +91,10 @@ cl_command_queue_delete(cl_command_queue
> > queue)
> >
> > cl_mem_delete(queue->perf);
> > if (queue->barrier_events) {
> > - cl_free(queue->barrier_events);
> > + CL_FREE(queue->barrier_events);
> > }
> > CL_OBJECT_DESTROY_BASE(queue);
> > - cl_free(queue);
> > + CL_FREE(queue);
> > }
> >
> > LOCAL void
> > @@ -311,7 +311,7 @@
> > cl_command_queue_insert_barrier_event(cl_command_queue queue,
> > cl_event event)
> >
> > if (queue->barrier_events == NULL) {
> > queue->barrier_events_size = 4;
> > - queue->barrier_events = cl_calloc(queue->barrier_events_size,
> > sizeof(cl_event));
> > + queue->barrier_events = CL_CALLOC(queue->barrier_events_size,
> > sizeof(cl_event));
> > assert(queue->barrier_events);
> > }
> >
> > @@ -327,7 +327,7 @@
> > cl_command_queue_insert_barrier_event(cl_command_queue queue,
> > cl_event event)
> >
> > /* Array is full, double expand. */
> > queue->barrier_events_size *= 2;
> > - queue->barrier_events = cl_realloc(queue->barrier_events,
> > + queue->barrier_events = CL_REALLOC(queue->barrier_events,
> > queue->barrier_events_size * sizeof(cl_event));
> > assert(queue->barrier_events);
> >
> > diff --git a/src/cl_command_queue_enqueue.c
> > b/src/cl_command_queue_enqueue.c
> > index 44a0761..94c56bd 100644
> > --- a/src/cl_command_queue_enqueue.c
> > +++ b/src/cl_command_queue_enqueue.c
> > @@ -212,7 +212,7 @@
> > cl_command_queue_record_in_queue_events(cl_command_queue queue,
> > cl_uint *list_nu
> > }
> > assert(event_num > 0);
> >
> > - enqueued_list = cl_calloc(event_num, sizeof(cl_event));
> > + enqueued_list = CL_CALLOC(event_num, sizeof(cl_event));
> > assert(enqueued_list);
> >
> > i = 0;
> > @@ -274,7 +274,7 @@ cl_command_queue_wait_flush(cl_command_queue
> > queue)
> > cl_event_delete(enqueued_list[i]);
> > }
> > if (enqueued_list)
> > - cl_free(enqueued_list);
> > + CL_FREE(enqueued_list);
> >
> > return CL_SUCCESS;
> > }
> > @@ -324,7 +324,7 @@
> > cl_command_queue_wait_finish(cl_command_queue queue)
> > cl_event_delete(enqueued_list[i]);
> > }
> > if (enqueued_list)
> > - cl_free(enqueued_list);
> > + CL_FREE(enqueued_list);
> >
> > return CL_SUCCESS;
> > }
> > diff --git a/src/cl_command_queue_gen7.c
> > b/src/cl_command_queue_gen7.c
> > index dd82a44..ea64abc 100644
> > --- a/src/cl_command_queue_gen7.c
> > +++ b/src/cl_command_queue_gen7.c
> > @@ -382,7 +382,7 @@
> > cl_command_queue_ND_range_gen7(cl_command_queue queue,
> > if (ker->exec_info_n > 0) {
> > cst_sz += ker->exec_info_n * sizeof(void *);
> > cst_sz = (cst_sz + 31) / 32 * 32; //align to register size, hard code here.
> > - ker->curbe = cl_realloc(ker->curbe, cst_sz);
> > + ker->curbe = CL_REALLOC(ker->curbe, cst_sz);
> > }
> > ker->curbe_sz = cst_sz;
> >
> > diff --git a/src/cl_context.c b/src/cl_context.c
> > index 1ba2302..c54760f 100644
> > --- a/src/cl_context.c
> > +++ b/src/cl_context.c
> > @@ -273,7 +273,7 @@ cl_create_context(const cl_context_properties *
> > properties,
> >
> > /* Filter out repeated device. */
> > assert(num_devices > 0);
> > - all_dev = cl_calloc(num_devices, sizeof(cl_device_id));
> > + all_dev = CL_CALLOC(num_devices, sizeof(cl_device_id));
> > if (all_dev == NULL) {
> > *errcode_ret = CL_OUT_OF_HOST_MEMORY;
> > return NULL;
> > @@ -296,13 +296,13 @@ cl_create_context(const cl_context_properties *
> > properties,
> >
> > /* We are good */
> > if (UNLIKELY((ctx = cl_context_new(&props, dev_num, all_dev)) == NULL))
> > {
> > - cl_free(all_dev);
> > + CL_FREE(all_dev);
> > err = CL_OUT_OF_HOST_MEMORY;
> > goto error;
> > }
> >
> > if(properties != NULL && prop_len > 0) {
> > - TRY_ALLOC (ctx->prop_user, CALLOC_ARRAY(cl_context_properties,
> > prop_len));
> > + TRY_ALLOC (ctx->prop_user, CL_CALLOC(prop_len,
> > sizeof(cl_context_properties)));
> > memcpy(ctx->prop_user, properties,
> > sizeof(cl_context_properties)*prop_len);
> > }
> > ctx->prop_len = prop_len;
> > @@ -329,7 +329,7 @@ cl_context_new(struct _cl_context_prop *props,
> > cl_uint dev_num, cl_device_id* al
> > {
> > cl_context ctx = NULL;
> >
> > - TRY_ALLOC_NO_ERR (ctx, CALLOC(struct _cl_context));
> > + TRY_ALLOC_NO_ERR (ctx, CL_CALLOC(1, sizeof(struct _cl_context)));
> > CL_OBJECT_INIT_BASE(ctx, CL_OBJECT_CONTEXT_MAGIC);
> > ctx->devices = all_dev;
> > ctx->device_num = dev_num;
> > @@ -382,11 +382,11 @@ cl_context_delete(cl_context ctx)
> > cl_program_delete(ctx->built_in_prgs);
> > ctx->built_in_prgs = NULL;
> >
> > - cl_free(ctx->prop_user);
> > - cl_free(ctx->devices);
> > + CL_FREE(ctx->prop_user);
> > + CL_FREE(ctx->devices);
> > cl_driver_delete(ctx->drv);
> > CL_OBJECT_DESTROY_BASE(ctx);
> > - cl_free(ctx);
> > + CL_FREE(ctx);
> > }
> >
> > LOCAL void
> > diff --git a/src/cl_device_enqueue.c b/src/cl_device_enqueue.c
> > index b6932df..5d55c22 100644
> > --- a/src/cl_device_enqueue.c
> > +++ b/src/cl_device_enqueue.c
> > @@ -67,7 +67,7 @@ cl_device_enqueue_bind_buffer(cl_gpgpu gpgpu,
> > cl_kernel ker, uint32_t *max_bti,
> > if(ker->device_enqueue_ptr == NULL)
> > ker->device_enqueue_ptr = cl_mem_svm_allocate(ker->program->ctx,
> > 0, buf_size, 0);
> > if(ker->device_enqueue_infos == NULL)
> > - ker->device_enqueue_infos = cl_calloc(ker->arg_n, sizeof(void *));
> > + ker->device_enqueue_infos = CL_CALLOC(ker->arg_n, sizeof(void *));
> > ker->device_enqueue_info_n = 0;
> > ker->useDeviceEnqueue = CL_TRUE;
> > cl_device_enqueue_fix_offset(ker);
> > diff --git a/src/cl_enqueue.c b/src/cl_enqueue.c
> > index 8350089..933b2b7 100644
> > --- a/src/cl_enqueue.c
> > +++ b/src/cl_enqueue.c
> > @@ -613,15 +613,15 @@ cl_enqueue_delete(enqueue_data *data)
> >
> > if (data->type == EnqueueNativeKernel) {
> > if (data->mem_list) {
> > - cl_free((void*)data->mem_list);
> > + CL_FREE((void*)data->mem_list);
> > data->mem_list = NULL;
> > }
> > if (data->ptr) {
> > - cl_free((void*)data->ptr);
> > + CL_FREE((void*)data->ptr);
> > data->ptr = NULL;
> > }
> > if (data->const_ptr) {
> > - cl_free((void*)data->const_ptr);
> > + CL_FREE((void*)data->const_ptr);
> > data->const_ptr = NULL;
> > }
> > }
> > diff --git a/src/cl_event.c b/src/cl_event.c
> > index a2b16be..6b018ee 100644
> > --- a/src/cl_event.c
> > +++ b/src/cl_event.c
> > @@ -149,7 +149,7 @@ cl_event_new(cl_context ctx, cl_command_queue
> > queue, cl_command_type type,
> > cl_uint num_events, cl_event *event_list)
> > {
> > int i;
> > - cl_event e = cl_calloc(1, sizeof(_cl_event));
> > + cl_event e = CL_CALLOC(1, sizeof(_cl_event));
> > if (e == NULL)
> > return NULL;
> >
> > @@ -204,14 +204,14 @@ cl_event_delete(cl_event event)
> > for (i = 0; i < event->depend_event_num; i++) {
> > cl_event_delete(event->depend_events[i]);
> > }
> > - cl_free(event->depend_events);
> > + CL_FREE(event->depend_events);
> > }
> >
> > /* Free all the callbacks. Last ref, no need to lock. */
> > while (!list_empty(&event->callbacks)) {
> > cb = list_entry(event->callbacks.head_node.n, _cl_event_user_callback,
> > node);
> > list_node_del(&cb->node);
> > - cl_free(cb);
> > + CL_FREE(cb);
> > }
> >
> > /* Remove it from the list */
> > @@ -219,7 +219,7 @@ cl_event_delete(cl_event event)
> > cl_context_remove_event(event->ctx, event);
> >
> > CL_OBJECT_DESTROY_BASE(event);
> > - cl_free(event);
> > + CL_FREE(event);
> > }
> >
> > LOCAL cl_event
> > @@ -253,7 +253,7 @@ cl_event_create(cl_context ctx, cl_command_queue
> > queue, cl_uint num_events,
> > total_events = queue->barrier_events_num + num_events;
> >
> > if (total_events) {
> > - depend_events = cl_calloc(total_events, sizeof(cl_event));
> > + depend_events = CL_CALLOC(total_events, sizeof(cl_event));
> > if (depend_events == NULL) {
> > CL_OBJECT_UNLOCK(queue);
> > err = CL_OUT_OF_HOST_MEMORY;
> > @@ -295,7 +295,7 @@ cl_event_create(cl_context ctx, cl_command_queue
> > queue, cl_uint num_events,
> > for (i = 0; i < total_events; i++) {
> > cl_event_delete(depend_events[i]);
> > }
> > - cl_free(depend_events);
> > + CL_FREE(depend_events);
> > }
> >
> > // if set depend_events, must succeed.
> > @@ -320,7 +320,7 @@ cl_event_set_callback(cl_event event, cl_int
> > exec_type, cl_event_notify_cb pfn_n
> > assert(pfn_notify);
> >
> > do {
> > - cb = cl_calloc(1, sizeof(_cl_event_user_callback));
> > + cb = CL_CALLOC(1, sizeof(_cl_event_user_callback));
> > if (cb == NULL) {
> > err = CL_OUT_OF_HOST_MEMORY;
> > break;
> > @@ -349,7 +349,7 @@ cl_event_set_callback(cl_event event, cl_int
> > exec_type, cl_event_notify_cb pfn_n
> > } while (0);
> >
> > if (cb)
> > - cl_free(cb);
> > + CL_FREE(cb);
> >
> > return err;
> > }
> > @@ -405,7 +405,7 @@ cl_event_set_status(cl_event event, cl_int status)
> > list_node_del(&cb->node);
> > cb->executed = CL_TRUE;
> > cb->pfn_notify(event, status, cb->user_data);
> > - cl_free(cb);
> > + CL_FREE(cb);
> > }
> >
> > CL_OBJECT_LOCK(event);
> > @@ -683,7 +683,7 @@
> > cl_event_create_marker_or_barrier(cl_command_queue queue, cl_uint
> > num_events_in_
> > cl_event_delete(depend_events[i]);
> > }
> > if (depend_events)
> > - cl_free(depend_events);
> > + CL_FREE(depend_events);
> >
> > if (err != CL_SUCCESS) {
> > *error = err;
> > diff --git a/src/cl_kernel.c b/src/cl_kernel.c
> > index f687084..867231d 100644
> > --- a/src/cl_kernel.c
> > +++ b/src/cl_kernel.c
> > @@ -46,7 +46,7 @@ cl_kernel_delete(cl_kernel k)
> > if (k->cmrt_kernel != NULL) {
> > cmrt_destroy_kernel(k);
> > CL_OBJECT_DESTROY_BASE(k);
> > - cl_free(k);
> > + CL_FREE(k);
> > return;
> > }
> > #endif
> > @@ -60,35 +60,35 @@ cl_kernel_delete(cl_kernel k)
> > /* This will be true for kernels created by clCreateKernel */
> > if (k->ref_its_program) cl_program_delete(k->program);
> > /* Release the curbe if allocated */
> > - if (k->curbe) cl_free(k->curbe);
> > + if (k->curbe) CL_FREE(k->curbe);
> > /* Release the argument array if required */
> > if (k->args) {
> > for (i = 0; i < k->arg_n; ++i)
> > if (k->args[i].mem != NULL)
> > cl_mem_delete(k->args[i].mem);
> > - cl_free(k->args);
> > + CL_FREE(k->args);
> > }
> > if (k->image_sz)
> > - cl_free(k->images);
> > + CL_FREE(k->images);
> >
> > if (k->exec_info)
> > - cl_free(k->exec_info);
> > + CL_FREE(k->exec_info);
> >
> > if (k->device_enqueue_ptr)
> > cl_mem_svm_delete(k->program->ctx, k->device_enqueue_ptr);
> > if (k->device_enqueue_infos)
> > - cl_free(k->device_enqueue_infos);
> > + CL_FREE(k->device_enqueue_infos);
> >
> > CL_OBJECT_DESTROY_BASE(k);
> >
> > - cl_free(k);
> > + CL_FREE(k);
> > }
> >
> > LOCAL cl_kernel
> > cl_kernel_new(cl_program p)
> > {
> > cl_kernel k = NULL;
> > - TRY_ALLOC_NO_ERR (k, CALLOC(struct _cl_kernel));
> > + TRY_ALLOC_NO_ERR (k, CL_CALLOC(1, sizeof(struct _cl_kernel)));
> > CL_OBJECT_INIT_BASE(k, CL_OBJECT_KERNEL_MAGIC);
> > k->program = p;
> > k->cmrt_kernel = NULL;
> > @@ -317,7 +317,7 @@ cl_kernel_set_exec_info(cl_kernel k, size_t n, const
> > void *value)
> > assert(k != NULL);
> >
> > if (n == 0) return err;
> > - TRY_ALLOC(k->exec_info, cl_calloc(n, 1));
> > + TRY_ALLOC(k->exec_info, CL_CALLOC(n, 1));
> > memcpy(k->exec_info, value, n);
> > k->exec_info_n = n / sizeof(void *);
> >
> > @@ -462,7 +462,7 @@ cl_kernel_setup(cl_kernel k, gbe_kernel opaque)
> > assert(k->sampler_sz <= GEN_MAX_SURFACES);
> > assert(k->image_sz <= ctx->devices[0]->max_read_image_args + ctx-
> > >devices[0]->max_write_image_args);
> > if (k->image_sz > 0) {
> > - TRY_ALLOC_NO_ERR(k->images, cl_calloc(k->image_sz, sizeof(k-
> > >images[0])));
> > + TRY_ALLOC_NO_ERR(k->images, CL_CALLOC(k->image_sz, sizeof(k-
> > >images[0])));
> > interp_kernel_get_image_data(k->opaque, k->images);
> > } else
> > k->images = NULL;
> > @@ -479,7 +479,7 @@ cl_kernel_dup(cl_kernel from)
> >
> > if (UNLIKELY(from == NULL))
> > return NULL;
> > - TRY_ALLOC_NO_ERR (to, CALLOC(struct _cl_kernel));
> > + TRY_ALLOC_NO_ERR (to, CL_CALLOC(1, sizeof(struct _cl_kernel)));
> > CL_OBJECT_INIT_BASE(to, CL_OBJECT_KERNEL_MAGIC);
> > to->bo = from->bo;
> > to->opaque = from->opaque;
> > @@ -495,16 +495,16 @@ cl_kernel_dup(cl_kernel from)
> > if (to->sampler_sz)
> > memcpy(to->samplers, from->samplers, to->sampler_sz *
> > sizeof(uint32_t));
> > if (to->image_sz) {
> > - TRY_ALLOC_NO_ERR(to->images, cl_calloc(to->image_sz, sizeof(to-
> > >images[0])));
> > + TRY_ALLOC_NO_ERR(to->images, CL_CALLOC(to->image_sz, sizeof(to-
> > >images[0])));
> > memcpy(to->images, from->images, to->image_sz * sizeof(to-
> > >images[0]));
> > } else
> > to->images = NULL;
> > if (to->exec_info_n) { /* Must always 0 here */
> > - TRY_ALLOC_NO_ERR(to->exec_info, cl_calloc(to->exec_info_n,
> > sizeof(void *)));
> > + TRY_ALLOC_NO_ERR(to->exec_info, CL_CALLOC(to->exec_info_n,
> > sizeof(void *)));
> > memcpy(to->exec_info, from->exec_info, to->exec_info_n * sizeof(void
> > *));
> > }
> > - TRY_ALLOC_NO_ERR(to->args, cl_calloc(to->arg_n, sizeof(cl_argument)));
> > - if (to->curbe_sz) TRY_ALLOC_NO_ERR(to->curbe, cl_calloc(1, to-
> > >curbe_sz));
> > + TRY_ALLOC_NO_ERR(to->args, CL_CALLOC(to->arg_n,
> > sizeof(cl_argument)));
> > + if (to->curbe_sz) TRY_ALLOC_NO_ERR(to->curbe, CL_CALLOC(1, to-
> > >curbe_sz));
> >
> > /* Retain the bos */
> > if (from->bo) cl_buffer_reference(from->bo);
> > diff --git a/src/cl_mem.c b/src/cl_mem.c
> > index 0278b7f..f0cccb8 100644
> > --- a/src/cl_mem.c
> > +++ b/src/cl_mem.c
> > @@ -122,23 +122,23 @@ cl_mem_allocate(enum cl_mem_type type,
> > /* Allocate and inialize the structure itself */
> > if (type == CL_MEM_IMAGE_TYPE) {
> > struct _cl_mem_image *image = NULL;
> > - TRY_ALLOC (image, CALLOC(struct _cl_mem_image));
> > + TRY_ALLOC (image, CL_CALLOC(1, sizeof(struct _cl_mem_image)));
> > mem = &image->base;
> > } else if (type == CL_MEM_GL_IMAGE_TYPE ) {
> > struct _cl_mem_gl_image *gl_image = NULL;
> > - TRY_ALLOC (gl_image, CALLOC(struct _cl_mem_gl_image));
> > + TRY_ALLOC (gl_image, CL_CALLOC(1, sizeof(struct _cl_mem_gl_image)));
> > mem = &gl_image->base.base;
> > } else if (type == CL_MEM_BUFFER1D_IMAGE_TYPE) {
> > struct _cl_mem_buffer1d_image *buffer1d_image = NULL;
> > - TRY_ALLOC(buffer1d_image, CALLOC(struct _cl_mem_buffer1d_image));
> > + TRY_ALLOC(buffer1d_image, CL_CALLOC(1, sizeof(struct
> > _cl_mem_buffer1d_image)));
> > mem = &buffer1d_image->base.base;
> > } else if (type == CL_MEM_PIPE_TYPE) {
> > _cl_mem_pipe *pipe = NULL;
> > - TRY_ALLOC(pipe, CALLOC(struct _cl_mem_pipe));
> > + TRY_ALLOC(pipe, CL_CALLOC(1, sizeof(struct _cl_mem_pipe)));
> > mem = &pipe->base;
> > } else {
> > struct _cl_mem_buffer *buffer = NULL;
> > - TRY_ALLOC (buffer, CALLOC(struct _cl_mem_buffer));
> > + TRY_ALLOC (buffer, CL_CALLOC(1, sizeof(struct _cl_mem_buffer)));
> > mem = &buffer->base;
> > }
> >
> > @@ -197,7 +197,7 @@ cl_mem_allocate(enum cl_mem_type type,
> > }
> > else if (flags & CL_MEM_ALLOC_HOST_PTR) {
> > const size_t alignedSZ = ALIGN(sz, page_size);
> > - void* internal_host_ptr = cl_aligned_malloc(alignedSZ, page_size);
> > + void* internal_host_ptr = CL_MEMALIGN(page_size, alignedSZ);
> > mem->host_ptr = internal_host_ptr;
> > mem->is_userptr = 1;
> > mem->bo = cl_buffer_alloc_userptr(bufmgr, "CL userptr memory
> > object", internal_host_ptr, alignedSZ, 0);
> > @@ -447,7 +447,7 @@ cl_mem_new_sub_buffer(cl_mem buffer,
> > }
> >
> > /* Now create the sub buffer and link it to the buffer. */
> > - TRY_ALLOC (sub_buf, CALLOC(struct _cl_mem_buffer));
> > + TRY_ALLOC (sub_buf, CL_CALLOC(1, sizeof(struct _cl_mem_buffer)));
> > mem = &sub_buf->base;
> >
> > CL_OBJECT_INIT_BASE(mem, CL_OBJECT_MEM_MAGIC);
> > @@ -498,7 +498,7 @@ cl_mem cl_mem_new_pipe(cl_context ctx,
> > cl_mem mem = NULL;
> > cl_int err;
> > cl_uint sz;
> > - if(UNLIKELY((pipe = CALLOC(_cl_mem_pipe)) == NULL)) {
> > + if(UNLIKELY((pipe = CL_CALLOC(1, sizeof(_cl_mem_pipe))) == NULL)) {
> > err = CL_OUT_OF_RESOURCES;
> > goto error;
> > }
> > @@ -602,7 +602,7 @@ void* cl_mem_svm_allocate(cl_context ctx,
> > cl_svm_mem_flags flags,
> > cl_buffer_mgr bufmgr = NULL;
> > cl_mem mem;
> > _cl_mem_svm* svm;
> > - if(UNLIKELY((svm = CALLOC(_cl_mem_svm)) == NULL))
> > + if(UNLIKELY((svm = CL_CALLOC(1, sizeof(_cl_mem_svm))) == NULL))
> > return NULL;
> > mem = &svm->base;
> >
> > @@ -623,7 +623,7 @@ void* cl_mem_svm_allocate(cl_context ctx,
> > cl_svm_mem_flags flags,
> > alignment = page_size;
> > else
> > alignment = ALIGN(alignment, page_size);
> > - ptr = cl_aligned_malloc(alignedSZ, alignment);
> > + ptr = CL_MEMALIGN(alignment, alignedSZ);
> > if(ptr == NULL) return NULL;
> >
> > mem->host_ptr = ptr;
> > @@ -1232,7 +1232,7 @@ cl_mem_delete(cl_mem mem)
> > cb = list_entry(mem->dstr_cb_head.head_node.n, _cl_mem_dstr_cb,
> > node);
> > list_node_del(&cb->node);
> > cb->pfn_notify(mem, cb->user_data);
> > - cl_free(cb);
> > + CL_FREE(cb);
> > }
> >
> > /* iff we are a image, delete the 1d buffer if has. */
> > @@ -1293,10 +1293,10 @@ cl_mem_delete(cl_mem mem)
> > (mem->flags & CL_MEM_ALLOC_HOST_PTR) &&
> > (mem->type != CL_MEM_SUBBUFFER_TYPE)) ||
> > (mem->is_svm && mem->type == CL_MEM_SVM_TYPE))
> > - cl_free(mem->host_ptr);
> > + CL_FREE(mem->host_ptr);
> >
> > CL_OBJECT_DESTROY_BASE(mem);
> > - cl_free(mem);
> > + CL_FREE(mem);
> > }
> >
> > LOCAL void
> > @@ -2473,7 +2473,7 @@ LOCAL cl_int
> > cl_mem_set_destructor_callback(cl_mem memobj,
> > void(CL_CALLBACK *pfn_notify)(cl_mem, void *), void
> > *user_data)
> > {
> > - cl_mem_dstr_cb cb = cl_calloc(1, sizeof(_cl_mem_dstr_cb));
> > + cl_mem_dstr_cb cb = CL_CALLOC(1, sizeof(_cl_mem_dstr_cb));
> > if (cb == NULL) {
> > return CL_OUT_OF_HOST_MEMORY;
> > }
> > diff --git a/src/cl_program.c b/src/cl_program.c
> > index 46f9d1f..c090bba 100644
> > --- a/src/cl_program.c
> > +++ b/src/cl_program.c
> > @@ -43,7 +43,7 @@ static void
> > cl_program_release_sources(cl_program p)
> > {
> > if (p->source) {
> > - cl_free(p->source);
> > + CL_FREE(p->source);
> > p->source = NULL;
> > }
> > }
> > @@ -52,7 +52,7 @@ static void
> > cl_program_release_binary(cl_program p)
> > {
> > if (p->binary) {
> > - cl_free(p->binary);
> > + CL_FREE(p->binary);
> > p->binary = NULL;
> > }
> > }
> > @@ -74,7 +74,7 @@ cl_program_delete(cl_program p)
> >
> > /* Release the build options. */
> > if (p->build_opts) {
> > - cl_free(p->build_opts);
> > + CL_FREE(p->build_opts);
> > p->build_opts = NULL;
> > }
> >
> > @@ -89,15 +89,15 @@ cl_program_delete(cl_program p)
> > else
> > #endif
> > {
> > - cl_free(p->bin); /* Free the blob */
> > + CL_FREE(p->bin); /* Free the blob */
> > for (i = 0; i < p->ker_n; ++i) /* Free the kernels */
> > cl_kernel_delete(p->ker[i]);
> > - cl_free(p->ker);
> > + CL_FREE(p->ker);
> > }
> >
> > if (p->global_data_ptr)
> > cl_buffer_unreference(p->global_data);
> > - cl_free(p->global_data_ptr);
> > + CL_FREE(p->global_data_ptr);
> >
> > /* Remove it from the list */
> > cl_context_remove_program(p->ctx, p);
> > @@ -114,7 +114,7 @@ cl_program_delete(cl_program p)
> > }
> >
> > CL_OBJECT_DESTROY_BASE(p);
> > - cl_free(p);
> > + CL_FREE(p);
> > }
> >
> > LOCAL cl_program
> > @@ -123,7 +123,7 @@ cl_program_new(cl_context ctx)
> > cl_program p = NULL;
> >
> > /* Allocate the structure */
> > - TRY_ALLOC_NO_ERR (p, CALLOC(struct _cl_program));
> > + TRY_ALLOC_NO_ERR (p, CL_CALLOC(1, sizeof(struct _cl_program)));
> > CL_OBJECT_INIT_BASE(p, CL_OBJECT_PROGRAM_MAGIC);
> > p->build_status = CL_BUILD_NONE;
> > p->cmrt_program = NULL;
> > @@ -158,7 +158,7 @@ cl_program_load_gen_program(cl_program p)
> > p->ker_n = interp_program_get_kernel_num(p->opaque);
> >
> > /* Allocate the kernel array */
> > - TRY_ALLOC (p->ker, CALLOC_ARRAY(cl_kernel, p->ker_n));
> > + TRY_ALLOC (p->ker, CL_CALLOC(p->ker_n, sizeof(cl_kernel)));
> >
> > for (i = 0; i < p->ker_n; ++i) {
> > const gbe_kernel opaque = interp_program_get_kernel(p->opaque, i);
> > @@ -218,7 +218,7 @@ static cl_int get_program_global_data(cl_program
> > prog) {
> >
> > int page_size = getpagesize();
> > size_t alignedSz = ALIGN(const_size, page_size);
> > - char * p = (char*)cl_aligned_malloc(alignedSz, page_size);
> > + char * p = (char*)CL_MEMALIGN(page_size, alignedSz);
> > prog->global_data_ptr = p;
> > interp_program_get_global_constant_data(prog->opaque, (char*)p);
> >
> > @@ -292,7 +292,7 @@ cl_program_create_from_binary(cl_context ctx,
> > goto error;
> > }
> >
> > - TRY_ALLOC(program->binary, cl_calloc(lengths[0], sizeof(char)));
> > + TRY_ALLOC(program->binary, CL_CALLOC(lengths[0], sizeof(char)));
> > memcpy(program->binary, binaries[0], lengths[0]);
> > program->binary_sz = lengths[0];
> > program->source_type = FROM_BINARY;
> > @@ -301,11 +301,11 @@ cl_program_create_from_binary(cl_context
> > ctx,
> > program->source_type = FROM_CMRT;
> > }else if(isSPIR((unsigned char*)program->binary)) {
> > char* typed_binary;
> > - TRY_ALLOC(typed_binary, cl_calloc(lengths[0]+1, sizeof(char)));
> > + TRY_ALLOC(typed_binary, CL_CALLOC(lengths[0]+1, sizeof(char)));
> > memcpy(typed_binary+1, binaries[0], lengths[0]);
> > *typed_binary = 1;
> > program->opaque = compiler_program_new_from_llvm_binary(program-
> > >ctx->devices[0]->device_id, typed_binary, program->binary_sz+1);
> > - cl_free(typed_binary);
> > + CL_FREE(typed_binary);
> > if (UNLIKELY(program->opaque == NULL)) {
> > err = CL_INVALID_PROGRAM;
> > goto error;
> > @@ -403,7 +403,7 @@ cl_program_create_with_built_in_kernles(cl_context
> > ctx,
> > int i = 0;
> >
> > //copy the content to local_kernel_names to protect the kernel_names.
> > - TRY_ALLOC(local_kernel_names, cl_calloc(strlen(kernel_names)+1,
> > sizeof(char) ) );
> > + TRY_ALLOC(local_kernel_names, CL_CALLOC(strlen(kernel_names)+1,
> > sizeof(char) ) );
> > memcpy(local_kernel_names, kernel_names, strlen(kernel_names)+1);
> >
> > kernel = strtok_r( local_kernel_names, delims , &saveptr);
> > @@ -423,7 +423,7 @@ cl_program_create_with_built_in_kernles(cl_context
> > ctx,
> > kernel = strtok_r((char*)saveptr , delims, &saveptr );
> > }
> >
> > - cl_free(local_kernel_names);
> > + CL_FREE(local_kernel_names);
> >
> > exit:
> > if (errcode_ret)
> > @@ -500,7 +500,7 @@ cl_program_create_from_source(cl_context ctx,
> > goto error;
> > }
> >
> > - 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)
> > @@ -510,7 +510,7 @@ cl_program_create_from_source(cl_context ctx,
> > 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]);
> > @@ -522,7 +522,7 @@ cl_program_create_from_source(cl_context ctx,
> > program->binary_type = CL_PROGRAM_BINARY_TYPE_NONE;
> >
> > exit:
> > - cl_free(lens);
> > + CL_FREE(lens);
> > lens = NULL;
> > if (errcode_ret)
> > *errcode_ret = err;
> > @@ -603,16 +603,16 @@ cl_program_build(cl_program p, const char
> > *options)
> > if (options) {
> > if(p->build_opts == NULL || strcmp(options, p->build_opts) != 0) {
> > if(p->build_opts) {
> > - cl_free(p->build_opts);
> > + CL_FREE(p->build_opts);
> > p->build_opts = NULL;
> > }
> > - TRY_ALLOC (p->build_opts, cl_calloc(strlen(options) + 1, sizeof(char)));
> > + TRY_ALLOC (p->build_opts, CL_CALLOC(strlen(options) + 1,
> > sizeof(char)));
> > memcpy(p->build_opts, options, strlen(options));
> > }
> > }
> >
> > if (options == NULL && p->build_opts) {
> > - cl_free(p->build_opts);
> > + CL_FREE(p->build_opts);
> > p->build_opts = NULL;
> > }
> >
> > @@ -666,7 +666,7 @@ cl_program_build(cl_program p, const char *options)
> > p->bin_sz += interp_kernel_get_code_size(opaque);
> > }
> >
> > - TRY_ALLOC (p->bin, cl_calloc(p->bin_sz, sizeof(char)));
> > + TRY_ALLOC (p->bin, CL_CALLOC(p->bin_sz, sizeof(char)));
> > for (i = 0; i < p->ker_n; i ++) {
> > const gbe_kernel opaque = interp_program_get_kernel(p->opaque, i);
> > size_t sz = interp_kernel_get_code_size(opaque);
> > @@ -736,7 +736,7 @@ cl_program_link(cl_context context,
> > }
> >
> > if(option_exist) {
> > - TRY_ALLOC (p->build_opts, cl_calloc(strlen(kernel_arg_option) + 1,
> > sizeof(char)));
> > + TRY_ALLOC (p->build_opts, CL_CALLOC(strlen(kernel_arg_option) + 1,
> > sizeof(char)));
> > memcpy(p->build_opts, kernel_arg_option, strlen(kernel_arg_option));
> > }
> >
> > @@ -774,7 +774,7 @@ cl_program_link(cl_context context,
> > p->bin_sz += interp_kernel_get_code_size(opaque);
> > }
> >
> > - TRY_ALLOC (p->bin, cl_calloc(p->bin_sz, sizeof(char)));
> > + TRY_ALLOC (p->bin, CL_CALLOC(p->bin_sz, sizeof(char)));
> > for (i = 0; i < p->ker_n; i ++) {
> > const gbe_kernel opaque = interp_program_get_kernel(p->opaque, i);
> > size_t sz = interp_kernel_get_code_size(opaque);
> > @@ -824,16 +824,16 @@ cl_program_compile(cl_program p,
> > if (options) {
> > if(p->build_opts == NULL || strcmp(options, p->build_opts) != 0) {
> > if(p->build_opts) {
> > - cl_free(p->build_opts);
> > + CL_FREE(p->build_opts);
> > p->build_opts = NULL;
> > }
> > - TRY_ALLOC (p->build_opts, cl_calloc(strlen(options) + 1, sizeof(char)));
> > + TRY_ALLOC (p->build_opts, CL_CALLOC(strlen(options) + 1,
> > sizeof(char)));
> > memcpy(p->build_opts, options, strlen(options));
> > }
> > }
> >
> > if (options == NULL && p->build_opts) {
> > - cl_free(p->build_opts);
> > + CL_FREE(p->build_opts);
> > p->build_opts = NULL;
> > }
> >
> > diff --git a/src/cl_sampler.c b/src/cl_sampler.c
> > index d1e6dfe..69d90e6 100644
> > --- a/src/cl_sampler.c
> > +++ b/src/cl_sampler.c
> > @@ -77,7 +77,7 @@ cl_create_sampler(cl_context ctx, cl_bool
> > normalized_coords, cl_addressing_mode
> > cl_sampler sampler = NULL;
> >
> > /* Allocate and inialize the structure itself */
> > - sampler = cl_calloc(1, sizeof(_cl_sampler));
> > + sampler = CL_CALLOC(1, sizeof(_cl_sampler));
> > if (sampler == NULL) {
> > *errcode_ret = CL_OUT_OF_HOST_MEMORY;
> > return NULL;
> > @@ -108,7 +108,7 @@ cl_sampler_delete(cl_sampler sampler)
> >
> > cl_context_remove_sampler(sampler->ctx, sampler);
> > CL_OBJECT_DESTROY_BASE(sampler);
> > - cl_free(sampler);
> > + CL_FREE(sampler);
> > }
> >
> > LOCAL void
> > diff --git a/src/cl_utils.h b/src/cl_utils.h
> > index 2d24207..1f5dbce 100644
> > --- a/src/cl_utils.h
> > +++ b/src/cl_utils.h
> > @@ -271,9 +271,6 @@ do { \
> > } while (0)
> >
> > #define ELEMENTS(x) (sizeof(x)/sizeof(*(x)))
> > -#define CALLOC_STRUCT(T) (struct T*) cl_calloc(1, sizeof(struct T))
> > -#define CALLOC(T) (T*) cl_calloc(1, sizeof(T))
> > -#define CALLOC_ARRAY(T, N) (T*) cl_calloc(N, sizeof(T))
> > #define MEMZERO(x) do { memset((x),0,sizeof(*(x))); } while (0)
> >
> > /* Run some code and catch errors */
> > diff --git a/src/gen/cl_command_queue_gen.c
> > b/src/gen/cl_command_queue_gen.c
> > index d12ced8..c2f3888 100644
> > --- a/src/gen/cl_command_queue_gen.c
> > +++ b/src/gen/cl_command_queue_gen.c
> > @@ -161,7 +161,7 @@ gen_gpgpu_setup_curbe(cl_kernel kernel,
> > cl_kernel_gen kernel_gen, gen_gpgpu *gpu
> > return CL_SUCCESS;
> > }
> >
> > - curbe = cl_malloc(curbe_size);
> > + curbe = CL_MALLOC(curbe_size);
> > if (curbe == NULL) {
> > return CL_OUT_OF_HOST_MEMORY;
> > }
> > @@ -469,7 +469,7 @@ gen_gpgpu_upload_final_curbe(cl_kernel kernel,
> > cl_kernel_gen kernel_gen,
> > }
> >
> > assert(gpu->thread.thread_num > 0);
> > - final_curbe = cl_malloc(gpu->thread.thread_num * gpu-
> > >thread.curbe_size);
> > + final_curbe = CL_MALLOC(gpu->thread.thread_num * gpu-
> > >thread.curbe_size);
> > if (final_curbe == NULL)
> > return CL_OUT_OF_HOST_MEMORY;
> >
> > @@ -583,7 +583,7 @@ gen_gpgpu_upload_final_curbe(cl_kernel kernel,
> > cl_kernel_gen kernel_gen,
> >
> > /* All settings are OK, upload it to GPU */
> > gen_gpgpu_upload_curbes(gpu, final_curbe, gpu->thread.thread_num *
> > gpu->thread.curbe_size);
> > - cl_free(final_curbe);
> > + CL_FREE(final_curbe);
> > return CL_SUCCESS;
> > }
> >
> > @@ -668,7 +668,7 @@
> > cl_command_queue_ND_range_gen(cl_command_queue queue, cl_kernel
> > kernel, cl_event
> > if (kernel_gen->scratch_size > queue->device->scratch_mem_size)
> > return CL_OUT_OF_RESOURCES;
> >
> > - gpu = cl_calloc(1, sizeof(gen_gpgpu));
> > + gpu = CL_CALLOC(1, sizeof(gen_gpgpu));
> > if (gpu == NULL)
> > return CL_OUT_OF_HOST_MEMORY;
> >
> > @@ -836,7 +836,7 @@ cl_command_queue_delete_gpgpu(void *gpgpu)
> > }
> >
> > if (gpu->thread.curbe) {
> > - cl_free(gpu->thread.curbe);
> > + CL_FREE(gpu->thread.curbe);
> > gpu->thread.curbe = NULL;
> > }
> >
> > @@ -871,6 +871,6 @@ cl_command_queue_delete_gpgpu(void *gpgpu)
> > gpu->batch = NULL;
> > }
> >
> > - cl_free(gpu);
> > + CL_FREE(gpu);
> > return;
> > }
> > diff --git a/src/gen/cl_kernel_gen.c b/src/gen/cl_kernel_gen.c
> > index f555212..78ce6b8 100644
> > --- a/src/gen/cl_kernel_gen.c
> > +++ b/src/gen/cl_kernel_gen.c
> > @@ -87,7 +87,7 @@ cl_kernel_get_max_workgroup_size_gen(cl_kernel
> > kernel, cl_device_id device)
> > LOCAL void *
> > cl_kernel_new_gen(cl_device_id device, cl_kernel kernel)
> > {
> > - cl_kernel_gen gen_kernel = cl_calloc(1, sizeof(_cl_kernel_gen));
> > + cl_kernel_gen gen_kernel = CL_CALLOC(1, sizeof(_cl_kernel_gen));
> > if (gen_kernel == NULL)
> > return NULL;
> >
> > @@ -102,23 +102,23 @@ cl_kernel_delete_gen(cl_device_id device,
> > cl_kernel kernel)
> > DEV_PRIVATE_DATA(kernel, device, kernel_gen);
> >
> > if (kernel_gen->samper_info) {
> > - cl_free(kernel_gen->samper_info);
> > + CL_FREE(kernel_gen->samper_info);
> > kernel_gen->samper_info = NULL;
> > }
> > if (kernel_gen->arg_extra_info) {
> > - cl_free(kernel_gen->arg_extra_info);
> > + CL_FREE(kernel_gen->arg_extra_info);
> > kernel_gen->arg_extra_info = NULL;
> > }
> > if (kernel_gen->virt_reg_phy_offset) {
> > - cl_free(kernel_gen->virt_reg_phy_offset);
> > + CL_FREE(kernel_gen->virt_reg_phy_offset);
> > kernel_gen->virt_reg_phy_offset = NULL;
> > }
> > if (kernel_gen->image_info) {
> > - cl_free(kernel_gen->image_info);
> > + CL_FREE(kernel_gen->image_info);
> > kernel_gen->image_info = NULL;
> > }
> >
> > - cl_free(kernel_gen);
> > + CL_FREE(kernel_gen);
> > }
> >
> > LOCAL cl_int
> > @@ -228,7 +228,7 @@
> > cl_program_gen_get_kernel_func_cl_info(cl_device_id device, cl_kernel
> > kernel)
> > return CL_INVALID_KERNEL_DEFINITION;
> >
> > if (kernel->kernel_attr == NULL) {
> > - kernel->kernel_attr = cl_malloc(strlen(ptr) + 1);
> > + kernel->kernel_attr = CL_MALLOC(strlen(ptr) + 1);
> > if (kernel->kernel_attr == NULL)
> > return CL_OUT_OF_HOST_MEMORY;
> > memcpy(kernel->kernel_attr, ptr, strlen(ptr) + 1);
> > @@ -258,7 +258,7 @@
> > cl_program_gen_get_kernel_func_cl_info(cl_device_id device, cl_kernel
> > kernel)
> > if (strcmp(kernel->args[i].arg_type_name, ptr) != 0)
> > return CL_INVALID_KERNEL_DEFINITION;
> > } else {
> > - kernel->args[i].arg_type_name = cl_malloc(strlen(ptr) + 1);
> > + kernel->args[i].arg_type_name = CL_MALLOC(strlen(ptr) + 1);
> > if (kernel->args[i].arg_type_name == NULL)
> > return CL_OUT_OF_HOST_MEMORY;
> > memcpy(kernel->args[i].arg_type_name, ptr, strlen(ptr) + 1);
> > @@ -275,7 +275,7 @@
> > cl_program_gen_get_kernel_func_cl_info(cl_device_id device, cl_kernel
> > kernel)
> > if (strcmp(kernel->args[i].arg_name, ptr) != 0)
> > return CL_INVALID_KERNEL_DEFINITION;
> > } else {
> > - kernel->args[i].arg_name = cl_malloc(strlen(ptr) + 1);
> > + kernel->args[i].arg_name = CL_MALLOC(strlen(ptr) + 1);
> > if (kernel->args[i].arg_name == NULL)
> > return CL_OUT_OF_HOST_MEMORY;
> > memcpy(kernel->args[i].arg_name, ptr, strlen(ptr) + 1);
> > @@ -381,12 +381,12 @@
> > cl_program_gen_get_one_kernel_func(cl_device_id device, cl_kernel
> > kernel, GElf_S
> > cmp_arg = 1;
> > } else {
> > kernel->arg_n = arg_num;
> > - kernel->args = cl_calloc(arg_num, sizeof(cl_argument));
> > + kernel->args = CL_CALLOC(arg_num, sizeof(cl_argument));
> > if (kernel->args == NULL)
> > return CL_OUT_OF_HOST_MEMORY;
> > }
> >
> > - kernel_gen->arg_extra_info = cl_calloc(arg_num,
> > sizeof(_cl_gen_arg_extra_info));
> > + kernel_gen->arg_extra_info = CL_CALLOC(arg_num,
> > sizeof(_cl_gen_arg_extra_info));
> > if (kernel_gen->arg_extra_info == NULL)
> > return CL_OUT_OF_HOST_MEMORY;
> >
> > @@ -453,7 +453,7 @@ cl_program_gen_get_one_kernel_func(cl_device_id
> > device, cl_kernel kernel, GElf_S
> > kernel_gen->samper_info_num = *((cl_uint *)ptr);
> > ptr += sizeof(cl_uint);
> > if (kernel_gen->samper_info_num) {
> > - kernel_gen->samper_info = cl_calloc(kernel_gen->samper_info_num,
> > sizeof(cl_uint));
> > + kernel_gen->samper_info = CL_CALLOC(kernel_gen-
> > >samper_info_num, sizeof(cl_uint));
> > if (kernel_gen->samper_info == NULL)
> > return CL_OUT_OF_HOST_MEMORY;
> >
> > @@ -468,7 +468,7 @@ cl_program_gen_get_one_kernel_func(cl_device_id
> > device, cl_kernel kernel, GElf_S
> > ptr += sizeof(cl_uint);
> > if (kernel_gen->image_info_num) {
> > kernel_gen->image_info =
> > - cl_calloc(kernel_gen->image_info_num,
> > sizeof(_cl_gen_image_info_offset));
> > + CL_CALLOC(kernel_gen->image_info_num,
> > sizeof(_cl_gen_image_info_offset));
> > if (kernel_gen->image_info == NULL)
> > return CL_OUT_OF_HOST_MEMORY;
> >
> > @@ -493,7 +493,7 @@ cl_program_gen_get_one_kernel_func(cl_device_id
> > device, cl_kernel kernel, GElf_S
> > ptr += sizeof(cl_uint);
> > if (kernel_gen->virt_reg_phy_offset_num) {
> > kernel_gen->virt_reg_phy_offset =
> > - cl_calloc(kernel_gen->virt_reg_phy_offset_num,
> > sizeof(_cl_gen_virt_phy_offset));
> > + CL_CALLOC(kernel_gen->virt_reg_phy_offset_num,
> > sizeof(_cl_gen_virt_phy_offset));
> > if (kernel_gen->virt_reg_phy_offset == NULL)
> > return CL_OUT_OF_HOST_MEMORY;
> >
> > diff --git a/src/gen/cl_program_gen.c b/src/gen/cl_program_gen.c
> > index 58be603..561c7e0 100644
> > --- a/src/gen/cl_program_gen.c
> > +++ b/src/gen/cl_program_gen.c
> > @@ -64,7 +64,7 @@ cl_program_parse_gen_elf_stream(cl_char *bit_stream,
> > size_t size)
> > LOCAL void *
> > cl_program_new_gen(cl_device_id device, cl_program p)
> > {
> > - cl_program_gen gen_elf = cl_calloc(1, sizeof(_cl_program_gen));
> > + cl_program_gen gen_elf = CL_CALLOC(1, sizeof(_cl_program_gen));
> > if (gen_elf == NULL)
> > return NULL;
> >
> > @@ -87,9 +87,9 @@ cl_program_delete_gen(cl_device_id device,
> > cl_program p)
> > assert(pd->kernel_num > 0);
> > for (i = 0; i < pd->kernel_num; i++) {
> > if (pd->kernel_names[i])
> > - cl_free(pd->kernel_names[i]);
> > + CL_FREE(pd->kernel_names[i]);
> > }
> > - cl_free(pd->kernel_names);
> > + CL_FREE(pd->kernel_names);
> > }
> > pd->kernel_names = NULL;
> >
> > @@ -97,7 +97,7 @@ cl_program_delete_gen(cl_device_id device,
> > cl_program p)
> > elf_end(gen_elf->elf);
> > gen_elf->elf = NULL;
> >
> > - cl_free(gen_elf);
> > + CL_FREE(gen_elf);
> > }
> >
> > static cl_int
> > @@ -243,7 +243,7 @@ cl_program_load_binary_gen_elf(cl_device_id device,
> > cl_program prog)
> > return CL_INVALID_PROGRAM;
> > }
> >
> > - pd->kernel_names = cl_calloc(pd->kernel_num, sizeof(char *));
> > + pd->kernel_names = CL_CALLOC(pd->kernel_num, sizeof(char *));
> > if (pd->kernel_names == NULL) {
> > elf_end(elf_p);
> > elf->elf = NULL;
> > @@ -259,7 +259,7 @@ cl_program_load_binary_gen_elf(cl_device_id device,
> > cl_program prog)
> > continue;
> >
> > pd->kernel_names[j] =
> > - cl_calloc(1, strlen(p_sym_entry->st_name + elf->strtab_data->d_buf) +
> > 1);
> > + CL_CALLOC(1, strlen(p_sym_entry->st_name + elf->strtab_data->d_buf)
> > + 1);
> > if (pd->kernel_names[j] == NULL) {
> > elf_end(elf_p);
> > elf->elf = NULL;
> > diff --git a/src/intel/intel_batchbuffer.c b/src/intel/intel_batchbuffer.c
> > index be104bb..96453d4 100644
> > --- a/src/intel/intel_batchbuffer.c
> > +++ b/src/intel/intel_batchbuffer.c
> > @@ -166,7 +166,7 @@ intel_batchbuffer_new(intel_driver_t *intel)
> > {
> > intel_batchbuffer_t *batch = NULL;
> > assert(intel);
> > - TRY_ALLOC_NO_ERR (batch, CALLOC(intel_batchbuffer_t));
> > + TRY_ALLOC_NO_ERR (batch, CL_CALLOC(1, sizeof(intel_batchbuffer_t)));
> > intel_batchbuffer_init(batch, intel);
> >
> > exit:
> > @@ -185,5 +185,5 @@ intel_batchbuffer_delete(intel_batchbuffer_t *batch)
> > if(batch->buffer)
> > intel_batchbuffer_terminate(batch);
> >
> > - cl_free(batch);
> > + CL_FREE(batch);
> > }
> > diff --git a/src/intel/intel_driver.c b/src/intel/intel_driver.c
> > index b8a1b52..d7b9919 100644
> > --- a/src/intel/intel_driver.c
> > +++ b/src/intel/intel_driver.c
> > @@ -86,7 +86,7 @@ intel_driver_delete(intel_driver_t *driver)
> > if (driver == NULL)
> > return;
> >
> > - cl_free(driver);
> > + CL_FREE(driver);
> > }
> >
> > static intel_driver_t*
> > @@ -94,7 +94,7 @@ intel_driver_new(void)
> > {
> > intel_driver_t *driver = NULL;
> >
> > - TRY_ALLOC_NO_ERR (driver, CALLOC(intel_driver_t));
> > + TRY_ALLOC_NO_ERR (driver, CL_CALLOC(1, sizeof(intel_driver_t)));
> > driver->fd = -1;
> >
> > exit:
> > @@ -919,7 +919,7 @@ if (intel_driver_open(driver, NULL) != CL_SUCCESS) {
> > const size_t sz = 4096;
> > void *host_ptr;
> >
> > -host_ptr = cl_aligned_malloc(sz, 4096);
> > +host_ptr = CL_MEMALIGN(sz, 4096);
> > if (host_ptr != NULL) {
> > cl_buffer bo = intel_buffer_alloc_userptr((cl_buffer_mgr)driver->bufmgr,
> > "CL memory object", host_ptr, sz, 0);
> > @@ -927,7 +927,7 @@ if (host_ptr != NULL) {
> > device->host_unified_memory = CL_FALSE;
> > else
> > drm_intel_bo_unreference((drm_intel_bo*)bo);
> > - cl_free(host_ptr);
> > + CL_FREE(host_ptr);
> > }
> > else
> > device->host_unified_memory = CL_FALSE;
> > diff --git a/src/intel/intel_gpgpu.c b/src/intel/intel_gpgpu.c
> > index 283b07a..817cc00 100644
> > --- a/src/intel/intel_gpgpu.c
> > +++ b/src/intel/intel_gpgpu.c
> > @@ -157,7 +157,7 @@ intel_gpgpu_delete_finished(intel_gpgpu_t *gpgpu)
> > drm_intel_bo_unreference(gpgpu->constant_b.bo);
> >
> > intel_batchbuffer_delete(gpgpu->batch);
> > - cl_free(gpgpu);
> > + CL_FREE(gpgpu);
> > }
> >
> > /* Destroy the all intel_gpgpu, no matter finish or not, when driver destroy
> > */
> > @@ -172,7 +172,7 @@ void intel_gpgpu_delete_all(intel_driver_t *drv)
> > p = drv->gpgpu_list;
> > drv->gpgpu_list = p->next;
> > intel_gpgpu_delete_finished(p->gpgpu);
> > - cl_free(p);
> > + CL_FREE(p);
> > }
> > PPTHREAD_MUTEX_UNLOCK(drv);
> > }
> > @@ -195,7 +195,7 @@ intel_gpgpu_delete(intel_gpgpu_t *gpgpu)
> > !drm_intel_bo_busy(node->gpgpu->batch->buffer)) {
> > p->next = node->next;
> > intel_gpgpu_delete_finished(node->gpgpu);
> > - cl_free(node);
> > + CL_FREE(node);
> > node = p->next;
> > } else {
> > p = node;
> > @@ -207,7 +207,7 @@ intel_gpgpu_delete(intel_gpgpu_t *gpgpu)
> > !drm_intel_bo_busy(node->gpgpu->batch->buffer)) {
> > drv->gpgpu_list = drv->gpgpu_list->next;
> > intel_gpgpu_delete_finished(node->gpgpu);
> > - cl_free(node);
> > + CL_FREE(node);
> > }
> > }
> > if (gpgpu == NULL)
> > @@ -215,7 +215,7 @@ intel_gpgpu_delete(intel_gpgpu_t *gpgpu)
> >
> > if(gpgpu->batch && gpgpu->batch->buffer &&
> > drm_intel_bo_busy(gpgpu->batch->buffer)) {
> > - TRY_ALLOC_NO_ERR (node, CALLOC(struct intel_gpgpu_node));
> > + TRY_ALLOC_NO_ERR (node, CL_CALLOC(1, sizeof(struct
> > intel_gpgpu_node)));
> > node->gpgpu = gpgpu;
> > node->next = NULL;
> > p = drv->gpgpu_list;
> > @@ -238,7 +238,7 @@ intel_gpgpu_new(intel_driver_t *drv)
> > {
> > intel_gpgpu_t *state = NULL;
> >
> > - TRY_ALLOC_NO_ERR (state, CALLOC(intel_gpgpu_t));
> > + TRY_ALLOC_NO_ERR (state, CL_CALLOC(1, sizeof(intel_gpgpu_t)));
> > state->drv = drv;
> > state->batch = intel_batchbuffer_new(state->drv);
> > assert(state->batch);
> > @@ -2207,7 +2207,7 @@ static intel_event_t*
> > intel_gpgpu_event_new(intel_gpgpu_t *gpgpu)
> > {
> > intel_event_t *event = NULL;
> > - TRY_ALLOC_NO_ERR (event, CALLOC(intel_event_t));
> > + TRY_ALLOC_NO_ERR (event, CL_CALLOC(1, sizeof(intel_event_t)));
> >
> > event->buffer = gpgpu->batch->buffer;
> > if (event->buffer)
> > @@ -2222,7 +2222,7 @@ intel_gpgpu_event_new(intel_gpgpu_t *gpgpu)
> > exit:
> > return event;
> > error:
> > - cl_free(event);
> > + CL_FREE(event);
> > event = NULL;
> > goto exit;
> > }
> > @@ -2272,7 +2272,7 @@ intel_gpgpu_event_delete(intel_event_t *event)
> > drm_intel_bo_unreference(event->buffer);
> > if(event->ts_buf)
> > drm_intel_bo_unreference(event->ts_buf);
> > - cl_free(event);
> > + CL_FREE(event);
> > }
> >
> > /* IVB and HSW's result MUST shift in x86_64 system */
> > diff --git a/src/x11/dricommon.c b/src/x11/dricommon.c
> > index 98eb713..345bc47 100644
> > --- a/src/x11/dricommon.c
> > +++ b/src/x11/dricommon.c
> > @@ -115,14 +115,14 @@ dri_state_delete(dri_state_t *state)
> > if (state == NULL)
> > return;
> > dri_state_close(state);
> > - cl_free(state);
> > + CL_FREE(state);
> > }
> >
> > LOCAL dri_state_t*
> > dri_state_new(void)
> > {
> > dri_state_t *state = NULL;
> > - TRY_ALLOC_NO_ERR (state, CALLOC(dri_state_t));
> > + TRY_ALLOC_NO_ERR (state, CL_CALLOC(1, sizeof(dri_state_t)));
> > state->fd = -1;
> > state->driConnectedFlag = NONE;
> > dri_state_init_drawable_hash_table(state);
> > @@ -160,7 +160,7 @@ LOCAL dri_drawable_t*
> > dri_state_create_drawable(dri_state_t *state, XID x_drawable)
> > {
> > dri2_drawable_t *dri2_drwble;
> > - dri2_drwble = (dri2_drawable_t*)calloc(1, sizeof(*dri2_drwble));
> > + dri2_drwble = (dri2_drawable_t*)CL_CALLOC(1, sizeof(*dri2_drwble));
> >
> > if (!dri2_drwble)
> > return NULL;
> > --
> > 2.7.4
> >
> > _______________________________________________
> > Beignet mailing list
> > Beignet at lists.freedesktop.org
> > https://lists.freedesktop.org/mailman/listinfo/beignet
> _______________________________________________
> Beignet mailing list
> Beignet at lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/beignet
More information about the Beignet
mailing list