[Beignet] [PATCH newRT] Wrap all memory allocate functions.
Yang, Rong R
rong.r.yang at intel.com
Thu Mar 30 07:35:20 UTC 2017
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
More information about the Beignet
mailing list