event

5 files changed, 66 insertions, 21 deletions

diff --git a/backend/src/driver/cl_gen_command_queue.cpp b/backend/src/driver/cl_gen_command_queue.cpp
index 66de1173..e01aaec9 100644
--- a/backend/src/driver/cl_gen_command_queue.cpp
+++ b/backend/src/driver/cl_gen_command_queue.cpp
@@ -38,8 +38,8 @@ bool GenGPUWorkItem::setStatus(cl_int status)
     return false;
 
   pthread_mutex_lock(&event->lock);
-  GBE_ASSERT(status < event->status); //Should never go back.
-  event->status = status;
+  GBE_ASSERT(state < event->status); //Should never go back.
+  event->status = state;
   cl_event_user_cb user_cb = event->user_cb;
   while (user_cb) {
     if (user_cb->status < event->status)
@@ -95,10 +95,11 @@ static void *workerFunction(void *Arg)
   cl_uint lastCookie = gpuCmdQueue->cookie;
 
   while (gpuCmdQueue->quit == false) {
-    if (gpuCmdQueue->workItems.empty() || lastCookie == gpuCmdQueue->cookie) {
+    while (gpuCmdQueue->workItems.empty() || lastCookie == gpuCmdQueue->cookie) {
       pthread_cond_wait(&gpuCmdQueue->cond, &gpuCmdQueue->mutex);
       if (gpuCmdQueue->quit) {
-        break;
+        pthread_mutex_unlock(&gpuCmdQueue->mutex);
+        return NULL;
       }
     }
 
@@ -172,7 +173,7 @@ bool GenGPUCommandQueue::enqueueWorkItem(GenGPUWorkItem* item)
   return true;
 }
 
-bool GenGPUCommandQueue::waitForEvents(cl_event* events, int num)
+bool GenGPUCommandQueue::waitForEvents(const cl_event* events, int num)
 {
   pthread_mutex_lock(&this->mutex);
   if (this->quit) { // already destroy the queue?
@@ -267,7 +268,7 @@ void GenGPUCommandQueue::waitForFinish(void)
   pthread_mutex_unlock(&this->mutex);
 }
 
-void GenGPUCommandQueue::userEventChange(void)
+void GenGPUCommandQueue::eventStateChanged(void)
 {
   pthread_mutex_lock(&this->mutex);
   if (this->quit) { // already destroy the queue?
@@ -280,6 +281,30 @@ void GenGPUCommandQueue::userEventChange(void)
   pthread_mutex_unlock(&this->mutex);
 }
 
+bool GenGPUCommandQueue::setEventStatus(cl_event event, cl_int state)
+{
+  GBE_ASSERT(event);
+  pthread_mutex_lock(&event->lock);
+  GBE_ASSERT(state < event->status); //Should never go back.
+  event->status = state;
+  cl_event_user_cb user_cb = event->user_cb;
+  while (user_cb) {
+    if (user_cb->status < event->status)
+      continue;
+
+    if (user_cb->executed)
+      continue;
+
+    user_cb->executed = CL_TRUE;
+    user_cb->pfn_notify(event, event->status, user_cb->user_data);
+    user_cb = user_cb->next;
+  }
+  pthread_mutex_unlock(&event->lock);
+
+  this->eventStateChanged(); // Notify others
+  return true;
+}
+
 GenGPUCommandQueue::GenGPUCommandQueue(dri_bufmgr *bufmgr, drm_intel_context *ctx)
 {
   GBE_ASSERT(bufmgr != NULL);
diff --git a/backend/src/driver/cl_gen_driver.h b/backend/src/driver/cl_gen_driver.h
index 27e3b188..3849bc3d 100644
--- a/backend/src/driver/cl_gen_driver.h
+++ b/backend/src/driver/cl_gen_driver.h
@@ -55,9 +55,9 @@ cl_int GenCreateBuffer(cl_mem mem, const cl_device_id device);
 cl_int GenReleaseMem(cl_mem mem, const cl_device_id device);
 cl_int GenEnqueueMapBuffer(cl_command_queue queue, cl_mem mem, void** ret_addr, cl_bool block,
                            cl_map_flags flags, size_t offset, size_t size, cl_uint num_events,
-                           const cl_event *event_list, cl_event *event_ret);
+                           const cl_event *event_list, cl_event event_ret);
 cl_int GenEnqueueUnmapMem(cl_command_queue queue, cl_mem mem, void *mapped_ptr,
-                          cl_uint num_events, const cl_event *event_list, cl_event *event_ret);
+                          cl_uint num_events, const cl_event *event_list, cl_event event_ret);
 cl_int GenEnqueueNDRangeKernel(cl_command_queue queue, cl_kernel kernel, const uint32_t work_dim,
                                const size_t *global_wk_off, const size_t *global_wk_sz,
                                const size_t *local_wk_sz, cl_uint num_events,
diff --git a/backend/src/driver/cl_gen_driver.hpp b/backend/src/driver/cl_gen_driver.hpp
index e372dfc8..fd25ff73 100644
--- a/backend/src/driver/cl_gen_driver.hpp
+++ b/backend/src/driver/cl_gen_driver.hpp
@@ -252,8 +252,9 @@ struct GenGPUCommandQueue {
   list<GenGPUWorkItem*> workItems;
   cl_uint cookie;
   bool enqueueWorkItem(GenGPUWorkItem* item);
-  void userEventChange(void);
-  bool waitForEvents(cl_event* events, int num); // True means ok, False means canceled.
+  void eventStateChanged(void);
+  bool setEventStatus(cl_event event, cl_int state);
+  bool waitForEvents(const cl_event* events, int num); // True means ok, False means canceled.
   void waitForFlush(void);
   void waitForFinish(void);
   GenGPUCommandQueue(dri_bufmgr *bufmgr, drm_intel_context *ctx);
diff --git a/backend/src/driver/cl_gen_mem.cpp b/backend/src/driver/cl_gen_mem.cpp
index ae103b36..cf35f06c 100644
--- a/backend/src/driver/cl_gen_mem.cpp
+++ b/backend/src/driver/cl_gen_mem.cpp
@@ -252,7 +252,7 @@ static void* genDoMapBuffer(GenGPUMem* genMem, cl_mem mem, cl_map_flags flags, s
 extern "C"
 cl_int GenEnqueueMapBuffer(cl_command_queue queue, cl_mem mem, void** ret_addr, cl_bool block,
                            cl_map_flags flags, size_t offset, size_t size, cl_uint num_events,
-                           const cl_event *event_list, cl_event *event_ret)
+                           const cl_event *event_list, cl_event event_ret)
 {
   if (mem->type != CL_MEM_OBJECT_BUFFER) {
     return CL_INVALID_VALUE;
@@ -273,20 +273,39 @@ cl_int GenEnqueueMapBuffer(cl_command_queue queue, cl_mem mem, void** ret_addr,
     GenGPUCommandQueue* gpuQueue = (GenGPUCommandQueue*)getGenCommandQueuePrivate(queue);
     GBE_ASSERT(gpuQueue);
     gpuQueue->waitForFlush();
-  }
 
-  retAddr = genDoMapBuffer(genMem, mem, flags, offset, size);
-  if (retAddr == NULL)
-    return CL_MAP_FAILURE;
+    if (event_list) { // Need to wait for events.
+      if (gpuQueue->waitForEvents(event_list, num_events) == false) {
+        /* canceled or some errors. */
+        return CL_MAP_FAILURE;
+      }
+    }
 
-  if (ret_addr)
-    *ret_addr = retAddr;
-  return CL_SUCCESS;
+    retAddr = genDoMapBuffer(genMem, mem, flags, offset, size);
+    if (retAddr == NULL) {
+      if (event_ret) {
+        gpuQueue->setEventStatus(event_ret, -1); // Set error for that event.
+      }
+      return CL_MAP_FAILURE;
+    }
+
+    if (ret_addr)
+      *ret_addr = retAddr;
+
+    if (event_ret) {
+      gpuQueue->setEventStatus(event_ret, CL_COMPLETE);
+    }
+    return CL_SUCCESS;
+  }
+
+  // Never come to here.
+  GBE_ASSERT(0);
+  return CL_MAP_FAILURE;
 }
 
 extern "C"
 cl_int GenEnqueueUnmapMem(cl_command_queue queue, cl_mem mem, void *mapped_ptr,
-                          cl_uint num_events, const cl_event *event_list, cl_event *event_ret)
+                          cl_uint num_events, const cl_event *event_list, cl_event event_ret)
 {
   if (mapped_ptr == NULL)
     return CL_INVALID_VALUE;
diff --git a/include/cl_driver.h b/include/cl_driver.h
index 38107e0e..d0ec7775 100644
--- a/include/cl_driver.h
+++ b/include/cl_driver.h
@@ -66,9 +66,9 @@ typedef struct _cl_driver {
   cl_int (*release_mem)(cl_mem mem, const cl_device_id device);
   cl_int (*enqueue_map_buffer)(cl_command_queue queue, cl_mem buffer, void** ret_addr, cl_bool block,
       cl_map_flags flags, size_t offset, size_t size, cl_uint num_events, const cl_event *event_list,
-      cl_event *event_ret);
+      cl_event event_ret);
   cl_int (*enqueue_unmap_mem)(cl_command_queue queue, cl_mem memobj, void *mapped_ptr,
-      cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event);
+      cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event event_ret);
   cl_int (*enqueue_nd_range_kernel)(cl_command_queue queue, cl_kernel kernel, const uint32_t work_dim,
       const size_t *global_wk_off, const size_t *global_wk_sz, const size_t *local_wk_sz, cl_uint num_events,
       const cl_event *event_wait_list, cl_event event_ret);