1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
/*
* Copyright (C) 2019-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/os_interface/linux/drm_memory_operations_handler.h"
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "shared/source/os_interface/linux/os_context_linux.h"
#include "shared/test/common/helpers/engine_descriptor_helper.h"
#include "shared/test/common/libult/linux/drm_mock.h"
#include "shared/test/common/mocks/linux/mock_os_context_linux.h"
#include "shared/test/common/mocks/mock_execution_environment.h"
#include "shared/test/common/os_interface/linux/device_command_stream_fixture.h"
#include "gtest/gtest.h"
#include <memory>
using namespace NEO;
TEST(OSContextLinux, givenReinitializeContextWhenContextIsInitThenContextIsStillIinitializedAfter) {
MockExecutionEnvironment executionEnvironment;
auto mock = DrmMockCustom::create(*executionEnvironment.rootDeviceEnvironments[0]);
executionEnvironment.rootDeviceEnvironments[0]->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*mock.get(), 0u, false);
OsContextLinux osContext(*mock, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor());
EXPECT_NO_THROW(osContext.reInitializeContext());
EXPECT_NO_THROW(osContext.ensureContextInitialized(false));
}
TEST(OSContextLinux, givenInitializeContextWhenContextCreateIoctlFailsThenContextNotInitialized) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
DrmMock *pDrm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
pDrm->storedRetVal = -1;
EXPECT_EQ(-1, pDrm->createDrmContext(1, false, false));
OsContextLinux osContext(*pDrm, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor());
EXPECT_EQ(false, osContext.ensureContextInitialized(false));
delete pDrm;
}
TEST(OSContextLinux, givenOsContextLinuxWhenQueryingForOfflineDumpContextIdThenCorrectValueIsReturned) {
MockExecutionEnvironment executionEnvironment;
auto mock = DrmMockCustom::create(*executionEnvironment.rootDeviceEnvironments[0]);
executionEnvironment.rootDeviceEnvironments[0]->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*mock.get(), 0u, false);
MockOsContextLinux osContext(*mock, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor());
osContext.drmContextIds.clear();
osContext.drmContextIds.push_back(1u);
osContext.drmContextIds.push_back(3u);
osContext.drmContextIds.push_back(5u);
const auto processId = 0xABCEDF;
const uint64_t highBitsMask = 0xffffffff00000000;
const uint64_t lowBitsMask = 0x00000000ffffffff;
auto ctxId = osContext.getOfflineDumpContextId(0);
EXPECT_EQ(ctxId & lowBitsMask, static_cast<uint64_t>(1u));
EXPECT_EQ(ctxId & highBitsMask, static_cast<uint64_t>(processId) << 32);
ctxId = osContext.getOfflineDumpContextId(1);
EXPECT_EQ(ctxId & lowBitsMask, static_cast<uint64_t>(3u));
EXPECT_EQ(ctxId & highBitsMask, static_cast<uint64_t>(processId) << 32);
ctxId = osContext.getOfflineDumpContextId(2);
EXPECT_EQ(ctxId & lowBitsMask, static_cast<uint64_t>(5u));
EXPECT_EQ(ctxId & highBitsMask, static_cast<uint64_t>(processId) << 32);
EXPECT_EQ(0u, osContext.getOfflineDumpContextId(10));
}
TEST(OSContextLinux, givenPerContextVmsAndBindNotCompleteWhenWaitForPagingFenceThenContextFenceIsPassedToWaitUserFenceIoctl) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
drm.requirePerContextVM = true;
MockOsContextLinux osContext(drm, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor());
osContext.ensureContextInitialized(false);
drm.pagingFence[0] = 26u;
drm.fenceVal[0] = 31u;
osContext.pagingFence[0] = 46u;
osContext.fenceVal[0] = 51u;
osContext.waitForPagingFence();
EXPECT_EQ(1u, drm.waitUserFenceParams.size());
EXPECT_EQ(0u, drm.waitUserFenceParams[0].ctxId);
EXPECT_EQ(castToUint64(&osContext.pagingFence[0]), drm.waitUserFenceParams[0].address);
EXPECT_EQ(drm.ioctlHelper->getWaitUserFenceSoftFlag(), drm.waitUserFenceParams[0].flags);
EXPECT_EQ(osContext.fenceVal[0], drm.waitUserFenceParams[0].value);
EXPECT_EQ(-1, drm.waitUserFenceParams[0].timeout);
drm.requirePerContextVM = false;
osContext.waitForPagingFence();
EXPECT_EQ(castToUint64(&drm.pagingFence[0]), drm.waitUserFenceParams[1].address);
EXPECT_EQ(drm.ioctlHelper->getWaitUserFenceSoftFlag(), drm.waitUserFenceParams[1].flags);
EXPECT_EQ(drm.fenceVal[0], drm.waitUserFenceParams[1].value);
}
TEST(OSContextLinux, givenPerContextVmsAndBindCompleteWhenWaitForPagingFenceThenWaitUserFenceIoctlIsNotCalled) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
drm.requirePerContextVM = true;
MockOsContextLinux osContext(drm, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor());
osContext.ensureContextInitialized(false);
osContext.pagingFence[0] = 3u;
osContext.fenceVal[0] = 3u;
osContext.waitForPagingFence();
EXPECT_EQ(0u, drm.waitUserFenceParams.size());
}
|
