lock

4 files changed, 93 insertions, 89 deletions

diff --git a/libclapi/cl_kernel.c b/libclapi/cl_kernel.c
index c92a233c..7398621b 100644
--- a/libclapi/cl_kernel.c
+++ b/libclapi/cl_kernel.c
@@ -21,6 +21,7 @@
 #include "CL/cl.h"
 #include "CL/cl_gl.h"
 #include "cl_alloc.h"
+#include "cl_mutex.h"
 #include "cl_internals.h"
 #include "cl_driver.h"
 #include "cl_kernel.h"
@@ -138,13 +139,13 @@ static cl_kernel cl_kernel_new(cl_program p, const char* name)
 
   cl_retain_program(p);
   k->program = p;
-  pthread_mutex_lock(&p->lock);
+  CL_MUTEX_LOCK(&p->lock);
   k->next = p->kernels;
   if (p->kernels != NULL)
     p->kernels->prev = k;
   p->kernels = k;
   p->kernel_created++;
-  pthread_mutex_unlock(&p->lock);
+  CL_MUTEX_UNLOCK(&p->lock);
 
   strcpy(k->name, name);
   return k;
@@ -157,7 +158,7 @@ static void cl_kernel_delete(cl_kernel k)
   assert(k);
 
   assert(k->program);
-  pthread_mutex_lock(&k->program->lock);
+  CL_MUTEX_LOCK(&k->program->lock);
   if (k->prev)
     k->prev->next = k->next;
   if (k->next)
@@ -165,7 +166,7 @@ static void cl_kernel_delete(cl_kernel k)
   if (k->program->kernels == k)
     k->program->kernels = k->next;
   k->program->kernel_created--;
-  pthread_mutex_unlock(&k->program->lock);
+  CL_MUTEX_UNLOCK(&k->program->lock);
   cl_release_program(k->program);
 
   if (k->args) {
@@ -211,10 +212,10 @@ LOCAL void cl_release_kernel(cl_kernel k)
 
   build_status = CL_CALLOC(k->program->ctx->device_num, sizeof(int32_t));
   assert(build_status != NULL);
-  pthread_mutex_lock(&k->program->lock);
+  CL_MUTEX_LOCK(&k->program->lock);
   for (i = 0; i < k->program->ctx->device_num; i++)
     build_status[i] = k->program->device_status[i].build_status;
-  pthread_mutex_unlock(&k->program->lock);
+  CL_MUTEX_UNLOCK(&k->program->lock);
 
   for (i = 0; i < k->program->ctx->device_num; i++) {
     if (build_status[i] != CL_BUILD_SUCCESS) // We do not build for that device.
@@ -336,28 +337,28 @@ static cl_int cl_find_kernel_by_name(cl_program p, const char* kernel_name)
     return err;
   }
 
-  pthread_mutex_lock(&p->lock);
+  CL_MUTEX_LOCK(&p->lock);
   s = strstr(p->kernel_names, kernel_name);
   /* Make sure this kernel name is valid. */
   if (s == NULL) {
-    pthread_mutex_unlock(&p->lock);
+    CL_MUTEX_UNLOCK(&p->lock);
     err = CL_INVALID_KERNEL_NAME;
     return err;
   }
 
   assert(s >= p->kernel_names);
   if (s > p->kernel_names && p->kernel_names[s - p->kernel_names - 1] != ';') {
-    pthread_mutex_unlock(&p->lock);
+    CL_MUTEX_UNLOCK(&p->lock);
     err = CL_INVALID_KERNEL_NAME;
     return err;
   }
   if (s[strlen(kernel_name)] != 0 && s[strlen(kernel_name)] != ';') {
-    pthread_mutex_unlock(&p->lock);
+    CL_MUTEX_UNLOCK(&p->lock);
     err = CL_INVALID_KERNEL_NAME;
     return err;
   }
 
-  pthread_mutex_unlock(&p->lock);
+  CL_MUTEX_UNLOCK(&p->lock);
   return err;
 }
 
@@ -398,10 +399,10 @@ LOCAL cl_kernel cl_create_kernel(cl_program p, const char* kernel_name, cl_int*
     goto error;
   }
 
