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

UM-KM data refactor for Windows

Browse Source 
Signed-off-by: Jaroslaw Chodor <jaroslaw.chodor@intel.com>
This commit is contained in:
Jaroslaw Chodor
2021-05-02 22:41:01 +02:00
committed by Compute-Runtime-Automation
parent dd6653892e
commit 70f8fe1c01
33 changed files with 522 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
shared/test/unit_test/gmm_helper/CMakeLists.txt Normal file
View File

@@ -0,0 +1,12 @@
#
# Copyright (C) 2020-2021 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/gmm_resource_info_tests.cpp
)
add_subdirectories()

75
shared/test/unit_test/gmm_helper/gmm_resource_info_tests.cpp Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/gmm_helper/client_context/gmm_handle_allocator.h"
#include "shared/source/gmm_helper/resource_info.h"
#include "opencl/test/unit_test/mocks/mock_gmm_client_context.h"
#include "opencl/test/unit_test/mocks/mock_gmm_resource_info.h"
#include "opencl/test/unit_test/mocks/mock_hw_helper.h"
#include "test.h"
extern PRODUCT_FAMILY productFamily;
struct MockGmmHandleAllocator : NEO::GmmHandleAllocator {
void *createHandle(const GMM_RESOURCE_INFO *gmmResourceInfo) override {
auto ret = new char;
createdHandles.push_back(ret);
return ret;
}
void destroyHandle(void *handle) override {
destroyedHandles.push_back(reinterpret_cast<char *>(handle));
delete reinterpret_cast<char *>(handle);
}
size_t getHandleSize() override {
return sizeof(char);
}
std::vector<char *> createdHandles;
std::vector<char *> destroyedHandles;
};
TEST(GmmResourceInfo, WhenGmmHandleAllocatorIsPresentThenItsBeingUsedForCreatingGmmResourceInfoHandles) {
NEO::HardwareInfo hwInfo;
hwInfo.platform.eProductFamily = productFamily;
NEO::MockGmmClientContext gmmClientCtx{nullptr, &hwInfo};
gmmClientCtx.setHandleAllocator(std::make_unique<MockGmmHandleAllocator>());
auto handleAllocator = static_cast<MockGmmHandleAllocator *>(gmmClientCtx.getHandleAllocator());
GMM_RESCREATE_PARAMS createParams = {};
createParams.Type = RESOURCE_BUFFER;
createParams.Format = GMM_FORMAT_R8G8B8A8_SINT;
auto resInfo = static_cast<NEO::MockGmmResourceInfo *>(NEO::GmmResourceInfo::create(nullptr, &createParams));
ASSERT_NE(nullptr, resInfo);
resInfo->clientContext = &gmmClientCtx;
resInfo->createResourceInfo(nullptr);
auto &created = handleAllocator->createdHandles;
auto &destroyed = handleAllocator->destroyedHandles;
EXPECT_EQ(1U, created.size());
EXPECT_EQ(0U, destroyed.size());
EXPECT_EQ(handleAllocator->getHandleSize(), resInfo->GmmResourceInfo::peekHandleSize());
auto handle = resInfo->GmmResourceInfo::peekHandle();
EXPECT_NE(nullptr, handle);
EXPECT_NE(created.end(), std::find(created.begin(), created.end(), handle));
delete resInfo;
EXPECT_EQ(1U, created.size());
EXPECT_EQ(1U, destroyed.size());
EXPECT_NE(destroyed.end(), std::find(destroyed.begin(), destroyed.end(), handle));
}
TEST(GmmResourceInfo, WhenUsingBaseHandleAllocatorThenHandlesAreEmpty) {
NEO::GmmHandleAllocator defaultAllocator;
EXPECT_EQ(0U, defaultAllocator.getHandleSize());
auto handle = defaultAllocator.createHandle(nullptr);
EXPECT_EQ(nullptr, handle);
defaultAllocator.destroyHandle(handle);
}

4
shared/test/unit_test/os_interface/windows/CMakeLists.txt
View File

@@ -7,10 +7,12 @@
set(NEO_CORE_OS_INTERFACE_TESTS_WINDOWS
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/adapter_info_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/adapter_info_tests.h
${CMAKE_CURRENT_SOURCE_DIR}/gdi_interface_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/gmm_helper_tests_win.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_gdi_interface.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_gdi_interface.h
${CMAKE_CURRENT_SOURCE_DIR}/um_km_data_translator_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/wddm_preemption_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/wddm_special_heap_test.cpp
${CMAKE_CURRENT_SOURCE_DIR}/wddm_tests.cpp
@@ -23,3 +25,5 @@ if(WIN32)
${NEO_CORE_OS_INTERFACE_TESTS_WINDOWS}
)
endif()
add_subdirectories()

51
shared/test/unit_test/os_interface/windows/adapter_info_tests.cpp
View File

