[chimp] also insert pthread calls to chimp_list

include/chimp/chimp.h

 #ifndef _CHIMP_H_
 #define _CHIMP_H_
 
+#include <pthread.h>
+
 typedef struct chimp_libc_ops
 {
     void *(*calloc)(size_t nmemb, size_t size);
     void *(*malloc)(size_t size);
-    void (*free)(void *ptr);
+    void  (*free)(void *ptr);
     void *(*realloc)(void *ptr, size_t size);
     void *(*memalign)(size_t blocksize, size_t bytes);
+    int   (*pthread_create)(pthread_t *thread, const pthread_attr_t *attr,
+                            void *(*start_routine) (void *), void *arg);
+    int   (*pthread_join)(pthread_t thread, void **retval);
 } chimp_libc_ops_t;
 
 #endif //_CHIMP_H_

include/chimp/chimp_list.h

@@ -10,6 +10,8 @@
 enum chimp_list_func {
     FUNC_MALLOC,
     FUNC_FREE,
+    FUNC_PTHREAD_CREATE,
+    FUNC_PTHREAD_JOIN,
 };
 
 typedef struct chimp_list_elem
@@ -17,6 +19,7 @@ typedef struct chimp_list_elem
     enum chimp_list_func func;
     void *ptr;
     size_t mem_size;
+    pthread_t tid;
 } chimp_list_elem_t;
 
 typedef struct chimp_list
@@ -32,6 +35,8 @@ bool chimp_list_init(chimp_list_t *list, chimp_libc_ops_t *ops);
 void chimp_list_free(chimp_list_t *list);
 
 bool chimp_list_add_elem(chimp_list_t *list, chimp_list_elem_t elem);
+bool chimp_list_add_pthread(chimp_list_t *list, enum chimp_list_func func,
+                            void *ptr, pthread_t tid);
 bool chimp_list_add(chimp_list_t *list, enum chimp_list_func func, void *ptr,
                     size_t mem_size);
 bool chimp_list_compress(chimp_list_t *list);

src/chimp/chimp.c

@@ -70,6 +70,21 @@ void kill_threads()
         }
     }
 }
+
+void kill_threads2()
+{
+    int i;
+    chimp_list_elem_t elem;
+
+    for (i = 0; i < list.size; ++i) {
+        elem = list.arr[i];
+        if (elem.func == FUNC_PTHREAD_CREATE) {
+            pthread_cancel(list.arr[i].tid);
+            ops.pthread_join(list.arr[i].tid, NULL);
+        }
+    }
+    
+}
 // ****
 
 static void init()
@@ -79,9 +94,11 @@ static void init()
     ops.calloc     = dlsym(RTLD_NEXT, "calloc");
     ops.realloc    = dlsym(RTLD_NEXT, "realloc");
     ops.memalign   = dlsym(RTLD_NEXT, "memalign");
+    ops.pthread_create = dlsym(RTLD_NEXT, "pthread_create");
+    ops.pthread_join = dlsym(RTLD_NEXT, "pthread_join");
 
     if (!ops.malloc || !ops.free || !ops.calloc || !ops.realloc ||
-        !ops.memalign) {
+        !ops.memalign || !ops.pthread_create || !ops.pthread_join) {
         fprintf(stderr, "Error in `dlsym`: %s\n", dlerror());
         exit(1);
     }
