Skip to content

Commit ec0846c

Browse files
author
Ivan Karachun
authored
[SYCL][NFC] Refactored scheduler unit tests (#1598)
In all test cases almost the same structures which represents the same object/entity (e.g. MockCommand) are used. Test cases should reuse what already exists. Signed-off-by: Ivan Karachun <[email protected]>
1 parent b378e69 commit ec0846c

File tree

7 files changed

+97
-146
lines changed

7 files changed

+97
-146
lines changed

‎sycl/unittests/scheduler/BlockedCommands.cpp

Lines changed: 4 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -7,37 +7,10 @@
77
//===----------------------------------------------------------------------===//
88

99
#include "SchedulerTest.hpp"
10-
11-
#include <CL/cl.h>
12-
#include <CL/sycl.hpp>
13-
#include <detail/scheduler/scheduler.hpp>
14-
15-
#include <gtest/gtest.h>
10+
#include "SchedulerTestUtils.hpp"
1611

1712
using namespace cl::sycl;
1813

19-
class MockCommand : public detail::Command {
20-
public:
21-
MockCommand(detail::QueueImplPtr Queue)
22-
: Command(detail::Command::ALLOCA, Queue) {}
23-
void printDot(std::ostream &Stream) const override {}
24-
25-
void emitInstrumentationData() override {}
26-
27-
cl_int enqueueImp() override { return MRetVal; }
28-
29-
cl_int MRetVal = CL_SUCCESS;
30-
};
31-
32-
class TestScheduler : public detail::Scheduler {
33-
public:
34-
static bool enqueueCommand(detail::Command *Cmd,
35-
detail::EnqueueResultT &EnqueueResult,
36-
detail::BlockingT Blocking) {
37-
return GraphProcessor::enqueueCommand(Cmd, EnqueueResult, Blocking);
38-
}
39-
};
40-
4114
TEST_F(SchedulerTest, BlockedCommands) {
4215
MockCommand MockCmd(detail::getSyclObjImpl(MQueue));
4316

@@ -47,7 +20,7 @@ TEST_F(SchedulerTest, BlockedCommands) {
4720

4821
detail::EnqueueResultT Res;
4922
bool Enqueued =
50-
TestScheduler::enqueueCommand(&MockCmd, Res, detail::NON_BLOCKING);
23+
MockScheduler::enqueueCommand(&MockCmd, Res, detail::NON_BLOCKING);
5124
ASSERT_FALSE(Enqueued) << "Blocked command should not be enqueued\n";
5225
ASSERT_EQ(detail::EnqueueResultT::SyclEnqueueBlocked, Res.MResult)
5326
<< "Result of enqueueing blocked command should be BLOCKED\n";
@@ -56,7 +29,7 @@ TEST_F(SchedulerTest, BlockedCommands) {
5629
Res.MResult = detail::EnqueueResultT::SyclEnqueueSuccess;
5730
MockCmd.MRetVal = CL_DEVICE_PARTITION_EQUALLY;
5831

59-
Enqueued = TestScheduler::enqueueCommand(&MockCmd, Res, detail::BLOCKING);
32+
Enqueued = MockScheduler::enqueueCommand(&MockCmd, Res, detail::BLOCKING);
6033
ASSERT_FALSE(Enqueued) << "Blocked command should not be enqueued\n";
6134
ASSERT_EQ(detail::EnqueueResultT::SyclEnqueueFailed, Res.MResult)
6235
<< "The command is expected to fail to enqueue.\n";
@@ -67,7 +40,7 @@ TEST_F(SchedulerTest, BlockedCommands) {
6740
Res = detail::EnqueueResultT{};
6841
MockCmd.MEnqueueStatus = detail::EnqueueResultT::SyclEnqueueReady;
6942
MockCmd.MRetVal = CL_SUCCESS;
70-
Enqueued = TestScheduler::enqueueCommand(&MockCmd, Res, detail::BLOCKING);
43+
Enqueued = MockScheduler::enqueueCommand(&MockCmd, Res, detail::BLOCKING);
7144
ASSERT_TRUE(Enqueued &&
7245
Res.MResult == detail::EnqueueResultT::SyclEnqueueSuccess)
7346
<< "The command is expected to be successfully enqueued.\n";

‎sycl/unittests/scheduler/FailedCommands.cpp

Lines changed: 2 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -7,38 +7,12 @@
77
//===----------------------------------------------------------------------===//
88

99
#include "SchedulerTest.hpp"
10-
11-
#include <CL/cl.h>
12-
#include <CL/sycl.hpp>
13-
#include <detail/scheduler/scheduler.hpp>
14-
15-
#include <gtest/gtest.h>
10+
#include "SchedulerTestUtils.hpp"
1611

1712
using namespace cl::sycl;
1813

19-
class MockCommand : public detail::Command {
20-
public:
21-
MockCommand(detail::QueueImplPtr Queue)
22-
: Command(detail::Command::ALLOCA, Queue) {}
23-
void printDot(std::ostream &Stream) const override {}
24-
void emitInstrumentationData() override {}
25-
cl_int enqueueImp() override { return CL_SUCCESS; }
26-
};
27-
28-
class MockScheduler : public detail::Scheduler {
29-
public:
30-
static bool enqueueCommand(detail::Command *Cmd,
31-
detail::EnqueueResultT &EnqueueResult,
32-
detail::BlockingT Blocking) {
33-
return GraphProcessor::enqueueCommand(Cmd, EnqueueResult, Blocking);
34-
}
35-
};
36-
3714
TEST_F(SchedulerTest, FailedDependency) {
38-
detail::Requirement MockReq(/*Offset*/ {0, 0, 0}, /*AccessRange*/ {1, 1, 1},
39-
/*MemoryRange*/ {1, 1, 1},
40-
access::mode::read_write, /*SYCLMemObjT*/ nullptr,
41-
/*Dims*/ 1, /*ElementSize*/ 1);
15+
detail::Requirement MockReq = getMockRequirement();
4216
MockCommand MDep(detail::getSyclObjImpl(MQueue));
4317
MockCommand MUser(detail::getSyclObjImpl(MQueue));
4418
MDep.addUser(&MUser);

‎sycl/unittests/scheduler/FinishedCmdCleanup.cpp

Lines changed: 19 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -9,24 +9,20 @@
99
#include "SchedulerTest.hpp"
1010
#include "SchedulerTestUtils.hpp"
1111

12-
#include <CL/sycl.hpp>
1312
#include <detail/event_impl.hpp>
14-
#include <detail/scheduler/scheduler.hpp>
15-
16-
#include <gtest/gtest.h>
1713

1814
using namespace cl::sycl;
1915

2016
TEST_F(SchedulerTest, FinishedCmdCleanup) {
21-
TestScheduler TS;
17+
MockScheduler MS;
2218
buffer<int, 1> BufA(range<1>(1));
2319
buffer<int, 1> BufB(range<1>(1));
2420
buffer<int, 1> BufC(range<1>(1));
25-
detail::Requirement FakeReqA = getFakeRequirement(BufA);
26-
detail::Requirement FakeReqB = getFakeRequirement(BufB);
27-
detail::Requirement FakeReqC = getFakeRequirement(BufC);
21+
detail::Requirement MockReqA = getMockRequirement(BufA);
22+
detail::Requirement MockReqB = getMockRequirement(BufB);
23+
detail::Requirement MockReqC = getMockRequirement(BufC);
2824
detail::MemObjRecord *RecC =
29-
TS.getOrInsertMemObjRecord(detail::getSyclObjImpl(MQueue), &FakeReqC);
25+
MS.getOrInsertMemObjRecord(detail::getSyclObjImpl(MQueue), &MockReqC);
3026

3127
// Create a graph and check that all inner nodes have been deleted and
3228
// their users have had the corresponding dependency replaced with a
@@ -53,37 +49,37 @@ TEST_F(SchedulerTest, FinishedCmdCleanup) {
5349
// +---------+
5450
// | AllocaB |
5551
// +---------+
56-
detail::AllocaCommand AllocaA{detail::getSyclObjImpl(MQueue), FakeReqA};
57-
detail::AllocaCommand AllocaB{detail::getSyclObjImpl(MQueue), FakeReqB};
52+
detail::AllocaCommand AllocaA{detail::getSyclObjImpl(MQueue), MockReqA};
53+
detail::AllocaCommand AllocaB{detail::getSyclObjImpl(MQueue), MockReqB};
5854

5955
int NInnerCommandsAlive = 3;
6056
std::function<void()> Callback = [&]() { --NInnerCommandsAlive; };
6157

62-
FakeCommand *InnerC = new FakeCommandWithCallback(
63-
detail::getSyclObjImpl(MQueue), FakeReqA, Callback);
58+
MockCommand *InnerC = new MockCommandWithCallback(
59+
detail::getSyclObjImpl(MQueue), MockReqA, Callback);
6460
addEdge(InnerC, &AllocaA, &AllocaA);
6561

66-
FakeCommand LeafB{detail::getSyclObjImpl(MQueue), FakeReqB};
62+
MockCommand LeafB{detail::getSyclObjImpl(MQueue), MockReqB};
6763
addEdge(&LeafB, &AllocaB, &AllocaB);
68-
TS.addNodeToLeaves(RecC, &LeafB);
64+
MS.addNodeToLeaves(RecC, &LeafB);
6965

70-
FakeCommand LeafA{detail::getSyclObjImpl(MQueue), FakeReqA};
66+
MockCommand LeafA{detail::getSyclObjImpl(MQueue), MockReqA};
7167
addEdge(&LeafA, InnerC, &AllocaA);
72-
TS.addNodeToLeaves(RecC, &LeafA);
68+
MS.addNodeToLeaves(RecC, &LeafA);
7369

74-
FakeCommand *InnerB = new FakeCommandWithCallback(
75-
detail::getSyclObjImpl(MQueue), FakeReqB, Callback);
70+
MockCommand *InnerB = new MockCommandWithCallback(
71+
detail::getSyclObjImpl(MQueue), MockReqB, Callback);
7672
addEdge(InnerB, &LeafB, &AllocaB);
7773

78-
FakeCommand *InnerA = new FakeCommandWithCallback(
79-
detail::getSyclObjImpl(MQueue), FakeReqA, Callback);
74+
MockCommand *InnerA = new MockCommandWithCallback(
75+
detail::getSyclObjImpl(MQueue), MockReqA, Callback);
8076
addEdge(InnerA, &LeafA, &AllocaA);
8177
addEdge(InnerA, InnerB, &AllocaB);
8278

8379
std::shared_ptr<detail::event_impl> Event{new detail::event_impl{}};
8480
Event->setCommand(InnerA);
85-
TS.cleanupFinishedCommands(Event);
86-
TS.removeRecordForMemObj(detail::getSyclObjImpl(BufC).get());
81+
MS.cleanupFinishedCommands(Event);
82+
MS.removeRecordForMemObj(detail::getSyclObjImpl(BufC).get());
8783

8884
EXPECT_EQ(NInnerCommandsAlive, 0);
8985

‎sycl/unittests/scheduler/LeafLimit.cpp

Lines changed: 13 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -9,8 +9,6 @@
99
#include "SchedulerTest.hpp"
1010
#include "SchedulerTestUtils.hpp"
1111

12-
#include <CL/sycl.hpp>
13-
1412
#include <algorithm>
1513
#include <cstddef>
1614
#include <memory>
@@ -19,36 +17,29 @@
1917
using namespace cl::sycl;
2018

2119
TEST_F(SchedulerTest, LeafLimit) {
22-
TestScheduler TS;
20+
MockScheduler MS;
2321

2422
buffer<int, 1> Buf(range<1>(1));
25-
detail::Requirement FakeReq{{0, 0, 0},
26-
{0, 0, 0},
27-
{0, 0, 0},
28-
access::mode::read_write,
29-
detail::getSyclObjImpl(Buf).get(),
30-
0,
31-
0,
32-
0};
33-
FakeCommand *FakeDepCmd =
34-
new FakeCommand(detail::getSyclObjImpl(MQueue), FakeReq);
23+
detail::Requirement MockReq = getMockRequirement(Buf);
24+
MockCommand *MockDepCmd =
25+
new MockCommand(detail::getSyclObjImpl(MQueue), MockReq);
3526
detail::MemObjRecord *Rec =
36-
TS.getOrInsertMemObjRecord(detail::getSyclObjImpl(MQueue), &FakeReq);
27+
MS.getOrInsertMemObjRecord(detail::getSyclObjImpl(MQueue), &MockReq);
3728

3829
// Create commands that will be added as leaves exceeding the limit by 1
39-
std::vector<FakeCommand *> LeavesToAdd;
30+
std::vector<MockCommand *> LeavesToAdd;
4031
for (std::size_t i = 0; i < Rec->MWriteLeaves.capacity() + 1; ++i) {
4132
LeavesToAdd.push_back(
42-
new FakeCommand(detail::getSyclObjImpl(MQueue), FakeReq));
33+
new MockCommand(detail::getSyclObjImpl(MQueue), MockReq));
4334
}
44-
// Create edges: all soon-to-be leaves are direct users of FakeDep
35+
// Create edges: all soon-to-be leaves are direct users of MockDep
4536
for (auto Leaf : LeavesToAdd) {
46-
FakeDepCmd->addUser(Leaf);
47-
Leaf->addDep(detail::DepDesc{FakeDepCmd, Leaf->getRequirement(), nullptr});
37+
MockDepCmd->addUser(Leaf);
38+
Leaf->addDep(detail::DepDesc{MockDepCmd, Leaf->getRequirement(), nullptr});
4839
}
4940
// Add edges as leaves and exceed the leaf limit
5041
for (auto LeafPtr : LeavesToAdd) {
51-
TS.addNodeToLeaves(Rec, LeafPtr);
42+
MS.addNodeToLeaves(Rec, LeafPtr);
5243
}
5344
// Check that the oldest leaf has been removed from the leaf list
5445
// and added as a dependency of the newest one instead
@@ -59,8 +50,8 @@ TEST_F(SchedulerTest, LeafLimit) {
5950
assert(std::find(Leaves.begin(), Leaves.end(), LeavesToAdd[i]) !=
6051
Leaves.end());
6152
}
62-
FakeCommand *OldestLeaf = LeavesToAdd.front();
63-
FakeCommand *NewestLeaf = LeavesToAdd.back();
53+
MockCommand *OldestLeaf = LeavesToAdd.front();
54+
MockCommand *NewestLeaf = LeavesToAdd.back();
6455
ASSERT_EQ(OldestLeaf->MUsers.size(), 1U);
6556
EXPECT_GT(OldestLeaf->MUsers.count(NewestLeaf), 0U);
6657
ASSERT_EQ(NewestLeaf->MDeps.size(), 2U);

‎sycl/unittests/scheduler/MemObjCommandCleanup.cpp

Lines changed: 21 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -9,49 +9,44 @@
99
#include "SchedulerTest.hpp"
1010
#include "SchedulerTestUtils.hpp"
1111

12-
#include <CL/sycl.hpp>
13-
#include <detail/scheduler/scheduler.hpp>
14-
15-
#include <gtest/gtest.h>
16-
1712
using namespace cl::sycl;
1813

1914
TEST_F(SchedulerTest, MemObjCommandCleanup) {
20-
TestScheduler TS;
15+
MockScheduler MS;
2116
buffer<int, 1> BufA(range<1>(1));
2217
buffer<int, 1> BufB(range<1>(1));
23-
detail::Requirement FakeReqA = getFakeRequirement(BufA);
24-
detail::Requirement FakeReqB = getFakeRequirement(BufB);
18+
detail::Requirement MockReqA = getMockRequirement(BufA);
19+
detail::Requirement MockReqB = getMockRequirement(BufB);
2520
detail::MemObjRecord *RecA =
26-
TS.getOrInsertMemObjRecord(detail::getSyclObjImpl(MQueue), &FakeReqA);
21+
MS.getOrInsertMemObjRecord(detail::getSyclObjImpl(MQueue), &MockReqA);
2722

2823
// Create 2 fake allocas, one of which will be cleaned up
29-
detail::AllocaCommand *FakeAllocaA =
30-
new detail::AllocaCommand(detail::getSyclObjImpl(MQueue), FakeReqA);
31-
std::unique_ptr<detail::AllocaCommand> FakeAllocaB{
32-
new detail::AllocaCommand(detail::getSyclObjImpl(MQueue), FakeReqB)};
33-
RecA->MAllocaCommands.push_back(FakeAllocaA);
24+
detail::AllocaCommand *MockAllocaA =
25+
new detail::AllocaCommand(detail::getSyclObjImpl(MQueue), MockReqA);
26+
std::unique_ptr<detail::AllocaCommand> MockAllocaB{
27+
new detail::AllocaCommand(detail::getSyclObjImpl(MQueue), MockReqB)};
28+
RecA->MAllocaCommands.push_back(MockAllocaA);
3429

3530
// Create a direct user of both allocas
36-
std::unique_ptr<FakeCommand> FakeDirectUser{
37-
new FakeCommand(detail::getSyclObjImpl(MQueue), FakeReqA)};
38-
addEdge(FakeDirectUser.get(), FakeAllocaA, FakeAllocaA);
39-
addEdge(FakeDirectUser.get(), FakeAllocaB.get(), FakeAllocaB.get());
31+
std::unique_ptr<MockCommand> MockDirectUser{
32+
new MockCommand(detail::getSyclObjImpl(MQueue), MockReqA)};
33+
addEdge(MockDirectUser.get(), MockAllocaA, MockAllocaA);
34+
addEdge(MockDirectUser.get(), MockAllocaB.get(), MockAllocaB.get());
4035

4136
// Create an indirect user of the soon-to-be deleted alloca
4237
bool IndirectUserDeleted = false;
4338
std::function<void()> Callback = [&]() { IndirectUserDeleted = true; };
44-
FakeCommand *FakeIndirectUser = new FakeCommandWithCallback(
45-
detail::getSyclObjImpl(MQueue), FakeReqA, Callback);
46-
addEdge(FakeIndirectUser, FakeDirectUser.get(), FakeAllocaA);
39+
MockCommand *MockIndirectUser = new MockCommandWithCallback(
40+
detail::getSyclObjImpl(MQueue), MockReqA, Callback);
41+
addEdge(MockIndirectUser, MockDirectUser.get(), MockAllocaA);
4742

48-
TS.cleanupCommandsForRecord(RecA);
49-
TS.removeRecordForMemObj(detail::getSyclObjImpl(BufA).get());
43+
MS.cleanupCommandsForRecord(RecA);
44+
MS.removeRecordForMemObj(detail::getSyclObjImpl(BufA).get());
5045

5146
// Check that the direct user has been left with the second alloca
5247
// as the only dependency, while the indirect user has been cleaned up.
53-
ASSERT_EQ(FakeDirectUser->MUsers.size(), 0U);
54-
ASSERT_EQ(FakeDirectUser->MDeps.size(), 1U);
55-
EXPECT_EQ(FakeDirectUser->MDeps[0].MDepCommand, FakeAllocaB.get());
48+
ASSERT_EQ(MockDirectUser->MUsers.size(), 0U);
49+
ASSERT_EQ(MockDirectUser->MDeps.size(), 1U);
50+
EXPECT_EQ(MockDirectUser->MDeps[0].MDepCommand, MockAllocaB.get());
5651
EXPECT_TRUE(IndirectUserDeleted);
5752
}

0 commit comments

Comments
 (0)