diff --git a/level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.cpp b/level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.cpp index f3c1e89d82..86aba0d648 100644 --- a/level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.cpp +++ b/level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -9,6 +9,7 @@ #include "shared/source/os_interface/windows/wddm/wddm.h" +#include "level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h" #include "level_zero/sysman/source/shared/windows/sysman_kmd_sys_manager.h" namespace L0 { @@ -177,52 +178,8 @@ ze_result_t WddmMemoryImp::getProperties(zes_mem_properties_t *pProperties) { } ze_result_t WddmMemoryImp::getBandwidth(zes_mem_bandwidth_t *pBandwidth) { - uint32_t retValu32 = 0; - uint64_t retValu64 = 0; - std::vector vRequests = {}; - std::vector vResponses = {}; - KmdSysman::RequestProperty request = {}; - - request.commandId = KmdSysman::Command::Get; - request.componentId = KmdSysman::Component::MemoryComponent; - - request.requestId = KmdSysman::Requests::Memory::MaxBandwidth; - vRequests.push_back(request); - - request.requestId = KmdSysman::Requests::Memory::CurrentBandwidthRead; - vRequests.push_back(request); - - request.requestId = KmdSysman::Requests::Memory::CurrentBandwidthWrite; - vRequests.push_back(request); - - ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses); - - if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) { - return status; - } - - pBandwidth->maxBandwidth = 0; - if (vResponses[0].returnCode == KmdSysman::Success) { - memcpy_s(&retValu32, sizeof(uint32_t), vResponses[0].dataBuffer, sizeof(uint32_t)); - pBandwidth->maxBandwidth = static_cast(retValu32) * static_cast(mbpsToBytesPerSecond); - } - - pBandwidth->readCounter = 0; - if (vResponses[1].returnCode == KmdSysman::Success) { - memcpy_s(&retValu64, sizeof(uint64_t), vResponses[1].dataBuffer, sizeof(uint64_t)); - pBandwidth->readCounter = retValu64; - } - - pBandwidth->writeCounter = 0; - if (vResponses[2].returnCode == KmdSysman::Success) { - memcpy_s(&retValu64, sizeof(uint64_t), vResponses[2].dataBuffer, sizeof(uint64_t)); - pBandwidth->writeCounter = retValu64; - } - - std::chrono::time_point ts = std::chrono::steady_clock::now(); - pBandwidth->timestamp = std::chrono::duration_cast(ts.time_since_epoch()).count(); - - return ZE_RESULT_SUCCESS; + auto pSysmanProductHelper = pWddmSysmanImp->getSysmanProductHelper(); + return pSysmanProductHelper->getMemoryBandWidth(pBandwidth, pWddmSysmanImp); } ze_result_t WddmMemoryImp::getState(zes_mem_state_t *pState) { @@ -269,7 +226,7 @@ ze_result_t WddmMemoryImp::getState(zes_mem_state_t *pState) { } WddmMemoryImp::WddmMemoryImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : isSubdevice(onSubdevice), subdeviceId(subdeviceId) { - WddmSysmanImp *pWddmSysmanImp = static_cast(pOsSysman); + pWddmSysmanImp = static_cast(pOsSysman); pKmdSysManager = &pWddmSysmanImp->getKmdSysManager(); hGetProcPDH = LoadLibrary(L"C:\\Windows\\System32\\pdh.dll"); diff --git a/level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.h b/level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.h index 6fdf820be7..8c8221e882 100644 --- a/level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.h +++ b/level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -35,6 +35,7 @@ class WddmMemoryImp : public OsMemory, NEO::NonCopyableOrMovableClass { protected: KmdSysManager *pKmdSysManager = nullptr; + WddmSysmanImp *pWddmSysmanImp = nullptr; bool isSubdevice = false; uint32_t subdeviceId = 0; diff --git a/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.cpp b/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.cpp index 84a3c7cb08..9581c24783 100644 --- a/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.cpp +++ b/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.cpp @@ -33,7 +33,7 @@ ze_result_t PlatformMonitoringTech::readValue(const std::string &key, uint32_t & auto res = ioctlReadWriteData(deviceInterface, PmtSysman::IoctlPmtGetTelemtryDword, (void *)&readRequest, sizeof(PmtSysman::PmtTelemetryRead), &value, sizeof(uint32_t), &bytesReturned); - if (res == ZE_RESULT_SUCCESS && value != NULL && bytesReturned != 0) { + if (res == ZE_RESULT_SUCCESS && bytesReturned != 0) { return ZE_RESULT_SUCCESS; } @@ -62,7 +62,7 @@ ze_result_t PlatformMonitoringTech::readValue(const std::string &key, uint64_t & auto res = ioctlReadWriteData(deviceInterface, PmtSysman::IoctlPmtGetTelemtryQword, (void *)&readRequest, sizeof(PmtSysman::PmtTelemetryRead), &value, sizeof(uint64_t), &bytesReturned); - if (res == ZE_RESULT_SUCCESS && value != NULL && bytesReturned != 0) { + if (res == ZE_RESULT_SUCCESS && bytesReturned != 0) { return ZE_RESULT_SUCCESS; } diff --git a/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h b/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h index 56d587d591..45f9eb6c93 100644 --- a/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h +++ b/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h @@ -47,6 +47,9 @@ class SysmanProductHelper { // Pci virtual ze_result_t getPciStats(zes_pci_stats_t *pStats, WddmSysmanImp *pWddmSysmanImp) = 0; + // Memory + virtual ze_result_t getMemoryBandWidth(zes_mem_bandwidth_t *pBandwidth, WddmSysmanImp *pWddmSysmanImp) = 0; + protected: SysmanProductHelper() = default; }; diff --git a/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h b/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h index c2c04a5996..f7acab5e9f 100644 --- a/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h +++ b/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h @@ -31,6 +31,9 @@ class SysmanProductHelperHw : public SysmanProductHelper { // Pci ze_result_t getPciStats(zes_pci_stats_t *pStats, WddmSysmanImp *pWddmSysmanImp) override; + // Memory + ze_result_t getMemoryBandWidth(zes_mem_bandwidth_t *pBandwidth, WddmSysmanImp *pWddmSysmanImp) override; + protected: SysmanProductHelperHw() = default; }; diff --git a/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.inl b/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.inl index fea2a755af..57052b2558 100644 --- a/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.inl +++ b/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.inl @@ -7,6 +7,7 @@ #include "level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h" #include "level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h" +#include "level_zero/sysman/source/sysman_const.h" namespace L0 { namespace Sysman { @@ -90,5 +91,56 @@ ze_result_t SysmanProductHelperHw::getPciStats(zes_pci_stats_t *pSta return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } +template +ze_result_t SysmanProductHelperHw::getMemoryBandWidth(zes_mem_bandwidth_t *pBandwidth, WddmSysmanImp *pWddmSysmanImp) { + KmdSysManager *pKmdSysManager = &pWddmSysmanImp->getKmdSysManager(); + uint32_t retValu32 = 0; + uint64_t retValu64 = 0; + std::vector vRequests = {}; + std::vector vResponses = {}; + KmdSysman::RequestProperty request = {}; + + request.commandId = KmdSysman::Command::Get; + request.componentId = KmdSysman::Component::MemoryComponent; + + request.requestId = KmdSysman::Requests::Memory::MaxBandwidth; + vRequests.push_back(request); + + request.requestId = KmdSysman::Requests::Memory::CurrentBandwidthRead; + vRequests.push_back(request); + + request.requestId = KmdSysman::Requests::Memory::CurrentBandwidthWrite; + vRequests.push_back(request); + + ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses); + + if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) { + return status; + } + + pBandwidth->maxBandwidth = 0; + if (vResponses[0].returnCode == KmdSysman::Success) { + memcpy_s(&retValu32, sizeof(uint32_t), vResponses[0].dataBuffer, sizeof(uint32_t)); + pBandwidth->maxBandwidth = static_cast(retValu32) * static_cast(mbpsToBytesPerSecond); + } + + pBandwidth->readCounter = 0; + if (vResponses[1].returnCode == KmdSysman::Success) { + memcpy_s(&retValu64, sizeof(uint64_t), vResponses[1].dataBuffer, sizeof(uint64_t)); + pBandwidth->readCounter = retValu64; + } + + pBandwidth->writeCounter = 0; + if (vResponses[2].returnCode == KmdSysman::Success) { + memcpy_s(&retValu64, sizeof(uint64_t), vResponses[2].dataBuffer, sizeof(uint64_t)); + pBandwidth->writeCounter = retValu64; + } + + std::chrono::time_point ts = std::chrono::steady_clock::now(); + pBandwidth->timestamp = std::chrono::duration_cast(ts.time_since_epoch()).count(); + + return ZE_RESULT_SUCCESS; +} + } // namespace Sysman } // namespace L0 diff --git a/level_zero/sysman/source/sysman_const.h b/level_zero/sysman/source/sysman_const.h index 9a724d6be3..21c5946132 100644 --- a/level_zero/sysman/source/sysman_const.h +++ b/level_zero/sysman/source/sysman_const.h @@ -70,7 +70,7 @@ constexpr uint64_t minTimeoutModeHeartbeat = 5000u; constexpr uint64_t minTimeoutInMicroSeconds = 1000u; constexpr uint16_t milliSecsToMicroSecs = 1000; constexpr uint32_t milliFactor = 1000u; -constexpr uint32_t microFacor = milliFactor * milliFactor; +constexpr uint32_t microFactor = milliFactor * milliFactor; constexpr uint64_t gigaUnitTransferToUnitTransfer = 1000 * 1000 * 1000; constexpr int32_t memoryBusWidth = 128; // bus width in bytes diff --git a/level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory.h b/level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory.h index 315ede4486..5567082163 100644 --- a/level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory.h +++ b/level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -7,15 +7,25 @@ #pragma once +#include "shared/test/common/test_macros/mock_method_macros.h" + #include "level_zero/sysman/source/api/memory/sysman_memory_imp.h" #include "level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.h" +#include "level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h" #include "level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory_manager.h" #include "level_zero/sysman/test/unit_tests/sources/windows/mock_kmd_sys_manager.h" +#include "level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h" namespace L0 { namespace Sysman { namespace ult { +constexpr uint32_t memoryHandleComponentCount = 1u; +constexpr uint32_t mockMemoryMaxBandwidth = 250000; +constexpr uint32_t mockMemoryCurrentBandwidthRead = 3840; +constexpr uint32_t mockMemoryCurrentBandwidthWrite = 2560; +constexpr uint32_t mockMemoryBandwidthTimestamp = 1230000; + struct MockMemoryManagerSysman : public MemoryManagerMock { MockMemoryManagerSysman(NEO::ExecutionEnvironment &executionEnvironment) : MemoryManagerMock(const_cast(executionEnvironment)) {} }; @@ -36,6 +46,11 @@ struct MockMemoryKmdSysManager : public MockKmdSysManager { uint32_t mockMemoryCurrentBandwidthWrite = 664521; uint32_t mockMemoryDomains = 1; uint32_t mockMemoryCurrentTotalAllocableMem = 4294813695; + uint32_t mockMemoryFailure[KmdSysman::Requests::Memory::MaxMemoryRequests] = {0}; + + uint32_t getReturnCode(uint32_t memoryRequestCode) { + return mockMemoryFailure[memoryRequestCode] ? KmdSysman::KmdSysmanFail : KmdSysman::KmdSysmanSuccess; + } void getMemoryProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override { uint8_t *pBuffer = reinterpret_cast(pResponse); @@ -45,85 +60,85 @@ struct MockMemoryKmdSysManager : public MockKmdSysManager { case KmdSysman::Requests::Memory::NumMemoryDomains: { uint32_t *pValue = reinterpret_cast(pBuffer); *pValue = mockMemoryDomains; - pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outReturnCode = getReturnCode(pRequest->inRequestId); pResponse->outDataSize = sizeof(uint32_t); } break; case KmdSysman::Requests::Memory::MemoryType: { uint32_t *pValue = reinterpret_cast(pBuffer); *pValue = mockMemoryType; - pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outReturnCode = getReturnCode(pRequest->inRequestId); pResponse->outDataSize = sizeof(uint32_t); } break; case KmdSysman::Requests::Memory::MemoryLocation: { uint32_t *pValue = reinterpret_cast(pBuffer); *pValue = mockMemoryLocation; - pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outReturnCode = getReturnCode(pRequest->inRequestId); pResponse->outDataSize = sizeof(uint32_t); } break; case KmdSysman::Requests::Memory::PhysicalSize: { uint64_t *pValue = reinterpret_cast(pBuffer); *pValue = mockMemoryPhysicalSize; - pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outReturnCode = getReturnCode(pRequest->inRequestId); pResponse->outDataSize = sizeof(uint64_t); } break; case KmdSysman::Requests::Memory::StolenSize: { uint64_t *pValue = reinterpret_cast(pBuffer); *pValue = mockMemoryStolen; - pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outReturnCode = getReturnCode(pRequest->inRequestId); pResponse->outDataSize = sizeof(uint64_t); } break; case KmdSysman::Requests::Memory::SystemSize: { uint64_t *pValue = reinterpret_cast(pBuffer); *pValue = mockMemorySystem; - pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outReturnCode = getReturnCode(pRequest->inRequestId); pResponse->outDataSize = sizeof(uint64_t); } break; case KmdSysman::Requests::Memory::DedicatedSize: { uint64_t *pValue = reinterpret_cast(pBuffer); *pValue = mockMemoryDedicated; - pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outReturnCode = getReturnCode(pRequest->inRequestId); pResponse->outDataSize = sizeof(uint64_t); } break; case KmdSysman::Requests::Memory::CurrentFreeMemorySize: { uint64_t *pValue = reinterpret_cast(pBuffer); *pValue = mockMemoryFree; - pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outReturnCode = getReturnCode(pRequest->inRequestId); pResponse->outDataSize = sizeof(uint64_t); } break; case KmdSysman::Requests::Memory::MemoryWidth: { uint32_t *pValue = reinterpret_cast(pBuffer); *pValue = mockMemoryBus; - pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outReturnCode = getReturnCode(pRequest->inRequestId); pResponse->outDataSize = sizeof(uint32_t); } break; case KmdSysman::Requests::Memory::NumChannels: { uint32_t *pValue = reinterpret_cast(pBuffer); *pValue = mockMemoryChannels; - pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outReturnCode = getReturnCode(pRequest->inRequestId); pResponse->outDataSize = sizeof(uint32_t); } break; case KmdSysman::Requests::Memory::MaxBandwidth: { uint32_t *pValue = reinterpret_cast(pBuffer); *pValue = mockMemoryMaxBandwidth; - pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outReturnCode = getReturnCode(pRequest->inRequestId); pResponse->outDataSize = sizeof(uint32_t); } break; case KmdSysman::Requests::Memory::CurrentBandwidthRead: { uint32_t *pValue = reinterpret_cast(pBuffer); *pValue = mockMemoryCurrentBandwidthRead; - pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outReturnCode = getReturnCode(pRequest->inRequestId); pResponse->outDataSize = sizeof(uint32_t); } break; case KmdSysman::Requests::Memory::CurrentBandwidthWrite: { uint32_t *pValue = reinterpret_cast(pBuffer); *pValue = mockMemoryCurrentBandwidthWrite; - pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outReturnCode = getReturnCode(pRequest->inRequestId); pResponse->outDataSize = sizeof(uint32_t); } break; case KmdSysman::Requests::Memory::CurrentTotalAllocableMem: { uint32_t *pValue = reinterpret_cast(pBuffer); *pValue = mockMemoryCurrentTotalAllocableMem; - pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outReturnCode = getReturnCode(pRequest->inRequestId); pResponse->outDataSize = sizeof(uint32_t); } break; default: { @@ -139,11 +154,62 @@ struct MockMemoryKmdSysManager : public MockKmdSysManager { } }; +class SysmanDeviceMemoryFixture : public SysmanDeviceFixture { + protected: + std::unique_ptr pKmdSysManager; + L0::Sysman::KmdSysManager *pOriginalKmdSysManager = nullptr; + + void SetUp() override { + SysmanDeviceFixture::SetUp(); + + pKmdSysManager.reset(new MockMemoryKmdSysManager); + + pKmdSysManager->allowSetCalls = true; + + pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager; + pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get(); + + pSysmanDeviceImp->pMemoryHandleContext->handleList.clear(); + + getMemoryHandles(0); + } + + void TearDown() override { + pWddmSysmanImp->pKmdSysManager = pOriginalKmdSysManager; + SysmanDeviceFixture::TearDown(); + } + + void setLocalSupportedAndReinit(bool supported) { + pMemoryManager->localMemorySupported[0] = supported; + pSysmanDeviceImp->pMemoryHandleContext->handleList.clear(); + pSysmanDeviceImp->pMemoryHandleContext->init(pOsSysman->getSubDeviceCount()); + } + + std::vector getMemoryHandles(uint32_t count) { + std::vector handles(count, nullptr); + EXPECT_EQ(zesDeviceEnumMemoryModules(pSysmanDevice->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS); + return handles; + } + + MockMemoryManagerSysman *pMemoryManager = nullptr; +}; + class PublicWddmPowerImp : public L0::Sysman::WddmMemoryImp { public: using WddmMemoryImp::pKmdSysManager; }; +class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech { + public: + PublicPlatformMonitoringTech(std::vector deviceInterfaceList) : PlatformMonitoringTech(deviceInterfaceList) {} + using PlatformMonitoringTech::keyOffsetMap; +}; + +struct MockSysmanProductHelperMemory : L0::Sysman::SysmanProductHelperHw { + MockSysmanProductHelperMemory() = default; + ADDMETHOD_NOBASE(getMemoryBandWidth, ze_result_t, ZE_RESULT_SUCCESS, (zes_mem_bandwidth_t * pBandwidth, WddmSysmanImp *pWddmSysmanImp)); +}; + } // namespace ult } // namespace Sysman } // namespace L0 diff --git a/level_zero/sysman/test/unit_tests/sources/memory/windows/test_zes_memory.cpp b/level_zero/sysman/test/unit_tests/sources/memory/windows/test_zes_memory.cpp index c566faf23e..25c784e065 100644 --- a/level_zero/sysman/test/unit_tests/sources/memory/windows/test_zes_memory.cpp +++ b/level_zero/sysman/test/unit_tests/sources/memory/windows/test_zes_memory.cpp @@ -1,59 +1,16 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * */ -#include "level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.h" #include "level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory.h" -#include "level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h" namespace L0 { namespace Sysman { namespace ult { -constexpr uint32_t memoryHandleComponentCount = 1u; -class SysmanDeviceMemoryFixture : public SysmanDeviceFixture { - protected: - std::unique_ptr pKmdSysManager; - L0::Sysman::KmdSysManager *pOriginalKmdSysManager = nullptr; - - void SetUp() override { - SysmanDeviceFixture::SetUp(); - - pKmdSysManager.reset(new MockMemoryKmdSysManager); - - pKmdSysManager->allowSetCalls = true; - - pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager; - pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get(); - - pSysmanDeviceImp->pMemoryHandleContext->handleList.clear(); - - getMemoryHandles(0); - } - - void TearDown() override { - pWddmSysmanImp->pKmdSysManager = pOriginalKmdSysManager; - SysmanDeviceFixture::TearDown(); - } - - void setLocalSupportedAndReinit(bool supported) { - pMemoryManager->localMemorySupported[0] = supported; - pSysmanDeviceImp->pMemoryHandleContext->handleList.clear(); - pSysmanDeviceImp->pMemoryHandleContext->init(pOsSysman->getSubDeviceCount()); - } - - std::vector getMemoryHandles(uint32_t count) { - std::vector handles(count, nullptr); - EXPECT_EQ(zesDeviceEnumMemoryModules(pSysmanDevice->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS); - return handles; - } - - MockMemoryManagerSysman *pMemoryManager = nullptr; -}; - TEST_F(SysmanDeviceMemoryFixture, DISABLED_GivenComponentCountZeroWhenEnumeratingMemoryModulesWithLocalMemorySupportThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) { setLocalSupportedAndReinit(true); @@ -149,21 +106,20 @@ TEST_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenGettingStateThenCall } } -TEST_F(SysmanDeviceMemoryFixture, DISABLED_GivenValidMemoryHandleWhenGettingBandwidthThenCallSucceeds) { - setLocalSupportedAndReinit(true); - auto handles = getMemoryHandles(memoryHandleComponentCount); - - for (auto handle : handles) { - zes_mem_bandwidth_t bandwidth; - - ze_result_t result = zesMemoryGetBandwidth(handle, &bandwidth); - - EXPECT_EQ(result, ZE_RESULT_SUCCESS); - EXPECT_EQ(bandwidth.maxBandwidth, pKmdSysManager->mockMemoryMaxBandwidth * mbpsToBytesPerSecond); - EXPECT_EQ(bandwidth.readCounter, pKmdSysManager->mockMemoryCurrentBandwidthRead); - EXPECT_EQ(bandwidth.writeCounter, pKmdSysManager->mockMemoryCurrentBandwidthWrite); - EXPECT_GT(bandwidth.timestamp, 0u); - } +TEST_F(SysmanDeviceMemoryFixture, GivenValidOsMemoryObjectWhenGettingMemoryBandWidthThenCallSucceeds) { + std::unique_ptr pSysmanProductHelper = std::make_unique(); + std::swap(pWddmSysmanImp->pSysmanProductHelper, pSysmanProductHelper); + std::unique_ptr pWddmMemoryImp = std::make_unique(pOsSysman, false, 0); + zes_mem_bandwidth_t mockedBandwidth = { + mockMemoryCurrentBandwidthRead, + mockMemoryCurrentBandwidthWrite, + mockMemoryMaxBandwidth, mockMemoryBandwidthTimestamp}; + zes_mem_bandwidth_t bandwidth = mockedBandwidth; + EXPECT_EQ(ZE_RESULT_SUCCESS, pWddmMemoryImp->getBandwidth(&bandwidth)); + EXPECT_EQ(mockMemoryCurrentBandwidthRead, bandwidth.readCounter); + EXPECT_EQ(mockMemoryCurrentBandwidthWrite, bandwidth.writeCounter); + EXPECT_EQ(mockMemoryMaxBandwidth, bandwidth.maxBandwidth); + EXPECT_EQ(mockMemoryBandwidthTimestamp, bandwidth.timestamp); } } // namespace ult diff --git a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/CMakeLists.txt b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/CMakeLists.txt index b4a40d87e8..5a0f597ade 100644 --- a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/CMakeLists.txt +++ b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/CMakeLists.txt @@ -9,6 +9,7 @@ if(WIN32) ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_temperature_tests.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_memory_tests.cpp ) endif() add_subdirectories() \ No newline at end of file diff --git a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_memory_tests.cpp b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_memory_tests.cpp new file mode 100644 index 0000000000..96ce357019 --- /dev/null +++ b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_memory_tests.cpp @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/test/common/test_macros/hw_test.h" + +#include "level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.h" +#include "level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory.h" +#include "level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h" + +namespace L0 { +namespace Sysman { +namespace ult { + +using SysmanProductHelperMemoryFixture = SysmanDeviceMemoryFixture; + +HWTEST2_F(SysmanProductHelperMemoryFixture, GivenValidMemoryHandleWhenGettingBandwidthThenCallSucceeds, IsAtMostDg2) { + auto handles = getMemoryHandles(memoryHandleComponentCount); + + for (auto handle : handles) { + zes_mem_bandwidth_t bandwidth; + + ze_result_t result = zesMemoryGetBandwidth(handle, &bandwidth); + + EXPECT_EQ(result, ZE_RESULT_SUCCESS); + EXPECT_EQ(bandwidth.maxBandwidth, static_cast(pKmdSysManager->mockMemoryMaxBandwidth) * mbpsToBytesPerSecond); + EXPECT_EQ(bandwidth.readCounter, pKmdSysManager->mockMemoryCurrentBandwidthRead); + EXPECT_EQ(bandwidth.writeCounter, pKmdSysManager->mockMemoryCurrentBandwidthWrite); + EXPECT_GT(bandwidth.timestamp, 0u); + + std::vector requestId = {KmdSysman::Requests::Memory::MaxBandwidth, KmdSysman::Requests::Memory::CurrentBandwidthRead, KmdSysman::Requests::Memory::CurrentBandwidthWrite}; + for (auto it = requestId.begin(); it != requestId.end(); it++) { + pKmdSysManager->mockMemoryFailure[*it] = 1; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesMemoryGetBandwidth(handle, &bandwidth)); + pKmdSysManager->mockMemoryFailure[*it] = 0; + } + } +} + +HWTEST2_F(SysmanProductHelperMemoryFixture, GivenValidMemoryHandleWhenGettingBandwidthCoverningNegativePathsThenCallFails, IsAtMostDg2) { + auto handles = getMemoryHandles(memoryHandleComponentCount); + + for (auto handle : handles) { + zes_mem_bandwidth_t bandwidth; + + pKmdSysManager->mockRequestMultiple = true; + EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, zesMemoryGetBandwidth(handle, &bandwidth)); + pKmdSysManager->mockRequestMultiple = false; + } +} + +} // namespace ult +} // namespace Sysman +} // namespace L0 diff --git a/level_zero/sysman/test/unit_tests/sources/temperature/windows/test_zes_temperature.cpp b/level_zero/sysman/test/unit_tests/sources/temperature/windows/test_zes_temperature.cpp index c8dceaaf5c..bf83749711 100644 --- a/level_zero/sysman/test/unit_tests/sources/temperature/windows/test_zes_temperature.cpp +++ b/level_zero/sysman/test/unit_tests/sources/temperature/windows/test_zes_temperature.cpp @@ -5,8 +5,6 @@ * */ -#include "shared/test/common/test_macros/hw_test.h" - #include "level_zero/sysman/source/api/temperature/windows/sysman_os_temperature_imp.h" #include "level_zero/sysman/test/unit_tests/sources/temperature/windows/mock_temperature.h" #include "level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h" diff --git a/level_zero/sysman/test/unit_tests/sources/windows/pmt/test_pmt.cpp b/level_zero/sysman/test/unit_tests/sources/windows/pmt/test_pmt.cpp index 19a154273c..c62a6b6d7f 100644 --- a/level_zero/sysman/test/unit_tests/sources/windows/pmt/test_pmt.cpp +++ b/level_zero/sysman/test/unit_tests/sources/windows/pmt/test_pmt.cpp @@ -101,20 +101,6 @@ TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint32 EXPECT_NE(0u, val); } -TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint32WithNullValueReturnedFromIoctlCallThenreadValueFails) { - VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL { - *lpBytesReturned = 4; - *(int *)lpOutBuffer = 0; - return true; - }); - pPmt = std::make_unique(deviceInterface); - pPmt->pcreateFile = mockCreateFileSuccess; - - uint32_t val = 0; - pPmt->keyOffsetMap = dummyKeyOffsetMap; - EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val)); -} - TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint32WithNullBytesCountReturnedFromIoctlCallThenreadValueFails) { VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL { *lpBytesReturned = 0; @@ -129,20 +115,6 @@ TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint32 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val)); } -TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint64WithNullValueReturnedFromIoctlCallThenreadValueFails) { - VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL { - *lpBytesReturned = 4; - *(int *)lpOutBuffer = 0; - return true; - }); - pPmt = std::make_unique(deviceInterface); - pPmt->pcreateFile = mockCreateFileSuccess; - - uint64_t val = 0; - pPmt->keyOffsetMap = dummyKeyOffsetMap; - EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val)); -} - TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint64WithNullBytesCountReturnedFromIoctlCallThenreadValueFails) { VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL { *lpBytesReturned = 0;