Merge from 'sycl' to 'sycl-web'

Author: iclsrc

sycl/source/detail/queue_impl.cpp

@@ -115,6 +115,22 @@ void queue_impl::addEvent(const event &Event) {
 /// addSharedEvent will have the queue track the events via a shared pointer.
 void queue_impl::addSharedEvent(const event &Event) {
   std::lock_guard<mutex_class> Lock(MMutex);
+  // Events stored in MEventsShared are not released anywhere else aside from
+  // calls to queue::wait/wait_and_throw, which a user application might not
+  // make, and ~queue_impl(). If the number of events grows large enough,
+  // there's a good chance that most of them are already completed and ownership
+  // of them can be released.
+  const size_t EventThreshold = 128;
+  if (MEventsShared.size() >= EventThreshold) {
+    MEventsShared.erase(
+        std::remove_if(
+            MEventsShared.begin(), MEventsShared.end(),
+            [](const event &E) {
+              return E.get_info<info::event::command_execution_status>() ==
+                     info::event_command_status::complete;
+            }),
+        MEventsShared.end());
+  }
   MEventsShared.push_back(Event);
 }
 

sycl/unittests/queue/CMakeLists.txt

@@ -1,3 +1,3 @@
 add_sycl_unittest(QueueTests OBJECT
-  wait.cpp
+  EventClear.cpp
 )

sycl/unittests/queue/wait.cpp renamed to sycl/unittests/queue/EventClear.cpp

@@ -1,4 +1,4 @@
-//==----------------- wait.cpp --- queue wait unit test --------------------==//
+//==------------------ EventClear.cpp --- queue unit tests -----------------==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -30,7 +30,6 @@ pi_result redefinedUSMEnqueueMemset(pi_queue queue, void *ptr, pi_int32 value,
                                     pi_event *event) {
   // Provide a dummy non-nullptr value
   *event = reinterpret_cast<pi_event>(1);
-  TestContext->EventReferenceCount = 1;
   return PI_SUCCESS;
 }
 
@@ -43,12 +42,12 @@ pi_result redefinedEventsWait(pi_uint32 num_events,
 pi_result redefinedEventGetInfo(pi_event event, pi_event_info param_name,
                                 size_t param_value_size, void *param_value,
                                 size_t *param_value_size_ret) {
-  EXPECT_EQ(param_name, PI_EVENT_INFO_CONTEXT)
+  EXPECT_EQ(param_name, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS)
       << "Unexpected event info requested";
-  auto *Result = reinterpret_cast<RT::PiContext *>(param_value);
-  RT::PiContext PiCtx =
-      detail::getSyclObjImpl(TestContext->Ctx)->getHandleRef();
-  *Result = PiCtx;
+  // Report half of events as complete
+  static int Counter = 0;
+  auto *Result = reinterpret_cast<pi_event_status *>(param_value);
+  *Result = (++Counter % 2 == 0) ? PI_EVENT_COMPLETE : PI_EVENT_RUNNING;
   return PI_SUCCESS;
 }
 
@@ -62,21 +61,17 @@ pi_result redefinedEventRelease(pi_event event) {
   return PI_SUCCESS;
 }
 
-// Check that the USM events are cleared from the queue upon call to wait(),
-// so that they are not waited for multiple times.
-TEST(QueueWaitTest, USMEventClear) {
-  platform Plt{default_selector()};
+bool preparePiMock(platform &Plt) {
   if (Plt.is_host()) {
     std::cout << "Not run on host - no PI events created in that case"
               << std::endl;
-    return;
+    return false;
   }
-
-  // TODO: Skip test for CUDA temporarily
+  // TODO: Skip tests for CUDA temporarily
   if (detail::getSyclObjImpl(Plt)->getPlugin().getBackend() == backend::cuda) {
     std::cout << "Not run on CUDA - usm is not supported for CUDA backend yet"
               << std::endl;
-    return;
+    return false;
   }
 
   unittest::PiMock Mock{Plt};
@@ -86,16 +81,48 @@ TEST(QueueWaitTest, USMEventClear) {
   Mock.redefine<detail::PiApiKind::piEventGetInfo>(redefinedEventGetInfo);
   Mock.redefine<detail::PiApiKind::piEventRetain>(redefinedEventRetain);
   Mock.redefine<detail::PiApiKind::piEventRelease>(redefinedEventRelease);
+  return true;
+}
+
+// Check that the USM events are cleared from the queue upon call to wait(),
+// so that they are not waited for multiple times.
+TEST(QueueEventClear, ClearOnQueueWait) {
+  platform Plt{default_selector()};
+  if (!preparePiMock(Plt))
+    return;
 
   context Ctx{Plt};
   TestContext.reset(new TestCtx(Ctx));
   queue Q{Ctx, default_selector()};
 
   unsigned char *HostAlloc = (unsigned char *)malloc_host(1, Ctx);
+  TestContext->EventReferenceCount = 1;
   Q.memset(HostAlloc, 42, 1);
   Q.wait();
   ASSERT_EQ(TestContext->NEventsWaitedFor, 1);
   ASSERT_EQ(TestContext->EventReferenceCount, 0);
   Q.wait();
   ASSERT_EQ(TestContext->NEventsWaitedFor, 1);
 }
+
+// Check that shared events are cleaned up from the queue once their number
+// exceeds a threshold.
+TEST(QueueEventClear, CleanupOnThreshold) {
+  platform Plt{default_selector()};
+  if (!preparePiMock(Plt))
+    return;
+
+  context Ctx{Plt};
+  TestContext.reset(new TestCtx(Ctx));
+  queue Q{Ctx, default_selector()};
+
+  unsigned char *HostAlloc = (unsigned char *)malloc_host(1, Ctx);
+  const int ExpectedEventThreshold = 128;
+  TestContext->EventReferenceCount = ExpectedEventThreshold;
+  for (size_t I = 0; I < ExpectedEventThreshold; ++I) {
+    Q.memset(HostAlloc, 42, 1).wait();
+  }
+  // Half of the events (those reported as completed) should be released.
+  Q.memset(HostAlloc, 42, 1);
+  ASSERT_EQ(TestContext->EventReferenceCount, ExpectedEventThreshold / 2);
+}