alloc free

3 files changed, 110 insertions, 38 deletions

diff --git a/libclapi/cl_alloc.c b/libclapi/cl_alloc.c
index f3566685..2dabd3d5 100644
--- a/libclapi/cl_alloc.c
+++ b/libclapi/cl_alloc.c
@@ -23,88 +23,155 @@
 #include "cl_alloc.h"
 #include "cl_internals.h"
 
-static volatile int cl_alloc_n = 0;
 static pthread_mutex_t cl_alloc_log_lock;
 
 typedef struct _cl_alloc_log_item {
   void* ptr;
-  char* where;
+  size_t size;
+  char* file;
+  int line;
 } _cl_alloc_log_item;
 typedef struct _cl_alloc_log_item*  cl_alloc_log_item;
 
-static cl_alloc_log_item* cl_alloc_log_map = NULL;
-static int cl_alloc_log_map_size;
+static cl_alloc_log_item* cl_alloc_log_map[8];
+static int cl_alloc_log_map_size[8];
 
 LOCAL void cl_alloc_log_init(void)
 {
   static int inited = 0;
+  int i;
   if (inited)
     return;
 
-  cl_alloc_log_map_size = 1024;
-  cl_alloc_log_map = malloc(cl_alloc_log_map_size*sizeof(cl_alloc_log_item));
-  memset(cl_alloc_log_map, 0, cl_alloc_log_map_size*sizeof(cl_alloc_log_item));
   pthread_mutex_init(&cl_alloc_log_lock, NULL);
+
+  for (i = 0; i < 8; 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));
+  }
+
   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;
+
+  slot = (cl_long)ptr;
+  slot = (slot>>5) & 0x07;
+  assert(slot < 8);
+
+  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;
+  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) & 0x07;
+  assert(slot < 8);
+
+  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]->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;
+
+  pthread_mutex_unlock(&cl_alloc_log_lock);
+}
+
+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)
+cl_aligned_malloc(size_t sz, size_t align, char* file, int line)
 {
   void * p = NULL;
-  atomic_inc(&cl_alloc_n);
   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)
+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)
+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)
+cl_free(void *ptr, char* file, int line)
 {
   if (ptr == NULL)
     return;
-  atomic_dec(&cl_alloc_n);
-  free(ptr);
-  ptr = NULL;
-}
 
-LOCAL size_t
-cl_report_unfreed(void)
-{
-  return cl_alloc_n;
+  delete_alloc_log_item(ptr, file, line);
+  free(ptr);
 }
 
 LOCAL void
-cl_report_set_all_freed(void)
+cl_alloc_report_unfreed(void)
 {
-  cl_alloc_n = 0;
 }
 
diff --git a/libclapi/cl_alloc.h b/libclapi/cl_alloc.h
index cf938d66..1121c44f 100644
--- a/libclapi/cl_alloc.h
+++ b/libclapi/cl_alloc.h
@@ -23,23 +23,28 @@
 #include <stdlib.h>
 
 /* 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_aligned_malloc(size_t sz, size_t align, char* file, int line);
+#define CL_ALIGNED_MALLOC(SZ, ALIGN) cl_aligned_malloc(SZ, ALIGN, __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);
 
 #endif /* __CL_ALLOC_H__ */
diff --git a/libclapi/cl_context.c b/libclapi/cl_context.c
index db808f27..5e0ea756 100644
--- a/libclapi/cl_context.c
+++ b/libclapi/cl_context.c
@@ -195,7 +195,7 @@ LOCAL void cl_release_context(cl_context ctx)
 
   /* Add a check point here. */
   barrier_events_list = cl_check_context_barrier_events(ctx, &barrier_events_num, &err);
-  assert(err != CL_SUCCESS);
+  assert(err == CL_SUCCESS);
   if (barrier_events_list) {
     assert(barrier_events_num > 0);
     cl_free(barrier_events_list);