Add a test

Signed-off-by: Sergey Semenov <[email protected]>

Author: sergey-semenov

sycl/test/scheduler/FakeCommand.hpp

@@ -0,0 +1,92 @@
+// RUN: %clangxx -fsycl %s -o %t.out
+// RUN: %t.out
+#include <CL/sycl.hpp>
+
+#include <algorithm>
+#include <vector>
+
+#include "SchedulerTestUtils.hpp"
+
+using namespace cl::sycl;
+
+// This test checks regular execution graph cleanup at host-device
+// synchronization points
+int main() {
+  TestScheduler TS;
+  queue Queue;
+  buffer<int, 1> BufA(range<1>(1));
+  buffer<int, 1> BufB(range<1>(1));
+  buffer<int, 1> BufC(range<1>(1));
+  detail::Requirement FakeReqA = getFakeRequirement(BufA);
+  detail::Requirement FakeReqB = getFakeRequirement(BufB);
+  detail::Requirement FakeReqC = getFakeRequirement(BufC);
+  detail::MemObjRecord *RecC =
+      TS.getOrInsertMemObjRecord(detail::getSyclObjImpl(Queue), &FakeReqC);
+
+  // Create a graph and check that all inner nodes have been deleted and
+  // their users have had the corresponding dependency replaced with a
+  // dependency on the alloca. The graph should undergo the following
+  // transformation:
+  // +---------+     +---------+              +---------++---------+
+  // |  LeafA  | <-- | InnerA  |              |  LeafA  ||  LeafB  |
+  // +---------+     +---------+              +---------++---------+
+  //   |               |                        |          |
+  //   |               |             ===>       |          |
+  //   v               v                        v          v
+  // +---------+     +---------+              +---------++---------+
+  // | InnerC  |     | InnerB  |              | AllocaA || AllocaB |
+  // +---------+     +---------+              +---------++---------+
+  //   |               |
+  //   |               |
+  //   v               v
+  // +---------+     +---------+
+  // | AllocaA |     |  LeafB  |
+  // +---------+     +---------+
+  //                   |
+  //                   |
+  //                   v
+  //                 +---------+
+  //                 | AllocaB |
+  //                 +---------+
+  detail::AllocaCommand AllocaA{detail::getSyclObjImpl(Queue), FakeReqA};
+  detail::AllocaCommand AllocaB{detail::getSyclObjImpl(Queue), FakeReqB};
+
+  int NInnerCommandsAlive = 3;
+  std::function<void()> Callback = [&]() { --NInnerCommandsAlive; };
+
+  FakeCommand *InnerC = new FakeCommandWithCallback(
+      detail::getSyclObjImpl(Queue), FakeReqA, Callback);
+  addEdge(InnerC, &AllocaA, &AllocaA);
+
+  FakeCommand LeafB{detail::getSyclObjImpl(Queue), FakeReqB};
+  addEdge(&LeafB, &AllocaB, &AllocaB);
+  TS.AddNodeToLeaves(RecC, &LeafB);
+
+  FakeCommand LeafA{detail::getSyclObjImpl(Queue), FakeReqA};
+  addEdge(&LeafA, InnerC, &AllocaA);
+  TS.AddNodeToLeaves(RecC, &LeafA);
+
+  FakeCommand *InnerB = new FakeCommandWithCallback(
+      detail::getSyclObjImpl(Queue), FakeReqB, Callback);
+  addEdge(InnerB, &LeafB, &AllocaB);
+
+  FakeCommand *InnerA = new FakeCommandWithCallback(
+      detail::getSyclObjImpl(Queue), FakeReqA, Callback);
+  addEdge(InnerA, &LeafA, &AllocaA);
+  addEdge(InnerA, InnerB, &AllocaB);
+
+  TS.cleanupFinishedCommands(InnerA);
+  TS.removeRecordForMemObj(detail::getSyclObjImpl(BufC).get());
+
+  assert(NInnerCommandsAlive == 0);
+
+  assert(LeafA.MDeps.size() == 1);
+  assert(LeafA.MDeps[0].MDepCommand == &AllocaA);
+  assert(AllocaA.MUsers.size() == 1);
+  assert(*AllocaA.MUsers.begin() == &LeafA);
+
+  assert(LeafB.MDeps.size() == 1);
+  assert(LeafB.MDeps[0].MDepCommand == &AllocaB);
+  assert(AllocaB.MUsers.size() == 1);
+  assert(*AllocaB.MUsers.begin() == &LeafB);
+}

sycl/test/scheduler/FinishedCmdCleanup.cpp

@@ -7,26 +7,12 @@
 #include <memory>
 #include <vector>
 
-#include "FakeCommand.hpp"
+#include "SchedulerTestUtils.hpp"
 
 // This test checks the leaf limit imposed on the execution graph
 
 using namespace cl::sycl;
 
