event: add retain event during event sync

Since the waiting event is added to the notify_list
of the notifier_event, a reference should be kept
to prevent the notifier event from notifying an
event that doesn't exist anymore. With the recent
changes to the lock_events_inorder, this also
greatly simplifies the broadcast code.

Author: RABijl

lib/CL/devices/common.c

@@ -847,14 +847,11 @@ pocl_broadcast (cl_event brc_event)
   POCL_LOCK_OBJ (brc_event);
   while ((target = brc_event->notify_list))
     {
-      cl_event target_event = target->event;
-      POCL_UNLOCK_OBJ (brc_event);
-      POname (clRetainEvent) (target_event);
-
-      pocl_lock_events_inorder (brc_event, target_event);
+      POCL_LOCK_OBJ (target->event);
       if (target != brc_event->notify_list)
         {
-          pocl_unlock_events_inorder (brc_event, target_event);
+          assert (0 && "should be unreachable");
+          pocl_unlock_events_inorder (brc_event, target->event);
           POCL_LOCK_OBJ (brc_event);
           continue;
         }
@@ -888,10 +885,11 @@ pocl_broadcast (cl_event brc_event)
                 }
           }
         LL_DELETE (brc_event->notify_list, target);
-        pocl_unlock_events_inorder (brc_event, target_event);
+        POCL_UNLOCK_OBJ (target->event);
+        /* Now that the event is deleted from the notify_list,
+         * undo the retain done during pocl_create_event_sync. */
         POname (clReleaseEvent) (target->event);
         pocl_mem_manager_free_event_node (target);
-        POCL_LOCK_OBJ (brc_event);
     }
   POCL_UNLOCK_OBJ (brc_event);
 }

lib/CL/pocl_util.c

@@ -364,8 +364,20 @@ pocl_create_event_sync (cl_event notifier_event, cl_event waiting_event)
         }
     }
 
-  if (notifier_event->status == CL_COMPLETE)
-    goto FINISH;
+  /* If the notifier event is already complete (or failed),
+     don't create an event sync. This is fine since if the wait
+     event has no notifier events and gets submitted, it can start
+     right away.
+   */
+  if (notifier_event->status < 0 || notifier_event->status == CL_COMPLETE)
+    {
+      POCL_MSG_PRINT_EVENTS (
+        "notifier event %" PRIu64
+        " already complete, not creating sync with event %" PRIu64 "\n",
+        notifier_event->id, waiting_event->id);
+      goto FINISH;
+    }
+
   notify_target = pocl_mem_manager_new_event_node();
   wait_list_item = pocl_mem_manager_new_event_node();
   if (!notify_target || !wait_list_item)
@@ -377,6 +389,11 @@ pocl_create_event_sync (cl_event notifier_event, cl_event waiting_event)
 
   notify_target->event = waiting_event;
   wait_list_item->event = notifier_event;
+  /* Retain the waiting_event since we hold a reference to it in the notify
+     list. This is not needed for the wait_list since the only purpose is to
+     keep a count of the number of events it's waiting on.
+   */
+  POCL_RETAIN_OBJECT_UNLOCKED (waiting_event);
   LL_PREPEND (notifier_event->notify_list, notify_target);
   LL_PREPEND (waiting_event->wait_list, wait_list_item);
 
@@ -1980,14 +1997,14 @@ pocl_update_event_finished (cl_int status, const char *func, unsigned line,
 {
   assert (event != NULL);
   assert (event->queue != NULL);
-  assert (event->status > CL_COMPLETE);
   int notify_cmdq = CL_FALSE;
   cl_command_buffer_khr command_buffer = NULL;
   _cl_command_node *node = NULL;
 
   cl_command_queue cq = event->queue;
   POCL_LOCK_OBJ (cq);
   POCL_LOCK_OBJ (event);
+  assert (event->status > CL_COMPLETE);
   if ((cq->properties & CL_QUEUE_PROFILING_ENABLE)
       && (cq->device->has_own_timer == 0))
     event->time_end = pocl_gettimemono_ns ();
@@ -2064,45 +2081,6 @@ pocl_update_event_finished (cl_int status, const char *func, unsigned line,
 
   ops->broadcast (event);
 
-#ifdef ENABLE_REMOTE_CLIENT
-  /* With remote being asynchronous it is possible that an event completion
-   * signal is received before some of its dependencies. Therefore this event
-   * has to be removed from the notify lists of any remaining events in the
-   * wait list.
-   *
-   * Mind the acrobatics of trying to avoid races with pocl_broadcast and
-   * pocl_create_event_sync. */
-  event_node *tmp;
-  POCL_LOCK_OBJ (event);
-  while ((tmp = event->wait_list))
-    {
-      cl_event notifier = tmp->event;
-      POCL_UNLOCK_OBJ (event);
-      pocl_lock_events_inorder (notifier, event);
-      if (tmp != event->wait_list)
-        {
-          pocl_unlock_events_inorder (notifier, event);
-          POCL_LOCK_OBJ (event);
-          continue;
-        }
-      event_node *tmp2;
-      LL_FOREACH (notifier->notify_list, tmp2)
-      {
-        if (tmp2->event == event)
-          {
-            LL_DELETE (notifier->notify_list, tmp2);
-            pocl_mem_manager_free_event_node (tmp2);
-            break;
-          }
-      }
-      LL_DELETE (event->wait_list, tmp);
-      pocl_unlock_events_inorder (notifier, event);
-      pocl_mem_manager_free_event_node (tmp);
-      POCL_LOCK_OBJ (event);
-    }
-  POCL_UNLOCK_OBJ (event);
-#endif
-
 #ifdef POCL_DEBUG_MESSAGES
   if (msg != NULL)
     {