@@ -5,60 +5,11 @@
*
*/
#include "shared/source/os_interface/windows/gdi_interface.h"
#include "shared/source/os_interface/windows/wddm/adapter_info.h"
#include "shared/test/unit_test/os_interface/windows/adapter_info_tests.h"
#include "test.h"
TEST(AdapterInfoTest, whenQueryingForDriverStorePathThenProvidesEnoughMemoryForReturnString) {
static constexpr D3DKMT_HANDLE validHandle = 0x7;
static constexpr auto error = STATUS_SUCCESS + 1;
static const wchar_t *driverStorePathStr = L"some/path/fffff";
struct QueryAdapterInfoMock {
static NTSTATUS(APIENTRY queryadapterinfo)(
const D3DKMT_QUERYADAPTERINFO *queryAdapterInfo) {
EXPECT_NE(nullptr, queryAdapterInfo);
if (nullptr == queryAdapterInfo) {
return error;
}
EXPECT_EQ(validHandle, queryAdapterInfo->hAdapter);
EXPECT_EQ(KMTQAITYPE_QUERYREGISTRY, queryAdapterInfo->Type);
if (KMTQAITYPE_QUERYREGISTRY != queryAdapterInfo->Type) {
return error;
}
EXPECT_NE(nullptr, queryAdapterInfo->pPrivateDriverData);
EXPECT_LE(sizeof(D3DDDI_QUERYREGISTRY_INFO), queryAdapterInfo->PrivateDriverDataSize);
if ((nullptr == queryAdapterInfo->pPrivateDriverData) || (sizeof(D3DDDI_QUERYREGISTRY_INFO) > queryAdapterInfo->PrivateDriverDataSize)) {
return error;
}
D3DDDI_QUERYREGISTRY_INFO *queryRegistryInfo = reinterpret_cast<D3DDDI_QUERYREGISTRY_INFO *>(queryAdapterInfo->pPrivateDriverData);
EXPECT_EQ(D3DDDI_QUERYREGISTRY_DRIVERSTOREPATH, queryRegistryInfo->QueryType);
EXPECT_EQ(0U, queryRegistryInfo->QueryFlags.Value);
bool regValueNameIsEmpty = std::wstring(std::wstring(queryRegistryInfo->ValueName[0], queryRegistryInfo->ValueName[0] + sizeof(queryRegistryInfo->ValueName)).c_str()).empty();
EXPECT_TRUE(regValueNameIsEmpty);
EXPECT_EQ(0U, queryRegistryInfo->ValueType);
EXPECT_EQ(0U, queryRegistryInfo->PhysicalAdapterIndex);
if (D3DDDI_QUERYREGISTRY_DRIVERSTOREPATH != queryRegistryInfo->QueryType) {
return error;
}
queryRegistryInfo->OutputValueSize = static_cast<ULONG>(std::wstring(driverStorePathStr).size() * sizeof(wchar_t));
if (queryAdapterInfo->PrivateDriverDataSize < queryRegistryInfo->OutputValueSize + sizeof(D3DDDI_QUERYREGISTRY_INFO)) {
EXPECT_EQ(sizeof(D3DDDI_QUERYREGISTRY_INFO), queryAdapterInfo->PrivateDriverDataSize);
queryRegistryInfo->Status = D3DDDI_QUERYREGISTRY_STATUS_BUFFER_OVERFLOW;
return STATUS_SUCCESS;
}
memcpy_s(queryRegistryInfo->OutputString, queryAdapterInfo->PrivateDriverDataSize - sizeof(D3DDDI_QUERYREGISTRY_INFO),
driverStorePathStr, queryRegistryInfo->OutputValueSize);
queryRegistryInfo->Status = D3DDDI_QUERYREGISTRY_STATUS_SUCCESS;
return STATUS_SUCCESS;
}
};
NEO::Gdi gdi;
auto handle = validHandle;
gdi.queryAdapterInfo.mFunc = QueryAdapterInfoMock::queryadapterinfo;

62
shared/test/unit_test/os_interface/windows/adapter_info_tests.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/os_interface/windows/gdi_interface.h"
#include "shared/source/os_interface/windows/wddm/adapter_info.h"
static constexpr D3DKMT_HANDLE validHandle = 0x7;
static constexpr auto error = STATUS_SUCCESS + 1;
static const wchar_t *driverStorePathStr = L"some/path/fffff";
struct QueryAdapterInfoMock {
static NTSTATUS(APIENTRY queryadapterinfo)(
const D3DKMT_QUERYADAPTERINFO *queryAdapterInfo) {
if (nullptr == queryAdapterInfo) {
return error;
}
if (KMTQAITYPE_QUERYREGISTRY != queryAdapterInfo->Type) {
return error;
}
if ((nullptr == queryAdapterInfo->pPrivateDriverData) || (sizeof(D3DDDI_QUERYREGISTRY_INFO) > queryAdapterInfo->PrivateDriverDataSize)) {
return error;
}
D3DDDI_QUERYREGISTRY_INFO *queryRegistryInfo = reinterpret_cast<D3DDDI_QUERYREGISTRY_INFO *>(queryAdapterInfo->pPrivateDriverData);
if (D3DDDI_QUERYREGISTRY_DRIVERSTOREPATH != queryRegistryInfo->QueryType) {
return error;
}
if (0U != queryRegistryInfo->QueryFlags.Value) {
return error;
}
bool regValueNameIsEmpty = std::wstring(std::wstring(queryRegistryInfo->ValueName[0], queryRegistryInfo->ValueName[0] + sizeof(queryRegistryInfo->ValueName)).c_str()).empty();
if (false == regValueNameIsEmpty) {
return error;
}
if (0U != queryRegistryInfo->ValueType) {
return error;
}
if (0U != queryRegistryInfo->PhysicalAdapterIndex) {
return error;
}
if (D3DDDI_QUERYREGISTRY_DRIVERSTOREPATH != queryRegistryInfo->QueryType) {
return error;
}
queryRegistryInfo->OutputValueSize = static_cast<ULONG>(std::wstring(driverStorePathStr).size() * sizeof(wchar_t));
if (queryAdapterInfo->PrivateDriverDataSize < queryRegistryInfo->OutputValueSize + sizeof(D3DDDI_QUERYREGISTRY_INFO)) {
queryRegistryInfo->Status = D3DDDI_QUERYREGISTRY_STATUS_BUFFER_OVERFLOW;
return STATUS_SUCCESS;
}
memcpy_s(queryRegistryInfo->OutputString, queryAdapterInfo->PrivateDriverDataSize - sizeof(D3DDDI_QUERYREGISTRY_INFO),
driverStorePathStr, queryRegistryInfo->OutputValueSize);
queryRegistryInfo->Status = D3DDDI_QUERYREGISTRY_STATUS_SUCCESS;
return STATUS_SUCCESS;
}
};

44
shared/test/unit_test/os_interface/windows/um_km_data_translator_tests.cpp Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/os_interface/windows/gdi_interface.h"
#include "shared/source/os_interface/windows/wddm/um_km_data_translator.h"
#include "test.h"
TEST(UmKmDataTranslator, whenCreatingDefaultTranslatorThenTranslationIsDisabled) {
NEO::Gdi gdi;
auto translator = NEO::createUmKmDataTranslator(gdi, 0);
EXPECT_FALSE(translator->enabled());
}
TEST(UmKmDataTranslator, whenUsingDefaultTranslatorThenTranslationIsDisabled) {
NEO::UmKmDataTranslator translator;
EXPECT_FALSE(translator.enabled());
EXPECT_FALSE(translator.createGmmHandleAllocator());
EXPECT_EQ(sizeof(ADAPTER_INFO), translator.getSizeForAdapterInfoInternalRepresentation());
EXPECT_EQ(sizeof(COMMAND_BUFFER_HEADER), translator.getSizeForCommandBufferHeaderDataInternalRepresentation());
EXPECT_EQ(sizeof(CREATECONTEXT_PVTDATA), translator.getSizeForCreateContextDataInternalRepresentation());
ADAPTER_INFO srcAdapterInfo, dstAdapterInfo;
memset(&srcAdapterInfo, 7, sizeof(srcAdapterInfo));
auto ret = translator.translateAdapterInfoFromInternalRepresentation(dstAdapterInfo, &srcAdapterInfo, sizeof(ADAPTER_INFO));
EXPECT_TRUE(ret);
EXPECT_EQ(0, memcmp(&dstAdapterInfo, &srcAdapterInfo, sizeof(ADAPTER_INFO)));
COMMAND_BUFFER_HEADER srcCmdBufferHeader, dstCmdBufferHeader;
memset(&srcCmdBufferHeader, 7, sizeof(srcCmdBufferHeader));
ret = translator.tranlateCommandBufferHeaderDataToInternalRepresentation(&dstCmdBufferHeader, sizeof(COMMAND_BUFFER_HEADER), srcCmdBufferHeader);
EXPECT_TRUE(ret);
EXPECT_EQ(0, memcmp(&dstCmdBufferHeader, &srcCmdBufferHeader, sizeof(COMMAND_BUFFER_HEADER)));
CREATECONTEXT_PVTDATA srcCreateContextPvtData, dstCreateContextPvtData;
memset(&srcCreateContextPvtData, 7, sizeof(srcCreateContextPvtData));
ret = translator.translateCreateContextDataToInternalRepresentation(&dstCreateContextPvtData, sizeof(CREATECONTEXT_PVTDATA), srcCreateContextPvtData);
EXPECT_TRUE(ret);
EXPECT_EQ(0, memcmp(&dstCreateContextPvtData, &srcCreateContextPvtData, sizeof(CREATECONTEXT_PVTDATA)));
}