-class TestScheduler : public detail::Scheduler {
-public:
-  void AddNodeToLeaves(detail::MemObjRecord *Rec, detail::Command *Cmd,
-                       access::mode Mode) {
-    return MGraphBuilder.AddNodeToLeaves(Rec, Cmd, Mode);
-  }
-
-  detail::MemObjRecord *
-  getOrInsertMemObjRecord(const detail::QueueImplPtr &Queue,
-                          detail::Requirement *Req) {
-    return MGraphBuilder.getOrInsertMemObjRecord(Queue, Req);
-  }
-};
-
 int main() {
   TestScheduler TS;
   queue Queue;
@@ -57,7 +43,7 @@ int main() {
   }
   // Add edges as leaves and exceed the leaf limit
   for (auto LeafPtr : LeavesToAdd) {
-    TS.AddNodeToLeaves(Rec, LeafPtr, access::mode::read_write);
+    TS.AddNodeToLeaves(Rec, LeafPtr);
   }
   // Check that the oldest leaf has been removed from the leaf list
   // and added as a dependency of the newest one instead

sycl/test/scheduler/LeafLimit.cpp

@@ -2,65 +2,17 @@
 // RUN: %t.out
 #include <CL/sycl.hpp>
 
-#include <functional>
 #include <memory>
 #include <utility>
 
-#include "FakeCommand.hpp"
+#include "SchedulerTestUtils.hpp"
 
 // This test checks that the execution graph cleanup on memory object
 // destruction traverses the entire graph, rather than only the immediate users
 // of deleted commands.
 
 using namespace cl::sycl;
 
-class TestScheduler : public detail::Scheduler {
-public:
-  void cleanupCommandsForRecord(detail::MemObjRecord *Rec) {
-    MGraphBuilder.cleanupCommandsForRecord(Rec);
-  }
-
-  void removeRecordForMemObj(detail::SYCLMemObjI *MemObj) {
-    MGraphBuilder.removeRecordForMemObj(MemObj);
-  }
-
-  detail::MemObjRecord *
-  getOrInsertMemObjRecord(const detail::QueueImplPtr &Queue,
-                          detail::Requirement *Req) {
-    return MGraphBuilder.getOrInsertMemObjRecord(Queue, Req);
-  }
-};
-
-class FakeCommandWithCallback : public FakeCommand {
-public:
-  FakeCommandWithCallback(detail::QueueImplPtr Queue, detail::Requirement Req,
-                          std::function<void()> Callback)
-      : FakeCommand(Queue, Req), MCallback(std::move(Callback)) {}
-
-  ~FakeCommandWithCallback() override { MCallback(); }
-
-protected:
-  std::function<void()> MCallback;
-};
-
-template <typename MemObjT>
-detail::Requirement getFakeRequirement(const MemObjT &MemObj) {
-  return {{0, 0, 0},
-          {0, 0, 0},
-          {0, 0, 0},
-          access::mode::read_write,
-          detail::getSyclObjImpl(MemObj).get(),
-          0,
-          0,
-          0};
-}
-
-void addEdge(detail::Command *User, detail::Command *Dep,
-             detail::AllocaCommandBase *Alloca) {
-  User->addDep(detail::DepDesc{Dep, User->getRequirement(), Alloca});
-  Dep->addUser(User);
-}
-
 int main() {
   TestScheduler TS;
   queue Queue;

sycl/test/scheduler/MemObjCommandCleanup.cpp

@@ -0,0 +1,81 @@
+#pragma once
+#include <CL/sycl.hpp>
+
+#include <functional>
+// This header contains a few common classes/methods used in
+// execution graph testing.
+
+class FakeCommand : public cl::sycl::detail::Command {
+public:
+  FakeCommand(cl::sycl::detail::QueueImplPtr Queue,
+              cl::sycl::detail::Requirement Req)
+      : Command{cl::sycl::detail::Command::EMPTY_TASK, Queue},
+        MRequirement{std::move(Req)} {}
+
+  void printDot(std::ostream &Stream) const override {}
+
+  const cl::sycl::detail::Requirement *getRequirement() const final {
+    return &MRequirement;
+  };
+
+  cl_int enqueueImp() override { return MRetVal; }
+
+  cl_int MRetVal = CL_SUCCESS;
+
+protected:
+  cl::sycl::detail::Requirement MRequirement;
+};
+
+class FakeCommandWithCallback : public FakeCommand {
+public:
+  FakeCommandWithCallback(cl::sycl::detail::QueueImplPtr Queue,
+                          cl::sycl::detail::Requirement Req,
+                          std::function<void()> Callback)
+      : FakeCommand(Queue, Req), MCallback(std::move(Callback)) {}
+
+  ~FakeCommandWithCallback() override { MCallback(); }
+
+protected:
+  std::function<void()> MCallback;
+};
+
+class TestScheduler : public cl::sycl::detail::Scheduler {
+public:
+  cl::sycl::detail::MemObjRecord *
+  getOrInsertMemObjRecord(const cl::sycl::detail::QueueImplPtr &Queue,
+                          cl::sycl::detail::Requirement *Req) {
+    return MGraphBuilder.getOrInsertMemObjRecord(Queue, Req);
+  }
+
+  void removeRecordForMemObj(cl::sycl::detail::SYCLMemObjI *MemObj) {
+    MGraphBuilder.removeRecordForMemObj(MemObj);
+  }
+
+  void cleanupCommandsForRecord(cl::sycl::detail::MemObjRecord *Rec) {
+    MGraphBuilder.cleanupCommandsForRecord(Rec);
+  }
+
+  void AddNodeToLeaves(
+      cl::sycl::detail::MemObjRecord *Rec, cl::sycl::detail::Command *Cmd,
+      cl::sycl::access::mode Mode = cl::sycl::access::mode::read_write) {
+    return MGraphBuilder.AddNodeToLeaves(Rec, Cmd, Mode);
+  }
+};
+
+void addEdge(cl::sycl::detail::Command *User, cl::sycl::detail::Command *Dep,
+             cl::sycl::detail::AllocaCommandBase *Alloca) {
+  User->addDep(cl::sycl::detail::DepDesc{Dep, User->getRequirement(), Alloca});
+  Dep->addUser(User);
+}
+
+template <typename MemObjT>
+cl::sycl::detail::Requirement getFakeRequirement(const MemObjT &MemObj) {
+  return {{0, 0, 0},
+          {0, 0, 0},
+          {0, 0, 0},
+          cl::sycl::access::mode::read_write,
+          cl::sycl::detail::getSyclObjImpl(MemObj).get(),
+          0,
+          0,
+          0};
+}