Debian Codegraph @

level_zero/sysman/test/unit_tests/sources/events/windows/test_zes_events.cpp

raw
1 /*
2 * Copyright (C) 2023 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/source/os_interface/windows/sys_calls.h"
9
10 #include "level_zero/sysman/source/api/events/sysman_events_imp.h"
11 #include "level_zero/sysman/source/api/events/windows/sysman_os_events_imp.h"
12 #include "level_zero/sysman/source/api/global_operations/sysman_global_operations_imp.h"
13 #include "level_zero/sysman/test/unit_tests/sources/windows/mock_kmd_sys_manager.h"
14 #include "level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h"
15
16 namespace L0 {
17 namespace Sysman {
18 namespace ult {
19
20 class MockWddmEventsImp : public WddmEventsImp {
21 public:
22 bool mockSignalledEventList[KmdSysman::Events::MaxEvents];
23
24 MockWddmEventsImp(OsSysman *pOsSysman) : WddmEventsImp(pOsSysman) {
25 for (int i = 0; i < KmdSysman::Events::MaxEvents; i++) {
26 mockSignalledEventList[i] = false;
27 }
28 }
29
30 void mockSignalEvent(zes_event_type_flags_t signalledFlag) {
31
32 if (signalledFlag & ZES_EVENT_TYPE_FLAG_ENERGY_THRESHOLD_CROSSED) {
33 mockSignalledEventList[KmdSysman::Events::EnergyThresholdCrossed] = true;
34 }
35
36 if (signalledFlag & ZES_EVENT_TYPE_FLAG_DEVICE_SLEEP_STATE_ENTER) {
37 mockSignalledEventList[KmdSysman::Events::EnterD3] = true;
38 }
39
40 if (signalledFlag & ZES_EVENT_TYPE_FLAG_DEVICE_SLEEP_STATE_EXIT) {
41 mockSignalledEventList[KmdSysman::Events::EnterD0] = true;
42 }
43
44 if (signalledFlag & ZES_EVENT_TYPE_FLAG_DEVICE_DETACH) {
45 mockSignalledEventList[KmdSysman::Events::EnterTDR] = true;
46 }
47
48 if (signalledFlag & ZES_EVENT_TYPE_FLAG_DEVICE_ATTACH) {
49 mockSignalledEventList[KmdSysman::Events::ExitTDR] = true;
50 }
51 }
52
53 HANDLE createWddmEvent(
54 LPSECURITY_ATTRIBUTES lpEventAttributes,
55 BOOL bManualReset,
56 BOOL bInitialState,
57 LPCWSTR lpName) override {
58 return NEO::SysCalls::createEvent(lpEventAttributes, bManualReset, bInitialState, (LPCSTR)lpName);
59 }
60
61 void resetWddmEvent(HANDLE resetHandle) override {
62 }
63
64 void setWddmEvent(HANDLE setHandle) override {
65 }
66
67 void closeWddmHandle(HANDLE exitHandle) override {
68 NEO::SysCalls::closeHandle(exitHandle);
69 }
70
71 uint32_t waitForMultipleWddmEvents(_In_ DWORD nCount,
72 _In_reads_(nCount) CONST HANDLE *lpHandles,
73 _In_ BOOL bWaitAll,
74 _In_ DWORD dwMilliseconds) override {
75
76 for (uint32_t k = 0; k < nCount; k++) {
77 for (uint32_t j = 0; j < eventList.size(); j++) {
78
79 if (eventList[j].windowsHandle == lpHandles[k]) {
80
81 if (eventList[j].id & ZES_EVENT_TYPE_FLAG_ENERGY_THRESHOLD_CROSSED) {
82 if (mockSignalledEventList[KmdSysman::Events::EnergyThresholdCrossed] == true) {
83 return j;
84 }
85 }
86
87 if (eventList[j].id & ZES_EVENT_TYPE_FLAG_DEVICE_SLEEP_STATE_ENTER) {
88 if (mockSignalledEventList[KmdSysman::Events::EnterD3] == true) {
89 return j;
90 }
91 }
92
93 if (eventList[j].id & ZES_EVENT_TYPE_FLAG_DEVICE_SLEEP_STATE_EXIT) {
94 if (mockSignalledEventList[KmdSysman::Events::EnterD0] == true) {
95 return j;
96 }
97 }
98
99 if (eventList[j].id & ZES_EVENT_TYPE_FLAG_DEVICE_DETACH) {
100 if (mockSignalledEventList[KmdSysman::Events::EnterTDR] == true) {
101 return j;
102 }
103 }
104
105 if (eventList[j].id & ZES_EVENT_TYPE_FLAG_DEVICE_ATTACH) {
106 if (mockSignalledEventList[KmdSysman::Events::ExitTDR] == true) {
107 return j;
108 }
109 }
110 }
111 }
112 }
113 return WAIT_TIMEOUT;
114 }
115 };
116
117 class SysmanEventsFixture : public SysmanDeviceFixture {
118 protected:
119 std::unique_ptr<MockKmdSysManager> pKmdSysManager;
120 std::unique_ptr<GlobalOperationsImp> pGlobalOperations;
121 OsEvents *pOsEventsPrev = nullptr;
122 L0::Sysman::EventsImp *pEventsImp;
123 KmdSysManager *pOriginalKmdSysManager = nullptr;
124 GlobalOperations *pGlobalOperationsOld = nullptr;
125 MockWddmEventsImp *pWddmEventsImp;
126
127 void SetUp() override {
128 SysmanDeviceFixture::SetUp();
129 }
130
131 void init(bool allowSetCalls) {
132 pKmdSysManager.reset(new MockKmdSysManager);
133
134 pKmdSysManager->allowSetCalls = allowSetCalls;
135
136 pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
137 pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get();
138
139 pEventsImp = static_cast<L0::Sysman::EventsImp *>(pSysmanDeviceImp->pEvents);
140 pOsEventsPrev = pEventsImp->pOsEvents;
141
142 pWddmEventsImp = new MockWddmEventsImp(pOsSysman);
143 pEventsImp->pOsEvents = pWddmEventsImp;
144 pGlobalOperations = std::make_unique<GlobalOperationsImp>(pWddmSysmanImp);
145 pGlobalOperationsOld = pSysmanDeviceImp->pGlobalOperations;
146 pSysmanDeviceImp->pGlobalOperations = pGlobalOperations.get();
147 pSysmanDeviceImp->pGlobalOperations->init();
148 pEventsImp->init();
149 }
150
151 void TearDown() override {
152 if (nullptr != pEventsImp->pOsEvents) {
153 delete pEventsImp->pOsEvents;
154 }
155 pEventsImp->pOsEvents = pOsEventsPrev;
156 pEventsImp = nullptr;
157 pSysmanDeviceImp->pGlobalOperations = pGlobalOperationsOld;
158 pWddmSysmanImp->pKmdSysManager = pOriginalKmdSysManager;
159 SysmanDeviceFixture::TearDown();
160 }
161 };
162
163 TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForResetRequiredEventsThenEventListenAPIReturnsAfterTimingOutWithNoEvent) {
164 init(true);
165 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(pSysmanDevice->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_DETACH));
166 std::unique_ptr<zes_device_handle_t[]> phDevices(new zes_device_handle_t[1]);
167
168 phDevices[0] = pSysmanDevice->toHandle();
169 uint32_t numDeviceEvents = 0;
170 std::unique_ptr<zes_event_type_flags_t[]> pDeviceEvents(new zes_event_type_flags_t[1]);
171 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 100u, 1u, phDevices.get(), &numDeviceEvents, pDeviceEvents.get()));
172 EXPECT_EQ(1u, numDeviceEvents);
173 }
174
175 TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForResetRequiredEventsThenEventListenAPIReturnsAfterReceivingEventOnInfiniteWait) {
176 init(true);
177 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(pSysmanDevice->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_DETACH));
178 std::unique_ptr<zes_device_handle_t[]> phDevices(new zes_device_handle_t[1]);
179
180 phDevices[0] = pSysmanDevice->toHandle();
181 uint32_t numDeviceEvents = 0;
182 std::unique_ptr<zes_event_type_flags_t[]> pDeviceEvents(new zes_event_type_flags_t[1]);
183
184 pWddmEventsImp->mockSignalEvent(ZES_EVENT_TYPE_FLAG_DEVICE_DETACH);
185
186 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), INFINITE, 1u, phDevices.get(), &numDeviceEvents, pDeviceEvents.get()));
187 EXPECT_EQ(1u, numDeviceEvents);
188 }
189
190 TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForResetRequiredEventsThenEventListenAPIReturnsAfterReceivingEventOnInfiniteWaitMultipleTimes) {
191 init(true);
192 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(pSysmanDevice->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_DETACH));
193 std::unique_ptr<zes_device_handle_t[]> phDevices(new zes_device_handle_t[1]);
194 phDevices[0] = pSysmanDevice->toHandle();
195 uint32_t numDeviceEvents = 0;
196 std::unique_ptr<zes_event_type_flags_t[]> pDeviceEvents(new zes_event_type_flags_t[1]);
197
198 pWddmEventsImp->mockSignalEvent(ZES_EVENT_TYPE_FLAG_DEVICE_DETACH);
199
200 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), INFINITE, 1u, phDevices.get(), &numDeviceEvents, pDeviceEvents.get()));
201 EXPECT_EQ(1u, numDeviceEvents);
202
203 pWddmEventsImp->mockSignalEvent(ZES_EVENT_TYPE_FLAG_DEVICE_DETACH);
204
205 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), INFINITE, 1u, phDevices.get(), &numDeviceEvents, pDeviceEvents.get()));
206 EXPECT_EQ(1u, numDeviceEvents);
207 }
208
209 } // namespace ult
210 } // namespace Sysman
211 } // namespace L0