Add tests

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

Author: sergey-semenov

sycl/test/basic_tests/circular_buffer.cpp

@@ -0,0 +1,47 @@
+// RUN: %clangxx -fsycl %s -o %t.out
+// RUN: %t.out
+
+#include <CL/sycl/detail/circular_buffer.hpp>
+
+#include <algorithm>
+#include <cassert>
+#include <vector>
+
+// This test contains basic checks for cl::sycl::detail::CircularBuffer
+void checkEquality(const cl::sycl::detail::CircularBuffer<int> &CB,
+                   const std::vector<int> &V) {
+  assert(std::equal(CB.begin(), CB.end(), V.begin()));
+}
+
+int main() {
+  const size_t Capacity = 6;
+  cl::sycl::detail::CircularBuffer<int> CB{Capacity};
+  assert(CB.capacity() == Capacity);
+  assert(CB.empty());
+
+  int nextValue = 0;
+  for (; nextValue < Capacity; ++nextValue) {
+    assert(CB.size() == nextValue);
+    CB.push_back(nextValue);
+  }
+  assert(CB.full() && CB.size() == CB.capacity());
+  checkEquality(CB, {0, 1, 2, 3, 4, 5});
+
+  CB.push_back(nextValue++);
+  checkEquality(CB, {1, 2, 3, 4, 5, 6});
+  CB.push_front(nextValue++);
+  checkEquality(CB, {7, 1, 2, 3, 4, 5});
+
+  assert(CB.front() == 7);
+  assert(CB.back() == 5);
+
+  CB.erase(CB.begin() + 2);
+  checkEquality(CB, {7, 1, 3, 4, 5});
+  CB.erase(CB.begin(), CB.begin() + 2);
+  checkEquality(CB, {3, 4, 5});
+
+  CB.pop_back();
+  checkEquality(CB, {3, 4});
+  CB.pop_front();
+  checkEquality(CB, {4});
+}

sycl/test/scheduler/LeafLimit.cpp

@@ -0,0 +1,92 @@
+// RUN: %clangxx -fsycl %s -o %t.out
+// RUN: %t.out
+#include <CL/sycl.hpp>
+
+#include <memory>
+#include <vector>
+
+// This test checks the leaf limit imposed on the execution graph
+
+using namespace cl::sycl;
+
+class FakeCommand : public detail::Command {
+public:
+  FakeCommand(detail::QueueImplPtr Queue, detail::Requirement Req)
+      : Command{detail::Command::ALLOCA, Queue}, MRequirement{std::move(Req)} {}
+
+  void printDot(std::ostream &Stream) const override {}
+
+  const detail::Requirement *getRequirement() const final {
+    return &MRequirement;
+  };
+
+  cl_int enqueueImp() override { return MRetVal; }
+
+  cl_int MRetVal = CL_SUCCESS;
+
+protected:
+  detail::Requirement MRequirement;
+};
+
+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;
+  buffer<int, 1> Buf(range<1>(1));
+  detail::Requirement FakeReq{{0, 0, 0},
+                              {0, 0, 0},
+                              {0, 0, 0},
+                              access::mode::read_write,
+                              detail::getSyclObjImpl(Buf),
+                              0,
+                              0,
+                              0};
+  FakeCommand *FakeDepCmd =
+      new FakeCommand(detail::getSyclObjImpl(Queue), FakeReq);
+  detail::MemObjRecord *Rec =
+      TS.getOrInsertMemObjRecord(detail::getSyclObjImpl(Queue), &FakeReq);
+
+  // Create commands that will be added as leaves exceeding the limit by 1
+  std::vector<FakeCommand *> LeavesToAdd;
+  for (size_t i = 0; i < Rec->MWriteLeaves.capacity() + 1; ++i) {
+    LeavesToAdd.push_back(
+        new FakeCommand(detail::getSyclObjImpl(Queue), FakeReq));
+  }
+  // Create edges: all soon-to-be leaves are direct users of FakeDep
+  for (auto Leaf : LeavesToAdd) {
+    FakeDepCmd->addUser(Leaf);
+    Leaf->addDep(detail::DepDesc{FakeDepCmd, Leaf->getRequirement(), nullptr});
+  }
+  // Add edges as leaves and exceed the leaf limit
+  for (auto LeafPtr : LeavesToAdd) {
+    TS.AddNodeToLeaves(Rec, LeafPtr, access::mode::read_write);
+  }
+  // Check that the oldest leaf has been removed from the leaf list
+  // and added as a dependency of the newest one instead
+  const detail::CircularBuffer<detail::Command *> &Leaves = Rec->MWriteLeaves;
+  assert(std::find(Leaves.begin(), Leaves.end(), LeavesToAdd.front()) ==
+         Leaves.end());
+  for (size_t i = 1; i < LeavesToAdd.size(); ++i) {
+    assert(std::find(Leaves.begin(), Leaves.end(), LeavesToAdd[i]) !=
+           Leaves.end());
+  }
+  FakeCommand *OldestLeaf = LeavesToAdd.front();
+  FakeCommand *NewestLeaf = LeavesToAdd.back();
+  assert(OldestLeaf->MUsers.size() == 1);
+  assert(OldestLeaf->MUsers[0] == NewestLeaf);
+  assert(NewestLeaf->MDeps.size() == 2);
+  assert(NewestLeaf->MDeps[1].MDepCommand == OldestLeaf);
+}