393 lines
13 KiB
C++
393 lines
13 KiB
C++
/*
|
|
* Copyright (C) 2017-2020 Intel Corporation
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*
|
|
*/
|
|
|
|
#include "shared/source/helpers/file_io.h"
|
|
#include "shared/source/helpers/hw_info.h"
|
|
#include "shared/source/os_interface/device_factory.h"
|
|
#include "shared/source/os_interface/linux/os_context_linux.h"
|
|
#include "shared/source/os_interface/linux/os_interface.h"
|
|
#include "shared/test/unit_test/helpers/default_hw_info.h"
|
|
|
|
#include "opencl/test/unit_test/fixtures/memory_management_fixture.h"
|
|
#include "opencl/test/unit_test/os_interface/linux/drm_mock.h"
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
#include <fstream>
|
|
#include <memory>
|
|
|
|
using namespace NEO;
|
|
|
|
TEST(DrmTest, GetDeviceID) {
|
|
DrmMock *pDrm = new DrmMock;
|
|
EXPECT_NE(nullptr, pDrm);
|
|
|
|
pDrm->StoredDeviceID = 0x1234;
|
|
int deviceID = 0;
|
|
int ret = pDrm->getDeviceID(deviceID);
|
|
EXPECT_EQ(0, ret);
|
|
EXPECT_EQ(pDrm->StoredDeviceID, deviceID);
|
|
delete pDrm;
|
|
}
|
|
|
|
TEST(DrmTest, GivenInvalidPciPathWhenFrequencyIsQueriedThenReturnError) {
|
|
DrmMock drm{};
|
|
auto hwInfo = *defaultHwInfo;
|
|
|
|
int maxFrequency = 0;
|
|
|
|
drm.setPciPath("invalidPci");
|
|
int ret = drm.getMaxGpuFrequency(hwInfo, maxFrequency);
|
|
EXPECT_NE(0, ret);
|
|
|
|
EXPECT_EQ(0, maxFrequency);
|
|
}
|
|
|
|
TEST(DrmTest, GetRevisionID) {
|
|
DrmMock *pDrm = new DrmMock;
|
|
EXPECT_NE(nullptr, pDrm);
|
|
|
|
pDrm->StoredDeviceID = 0x1234;
|
|
pDrm->StoredDeviceRevID = 0xB;
|
|
int deviceID = 0;
|
|
int ret = pDrm->getDeviceID(deviceID);
|
|
EXPECT_EQ(0, ret);
|
|
int revID = 0;
|
|
ret = pDrm->getDeviceRevID(revID);
|
|
EXPECT_EQ(0, ret);
|
|
|
|
EXPECT_EQ(pDrm->StoredDeviceID, deviceID);
|
|
EXPECT_EQ(pDrm->StoredDeviceRevID, revID);
|
|
|
|
delete pDrm;
|
|
}
|
|
|
|
TEST(DrmTest, GivenDrmWhenAskedForGttSizeThenReturnCorrectValue) {
|
|
auto drm = std::make_unique<DrmMock>();
|
|
uint64_t queryGttSize = 0;
|
|
|
|
drm->StoredRetValForGetGttSize = 0;
|
|
drm->storedGTTSize = 1ull << 31;
|
|
EXPECT_EQ(0, drm->queryGttSize(queryGttSize));
|
|
EXPECT_EQ(drm->storedGTTSize, queryGttSize);
|
|
|
|
queryGttSize = 0;
|
|
drm->StoredRetValForGetGttSize = -1;
|
|
EXPECT_NE(0, drm->queryGttSize(queryGttSize));
|
|
EXPECT_EQ(0u, queryGttSize);
|
|
}
|
|
|
|
TEST(DrmTest, GivenDrmWhenAskedForPreemptionCorrectValueReturned) {
|
|
DrmMock *pDrm = new DrmMock;
|
|
pDrm->StoredRetVal = 0;
|
|
pDrm->StoredPreemptionSupport =
|
|
I915_SCHEDULER_CAP_ENABLED |
|
|
I915_SCHEDULER_CAP_PRIORITY |
|
|
I915_SCHEDULER_CAP_PREEMPTION;
|
|
pDrm->checkPreemptionSupport();
|
|
EXPECT_TRUE(pDrm->isPreemptionSupported());
|
|
|
|
pDrm->StoredPreemptionSupport = 0;
|
|
pDrm->checkPreemptionSupport();
|
|
EXPECT_FALSE(pDrm->isPreemptionSupported());
|
|
|
|
pDrm->StoredRetVal = -1;
|
|
pDrm->StoredPreemptionSupport =
|
|
I915_SCHEDULER_CAP_ENABLED |
|
|
I915_SCHEDULER_CAP_PRIORITY |
|
|
I915_SCHEDULER_CAP_PREEMPTION;
|
|
pDrm->checkPreemptionSupport();
|
|
EXPECT_FALSE(pDrm->isPreemptionSupported());
|
|
|
|
pDrm->StoredPreemptionSupport = 0;
|
|
pDrm->checkPreemptionSupport();
|
|
EXPECT_FALSE(pDrm->isPreemptionSupported());
|
|
|
|
delete pDrm;
|
|
}
|
|
|
|
TEST(DrmTest, GivenDrmWhenAskedForContextThatFailsThenFalseIsReturned) {
|
|
DrmMock *pDrm = new DrmMock;
|
|
pDrm->StoredRetVal = -1;
|
|
EXPECT_THROW(pDrm->createDrmContext(1), std::exception);
|
|
pDrm->StoredRetVal = 0;
|
|
delete pDrm;
|
|
}
|
|
|
|
TEST(DrmTest, givenDrmWhenOsContextIsCreatedThenCreateAndDestroyNewDrmOsContext) {
|
|
DrmMock drmMock;
|
|
|
|
{
|
|
OsContextLinux osContext1(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false);
|
|
|
|
EXPECT_EQ(1u, osContext1.getDrmContextIds().size());
|
|
EXPECT_EQ(drmMock.receivedCreateContextId, osContext1.getDrmContextIds()[0]);
|
|
EXPECT_EQ(0u, drmMock.receivedDestroyContextId);
|
|
|
|
{
|
|
OsContextLinux osContext2(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false);
|
|
EXPECT_EQ(1u, osContext2.getDrmContextIds().size());
|
|
EXPECT_EQ(drmMock.receivedCreateContextId, osContext2.getDrmContextIds()[0]);
|
|
EXPECT_EQ(0u, drmMock.receivedDestroyContextId);
|
|
}
|
|
}
|
|
|
|
EXPECT_EQ(2u, drmMock.receivedContextParamRequestCount);
|
|
}
|
|
|
|
TEST(DrmTest, whenCreatingDrmContextWithVirtualMemoryAddressSpaceThenProperVmIdIsSet) {
|
|
DrmMock drmMock;
|
|
|
|
ASSERT_EQ(1u, drmMock.virtualMemoryIds.size());
|
|
|
|
OsContextLinux osContext(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false);
|
|
|
|
EXPECT_EQ(drmMock.receivedContextParamRequest.value, drmMock.getVirtualMemoryAddressSpace(0u));
|
|
}
|
|
|
|
TEST(DrmTest, whenCreatingDrmContextWithNoVirtualMemoryAddressSpaceThenProperContextIdIsSet) {
|
|
DrmMock drmMock;
|
|
drmMock.destroyVirtualMemoryAddressSpace();
|
|
|
|
ASSERT_EQ(0u, drmMock.virtualMemoryIds.size());
|
|
|
|
OsContextLinux osContext(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false);
|
|
|
|
EXPECT_EQ(0u, drmMock.receivedCreateContextId);
|
|
EXPECT_EQ(0u, drmMock.receivedContextParamRequestCount);
|
|
}
|
|
|
|
TEST(DrmTest, givenDrmAndNegativeCheckNonPersistentContextsSupportWhenOsContextIsCreatedThenReceivedContextParamRequestCountReturnsCorrectValue) {
|
|
|
|
DrmMock drmMock;
|
|
auto expectedCount = 0u;
|
|
|
|
{
|
|
drmMock.StoredRetValForPersistant = -1;
|
|
drmMock.checkNonPersistentContextsSupport();
|
|
expectedCount += 2;
|
|
OsContextLinux osContext(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false);
|
|
EXPECT_EQ(expectedCount, drmMock.receivedContextParamRequestCount);
|
|
}
|
|
{
|
|
drmMock.StoredRetValForPersistant = 0;
|
|
drmMock.checkNonPersistentContextsSupport();
|
|
++expectedCount;
|
|
OsContextLinux osContext(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false);
|
|
expectedCount += 2;
|
|
EXPECT_EQ(expectedCount, drmMock.receivedContextParamRequestCount);
|
|
}
|
|
}
|
|
|
|
TEST(DrmTest, givenDrmPreemptionEnabledAndLowPriorityEngineWhenCreatingOsContextThenCallSetContextPriorityIoctl) {
|
|
DrmMock drmMock;
|
|
drmMock.preemptionSupported = false;
|
|
|
|
OsContextLinux osContext1(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false);
|
|
OsContextLinux osContext2(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, true, false, false);
|
|
|
|
EXPECT_EQ(2u, drmMock.receivedContextParamRequestCount);
|
|
|
|
drmMock.preemptionSupported = true;
|
|
|
|
OsContextLinux osContext3(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false);
|
|
EXPECT_EQ(3u, drmMock.receivedContextParamRequestCount);
|
|
|
|
OsContextLinux osContext4(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, true, false, false);
|
|
EXPECT_EQ(5u, drmMock.receivedContextParamRequestCount);
|
|
EXPECT_EQ(drmMock.receivedCreateContextId, drmMock.receivedContextParamRequest.ctx_id);
|
|
EXPECT_EQ(static_cast<uint64_t>(I915_CONTEXT_PARAM_PRIORITY), drmMock.receivedContextParamRequest.param);
|
|
EXPECT_EQ(static_cast<uint64_t>(-1023), drmMock.receivedContextParamRequest.value);
|
|
EXPECT_EQ(0u, drmMock.receivedContextParamRequest.size);
|
|
}
|
|
|
|
TEST(DrmTest, getExecSoftPin) {
|
|
DrmMock *pDrm = new DrmMock;
|
|
int execSoftPin = 0;
|
|
|
|
int ret = pDrm->getExecSoftPin(execSoftPin);
|
|
EXPECT_EQ(0, ret);
|
|
EXPECT_EQ(0, execSoftPin);
|
|
|
|
pDrm->StoredExecSoftPin = 1;
|
|
ret = pDrm->getExecSoftPin(execSoftPin);
|
|
EXPECT_EQ(0, ret);
|
|
EXPECT_EQ(1, execSoftPin);
|
|
|
|
delete pDrm;
|
|
}
|
|
|
|
TEST(DrmTest, enableTurboBoost) {
|
|
DrmMock *pDrm = new DrmMock;
|
|
|
|
int ret = pDrm->enableTurboBoost();
|
|
EXPECT_EQ(0, ret);
|
|
|
|
delete pDrm;
|
|
}
|
|
|
|
TEST(DrmTest, getEnabledPooledEu) {
|
|
DrmMock *pDrm = new DrmMock;
|
|
|
|
int enabled = 0;
|
|
int ret = 0;
|
|
pDrm->StoredHasPooledEU = -1;
|
|
#if defined(I915_PARAM_HAS_POOLED_EU)
|
|
ret = pDrm->getEnabledPooledEu(enabled);
|
|
EXPECT_EQ(0, ret);
|
|
EXPECT_EQ(-1, enabled);
|
|
|
|
pDrm->StoredHasPooledEU = 0;
|
|
ret = pDrm->getEnabledPooledEu(enabled);
|
|
EXPECT_EQ(0, ret);
|
|
EXPECT_EQ(0, enabled);
|
|
|
|
pDrm->StoredHasPooledEU = 1;
|
|
ret = pDrm->getEnabledPooledEu(enabled);
|
|
EXPECT_EQ(0, ret);
|
|
EXPECT_EQ(1, enabled);
|
|
|
|
pDrm->StoredRetValForPooledEU = -1;
|
|
ret = pDrm->getEnabledPooledEu(enabled);
|
|
EXPECT_EQ(-1, ret);
|
|
EXPECT_EQ(1, enabled);
|
|
#else
|
|
ret = pDrm->getEnabledPooledEu(enabled);
|
|
EXPECT_EQ(0, ret);
|
|
EXPECT_EQ(0, enabled);
|
|
#endif
|
|
delete pDrm;
|
|
}
|
|
|
|
TEST(DrmTest, getMinEuInPool) {
|
|
DrmMock *pDrm = new DrmMock;
|
|
|
|
pDrm->StoredMinEUinPool = -1;
|
|
int minEUinPool = 0;
|
|
int ret = 0;
|
|
#if defined(I915_PARAM_MIN_EU_IN_POOL)
|
|
ret = pDrm->getMinEuInPool(minEUinPool);
|
|
EXPECT_EQ(0, ret);
|
|
EXPECT_EQ(-1, minEUinPool);
|
|
|
|
pDrm->StoredMinEUinPool = 0;
|
|
ret = pDrm->getMinEuInPool(minEUinPool);
|
|
EXPECT_EQ(0, ret);
|
|
EXPECT_EQ(0, minEUinPool);
|
|
|
|
pDrm->StoredMinEUinPool = 1;
|
|
ret = pDrm->getMinEuInPool(minEUinPool);
|
|
EXPECT_EQ(0, ret);
|
|
EXPECT_EQ(1, minEUinPool);
|
|
|
|
pDrm->StoredRetValForMinEUinPool = -1;
|
|
ret = pDrm->getMinEuInPool(minEUinPool);
|
|
EXPECT_EQ(-1, ret);
|
|
EXPECT_EQ(1, minEUinPool);
|
|
#else
|
|
ret = pDrm->getMinEuInPool(minEUinPool);
|
|
EXPECT_EQ(0, ret);
|
|
EXPECT_EQ(0, minEUinPool);
|
|
#endif
|
|
delete pDrm;
|
|
}
|
|
|
|
TEST(DrmTest, givenDrmWhenGetErrnoIsCalledThenErrnoValueIsReturned) {
|
|
DrmMock *pDrm = new DrmMock;
|
|
EXPECT_NE(nullptr, pDrm);
|
|
|
|
auto errnoFromDrm = pDrm->getErrno();
|
|
EXPECT_EQ(errno, errnoFromDrm);
|
|
delete pDrm;
|
|
}
|
|
TEST(DrmTest, givenPlatformWhereGetSseuRetFailureWhenCallSetQueueSliceCountThenSliceCountIsNotSet) {
|
|
uint64_t newSliceCount = 1;
|
|
std::unique_ptr<DrmMock> drm = std::make_unique<DrmMock>();
|
|
drm->StoredRetValForGetSSEU = -1;
|
|
drm->checkQueueSliceSupport();
|
|
|
|
EXPECT_FALSE(drm->sliceCountChangeSupported);
|
|
EXPECT_FALSE(drm->setQueueSliceCount(newSliceCount));
|
|
EXPECT_NE(drm->getSliceMask(newSliceCount), drm->storedParamSseu);
|
|
}
|
|
|
|
TEST(DrmTest, whenCheckNonPeristentSupportIsCalledThenAreNonPersistentContextsSupportedReturnsCorrectValues) {
|
|
std::unique_ptr<DrmMock> drm = std::make_unique<DrmMock>();
|
|
drm->StoredRetValForPersistant = -1;
|
|
drm->checkNonPersistentContextsSupport();
|
|
EXPECT_FALSE(drm->areNonPersistentContextsSupported());
|
|
drm->StoredRetValForPersistant = 0;
|
|
drm->checkNonPersistentContextsSupport();
|
|
EXPECT_TRUE(drm->areNonPersistentContextsSupported());
|
|
}
|
|
|
|
TEST(DrmTest, givenPlatformWhereSetSseuRetFailureWhenCallSetQueueSliceCountThenReturnFalse) {
|
|
uint64_t newSliceCount = 1;
|
|
std::unique_ptr<DrmMock> drm = std::make_unique<DrmMock>();
|
|
drm->StoredRetValForSetSSEU = -1;
|
|
drm->StoredRetValForGetSSEU = 0;
|
|
drm->checkQueueSliceSupport();
|
|
|
|
EXPECT_TRUE(drm->sliceCountChangeSupported);
|
|
EXPECT_FALSE(drm->setQueueSliceCount(newSliceCount));
|
|
}
|
|
|
|
TEST(DrmTest, givenPlatformWithSupportToChangeSliceCountWhenCallSetQueueSliceCountThenReturnTrue) {
|
|
uint64_t newSliceCount = 1;
|
|
std::unique_ptr<DrmMock> drm = std::make_unique<DrmMock>();
|
|
drm->StoredRetValForSetSSEU = 0;
|
|
drm->StoredRetValForSetSSEU = 0;
|
|
drm->checkQueueSliceSupport();
|
|
|
|
EXPECT_TRUE(drm->sliceCountChangeSupported);
|
|
EXPECT_TRUE(drm->setQueueSliceCount(newSliceCount));
|
|
drm_i915_gem_context_param_sseu sseu = {};
|
|
EXPECT_EQ(0, drm->getQueueSliceCount(&sseu));
|
|
EXPECT_EQ(drm->getSliceMask(newSliceCount), sseu.slice_mask);
|
|
}
|
|
namespace NEO {
|
|
namespace SysCalls {
|
|
extern uint32_t closeFuncCalled;
|
|
extern int closeFuncArgPassed;
|
|
extern uint32_t vmId;
|
|
} // namespace SysCalls
|
|
} // namespace NEO
|
|
|
|
TEST(HwDeviceId, whenHwDeviceIdIsDestroyedThenFileDescriptorIsClosed) {
|
|
SysCalls::closeFuncCalled = 0;
|
|
int fileDescriptor = 0x1234;
|
|
{
|
|
HwDeviceId hwDeviceId(fileDescriptor, "");
|
|
}
|
|
EXPECT_EQ(1u, SysCalls::closeFuncCalled);
|
|
EXPECT_EQ(fileDescriptor, SysCalls::closeFuncArgPassed);
|
|
}
|
|
|
|
TEST(DrmTest, givenDrmWhenCreatingOsContextThenCreateDrmContextWithVmId) {
|
|
DrmMock drmMock;
|
|
OsContextLinux osContext(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false);
|
|
|
|
EXPECT_EQ(SysCalls::vmId, drmMock.getVirtualMemoryAddressSpace(0));
|
|
|
|
auto &contextIds = osContext.getDrmContextIds();
|
|
EXPECT_EQ(1u, contextIds.size());
|
|
}
|
|
|
|
TEST(DrmTest, givenDrmWithPerContextVMRequiredWhenCreatingOsContextsThenImplicitVmIdPerContextIsUsed) {
|
|
auto &rootEnv = *platform()->peekExecutionEnvironment()->rootDeviceEnvironments[0];
|
|
rootEnv.executionEnvironment.setPerContextMemorySpace();
|
|
|
|
DrmMock drmMock;
|
|
EXPECT_TRUE(drmMock.requirePerContextVM);
|
|
|
|
OsContextLinux osContext1(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false);
|
|
EXPECT_EQ(0u, drmMock.receivedCreateContextId);
|
|
|
|
OsContextLinux osContext2(drmMock, 5u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false);
|
|
EXPECT_EQ(0u, drmMock.receivedCreateContextId);
|
|
}
|