Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feature(sysman): Win support PMT based getMemoryBandWidth 

Related-To: NEO-10661

Signed-off-by: shubham kumar <shubham.kumar@intel.com>
This commit is contained in:
shubham kumar 2024-06-24 09:12:30 +00:00 committed by Compute-Runtime-Automation
parent 0c019c9f2b
commit 8d80941fff
13 changed files with 222 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.cpp
View File

@ -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<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> 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<uint64_t>(retValu32) * static_cast<uint64_t>(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<std::chrono::steady_clock> ts = std::chrono::steady_clock::now();
pBandwidth->timestamp = std::chrono::duration_cast<std::chrono::microseconds>(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<WddmSysmanImp *>(pOsSysman);
pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
hGetProcPDH = LoadLibrary(L"C:\\Windows\\System32\\pdh.dll");

3
level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.h
View File

@ -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;

4
level_zero/sysman/source/shared/windows/pmt/sysman_pmt.cpp
View File

@ -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;
}

3
level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h
View File

@ -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;
};

3
level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h
View File

@ -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;
};

52
level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.inl
View File

@ -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<gfxProduct>::getPciStats(zes_pci_stats_t *pSta
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
template <PRODUCT_FAMILY gfxProduct>
ze_result_t SysmanProductHelperHw<gfxProduct>::getMemoryBandWidth(zes_mem_bandwidth_t *pBandwidth, WddmSysmanImp *pWddmSysmanImp) {
KmdSysManager *pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
uint32_t retValu32 = 0;
uint64_t retValu64 = 0;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> 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<uint64_t>(retValu32) * static_cast<uint64_t>(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<std::chrono::steady_clock> ts = std::chrono::steady_clock::now();
pBandwidth->timestamp = std::chrono::duration_cast<std::chrono::microseconds>(ts.time_since_epoch()).count();
return ZE_RESULT_SUCCESS;
}
} // namespace Sysman
} // namespace L0

2
level_zero/sysman/source/sysman_const.h
View File

@ -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

96
level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory.h
View File

@ -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<NEO::ExecutionEnvironment &>(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<uint8_t *>(pResponse);
@ -45,85 +60,85 @@ struct MockMemoryKmdSysManager : public MockKmdSysManager {
case KmdSysman::Requests::Memory::NumMemoryDomains: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(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<uint32_t *>(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<uint32_t *>(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<uint64_t *>(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<uint64_t *>(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<uint64_t *>(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<uint64_t *>(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<uint64_t *>(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<uint32_t *>(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<uint32_t *>(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<uint32_t *>(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<uint32_t *>(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<uint32_t *>(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<uint32_t *>(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<MockMemoryKmdSysManager> 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<zes_mem_handle_t> getMemoryHandles(uint32_t count) {
std::vector<zes_mem_handle_t> 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<wchar_t> deviceInterfaceList) : PlatformMonitoringTech(deviceInterfaceList) {}
using PlatformMonitoringTech::keyOffsetMap;
};
struct MockSysmanProductHelperMemory : L0::Sysman::SysmanProductHelperHw<IGFX_UNKNOWN> {
MockSysmanProductHelperMemory() = default;
ADDMETHOD_NOBASE(getMemoryBandWidth, ze_result_t, ZE_RESULT_SUCCESS, (zes_mem_bandwidth_t * pBandwidth, WddmSysmanImp *pWddmSysmanImp));
};
} // namespace ult
} // namespace Sysman
} // namespace L0

74
level_zero/sysman/test/unit_tests/sources/memory/windows/test_zes_memory.cpp
View File

@ -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<MockMemoryKmdSysManager> 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<zes_mem_handle_t> getMemoryHandles(uint32_t count) {
std::vector<zes_mem_handle_t> 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<SysmanProductHelper> pSysmanProductHelper = std::make_unique<MockSysmanProductHelperMemory>();
std::swap(pWddmSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
std::unique_ptr<WddmMemoryImp> pWddmMemoryImp = std::make_unique<WddmMemoryImp>(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

1
level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/CMakeLists.txt
View File

@ -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()

57
level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_memory_tests.cpp Normal file
View File

@ -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<uint64_t>(pKmdSysManager->mockMemoryMaxBandwidth) * mbpsToBytesPerSecond);
EXPECT_EQ(bandwidth.readCounter, pKmdSysManager->mockMemoryCurrentBandwidthRead);
EXPECT_EQ(bandwidth.writeCounter, pKmdSysManager->mockMemoryCurrentBandwidthWrite);
EXPECT_GT(bandwidth.timestamp, 0u);
std::vector<uint32_t> 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

2
level_zero/sysman/test/unit_tests/sources/temperature/windows/test_zes_temperature.cpp
View File

@ -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"

28
level_zero/sysman/test/unit_tests/sources/windows/pmt/test_pmt.cpp
View File

@ -101,20 +101,6 @@ TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint32
EXPECT_NE(0u, val);
}
TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint32WithNullValueReturnedFromIoctlCallThenreadValueFails) {
VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> 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<PublicPlatformMonitoringTech>(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<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> 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<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> 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<PublicPlatformMonitoringTech>(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<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL {
*lpBytesReturned = 0;