@@ -98,17 +115,21 @@ static void init()
 void chimp_print_list()
 {
     int i;
-    char *func_str[] = {"malloc", "free"};
+    char *func_str[] = {"malloc", "free", "pthread_create", "pthread_join"};
     chimp_list_elem_t elem;
 
     chimp_list_compress(&list);
     for (i = 0; i < list.size; ++i) {
         elem = list.arr[i];
         if (elem.func == FUNC_MALLOC) {
-            printf("\t%s(%lu) = %p\n", func_str[elem.func], elem.mem_size,
-                   elem.ptr);
+           // printf("\t%s(%lu) = %p\n", func_str[elem.func], elem.mem_size,
+           //        elem.ptr);
         } else if (elem.func == FUNC_FREE) {
-            printf("\t%s(%p)\n", func_str[elem.func], elem.ptr);
+           // printf("\t%s(%p)\n", func_str[elem.func], elem.ptr);
+        } else if (elem.func == FUNC_PTHREAD_CREATE) {
+            printf("\t%s(%d)\n", func_str[elem.func], elem.tid);
+        } else if (elem.func == FUNC_PTHREAD_JOIN) {
+            printf("\t%s(%d)\n", func_str[elem.func], elem.tid);
         }
     }
 }
@@ -117,7 +138,7 @@ void chimp_free_all()
 {
     int i;
     chimp_list_elem_t elem;
-    kill_threads();
+    kill_threads2();
     pthread_mutex_lock(&list.lock);
     chimp_list_compress(&list);
     for (i=0; i < list.size; ++i) {
@@ -137,6 +158,38 @@ void chimp_malloc_togglelog()
     log_sw = !log_sw;
 }
 
+int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
+                   void *(*start_routine) (void *), void *arg)
+{
+    int ret = -1;
+    printf("pthread_create\n");
+    ret = ops.pthread_create(thread, attr, start_routine, arg);
+
+    if (log_sw) {
+        if (!thread) {
+            printf("[chimp]: error thread is NULL!\n");
+        } else if (!chimp_list_add_pthread(&list, FUNC_PTHREAD_CREATE, NULL,
+                                   *thread)) {
+            fprintf(stderr, "failed to add pthread_create to list\n");
+        }
+    }
+}
+
+int pthread_join(pthread_t thread, void **retval)
+{
+    int ret = -1;
+    ret = ops.pthread_join(thread, retval);
+
+    if (log_sw) {
+        if (!thread) {
+            printf("[chimp]: error thread is NULL!\n");
+        } else if (!chimp_list_add_pthread(&list, FUNC_PTHREAD_JOIN, NULL,
+                                   thread)) {
+            fprintf(stderr, "failed to add pthread_create to list\n");
+        }
+    }
+}
+
 void *malloc(size_t size)
 {
     static int initializing = 0;

src/chimp/chimp_list.c

@@ -44,6 +44,16 @@ bool chimp_list_add_elem(chimp_list_t *list, chimp_list_elem_t elem)
     return true;
 }
 
+bool chimp_list_add_pthread(chimp_list_t *list, enum chimp_list_func func,
+                            void *ptr, pthread_t tid)
+{
+    chimp_list_elem_t elem = {
+        .func = func,
+        .ptr = ptr,
+        .tid = tid,
+    };
+    return chimp_list_add_elem(list, elem);
+}
 bool chimp_list_add(chimp_list_t *list, enum chimp_list_func func, void *ptr,
                     size_t mem_size)
 {
@@ -171,7 +181,9 @@ bool chimp_list_compress(chimp_list_t *list)
     // Now we can remove all previously found malloc/free pairs from the array
     put = 0;
     for (get = 0; get < list->size; ++get) {
-        if (list->arr[get].ptr != NULL) {
+        if (list->arr[get].ptr != NULL || 
+            ( list->arr[get].func != FUNC_MALLOC &&
+              list->arr[get].func != FUNC_FREE) ) {
             list->arr[put++] = list->arr[get];
         }
     }

tests/matmul.cu

@@ -207,6 +207,7 @@ int main()
     chimp_malloc_togglelog();
     cudaMalloc( (void**)&dev_A, A_size );
     chimp_print_list();
+    sleep(3);
     chimp_free_all();
     chimp_malloc_togglelog();
 
@@ -220,6 +221,7 @@ int main()
     printf("Rerun first CUDA API call...\n");
 
 
+
     cudaMalloc( (void**)&dev_A, A_size );
 
     printf("dev_A = %p\n", dev_A);