intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-08 05:56:36 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: correct variable namings

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2023-11-23 17:09:04 +00:00
committed by Compute-Runtime-Automation
parent 9e3a8bdf1b
commit 36194c4e7d
126 changed files with 872 additions and 894 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
level_zero/core/source/driver/driver.cpp
View File

@@ -24,8 +24,8 @@
namespace L0 {
_ze_driver_handle_t *GlobalDriverHandle;
bool LevelZeroDriverInitialized = false;
_ze_driver_handle_t *globalDriverHandle;
bool levelZeroDriverInitialized = false;
uint32_t driverCount = 0;
void DriverImp::initialize(ze_result_t *result) {
@@ -68,8 +68,8 @@ void DriverImp::initialize(ze_result_t *result) {
auto neoDevices = NEO::DeviceFactory::createDevices(*executionEnvironment);
executionEnvironment->decRefInternal();
if (!neoDevices.empty()) {
GlobalDriverHandle = DriverHandle::create(std::move(neoDevices), envVariables, result);
if (GlobalDriverHandle != nullptr) {
globalDriverHandle = DriverHandle::create(std::move(neoDevices), envVariables, result);
if (globalDriverHandle != nullptr) {
driverCount = 1;
*result = ZE_RESULT_SUCCESS;
@@ -84,9 +84,9 @@ void DriverImp::initialize(ze_result_t *result) {
}
}
if (*result != ZE_RESULT_SUCCESS) {
delete GlobalDriver;
GlobalDriverHandle = nullptr;
GlobalDriver = nullptr;
delete globalDriver;
globalDriverHandle = nullptr;
globalDriver = nullptr;
driverCount = 0;
}
}
@@ -119,7 +119,7 @@ ze_result_t driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phDriverHandle
}
for (uint32_t i = 0; i < *pCount; i++) {
phDriverHandles[i] = GlobalDriverHandle;
phDriverHandles[i] = globalDriverHandle;
}
return ZE_RESULT_SUCCESS;
@@ -130,14 +130,14 @@ Driver *Driver::driver = &driverImp;
ze_result_t init(ze_init_flags_t flags) {
if (flags && !(flags & ZE_INIT_FLAG_GPU_ONLY)) {
L0::LevelZeroDriverInitialized = false;
L0::levelZeroDriverInitialized = false;
return ZE_RESULT_ERROR_UNINITIALIZED;
} else {
ze_result_t result = Driver::get()->driverInit(flags);
if (result == ZE_RESULT_SUCCESS) {
L0::LevelZeroDriverInitialized = true;
L0::levelZeroDriverInitialized = true;
} else {
L0::LevelZeroDriverInitialized = false;
L0::levelZeroDriverInitialized = false;
}
return result;
}

4
level_zero/core/source/driver/driver.h
View File

@@ -25,6 +25,6 @@ ze_result_t driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phDrivers);
extern bool sysmanInitFromCore;
extern uint32_t driverCount;
extern _ze_driver_handle_t *GlobalDriverHandle;
extern bool LevelZeroDriverInitialized;
extern _ze_driver_handle_t *globalDriverHandle;
extern bool levelZeroDriverInitialized;
} // namespace L0

4
level_zero/core/source/driver/driver_handle_imp.cpp
View File

@@ -40,7 +40,7 @@
namespace L0 {
struct DriverHandleImp *GlobalDriver;
struct DriverHandleImp *globalDriver;
DriverHandleImp::DriverHandleImp() = default;
@@ -289,7 +289,7 @@ DriverHandle *DriverHandle::create(std::vector<std::unique_ptr<NEO::Device>> dev
return nullptr;
}
GlobalDriver = driverHandle;
globalDriver = driverHandle;
driverHandle->getMemoryManager()->setForceNonSvmForExternalHostPtr(true);

2
level_zero/core/source/driver/driver_handle_imp.h
View File

@@ -175,6 +175,6 @@ struct DriverHandleImp : public DriverHandle {
ze_result_t clearErrorDescription() override;
};
extern struct DriverHandleImp *GlobalDriver;
extern struct DriverHandleImp *globalDriver;
} // namespace L0

12
level_zero/core/source/global_teardown.cpp
View File

@@ -11,13 +11,13 @@
namespace L0 {
void globalDriverTeardown() {
if (GlobalDriver != nullptr) {
delete GlobalDriver;
GlobalDriver = nullptr;
if (globalDriver != nullptr) {
delete globalDriver;
globalDriver = nullptr;
}
if (Sysman::GlobalSysmanDriver != nullptr) {
delete Sysman::GlobalSysmanDriver;
Sysman::GlobalSysmanDriver = nullptr;
if (Sysman::globalSysmanDriver != nullptr) {
delete Sysman::globalSysmanDriver;
Sysman::globalSysmanDriver = nullptr;
}
}
} // namespace L0

2
level_zero/core/source/linux/driver_teardown.cpp
View File

@@ -15,7 +15,7 @@
namespace L0 {
ze_result_t setDriverTeardownHandleInLoader(const char *loaderLibraryName) {
if (L0::LevelZeroDriverInitialized) {
if (L0::levelZeroDriverInitialized) {
ze_result_t result = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
std::unique_ptr<NEO::OsLibrary> loaderLibrary = std::unique_ptr<NEO::OsLibrary>{NEO::OsLibrary::load(loaderLibraryName)};
if (loaderLibrary) {

8
level_zero/core/source/windows/driver_teardown.cpp
View File

@@ -15,7 +15,7 @@
namespace L0 {
ze_result_t setDriverTeardownHandleInLoader(const char *loaderLibraryName) {
if (L0::LevelZeroDriverInitialized) {
if (L0::levelZeroDriverInitialized) {
HMODULE handle = nullptr;
ze_result_t result = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
handle = GetModuleHandleA(loaderLibraryName);
@@ -37,9 +37,9 @@ BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
if (fdwReason == DLL_PROCESS_DETACH) {
L0::setDriverTeardownHandleInLoader("ze_loader.dll");
L0::globalDriverTeardown();
if (L0::GlobalOsSysmanDriver != nullptr) {
delete L0::GlobalOsSysmanDriver;
L0::GlobalOsSysmanDriver = nullptr;
if (L0::globalOsSysmanDriver != nullptr) {
delete L0::globalOsSysmanDriver;
L0::globalOsSysmanDriver = nullptr;
}
}
return TRUE;

4
level_zero/core/test/common/ult_config_listener_l0.cpp
View File

@@ -12,13 +12,13 @@
void L0::UltConfigListenerL0::OnTestStart(const ::testing::TestInfo &testInfo) {
BaseUltConfigListener::OnTestStart(testInfo);
GlobalDriverHandle = nullptr;
globalDriverHandle = nullptr;
driverCount = 0;
}
void L0::UltConfigListenerL0::OnTestEnd(const ::testing::TestInfo &testInfo) {
EXPECT_EQ(nullptr, GlobalDriverHandle);
EXPECT_EQ(nullptr, globalDriverHandle);
EXPECT_EQ(0u, driverCount);
BaseUltConfigListener::OnTestEnd(testInfo);

2
level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.cpp
View File

@@ -576,7 +576,7 @@ void CommandQueueThreadArbitrationPolicyFixture::setUp() {
void CommandQueueThreadArbitrationPolicyFixture::tearDown() {
commandList->destroy();
commandQueue->destroy();
L0::GlobalDriver = nullptr;
L0::globalDriver = nullptr;
}
} // namespace ult

6
level_zero/core/test/unit_tests/fixtures/device_fixture.h
View File

@@ -32,7 +32,7 @@ struct Device;
struct ContextImp;
extern uint32_t driverCount;
extern _ze_driver_handle_t *GlobalDriverHandle;
extern _ze_driver_handle_t *globalDriverHandle;
namespace ult {
class MockBuiltins;
@@ -54,7 +54,7 @@ struct DeviceFixture {
const uint32_t rootDeviceIndex = 0u;
template <typename HelperType>
HelperType &getHelper() const;
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&GlobalDriverHandle};
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&globalDriverHandle};
VariableBackup<uint32_t> driverCountBackup{&driverCount};
};
@@ -117,7 +117,7 @@ struct MultiDeviceFixture {
uint32_t numSubDevices = 2u;
L0::ContextImp *context = nullptr;
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&GlobalDriverHandle};
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&globalDriverHandle};
VariableBackup<uint32_t> driverCountBackup{&driverCount};
};

26
level_zero/core/test/unit_tests/os_interface/global_teardown_tests.cpp
View File

@@ -19,37 +19,37 @@ namespace L0 {
namespace ult {
TEST(GlobalTearDownCallbackTests, givenL0LoaderThenGlobalTeardownCallbackIsCalled) {
L0::LevelZeroDriverInitialized = true;
L0::levelZeroDriverInitialized = true;
std::unique_ptr<NEO::OsLibrary> loaderLibrary = std::unique_ptr<NEO::OsLibrary>{NEO::OsLibrary::load(L0::ult::testLoaderDllName)};
EXPECT_EQ(ZE_RESULT_SUCCESS, setDriverTeardownHandleInLoader(L0::ult::testLoaderDllName));
L0::LevelZeroDriverInitialized = false;
L0::levelZeroDriverInitialized = false;
}
TEST(GlobalTearDownCallbackTests, givenL0LoaderButL0DriverDidNotInitThenSetTearDownReturnsUninitialized) {
L0::LevelZeroDriverInitialized = false;
L0::levelZeroDriverInitialized = false;
std::unique_ptr<NEO::OsLibrary> loaderLibrary = std::unique_ptr<NEO::OsLibrary>{NEO::OsLibrary::load(L0::ult::testLoaderDllName)};
EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, setDriverTeardownHandleInLoader(L0::ult::testLoaderDllName));
}
TEST(GlobalTearDownCallbackTests, givenL0LoaderIsMissingThenGlobalTeardownCallbackIsNotCalled) {
L0::LevelZeroDriverInitialized = true;
L0::levelZeroDriverInitialized = true;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, setDriverTeardownHandleInLoader("invalid.so"));
L0::LevelZeroDriverInitialized = false;
L0::levelZeroDriverInitialized = false;
}
TEST(GlobalTearDownCallbackTests, givenL0LoaderWithoutGlobalTeardownCallbackThenGlobalTeardownCallbackIsNotCalled) {
L0::LevelZeroDriverInitialized = true;
L0::levelZeroDriverInitialized = true;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, setDriverTeardownHandleInLoader(L0::ult::testDllName));
L0::LevelZeroDriverInitialized = false;
L0::levelZeroDriverInitialized = false;
}
TEST(GlobalTearDownTests, givenCallToGlobalTearDownFunctionThenGlobalDriversAreNull) {
globalDriverTeardown();
EXPECT_EQ(GlobalDriver, nullptr);
EXPECT_EQ(Sysman::GlobalSysmanDriver, nullptr);
EXPECT_EQ(globalDriver, nullptr);
EXPECT_EQ(Sysman::globalSysmanDriver, nullptr);
}
TEST(GlobalTearDownTests, givenCallToGlobalTearDownFunctionWithNullSysManDriverThenGlobalDriverIsNull) {
delete Sysman::GlobalSysmanDriver;
Sysman::GlobalSysmanDriver = nullptr;
delete Sysman::globalSysmanDriver;
Sysman::globalSysmanDriver = nullptr;
globalDriverTeardown();
EXPECT_EQ(GlobalDriver, nullptr);
EXPECT_EQ(Sysman::GlobalSysmanDriver, nullptr);
EXPECT_EQ(globalDriver, nullptr);
EXPECT_EQ(Sysman::globalSysmanDriver, nullptr);
}
} // namespace ult
} // namespace L0

7
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_3.cpp
View File

@@ -192,7 +192,6 @@ HWTEST2_F(CommandListCreate, givenHostAllocInMapWhenGetHostPtrAllocCalledThenCor
commandList->hostPtrMap.clear();
}
template <NEO::AllocationType AllocType>
class DeviceHostPtrFailMock : public MockDeviceImp {
public:
using MockDeviceImp::MockDeviceImp;
@@ -205,7 +204,7 @@ class DeviceHostPtrFailMock : public MockDeviceImp {
};
HWTEST2_F(CommandListCreate, givenGetAlignedAllocationCalledWithInvalidPtrThenNullptrReturned, IsAtLeastSkl) {
auto failDevice = std::make_unique<DeviceHostPtrFailMock<NEO::AllocationType::INTERNAL_HOST_MEMORY>>(device->getNEODevice(), execEnv);
auto failDevice = std::make_unique<DeviceHostPtrFailMock>(device->getNEODevice(), execEnv);
failDevice->neoDevice = device->getNEODevice();
auto commandList = std::make_unique<WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>>();
commandList->initialize(failDevice.get(), NEO::EngineGroupType::Copy, 0u);
@@ -1429,13 +1428,13 @@ HWTEST2_F(CommandListCreate, givenNonEmptyCommandsToPatchWhenClearCommandsToPatc
EXPECT_TRUE(pCommandList->commandsToPatch.empty());
}
template <NEO::AllocationType AllocType>
template <NEO::AllocationType allocType>
class MyDeviceMock : public MockDeviceImp {
public:
using MockDeviceImp::MockDeviceImp;
NEO::GraphicsAllocation *allocateMemoryFromHostPtr(const void *buffer, size_t size, bool hostCopyAllowed) override {
auto alloc = std::make_unique<NEO::MockGraphicsAllocation>(const_cast<void *>(buffer), reinterpret_cast<uintptr_t>(buffer), size);
alloc->allocationType = AllocType;
alloc->allocationType = allocType;
return alloc.release();
}
const NEO::HardwareInfo &getHwInfo() const override {

30
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_enqueue_cmdlist_2.cpp
View File

@@ -296,8 +296,9 @@ struct PauseOnGpuFixture : public Test<ModuleFixture> {
commandListHandle = commandList->toHandle();
}
template <typename MI_SEMAPHORE_WAIT>
template <typename FamilyType>
bool verifySemaphore(const GenCmdList::iterator &iterator, uint64_t debugPauseStateAddress, DebugPauseState requiredDebugPauseState) {
using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
auto semaphoreCmd = genCmdCast<MI_SEMAPHORE_WAIT *>(*iterator);
if ((static_cast<uint32_t>(requiredDebugPauseState) == semaphoreCmd->getSemaphoreDataDword()) &&
@@ -344,16 +345,17 @@ struct PauseOnGpuFixture : public Test<ModuleFixture> {
return false;
}
template <typename MI_SEMAPHORE_WAIT>
template <typename FamilyType>
void findSemaphores(GenCmdList &cmdList) {
using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
auto semaphore = find<MI_SEMAPHORE_WAIT *>(cmdList.begin(), cmdList.end());
while (semaphore != cmdList.end()) {
if (verifySemaphore<MI_SEMAPHORE_WAIT>(semaphore, debugPauseStateAddress, DebugPauseState::hasUserStartConfirmation)) {
if (verifySemaphore<FamilyType>(semaphore, debugPauseStateAddress, DebugPauseState::hasUserStartConfirmation)) {
semaphoreBeforeWalkerFound++;
}
if (verifySemaphore<MI_SEMAPHORE_WAIT>(semaphore, debugPauseStateAddress, DebugPauseState::hasUserEndConfirmation)) {
if (verifySemaphore<FamilyType>(semaphore, debugPauseStateAddress, DebugPauseState::hasUserEndConfirmation)) {
semaphoreAfterWalkerFound++;
}
@@ -451,7 +453,7 @@ HWTEST_F(PauseOnGpuTests, givenPauseOnEnqueueFlagSetWhenDispatchWalkersThenInser
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
cmdList, ptrOffset(commandList->getCmdContainer().getCommandStream()->getCpuBase(), 0), usedSpaceAfter));
findSemaphores<MI_SEMAPHORE_WAIT>(cmdList);
findSemaphores<FamilyType>(cmdList);
findPipeControls<FamilyType>(cmdList);
EXPECT_EQ(1u, semaphoreBeforeWalkerFound);
@@ -478,7 +480,7 @@ HWTEST_F(PauseOnGpuTests, givenPauseOnEnqueueFlagSetToAlwaysWhenDispatchWalkersT
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
cmdList, ptrOffset(commandList->getCmdContainer().getCommandStream()->getCpuBase(), 0), usedSpaceAfter));
findSemaphores<MI_SEMAPHORE_WAIT>(cmdList);
findSemaphores<FamilyType>(cmdList);
findPipeControls<FamilyType>(cmdList);
EXPECT_EQ(2u, semaphoreBeforeWalkerFound);
@@ -506,7 +508,7 @@ HWTEST_F(PauseOnGpuTests, givenPauseModeSetToBeforeOnlyWhenDispatchingThenInsert
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
cmdList, ptrOffset(commandList->getCmdContainer().getCommandStream()->getCpuBase(), 0), usedSpaceAfter));
findSemaphores<MI_SEMAPHORE_WAIT>(cmdList);
findSemaphores<FamilyType>(cmdList);
findPipeControls<FamilyType>(cmdList);
@@ -534,7 +536,7 @@ HWTEST_F(PauseOnGpuTests, givenPauseModeSetToAfterOnlyWhenDispatchingThenInsertP
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
cmdList, ptrOffset(commandList->getCmdContainer().getCommandStream()->getCpuBase(), 0), usedSpaceAfter));
findSemaphores<MI_SEMAPHORE_WAIT>(cmdList);
findSemaphores<FamilyType>(cmdList);
findPipeControls<FamilyType>(cmdList);
EXPECT_EQ(0u, semaphoreBeforeWalkerFound);
@@ -561,7 +563,7 @@ HWTEST_F(PauseOnGpuTests, givenPauseModeSetToBeforeAndAfterWhenDispatchingThenIn
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
cmdList, ptrOffset(commandList->getCmdContainer().getCommandStream()->getCpuBase(), 0), usedSpaceAfter));
findSemaphores<MI_SEMAPHORE_WAIT>(cmdList);
findSemaphores<FamilyType>(cmdList);
findPipeControls<FamilyType>(cmdList);
@@ -610,7 +612,7 @@ HWTEST_F(PauseOnGpuWithImmediateCommandListTests, givenPauseOnEnqueueFlagSetWhen
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
cmdList, ptrOffset(commandList->getCmdContainer().getCommandStream()->getCpuBase(), 0), usedSpaceAfter));
findSemaphores<MI_SEMAPHORE_WAIT>(cmdList);
findSemaphores<FamilyType>(cmdList);
findPipeControls<FamilyType>(cmdList);
EXPECT_EQ(1u, semaphoreBeforeWalkerFound);
@@ -637,7 +639,7 @@ HWTEST_F(PauseOnGpuWithImmediateCommandListTests, givenPauseOnEnqueueFlagSetToAl
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
cmdList, ptrOffset(commandList->getCmdContainer().getCommandStream()->getCpuBase(), 0), usedSpaceAfter));
findSemaphores<MI_SEMAPHORE_WAIT>(cmdList);
findSemaphores<FamilyType>(cmdList);
findPipeControls<FamilyType>(cmdList);
EXPECT_EQ(2u, semaphoreBeforeWalkerFound);
@@ -665,7 +667,7 @@ HWTEST_F(PauseOnGpuWithImmediateCommandListTests, givenPauseModeSetToBeforeOnlyW
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
cmdList, ptrOffset(commandList->getCmdContainer().getCommandStream()->getCpuBase(), 0), usedSpaceAfter));
findSemaphores<MI_SEMAPHORE_WAIT>(cmdList);
findSemaphores<FamilyType>(cmdList);
findPipeControls<FamilyType>(cmdList);
@@ -693,7 +695,7 @@ HWTEST_F(PauseOnGpuWithImmediateCommandListTests, givenPauseModeSetToAfterOnlyWh
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
cmdList, ptrOffset(commandList->getCmdContainer().getCommandStream()->getCpuBase(), 0), usedSpaceAfter));
findSemaphores<MI_SEMAPHORE_WAIT>(cmdList);
findSemaphores<FamilyType>(cmdList);
findPipeControls<FamilyType>(cmdList);
EXPECT_EQ(0u, semaphoreBeforeWalkerFound);
@@ -720,7 +722,7 @@ HWTEST_F(PauseOnGpuWithImmediateCommandListTests, givenPauseModeSetToBeforeAndAf
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
cmdList, ptrOffset(commandList->getCmdContainer().getCommandStream()->getCpuBase(), 0), usedSpaceAfter));
findSemaphores<MI_SEMAPHORE_WAIT>(cmdList);
findSemaphores<FamilyType>(cmdList);
findPipeControls<FamilyType>(cmdList);

5
level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_1.cpp
View File

@@ -5,6 +5,7 @@
*
*/
#include "shared/source/command_container/encode_surface_state.h"
#include "shared/source/gen_common/reg_configs_common.h"
#include "shared/source/gmm_helper/gmm_lib.h"
#include "shared/source/helpers/preamble.h"
@@ -224,7 +225,7 @@ HWTEST2_P(L0DebuggerParameterizedTests, givenDebuggerWhenAppendingKernelToComman
auto debugSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ssh->getCpuBase());
auto debugSurface = static_cast<L0::DeviceImp *>(device)->getDebugSurface();
SURFACE_STATE_BUFFER_LENGTH length;
SurfaceStateBufferLength length;
length.length = static_cast<uint32_t>(debugSurface->getUnderlyingBufferSize() - 1);
EXPECT_EQ(length.surfaceState.depth + 1u, debugSurfaceState->getDepth());
@@ -782,7 +783,7 @@ HWTEST_F(DebuggerWithGlobalBindlessTest, GivenGlobalBindlessHeapWhenDeviceIsCrea
EXPECT_EQ(globalBindlessBase, bindlessHelper->getHeap(NEO::BindlessHeapsHelper::SPECIAL_SSH)->getHeapGpuBase());
SURFACE_STATE_BUFFER_LENGTH length;
SurfaceStateBufferLength length;
length.length = static_cast<uint32_t>(debugSurface->getUnderlyingBufferSize() - 1);
EXPECT_EQ(length.surfaceState.depth + 1u, debugSurfaceState->getDepth());

164
level_zero/core/test/unit_tests/sources/driver/test_driver.cpp
View File

@@ -52,7 +52,7 @@ TEST(zeInit, whenCallingZeInitThenLevelZeroDriverInitializedIsSetToTrue) {
auto result = zeInit(ZE_INIT_FLAG_GPU_ONLY);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_TRUE(LevelZeroDriverInitialized);
EXPECT_TRUE(levelZeroDriverInitialized);
EXPECT_EQ(1u, driver.initCalledCount);
}
@@ -62,7 +62,7 @@ TEST(zeInit, whenCallingZeInitWithFailureInIinitThenLevelZeroDriverInitializedIs
auto result = zeInit(ZE_INIT_FLAG_GPU_ONLY);
EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, result);
EXPECT_FALSE(LevelZeroDriverInitialized);
EXPECT_FALSE(levelZeroDriverInitialized);
}
TEST(zeInit, whenCallingZeInitWithVpuOnlyThenLevelZeroDriverInitializedIsSetToFalse) {
@@ -70,7 +70,7 @@ TEST(zeInit, whenCallingZeInitWithVpuOnlyThenLevelZeroDriverInitializedIsSetToFa
auto result = zeInit(ZE_INIT_FLAG_VPU_ONLY);
EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, result);
EXPECT_FALSE(LevelZeroDriverInitialized);
EXPECT_FALSE(levelZeroDriverInitialized);
}
TEST(zeInit, whenCallingZeInitWithNoFlagsThenInitializeOnDriverIsCalled) {
@@ -379,7 +379,7 @@ TEST(DriverTestFamilySupport, whenInitializingDriverOnSupportedFamilyThenDriverI
auto driverHandle = DriverHandle::create(std::move(devices), L0EnvVariables{}, &returnValue);
EXPECT_NE(nullptr, driverHandle);
delete driverHandle;
L0::GlobalDriver = nullptr;
L0::globalDriver = nullptr;
}
TEST(DriverTestFamilySupport, whenInitializingDriverOnNotSupportedFamilyThenDriverIsNotCreated) {
@@ -413,11 +413,11 @@ TEST(DriverTest, givenNullEnvVariableWhenCreatingDriverThenEnableProgramDebuggin
EXPECT_EQ(NEO::DebuggingMode::Disabled, driverHandle->enableProgramDebugging);
delete driverHandle;
L0::GlobalDriver = nullptr;
L0::globalDriver = nullptr;
}
struct DriverImpTest : public ::testing::Test {
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&GlobalDriverHandle};
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&globalDriverHandle};
VariableBackup<uint32_t> driverCountBackup{&driverCount};
};
@@ -434,9 +434,9 @@ TEST_F(DriverImpTest, givenDriverImpWhenInitializedThenEnvVariablesAreRead) {
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_LE(3u, IoFunctions::mockGetenvCalled);
delete L0::GlobalDriver;
L0::GlobalDriverHandle = nullptr;
L0::GlobalDriver = nullptr;
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
}
TEST_F(DriverImpTest, givenMissingMetricApiDependenciesWhenInitializingDriverImpThenGlobalDriverHandleIsNull) {
@@ -459,8 +459,8 @@ TEST_F(DriverImpTest, givenMissingMetricApiDependenciesWhenInitializingDriverImp
DriverImp driverImp;
driverImp.initialize(&result);
EXPECT_NE(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(nullptr, L0::GlobalDriverHandle);
EXPECT_EQ(nullptr, L0::GlobalDriver);
EXPECT_EQ(nullptr, L0::globalDriverHandle);
EXPECT_EQ(nullptr, L0::globalDriver);
}
TEST_F(DriverImpTest, givenEnabledProgramDebuggingWhenCreatingExecutionEnvironmentThenDebuggingEnabledIsTrue) {
@@ -476,13 +476,13 @@ TEST_F(DriverImpTest, givenEnabledProgramDebuggingWhenCreatingExecutionEnvironme
DriverImp driverImp;
driverImp.initialize(&result);
ASSERT_NE(nullptr, L0::GlobalDriver);
ASSERT_NE(0u, L0::GlobalDriver->numDevices);
EXPECT_TRUE(L0::GlobalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
EXPECT_TRUE(L0::globalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
delete L0::GlobalDriver;
L0::GlobalDriverHandle = nullptr;
L0::GlobalDriver = nullptr;
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
}
TEST_F(DriverImpTest, whenCreatingExecutionEnvironmentThenDefaultHierarchyIsEnabled) {
@@ -493,19 +493,19 @@ TEST_F(DriverImpTest, whenCreatingExecutionEnvironmentThenDefaultHierarchyIsEnab
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
L0::DriverHandleImp *driverHandleImp = reinterpret_cast<L0::DriverHandleImp *>(L0::GlobalDriverHandle);
L0::DriverHandleImp *driverHandleImp = reinterpret_cast<L0::DriverHandleImp *>(L0::globalDriverHandle);
auto &gfxCoreHelper = driverHandleImp->memoryManager->peekExecutionEnvironment().rootDeviceEnvironments[0]->getHelper<NEO::GfxCoreHelper>();
if (strcmp(gfxCoreHelper.getDefaultDeviceHierarchy(), "COMPOSITE") == 0) {
EXPECT_EQ(driverHandleImp->deviceHierarchyMode, L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_COMPOSITE);
} else {
EXPECT_EQ(driverHandleImp->deviceHierarchyMode, L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_FLAT);
}
ASSERT_NE(nullptr, L0::GlobalDriver);
ASSERT_NE(0u, L0::GlobalDriver->numDevices);
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
delete L0::GlobalDriver;
L0::GlobalDriverHandle = nullptr;
L0::GlobalDriver = nullptr;
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
}
TEST_F(DriverImpTest, givenFlatDeviceHierarchyWhenCreatingExecutionEnvironmentThenFlatHierarchyIsEnabled) {
@@ -520,14 +520,14 @@ TEST_F(DriverImpTest, givenFlatDeviceHierarchyWhenCreatingExecutionEnvironmentTh
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
L0::DriverHandleImp *driverHandleImp = reinterpret_cast<L0::DriverHandleImp *>(L0::GlobalDriverHandle);
L0::DriverHandleImp *driverHandleImp = reinterpret_cast<L0::DriverHandleImp *>(L0::globalDriverHandle);
EXPECT_EQ(driverHandleImp->deviceHierarchyMode, L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_FLAT);
ASSERT_NE(nullptr, L0::GlobalDriver);
ASSERT_NE(0u, L0::GlobalDriver->numDevices);
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
delete L0::GlobalDriver;
L0::GlobalDriverHandle = nullptr;
L0::GlobalDriver = nullptr;
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
}
TEST_F(DriverImpTest, givenCompositeDeviceHierarchyWhenCreatingExecutionEnvironmentThenCompositeHierarchyIsEnabled) {
@@ -542,14 +542,14 @@ TEST_F(DriverImpTest, givenCompositeDeviceHierarchyWhenCreatingExecutionEnvironm
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
L0::DriverHandleImp *driverHandleImp = reinterpret_cast<L0::DriverHandleImp *>(L0::GlobalDriverHandle);
L0::DriverHandleImp *driverHandleImp = reinterpret_cast<L0::DriverHandleImp *>(L0::globalDriverHandle);
EXPECT_EQ(driverHandleImp->deviceHierarchyMode, L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_COMPOSITE);
ASSERT_NE(nullptr, L0::GlobalDriver);
ASSERT_NE(0u, L0::GlobalDriver->numDevices);
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
delete L0::GlobalDriver;
L0::GlobalDriverHandle = nullptr;
L0::GlobalDriver = nullptr;
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
}
TEST_F(DriverImpTest, givenCombinedDeviceHierarchyWhenCreatingExecutionEnvironmentThenCombinedHierarchyIsEnabled) {
@@ -564,14 +564,14 @@ TEST_F(DriverImpTest, givenCombinedDeviceHierarchyWhenCreatingExecutionEnvironme
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
L0::DriverHandleImp *driverHandleImp = reinterpret_cast<L0::DriverHandleImp *>(L0::GlobalDriverHandle);
L0::DriverHandleImp *driverHandleImp = reinterpret_cast<L0::DriverHandleImp *>(L0::globalDriverHandle);
EXPECT_EQ(driverHandleImp->deviceHierarchyMode, L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_COMBINED);
ASSERT_NE(nullptr, L0::GlobalDriver);
ASSERT_NE(0u, L0::GlobalDriver->numDevices);
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
delete L0::GlobalDriver;
L0::GlobalDriverHandle = nullptr;
L0::GlobalDriver = nullptr;
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
}
TEST_F(DriverImpTest, givenEnableProgramDebuggingWithValue2WhenCreatingExecutionEnvironmentThenDebuggingEnabledIsTrue) {
@@ -587,13 +587,13 @@ TEST_F(DriverImpTest, givenEnableProgramDebuggingWithValue2WhenCreatingExecution
DriverImp driverImp;
driverImp.initialize(&result);
ASSERT_NE(nullptr, L0::GlobalDriver);
ASSERT_NE(0u, L0::GlobalDriver->numDevices);
EXPECT_TRUE(L0::GlobalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
EXPECT_TRUE(L0::globalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
delete L0::GlobalDriver;
L0::GlobalDriverHandle = nullptr;
L0::GlobalDriver = nullptr;
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
}
TEST_F(DriverImpTest, givenEnabledFP64EmulationWhenCreatingExecutionEnvironmentThenFP64EmulationIsEnabled) {
@@ -609,19 +609,19 @@ TEST_F(DriverImpTest, givenEnabledFP64EmulationWhenCreatingExecutionEnvironmentT
DriverImp driverImp;
driverImp.initialize(&result);
ASSERT_NE(nullptr, L0::GlobalDriver);
ASSERT_NE(0u, L0::GlobalDriver->numDevices);
EXPECT_TRUE(L0::GlobalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isFP64EmulationEnabled());
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
EXPECT_TRUE(L0::globalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isFP64EmulationEnabled());
delete L0::GlobalDriver;
L0::GlobalDriverHandle = nullptr;
L0::GlobalDriver = nullptr;
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
}
TEST_F(DriverImpTest, givenEnabledProgramDebuggingAndEnabledExperimentalOpenCLWhenCreatingExecutionEnvironmentThenDebuggingEnabledIsFalse) {
DebugManagerStateRestore restorer;
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&GlobalDriverHandle};
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&globalDriverHandle};
VariableBackup<uint32_t> driverCountBackup{&driverCount};
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo.get();
hwInfo.capabilityTable.levelZeroSupported = true;
@@ -631,18 +631,18 @@ TEST_F(DriverImpTest, givenEnabledProgramDebuggingAndEnabledExperimentalOpenCLWh
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{"ZET_ENABLE_PROGRAM_DEBUGGING", "1"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
VariableBackup<decltype(L0::GlobalDriverHandle)> mockableDriverHandle(&L0::GlobalDriverHandle);
VariableBackup<decltype(L0::GlobalDriver)> mockableDriver(&L0::GlobalDriver);
VariableBackup<decltype(L0::globalDriverHandle)> mockableDriverHandle(&L0::globalDriverHandle);
VariableBackup<decltype(L0::globalDriver)> mockableDriver(&L0::globalDriver);
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
ASSERT_NE(nullptr, L0::GlobalDriver);
ASSERT_NE(0u, L0::GlobalDriver->numDevices);
EXPECT_FALSE(L0::GlobalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
EXPECT_FALSE(L0::globalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
delete L0::GlobalDriver;
delete L0::globalDriver;
}
TEST_F(DriverImpTest, givenEnableProgramDebuggingWithValue2AndEnabledExperimentalOpenCLWhenCreatingExecutionEnvironmentThenDebuggingEnabledIsFalse) {
@@ -655,18 +655,18 @@ TEST_F(DriverImpTest, givenEnableProgramDebuggingWithValue2AndEnabledExperimenta
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{"ZET_ENABLE_PROGRAM_DEBUGGING", "2"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
VariableBackup<decltype(L0::GlobalDriverHandle)> mockableDriverHandle(&L0::GlobalDriverHandle);
VariableBackup<decltype(L0::GlobalDriver)> mockableDriver(&L0::GlobalDriver);
VariableBackup<decltype(L0::globalDriverHandle)> mockableDriverHandle(&L0::globalDriverHandle);
VariableBackup<decltype(L0::globalDriver)> mockableDriver(&L0::globalDriver);
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
ASSERT_NE(nullptr, L0::GlobalDriver);
ASSERT_NE(0u, L0::GlobalDriver->numDevices);
EXPECT_FALSE(L0::GlobalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
EXPECT_FALSE(L0::globalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
delete L0::GlobalDriver;
delete L0::globalDriver;
}
TEST_F(DriverImpTest, givenNoProgramDebuggingEnvVarWhenCreatingExecutionEnvironmentThenDebuggingEnabledIsFalse) {
@@ -678,13 +678,13 @@ TEST_F(DriverImpTest, givenNoProgramDebuggingEnvVarWhenCreatingExecutionEnvironm
DriverImp driverImp;
driverImp.initialize(&result);
ASSERT_NE(nullptr, L0::GlobalDriver);
ASSERT_NE(0u, L0::GlobalDriver->numDevices);
EXPECT_FALSE(L0::GlobalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
EXPECT_FALSE(L0::globalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
delete L0::GlobalDriver;
L0::GlobalDriverHandle = nullptr;
L0::GlobalDriver = nullptr;
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
}
TEST(DriverTest, givenProgramDebuggingEnvVarValue1WhenCreatingDriverThenEnableProgramDebuggingIsSetToTrue) {
@@ -706,7 +706,7 @@ TEST(DriverTest, givenProgramDebuggingEnvVarValue1WhenCreatingDriverThenEnablePr
EXPECT_TRUE(driverHandle->enableProgramDebugging == NEO::DebuggingMode::Online);
delete driverHandle;
L0::GlobalDriver = nullptr;
L0::globalDriver = nullptr;
}
TEST(DriverTest, givenProgramDebuggingEnvVarValue2WhenCreatingDriverThenEnableProgramDebuggingIsSetToTrue) {
@@ -728,7 +728,7 @@ TEST(DriverTest, givenProgramDebuggingEnvVarValue2WhenCreatingDriverThenEnablePr
EXPECT_TRUE(driverHandle->enableProgramDebugging == NEO::DebuggingMode::Offline);
delete driverHandle;
L0::GlobalDriver = nullptr;
L0::globalDriver = nullptr;
}
TEST(DriverTest, givenInvalidCompilerEnvironmentThenDependencyUnavailableErrorIsReturned) {
@@ -750,7 +750,7 @@ TEST(DriverTest, givenInvalidCompilerEnvironmentThenDependencyUnavailableErrorIs
Os::igcDllName = oldIgcDllName;
Os::frontEndDllName = oldFclDllName;
ASSERT_EQ(nullptr, L0::GlobalDriver);
ASSERT_EQ(nullptr, L0::globalDriver);
}
TEST(DriverTest, givenInvalidCompilerEnvironmentAndEnableProgramDebuggingWithValue2ThenDependencyUnavailableErrorIsReturned) {
@@ -772,7 +772,7 @@ TEST(DriverTest, givenInvalidCompilerEnvironmentAndEnableProgramDebuggingWithVal
Os::igcDllName = oldIgcDllName;
Os::frontEndDllName = oldFclDllName;
ASSERT_EQ(nullptr, L0::GlobalDriver);
ASSERT_EQ(nullptr, L0::globalDriver);
}
struct DriverTestMultipleFamilySupport : public ::testing::Test {
@@ -813,7 +813,7 @@ TEST_F(DriverTestMultipleFamilySupport, whenInitializingDriverWithArrayOfDevices
}
delete driverHandle;
L0::GlobalDriver = nullptr;
L0::globalDriver = nullptr;
}
TEST(MultiRootDeviceDriverTest, whenInitializingDriverHandleWithMultipleDevicesThenOrderInRootDeviceIndicesMatchesOrderInDeviceVector) {
@@ -907,16 +907,16 @@ struct DriverHandleTest : public ::testing::Test {
envVariables.programDebugging = true;
driverHandle = whiteboxCast(DriverHandle::create(std::move(devices), envVariables, &returnValue));
L0::GlobalDriverHandle = driverHandle;
L0::globalDriverHandle = driverHandle;
L0::driverCount = 1;
}
void TearDown() override {
delete driverHandle;
L0::GlobalDriver = nullptr;
L0::GlobalDriverHandle = nullptr;
L0::globalDriver = nullptr;
L0::globalDriverHandle = nullptr;
}
L0::DriverHandle *driverHandle;
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&GlobalDriverHandle};
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&globalDriverHandle};
VariableBackup<uint32_t> driverCountBackup{&driverCount};
};
@@ -984,7 +984,7 @@ TEST_F(DriverHandleTest, givenInitializedDriverWhenZeDriverGetIsCalledThenGlobal
result = zeDriverGet(&count, &hDriverHandle);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, hDriverHandle);
EXPECT_EQ(hDriverHandle, GlobalDriver);
EXPECT_EQ(hDriverHandle, globalDriver);
}
TEST_F(DriverHandleTest, givenInitializedDriverWhenGetDeviceIsCalledThenOneDeviceIsObtained) {

12
level_zero/core/test/unit_tests/sources/module/test_module.cpp
View File

@@ -406,7 +406,7 @@ HWTEST_F(ModuleTest, givenBufferWhenOffsetIsNotPatchedThenSizeIsDecereasedByOffs
auto argInfo = kernelImp->getImmutableData()->getDescriptor().payloadMappings.explicitArgs[argIndex].as<NEO::ArgDescPointer>();
auto surfaceStateAddressRaw = ptrOffset(kernelImp->getSurfaceStateHeapData(), argInfo.bindful);
auto surfaceStateAddress = reinterpret_cast<RENDER_SURFACE_STATE *>(const_cast<unsigned char *>(surfaceStateAddressRaw));
SURFACE_STATE_BUFFER_LENGTH length = {0};
SurfaceStateBufferLength length = {0};
length.length = static_cast<uint32_t>((gpuAlloc->getUnderlyingBufferSize() - offset) - 1);
EXPECT_EQ(surfaceStateAddress->getWidth(), static_cast<uint32_t>(length.surfaceState.width + 1));
EXPECT_EQ(surfaceStateAddress->getHeight(), static_cast<uint32_t>(length.surfaceState.height + 1));
@@ -447,7 +447,7 @@ HWTEST_F(ModuleTest, givenUnalignedHostBufferWhenSurfaceStateProgrammedThenUnali
auto argInfo = kernelImp->getImmutableData()->getDescriptor().payloadMappings.explicitArgs[argIndex].as<NEO::ArgDescPointer>();
auto surfaceStateAddressRaw = ptrOffset(kernelImp->getSurfaceStateHeapData(), argInfo.bindful);
auto surfaceStateAddress = reinterpret_cast<RENDER_SURFACE_STATE *>(const_cast<unsigned char *>(surfaceStateAddressRaw));
SURFACE_STATE_BUFFER_LENGTH length = {0};
SurfaceStateBufferLength length = {0};
length.length = alignUp(static_cast<uint32_t>((mockGa.getUnderlyingBufferSize() + allocationOffset)), alignment) - 1;
EXPECT_EQ(surfaceStateAddress->getWidth(), static_cast<uint32_t>(length.surfaceState.width + 1));
EXPECT_EQ(surfaceStateAddress->getHeight(), static_cast<uint32_t>(length.surfaceState.height + 1));
@@ -2462,7 +2462,7 @@ HWTEST_F(MultiDeviceModuleSetArgBufferTest,
auto argInfo = kernel->getImmutableData()->getDescriptor().payloadMappings.explicitArgs[0].as<NEO::ArgDescPointer>();
auto surfaceStateAddressRaw = ptrOffset(kernel->getSurfaceStateHeapData(), argInfo.bindful);
auto surfaceStateAddress = reinterpret_cast<RENDER_SURFACE_STATE *>(const_cast<unsigned char *>(surfaceStateAddressRaw));
SURFACE_STATE_BUFFER_LENGTH length = {0};
SurfaceStateBufferLength length = {0};
length.length = static_cast<uint32_t>((baseAlloc->getUnderlyingBufferSize() + offsetAlloc->getUnderlyingBufferSize()) - 1);
EXPECT_EQ(surfaceStateAddress->getWidth(), static_cast<uint32_t>(length.surfaceState.width + 1));
EXPECT_EQ(surfaceStateAddress->getHeight(), static_cast<uint32_t>(length.surfaceState.height + 1));
@@ -2534,7 +2534,7 @@ HWTEST_F(MultiDeviceModuleSetArgBufferTest,
auto argInfo = kernel->getImmutableData()->getDescriptor().payloadMappings.explicitArgs[0].as<NEO::ArgDescPointer>();
auto surfaceStateAddressRaw = ptrOffset(kernel->getSurfaceStateHeapData(), argInfo.bindful);
auto surfaceStateAddress = reinterpret_cast<RENDER_SURFACE_STATE *>(const_cast<unsigned char *>(surfaceStateAddressRaw));
SURFACE_STATE_BUFFER_LENGTH length = {0};
SurfaceStateBufferLength length = {0};
length.length = static_cast<uint32_t>(offsetAlloc->getUnderlyingBufferSize() - 1);
EXPECT_EQ(surfaceStateAddress->getWidth(), static_cast<uint32_t>(length.surfaceState.width + 1));
EXPECT_EQ(surfaceStateAddress->getHeight(), static_cast<uint32_t>(length.surfaceState.height + 1));
@@ -2596,7 +2596,7 @@ HWTEST_F(MultiDeviceModuleSetArgBufferTest,
auto argInfo = kernel->getImmutableData()->getDescriptor().payloadMappings.explicitArgs[0].as<NEO::ArgDescPointer>();
auto surfaceStateAddressRaw = ptrOffset(kernel->getSurfaceStateHeapData(), argInfo.bindful);
auto surfaceStateAddress = reinterpret_cast<RENDER_SURFACE_STATE *>(const_cast<unsigned char *>(surfaceStateAddressRaw));
SURFACE_STATE_BUFFER_LENGTH length = {0};
SurfaceStateBufferLength length = {0};
length.length = static_cast<uint32_t>(baseAlloc->getUnderlyingBufferSize() - 1);
EXPECT_EQ(surfaceStateAddress->getWidth(), static_cast<uint32_t>(length.surfaceState.width + 1));
EXPECT_EQ(surfaceStateAddress->getHeight(), static_cast<uint32_t>(length.surfaceState.height + 1));
@@ -2673,7 +2673,7 @@ HWTEST_F(MultiDeviceModuleSetArgBufferTest,
auto argInfo = kernel->getImmutableData()->getDescriptor().payloadMappings.explicitArgs[0].as<NEO::ArgDescPointer>();
auto surfaceStateAddressRaw = ptrOffset(kernel->getSurfaceStateHeapData(), argInfo.bindful);
auto surfaceStateAddress = reinterpret_cast<RENDER_SURFACE_STATE *>(const_cast<unsigned char *>(surfaceStateAddressRaw));
SURFACE_STATE_BUFFER_LENGTH length = {0};
SurfaceStateBufferLength length = {0};
length.length = static_cast<uint32_t>((MemoryConstants::gigaByte * 4) - 1);
EXPECT_EQ(surfaceStateAddress->getWidth(), static_cast<uint32_t>(length.surfaceState.width + 1));
EXPECT_EQ(surfaceStateAddress->getHeight(), static_cast<uint32_t>(length.surfaceState.height + 1));