-  pthread_mutex_lock(&p->lock);
+  CL_MUTEX_LOCK(&p->lock);
   for (i = 0; i < p->ctx->device_num; i++)
     build_status[i] = p->device_status[i].build_status;
-  pthread_mutex_unlock(&p->lock);
+  CL_MUTEX_UNLOCK(&p->lock);
 
   for (i = 0; i < p->ctx->device_num; i++) {
     if (build_status[i] != CL_BUILD_SUCCESS) // We do not build for that device.
@@ -623,39 +624,39 @@ error:
 
 static cl_int cl_is_valid_mem(cl_mem mem, cl_context ctx)
 {
-  pthread_mutex_lock(&ctx->lock);
+  CL_MUTEX_LOCK(&ctx->lock);
   cl_mem tmp = ctx->buffers;
   while(tmp) {
     if(mem == tmp) {
       if (UNLIKELY(mem->magic != CL_MAGIC_MEM_HEADER)) {
-        pthread_mutex_unlock(&ctx->lock);
+        CL_MUTEX_UNLOCK(&ctx->lock);
         return CL_INVALID_MEM_OBJECT;
       }
-      pthread_mutex_unlock(&ctx->lock);
+      CL_MUTEX_UNLOCK(&ctx->lock);
       return CL_SUCCESS;
     }
     tmp = tmp->next;
   }
-  pthread_mutex_unlock(&ctx->lock);
+  CL_MUTEX_UNLOCK(&ctx->lock);
   return CL_INVALID_MEM_OBJECT;
 }
 
 static cl_int cl_is_valid_sampler(cl_sampler sampler, cl_context ctx)
 {
-  pthread_mutex_lock(&ctx->lock);
+  CL_MUTEX_LOCK(&ctx->lock);
   cl_sampler tmp = ctx->samplers;
   while(tmp) {
     if(sampler == tmp) {
       if (UNLIKELY(sampler->magic != CL_MAGIC_SAMPLER_HEADER)) {
-        pthread_mutex_unlock(&ctx->lock);
+        CL_MUTEX_UNLOCK(&ctx->lock);
         return CL_INVALID_SAMPLER;
       }
-      pthread_mutex_unlock(&ctx->lock);
+      CL_MUTEX_UNLOCK(&ctx->lock);
       return CL_SUCCESS;
     }
     tmp = tmp->next;
   }
-  pthread_mutex_unlock(&ctx->lock);
+  CL_MUTEX_UNLOCK(&ctx->lock);
   return CL_INVALID_SAMPLER;
 }
 
@@ -681,11 +682,11 @@ static cl_int cl_kernel_set_arg(cl_kernel k, cl_uint index, size_t sz, const voi
     if (UNLIKELY(sz == 0))
       return CL_INVALID_ARG_SIZE;
 
-    pthread_mutex_lock(&k->lock);
+    CL_MUTEX_LOCK(&k->lock);
     arg->local_sz = sz;
     arg->mem = NULL;
     arg->is_set = 1;
-    pthread_mutex_unlock(&k->lock);
+    CL_MUTEX_UNLOCK(&k->lock);
   } else if (arg->type == CL_KERNEL_ARG_CONST_PTR
              || arg->type == CL_KERNEL_ARG_GLOBAL_PTR) {
     if (UNLIKELY(sz != arg->size))
@@ -700,10 +701,10 @@ static cl_int cl_kernel_set_arg(cl_kernel k, cl_uint index, size_t sz, const voi
     if (mem && IS_IMAGE(mem))
       return CL_INVALID_ARG_VALUE;
 
-    pthread_mutex_lock(&k->lock);
+    CL_MUTEX_LOCK(&k->lock);
     arg->mem = mem;
     arg->is_set = 1;
-    pthread_mutex_unlock(&k->lock);
+    CL_MUTEX_UNLOCK(&k->lock);
   } else if (arg->type == CL_KERNEL_ARG_VALUE) {
     if(UNLIKELY(value == NULL))
       return CL_INVALID_ARG_VALUE;
@@ -712,10 +713,10 @@ static cl_int cl_kernel_set_arg(cl_kernel k, cl_uint index, size_t sz, const voi
       return CL_INVALID_ARG_SIZE;
 
     assert(sz <= sizeof(arg->val));
-    pthread_mutex_lock(&k->lock);
+    CL_MUTEX_LOCK(&k->lock);
     memcpy(&arg->val, value, sz);
     arg->is_set = 1;
-    pthread_mutex_unlock(&k->lock);
+    CL_MUTEX_UNLOCK(&k->lock);
   } else if (arg->type == CL_KERNEL_ARG_STRUCT) {
     if(UNLIKELY(value == NULL))
       return CL_INVALID_ARG_VALUE;
@@ -724,10 +725,10 @@ static cl_int cl_kernel_set_arg(cl_kernel k, cl_uint index, size_t sz, const voi
       return CL_INVALID_ARG_SIZE;
 
     assert(sz > sizeof(arg->val));
-    pthread_mutex_lock(&k->lock);
+    CL_MUTEX_LOCK(&k->lock);
     memcpy(arg->pstruct, value, sz);
     arg->is_set = 1;
-    pthread_mutex_unlock(&k->lock);
+    CL_MUTEX_UNLOCK(&k->lock);
   } else if (arg->type == CL_KERNEL_ARG_IMAGE) {
     if (UNLIKELY(sz != arg->size))
       return CL_INVALID_ARG_SIZE;
@@ -741,10 +742,10 @@ static cl_int cl_kernel_set_arg(cl_kernel k, cl_uint index, size_t sz, const voi
     if (mem && !IS_IMAGE(mem))
       return CL_INVALID_ARG_VALUE;
 
-    pthread_mutex_lock(&k->lock);
+    CL_MUTEX_LOCK(&k->lock);
     arg->mem = mem;
     arg->is_set = 1;
-    pthread_mutex_unlock(&k->lock);
+    CL_MUTEX_UNLOCK(&k->lock);
   } else if (arg->type == CL_KERNEL_ARG_SAMPLER) {
     if (UNLIKELY(sz != sizeof(cl_sampler))) // TODO: Need to refine
       return CL_INVALID_ARG_SIZE;
@@ -756,10 +757,10 @@ static cl_int cl_kernel_set_arg(cl_kernel k, cl_uint index, size_t sz, const voi
     if (cl_is_valid_sampler(sampler, k->program->ctx) != CL_SUCCESS)
       return CL_INVALID_SAMPLER;
 
-    pthread_mutex_lock(&k->lock);
+    CL_MUTEX_LOCK(&k->lock);
     arg->sampler = sampler;
     arg->is_set = 1;
-    pthread_mutex_unlock(&k->lock);
+    CL_MUTEX_UNLOCK(&k->lock);
   } else
     assert(0);
 
@@ -781,13 +782,13 @@ static cl_int cl_command_queue_ND_range(cl_command_queue queue, cl_kernel kernel
   }
 
   uint32_t i;
-  pthread_mutex_lock(&kernel->lock);
+  CL_MUTEX_LOCK(&kernel->lock);
   for (i = 0; i < kernel->arg_num; ++i)
     if (kernel->args[i]->is_set == CL_FALSE) {
       return CL_INVALID_KERNEL_ARGS;
-      pthread_mutex_unlock(&kernel->lock);
+      CL_MUTEX_UNLOCK(&kernel->lock);
     }
-  pthread_mutex_unlock(&kernel->lock);
+  CL_MUTEX_UNLOCK(&kernel->lock);
 
   err = queue->device->driver->enqueue_nd_range_kernel(queue, kernel, work_dim, global_wk_off,
         global_wk_sz, local_wk_sz, num_events_in_wait_list, event_wait_list, event);
@@ -804,9 +805,9 @@ static cl_int cl_command_queue_ND_range(cl_command_queue queue, cl_kernel kernel
         kernel->args[i]->type == CL_KERNEL_ARG_IMAGE ||
         kernel->args[i]->type == CL_KERNEL_ARG_CONST_PTR) {
       cl_int index = cl_context_get_device_index(queue->ctx, queue->device);
-      pthread_mutex_lock(&kernel->args[i]->mem->lock);
+      CL_MUTEX_LOCK(&kernel->args[i]->mem->lock);
       kernel->args[i]->mem->enqueued_devices[index] = CL_TRUE;
-      pthread_mutex_unlock(&kernel->args[i]->mem->lock);
+      CL_MUTEX_UNLOCK(&kernel->args[i]->mem->lock);
     }
   }
 
diff --git a/libclapi/cl_mem.c b/libclapi/cl_mem.c
index 14f20da7..f94a525f 100644
--- a/libclapi/cl_mem.c
+++ b/libclapi/cl_mem.c
@@ -21,6 +21,7 @@
 #include "cl_context.h"
 #include "cl_internals.h"
 #include "cl_alloc.h"
+#include "cl_mutex.h"
 #include "cl_driver.h"
 #include "cl_device_id.h"
 #include "cl_context.h"
@@ -162,12 +163,12 @@ LOCAL cl_mem cl_mem_new(cl_mem_object_type type, cl_context ctx, cl_mem_flags fl
   mem->ctx = ctx;
 
   /* Append the buffer in the context buffer list */
-  pthread_mutex_lock(&ctx->lock);
+  CL_MUTEX_LOCK(&ctx->lock);
   mem->next = ctx->buffers;
   if (ctx->buffers != NULL)
     ctx->buffers->prev = mem;
   ctx->buffers = mem;
-  pthread_mutex_unlock(&ctx->lock);
+  CL_MUTEX_UNLOCK(&ctx->lock);
 
   return mem;
 }
@@ -178,14 +179,14 @@ static void cl_mem_delete(cl_mem mem)
   assert(mem->ctx);
 
   /* Remove it from the list */
-  pthread_mutex_lock(&mem->ctx->lock);
+  CL_MUTEX_LOCK(&mem->ctx->lock);
   if (mem->prev)
     mem->prev->next = mem->next;
   if (mem->next)
     mem->next->prev = mem->prev;
   if (mem->ctx->buffers == mem)
     mem->ctx->buffers = mem->next;
-  pthread_mutex_unlock(&mem->ctx->lock);
+  CL_MUTEX_UNLOCK(&mem->ctx->lock);
   cl_release_context(mem->ctx);
 
   if (mem->mapped_ptr)
@@ -249,14 +250,14 @@ LOCAL void cl_release_mem(cl_mem mem)
   if (cl_mem_to_buffer(mem)->parent) {
     cl_mem_buffer buffer = cl_mem_to_buffer(mem);
     /* Remove it from the parent's list */
-    pthread_mutex_lock(&buffer->parent->base.lock);
+    CL_MUTEX_LOCK(&buffer->parent->base.lock);
     if (buffer->sub_prev)
       buffer->sub_prev->sub_next = buffer->sub_next;
     if (buffer->sub_next)
       buffer->sub_next->sub_prev = buffer->sub_prev;
     if (buffer->parent->subs == buffer)
       buffer->parent->subs = buffer->sub_next;
-    pthread_mutex_unlock(&buffer->parent->base.lock);
+    CL_MUTEX_UNLOCK(&buffer->parent->base.lock);
     cl_release_mem((cl_mem )(buffer->parent));
   }
 
@@ -424,12 +425,12 @@ static cl_mem cl_mem_create_sub_buffer(cl_mem buffer, cl_mem_flags flags, cl_buf
   sub_buf->parent = (struct _cl_mem_buffer*)buffer;
 
   /* Append the buffer in the parent buffer list */
-  pthread_mutex_lock(&buffer->lock);
+  CL_MUTEX_LOCK(&buffer->lock);
   sub_buf->sub_next = cl_mem_to_buffer(buffer)->subs;
   if (cl_mem_to_buffer(buffer)->subs != NULL)
     cl_mem_to_buffer(buffer)->subs->sub_prev = sub_buf;
   cl_mem_to_buffer(buffer)->subs = sub_buf;
-  pthread_mutex_unlock(&buffer->lock);
+  CL_MUTEX_UNLOCK(&buffer->lock);
 
   mem->size = info->size;
   sub_buf->sub_offset = info->origin;
@@ -458,14 +459,14 @@ static cl_int cl_record_mapped(cl_mem mem, void *ptr, size_t offset,
 {
   cl_int slot = -1;
 
-  pthread_mutex_lock(&mem->lock);
+  CL_MUTEX_LOCK(&mem->lock);
 
   /* Record the mapped address. */
   if (!mem->mapped_ptr_sz) {
     mem->mapped_ptr_sz = 16;
     mem->mapped_ptr = (cl_mapped_ptr *)CL_MALLOC(sizeof(cl_mapped_ptr) * mem->mapped_ptr_sz);
     if (!mem->mapped_ptr) {
-      pthread_mutex_unlock(&mem->lock);
+      CL_MUTEX_UNLOCK(&mem->lock);
       return CL_OUT_OF_HOST_MEMORY;
     }
     memset(mem->mapped_ptr, 0, mem->mapped_ptr_sz * sizeof(cl_mapped_ptr));
@@ -481,7 +482,7 @@ static cl_int cl_record_mapped(cl_mem mem, void *ptr, size_t offset,
     if (i == mem->mapped_ptr_sz) {
       cl_mapped_ptr *new_ptr = (cl_mapped_ptr *)CL_MALLOC(sizeof(cl_mapped_ptr) * mem->mapped_ptr_sz * 2);
       if (!new_ptr) {
-        pthread_mutex_unlock(&mem->lock);
+        CL_MUTEX_UNLOCK(&mem->lock);
         return CL_OUT_OF_HOST_MEMORY;
       }
       memset(new_ptr, 0, 2 * mem->mapped_ptr_sz * sizeof(cl_mapped_ptr));
@@ -515,7 +516,7 @@ static cl_int cl_record_mapped(cl_mem mem, void *ptr, size_t offset,
   }
   mem->map_ref++;
 
-  pthread_mutex_unlock(&mem->lock);
+  CL_MUTEX_UNLOCK(&mem->lock);
   return CL_SUCCESS;
 }
 
@@ -549,9 +550,9 @@ static void* cl_enqueue_map_buffer(cl_command_queue queue, cl_mem buffer, cl_boo
 
   index = cl_context_get_device_index(queue->ctx, queue->device);
 
-  pthread_mutex_lock(&buffer->lock);
+  CL_MUTEX_LOCK(&buffer->lock);
   buffer->enqueued_devices[index] = CL_TRUE;
-  pthread_mutex_unlock(&buffer->lock);
+  CL_MUTEX_UNLOCK(&buffer->lock);
 
   if (errcode_ret)
     *errcode_ret = err;
@@ -585,7 +586,7 @@ static cl_int cl_enqueue_unmap_mem(cl_command_queue queue, cl_mem memobj, void *
 
   /* Check the pointer valid. */
   INVALID_VALUE_IF(!mapped_ptr);
-  pthread_mutex_lock(&memobj->lock);
+  CL_MUTEX_LOCK(&memobj->lock);
   assert(memobj->mapped_ptr_sz >= memobj->map_ref);
   for (i = 0; i < memobj->mapped_ptr_sz; i++) {
     if (memobj->mapped_ptr[i].ptr == mapped_ptr) {
@@ -594,7 +595,7 @@ static cl_int cl_enqueue_unmap_mem(cl_command_queue queue, cl_mem memobj, void *
   }
   if (i == memobj->mapped_ptr_sz)
     ptr_invalid = CL_TRUE;
-  pthread_mutex_unlock(&memobj->lock);
+  CL_MUTEX_UNLOCK(&memobj->lock);
   /* can not find a mapped address? */
   INVALID_VALUE_IF(ptr_invalid == CL_TRUE);
 
@@ -604,7 +605,7 @@ static cl_int cl_enqueue_unmap_mem(cl_command_queue queue, cl_mem memobj, void *
     goto error;
 
   /* shrink the mapped slot. */
-  pthread_mutex_lock(&memobj->lock);
+  CL_MUTEX_LOCK(&memobj->lock);
   memobj->mapped_ptr[i].ptr = NULL;
   memobj->map_ref--;
   if (memobj->mapped_ptr_sz/2 > memobj->map_ref) {
@@ -613,7 +614,7 @@ static cl_int cl_enqueue_unmap_mem(cl_command_queue queue, cl_mem memobj, void *
       (cl_mapped_ptr *)CL_MALLOC(sizeof(cl_mapped_ptr) * (memobj->mapped_ptr_sz/2));
     if (!new_ptr) {
       /* Just do nothing. */
-      pthread_mutex_unlock(&memobj->lock);
+      CL_MUTEX_UNLOCK(&memobj->lock);
       goto error;
     }
     memset(new_ptr, 0, (memobj->mapped_ptr_sz/2) * sizeof(cl_mapped_ptr));
@@ -632,7 +633,7 @@ static cl_int cl_enqueue_unmap_mem(cl_command_queue queue, cl_mem memobj, void *
 
   index = cl_context_get_device_index(queue->ctx, queue->device);
   memobj->enqueued_devices[index] = CL_TRUE;
-  pthread_mutex_unlock(&memobj->lock);
+  CL_MUTEX_UNLOCK(&memobj->lock);
 
   if (event_ret)
     *event_ret = event;
@@ -724,13 +725,13 @@ clSetMemObjectDestructorCallback(cl_mem  memobj,
     goto error;
   }
 
-  pthread_mutex_lock(&memobj->lock);
+  CL_MUTEX_LOCK(&memobj->lock);
   memset(cb, 0, sizeof(cl_mem_dstr_cb));
   cb->pfn_notify = pfn_notify;
   cb->user_data = user_data;
   cb->next = memobj->dstr_cb;
   memobj->dstr_cb = cb;
-  pthread_mutex_unlock(&memobj->lock);
+  CL_MUTEX_UNLOCK(&memobj->lock);
 
 error:
   return err;
diff --git a/libclapi/cl_program.c b/libclapi/cl_program.c
index 4fb92f06..4bcb65cb 100644
--- a/libclapi/cl_program.c
+++ b/libclapi/cl_program.c
@@ -21,6 +21,7 @@
 #include "CL/cl.h"
 #include "CL/cl_gl.h"
 #include "cl_alloc.h"
+#include "cl_mutex.h"
 #include "cl_internals.h"
 #include "cl_driver.h"
 #include "cl_device_id.h"
@@ -70,14 +71,14 @@ static void cl_program_delete(cl_program p)
   assert(p);
   /* Remove it from the list */
   assert(p->ctx);
-  pthread_mutex_lock(&p->ctx->lock);
+  CL_MUTEX_LOCK(&p->ctx->lock);
   if (p->prev)
     p->prev->next = p->next;
   if (p->next)
     p->next->prev = p->prev;
   if (p->ctx->programs == p)
     p->ctx->programs = p->next;
-  pthread_mutex_unlock(&p->ctx->lock);
+  CL_MUTEX_UNLOCK(&p->ctx->lock);
   /* Program belongs to their parent context */
   cl_release_context(p->ctx);
 
@@ -163,12 +164,12 @@ static cl_program cl_program_new(cl_context ctx)
 
   /* The queue also belongs to its context */
   cl_retain_context(ctx);
-  pthread_mutex_lock(&p->ctx->lock);
+  CL_MUTEX_LOCK(&p->ctx->lock);
   p->next = ctx->programs;
   if (ctx->programs != NULL)
     ctx->programs->prev = p;
   ctx->programs = p;
-  pthread_mutex_unlock(&p->ctx->lock);
+  CL_MUTEX_UNLOCK(&p->ctx->lock);
   return p;
 
 error:
@@ -330,13 +331,13 @@ static cl_int cl_get_kernel_names(cl_program p, const cl_device_id device)
     goto error;
 
   /* All the devices should have same kernel number. */
-  pthread_mutex_lock(&p->lock);
+  CL_MUTEX_LOCK(&p->lock);
   if (p->kernel_num == 0) {
     p->kernel_num = ker_n;
     assert(p->kernel_names == NULL);
   } else {
     if (p->kernel_num != ker_n) {
-      pthread_mutex_unlock(&p->lock);
+      CL_MUTEX_UNLOCK(&p->lock);
       err = CL_BUILD_PROGRAM_FAILURE;
       goto error;
     }
@@ -355,18 +356,18 @@ static cl_int cl_get_kernel_names(cl_program p, const cl_device_id device)
       /* Make sure this kernel name is valid. */
       if (t == NULL) {
         err = CL_BUILD_PROGRAM_FAILURE;
-        pthread_mutex_unlock(&p->lock);
+        CL_MUTEX_UNLOCK(&p->lock);
         goto error;
       }
 
       if (t != p->kernel_names && p->kernel_names[t - p->kernel_names - 1] != ';') {
         err = CL_BUILD_PROGRAM_FAILURE;
-        pthread_mutex_unlock(&p->lock);
+        CL_MUTEX_UNLOCK(&p->lock);
         goto error;
       }
       if (t[strlen(s)] != 0 && t[strlen(s)] != ';') {
         err = CL_BUILD_PROGRAM_FAILURE;
-        pthread_mutex_unlock(&p->lock);
+        CL_MUTEX_UNLOCK(&p->lock);
         goto error;
       }
 
@@ -374,7 +375,7 @@ static cl_int cl_get_kernel_names(cl_program p, const cl_device_id device)
     }
   }
 
-  pthread_mutex_unlock(&p->lock);
+  CL_MUTEX_UNLOCK(&p->lock);
 
 error:
   if (kernel_names)
@@ -398,26 +399,26 @@ static cl_int cl_program_build(cl_program p, const char *options,
   /* if the build of a program executable for any of the devices listed
      in device_list by a previous call to clBuildProgram for program
      has not completed, return CL_INVALID_OPERATION */
-  pthread_mutex_lock(&p->lock);
+  CL_MUTEX_LOCK(&p->lock);
   for (i = 0; i < num_devices; i++) {
     index = cl_context_get_device_index(p->ctx, device_list[i]);
     assert(index >= 0);
     if (p->device_status[index].build_status == CL_BUILD_IN_PROGRESS) {
-      pthread_mutex_unlock(&p->lock);
+      CL_MUTEX_UNLOCK(&p->lock);
       return CL_INVALID_OPERATION;
     }
   }
 
   for (i = 0; i < num_devices; i++) {
     if (p->device_status[index].binary_type != CL_PROGRAM_BINARY_TYPE_NONE) { // already builded ?
-      pthread_mutex_unlock(&p->lock);
+      CL_MUTEX_UNLOCK(&p->lock);
       return CL_INVALID_OPERATION;
     }
 
     index = cl_context_get_device_index(p->ctx, device_list[i]);
     p->device_status[index].build_status = CL_BUILD_IN_PROGRESS;
   }
-  pthread_mutex_unlock(&p->lock);
+  CL_MUTEX_UNLOCK(&p->lock);
 
   for (i = 0; i < num_devices; i++) {
     index = cl_context_get_device_index(p->ctx, device_list[i]);
@@ -476,22 +477,22 @@ static cl_int cl_program_build(cl_program p, const char *options,
       goto error;
   }
 
-  pthread_mutex_lock(&p->lock);
+  CL_MUTEX_LOCK(&p->lock);
   for (i = 0; i < num_devices; i++) {
     index = cl_context_get_device_index(p->ctx, device_list[i]);
     p->device_status[index].build_status = CL_BUILD_SUCCESS;
     p->device_status[index].binary_type = CL_PROGRAM_BINARY_TYPE_EXECUTABLE;
   }
-  pthread_mutex_unlock(&p->lock);
+  CL_MUTEX_UNLOCK(&p->lock);
   return CL_SUCCESS;
 
 error:
-  pthread_mutex_lock(&p->lock);
+  CL_MUTEX_LOCK(&p->lock);
   for (i = 0; i < num_devices; i++) {
     index = cl_context_get_device_index(p->ctx, device_list[i]);
     p->device_status[index].build_status = CL_BUILD_ERROR;
   }
-  pthread_mutex_unlock(&p->lock);
+  CL_MUTEX_UNLOCK(&p->lock);
   return err;
 }
 
@@ -512,26 +513,26 @@ static cl_int cl_program_compile(cl_program p, cl_uint num_devices, const cl_dev
   /* if the build of a program executable for any of the devices listed
      in device_list by a previous call to clBuildProgram for program
      has not completed, return CL_INVALID_OPERATION */
-  pthread_mutex_lock(&p->lock);
+  CL_MUTEX_LOCK(&p->lock);
   for (i = 0; i < num_devices; i++) {
     index = cl_context_get_device_index(p->ctx, device_list[i]);
     assert(index >= 0);
     if (p->device_status[index].build_status == CL_BUILD_IN_PROGRESS) {
-      pthread_mutex_unlock(&p->lock);
+      CL_MUTEX_UNLOCK(&p->lock);
       return CL_INVALID_OPERATION;
     }
   }
 
   for (i = 0; i < num_devices; i++) {
     if (p->device_status[index].binary_type != CL_PROGRAM_BINARY_TYPE_NONE) { // already compiled ?
-      pthread_mutex_unlock(&p->lock);
+      CL_MUTEX_UNLOCK(&p->lock);
       return CL_INVALID_OPERATION;
     }
 
     index = cl_context_get_device_index(p->ctx, device_list[i]);
     p->device_status[index].build_status = CL_BUILD_IN_PROGRESS;
   }
-  pthread_mutex_unlock(&p->lock);
+  CL_MUTEX_UNLOCK(&p->lock);
 
   for (i = 0; i < num_devices; i++) {
     index = cl_context_get_device_index(p->ctx, device_list[i]);
@@ -585,22 +586,22 @@ static cl_int cl_program_compile(cl_program p, cl_uint num_devices, const cl_dev
     }
   }
 
-  pthread_mutex_lock(&p->lock);
+  CL_MUTEX_LOCK(&p->lock);
   for (i = 0; i < num_devices; i++) {
     index = cl_context_get_device_index(p->ctx, device_list[i]);
     p->device_status[index].build_status = CL_BUILD_SUCCESS;
     p->device_status[index].binary_type = CL_PROGRAM_BINARY_TYPE_COMPILED_OBJECT;
   }
-  pthread_mutex_unlock(&p->lock);
+  CL_MUTEX_UNLOCK(&p->lock);
   return CL_SUCCESS;
 
 error:
-  pthread_mutex_lock(&p->lock);
+  CL_MUTEX_LOCK(&p->lock);
   for (i = 0; i < num_devices; i++) {
     index = cl_context_get_device_index(p->ctx, device_list[i]);
     p->device_status[index].build_status = CL_BUILD_ERROR;
   }
-  pthread_mutex_unlock(&p->lock);
+  CL_MUTEX_UNLOCK(&p->lock);
   return err;
 }
 
diff --git a/libclapi/cl_sampler.c b/libclapi/cl_sampler.c
index 8fb87985..bdf5b462 100644
--- a/libclapi/cl_sampler.c
+++ b/libclapi/cl_sampler.c
@@ -21,6 +21,7 @@
 #include "cl_internals.h"
 #include "cl_alloc.h"
 #include "cl_sampler.h"
+#include "cl_mutex.h"
 #include "cl_context.h"
 #include "cl_device_id.h"
 #include "cl_platform_id.h"
@@ -30,14 +31,14 @@ static void cl_sampler_delete(cl_sampler sampler)
 {
   assert(sampler);
   assert(sampler->ctx);
-  pthread_mutex_lock(&sampler->ctx->lock);
+  CL_MUTEX_LOCK(&sampler->ctx->lock);
   if (sampler->prev)
     sampler->prev->next = sampler->next;
   if (sampler->next)
     sampler->next->prev = sampler->prev;
   if (sampler->ctx->samplers == sampler)
     sampler->ctx->samplers = sampler->next;
-  pthread_mutex_unlock(&sampler->ctx->lock);
+  CL_MUTEX_UNLOCK(&sampler->ctx->lock);
   cl_release_context(sampler->ctx);
 
   if (sampler->ctx->device_num > 1) {
@@ -90,12 +91,12 @@ static cl_sampler cl_sampler_new(cl_context ctx, cl_bool normalized_coords,
   sampler->ctx = ctx;
   cl_retain_context(ctx);
   /* Append the sampler in the context sampler list */
-  pthread_mutex_lock(&ctx->lock);
+  CL_MUTEX_LOCK(&ctx->lock);
   sampler->next = ctx->samplers;
   if (ctx->samplers != NULL)
     ctx->samplers->prev = sampler;
   ctx->samplers = sampler;
-  pthread_mutex_unlock(&ctx->lock);
+  CL_MUTEX_UNLOCK(&ctx->lock);
 
   return sampler;
 }