intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-29 17:13:29 +08:00
Code Issues Packages Projects Releases Wiki Activity

test: add test prelim mock drm class

Browse Source 
Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>
This commit is contained in:
Zbigniew Zdanowicz
2023-05-11 13:54:50 +00:00
committed by Compute-Runtime-Automation
parent d7c7ea7948
commit e5e39ce8f4
3 changed files with 364 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
shared/test/common/os_interface/linux/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
#
# Copyright (C) 2021-2022 Intel Corporation
# Copyright (C) 2021-2023 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@@ -19,6 +19,8 @@ if(UNIX)
${CMAKE_CURRENT_SOURCE_DIR}/device_command_stream_fixture_context.h
${CMAKE_CURRENT_SOURCE_DIR}/device_command_stream_fixture_prelim.h
${CMAKE_CURRENT_SOURCE_DIR}/drm_memory_manager_prelim_fixtures.h
${CMAKE_CURRENT_SOURCE_DIR}/drm_mock_extended.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_mock_extended.h
)
endif()
endif()

277
shared/test/common/os_interface/linux/drm_mock_extended.cpp Normal file
View File

@@ -0,0 +1,277 @@
/*
* Copyright (C) 2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/common/os_interface/linux/drm_mock_extended.h"
#include "shared/test/common/libult/linux/drm_mock_helper.h"
DrmMockExtended::DrmMockExtended(RootDeviceEnvironment &rootDeviceEnvironmentIn, const HardwareInfo *inputHwInfo) : DrmMock(rootDeviceEnvironmentIn) {
rootDeviceEnvironment.setHwInfoAndInitHelpers(inputHwInfo);
EXPECT_TRUE(queryMemoryInfo());
EXPECT_EQ(3u, ioctlCallsCount);
ioctlCallsCount = 0;
}
int DrmMockExtended::handleRemainingRequests(DrmIoctl request, void *arg) {
if ((request == DrmIoctl::Query) && (arg != nullptr)) {
if (i915QuerySuccessCount == 0) {
return EINVAL;
}
i915QuerySuccessCount--;
auto query = static_cast<Query *>(arg);
if (query->itemsPtr == 0) {
return EINVAL;
}
for (auto i = 0u; i < query->numItems; i++) {
if (!handleQueryItem(reinterpret_cast<QueryItem *>(query->itemsPtr) + i)) {
return EINVAL;
}
}
return 0;
} else if (request == DrmIoctl::GemContextSetparam && arg != nullptr && receivedContextParamRequest.param == I915_CONTEXT_PARAM_ENGINES) {
EXPECT_LE(receivedContextParamRequest.size, sizeof(receivedContextParamEngines));
memcpy(&receivedContextParamEngines, reinterpret_cast<const void *>(receivedContextParamRequest.value), receivedContextParamRequest.size);
auto srcBalancer = reinterpret_cast<const i915_context_engines_load_balance *>(receivedContextParamEngines.extensions);
if (srcBalancer) {
EXPECT_EQ(static_cast<__u32>(I915_CONTEXT_ENGINES_EXT_LOAD_BALANCE), srcBalancer->base.name);
auto balancerSize = ptrDiff(srcBalancer->engines + srcBalancer->num_siblings, srcBalancer);
EXPECT_LE(balancerSize, sizeof(receivedContextEnginesLoadBalance));
memcpy(&receivedContextEnginesLoadBalance, srcBalancer, balancerSize);
}
return this->storedRetValForSetParamEngines;
} else if (request == DrmIoctl::GemContextSetparam && arg != nullptr && receivedContextParamRequest.param == PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAGS) {
if (!this->contextDebugSupported) {
return EINVAL;
} else {
return 0;
}
} else if (request == DrmIoctl::GemContextGetparam && arg != nullptr) {
auto argIn = static_cast<GemContextParam *>(arg);
if (argIn->param == PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAGS) {
if (this->contextDebugSupported) {
argIn->value = PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAG_SIP << 32;
} else {
argIn->value = 0;
}
return 0;
}
} else if (request == DrmIoctl::GemCreateExt) {
auto createExtParams = static_cast<prelim_drm_i915_gem_create_ext *>(arg);
if (createExtParams->size == 0) {
return EINVAL;
}
this->createExt.size = createExtParams->size;
this->createExt.handle = createExtParams->handle = 1u;
auto extensions = reinterpret_cast<prelim_drm_i915_gem_create_ext_setparam *>(createExtParams->extensions);
if (extensions == nullptr) {
return EINVAL;
}
this->setparamRegion = *extensions;
if (this->setparamRegion.base.name != PRELIM_I915_GEM_CREATE_EXT_SETPARAM) {
return EINVAL;
}
if ((this->setparamRegion.param.size == 0) ||
(this->setparamRegion.param.param != (PRELIM_I915_OBJECT_PARAM | PRELIM_I915_PARAM_MEMORY_REGIONS))) {
return EINVAL;
}
if (setparamRegion.base.next_extension != 0) {
auto vmPrivate = reinterpret_cast<prelim_drm_i915_gem_create_ext_vm_private *>(setparamRegion.base.next_extension);
if (vmPrivate->base.name != PRELIM_I915_GEM_CREATE_EXT_VM_PRIVATE) {
return EINVAL;
}
}
auto data = reinterpret_cast<MemoryClassInstance *>(this->setparamRegion.param.data);
if (data == nullptr) {
return EINVAL;
}
this->memRegions = *data;
if (this->setparamRegion.param.size > 1) {
this->allMemRegions.clear();
for (uint32_t i = 0; i < this->setparamRegion.param.size; i++) {
this->allMemRegions.push_back(data[i]);
}
}
if ((this->memRegions.memoryClass != prelim_drm_i915_gem_memory_class::PRELIM_I915_MEMORY_CLASS_SYSTEM) && (this->memRegions.memoryClass != prelim_drm_i915_gem_memory_class::PRELIM_I915_MEMORY_CLASS_DEVICE)) {
return EINVAL;
}
return gemCreateExtRetVal;
} else if (request == DrmIoctl::GemMmapOffset) {
auto mmapArg = static_cast<GemMmapOffset *>(arg);
mmapArg->offset = 0;
return mmapOffsetRetVal;
} else if (request == DrmIoctl::GemClosReserve && (arg != nullptr)) {
auto closReserveArg = static_cast<prelim_drm_i915_gem_clos_reserve *>(arg);
this->closIndex++;
if (closIndex == 0) {
return EINVAL;
}
closReserveArg->clos_index = closIndex;
return 0;
} else if (request == DrmIoctl::GemClosFree && (arg != nullptr)) {
auto closFreeArg = static_cast<prelim_drm_i915_gem_clos_free *>(arg);
if (closFreeArg->clos_index > closIndex) {
return EINVAL;
}
this->closIndex--;
return 0;
} else if (request == DrmIoctl::GemCacheReserve && (arg != nullptr)) {
auto cacheReserveArg = static_cast<prelim_drm_i915_gem_cache_reserve *>(arg);
if (cacheReserveArg->clos_index > closIndex) {
return EINVAL;
}
auto cacheInfo = this->getCacheInfo();
auto maxReservationNumWays = cacheInfo ? cacheInfo->getMaxReservationNumWays() : maxNumWays;
if (cacheReserveArg->num_ways > maxReservationNumWays) {
return EINVAL;
}
auto freeNumWays = maxReservationNumWays - this->allocNumWays;
if (cacheReserveArg->num_ways > freeNumWays) {
return EINVAL;
}
this->allocNumWays += cacheReserveArg->num_ways;
return 0;
} else if ((request == DrmIoctl::DebuggerOpen) && (arg != nullptr)) {
auto debuggerOpen = reinterpret_cast<prelim_drm_i915_debugger_open_param *>(arg);
inputDebuggerOpen = *debuggerOpen;
return debuggerOpenRetval;
} else if ((request == DrmIoctl::GemVmAdvise) && (arg != nullptr)) {
auto vmAdvise = reinterpret_cast<prelim_drm_i915_gem_vm_advise *>(arg);
vmAdviseCalled = true;
vmAdviseFlags = vmAdvise->attribute;
vmAdviseHandle = vmAdvise->handle;
vmAdviseRegion = *reinterpret_cast<MemoryClassInstance *>(&vmAdvise->region);
return vmAdviseRetValue;
}
return DrmMock::handleRemainingRequests(request, arg);
}
bool DrmMockExtended::handleQueryItem(QueryItem *queryItem) {
auto hwInfo = rootDeviceEnvironment.getHardwareInfo();
auto &gtSystemInfo = hwInfo->gtSystemInfo;
switch (queryItem->queryId) {
case DRM_I915_QUERY_MEMORY_REGIONS: {
auto numberOfLocalMemories = gtSystemInfo.MultiTileArchInfo.IsValid ? gtSystemInfo.MultiTileArchInfo.TileCount : 0u;
auto numberOfRegions = 1u + numberOfLocalMemories;
int regionInfoSize = sizeof(drm_i915_query_memory_regions) + numberOfRegions * sizeof(drm_i915_memory_region_info);
if (queryItem->length == 0) {
queryItem->length = regionInfoSize;
} else {
EXPECT_EQ(regionInfoSize, queryItem->length);
auto queryMemoryRegionInfo = reinterpret_cast<drm_i915_query_memory_regions *>(queryItem->dataPtr);
EXPECT_EQ(0u, queryMemoryRegionInfo->num_regions);
queryMemoryRegionInfo->num_regions = numberOfRegions;
queryMemoryRegionInfo->regions[0].region.memory_class = prelim_drm_i915_gem_memory_class::PRELIM_I915_MEMORY_CLASS_SYSTEM;
queryMemoryRegionInfo->regions[0].region.memory_instance = 1;
queryMemoryRegionInfo->regions[0].probed_size = 2 * MemoryConstants::gigaByte;
for (auto tile = 0u; tile < numberOfLocalMemories; tile++) {
queryMemoryRegionInfo->regions[1 + tile].region.memory_class = prelim_drm_i915_gem_memory_class::PRELIM_I915_MEMORY_CLASS_DEVICE;
queryMemoryRegionInfo->regions[1 + tile].region.memory_instance = DrmMockHelper::getEngineOrMemoryInstanceValue(tile, 0);
queryMemoryRegionInfo->regions[1 + tile].probed_size = 2 * MemoryConstants::gigaByte;
}
}
break;
}
case PRELIM_DRM_I915_QUERY_DISTANCE_INFO:
if (failQueryDistanceInfo) {
queryItem->length = -EINVAL;
} else {
auto queryDistanceInfo = reinterpret_cast<prelim_drm_i915_query_distance_info *>(queryItem->dataPtr);
switch (queryDistanceInfo->region.memory_class) {
case prelim_drm_i915_gem_memory_class::PRELIM_I915_MEMORY_CLASS_SYSTEM:
EXPECT_EQ(sizeof(prelim_drm_i915_query_distance_info), static_cast<size_t>(queryItem->length));
queryDistanceInfo->distance = -1;
break;
case prelim_drm_i915_gem_memory_class::PRELIM_I915_MEMORY_CLASS_DEVICE: {
EXPECT_EQ(sizeof(prelim_drm_i915_query_distance_info), static_cast<size_t>(queryItem->length));
auto engineTile = DrmMockHelper::getTileFromEngineOrMemoryInstance(queryDistanceInfo->engine.engine_instance);
auto memoryTile = DrmMockHelper::getTileFromEngineOrMemoryInstance(queryDistanceInfo->region.memory_instance);
queryDistanceInfo->distance = (memoryTile == engineTile) ? 0 : 100;
break;
}
default:
queryItem->length = -EINVAL;
break;
}
}
break;
case PRELIM_DRM_I915_QUERY_HWCONFIG_TABLE: {
int deviceBlobSize = sizeof(dummyDeviceBlobData);
if (queryItem->length == 0) {
queryItem->length = deviceBlobSize;
} else {
EXPECT_EQ(deviceBlobSize, queryItem->length);
auto deviceBlobData = reinterpret_cast<uint32_t *>(queryItem->dataPtr);
memcpy(deviceBlobData, &dummyDeviceBlobData, deviceBlobSize);
}
} break;
case PRELIM_DRM_I915_QUERY_COMPUTE_SUBSLICES: {
auto maxEuPerSubslice = rootDeviceEnvironment.getHardwareInfo()->gtSystemInfo.MaxEuPerSubSlice;
auto maxSlices = rootDeviceEnvironment.getHardwareInfo()->gtSystemInfo.MaxSlicesSupported;
auto maxSubslices = rootDeviceEnvironment.getHardwareInfo()->gtSystemInfo.MaxSubSlicesSupported / maxSlices;
auto threadsPerEu = rootDeviceEnvironment.getHardwareInfo()->gtSystemInfo.ThreadCount / rootDeviceEnvironment.getHardwareInfo()->gtSystemInfo.EUCount;
auto realEuCount = threadsPerEu * maxEuPerSubslice * maxSubslices * maxSlices;
auto dataSize = static_cast<size_t>(std::ceil(realEuCount / 8.0)) + maxSlices * static_cast<uint16_t>(std::ceil(maxSubslices / 8.0)) +
static_cast<uint16_t>(std::ceil(maxSlices / 8.0));
if (queryItem->length == 0) {
queryItem->length = static_cast<int32_t>(sizeof(QueryTopologyInfo) + dataSize);
break;
} else {
auto topologyArg = reinterpret_cast<QueryTopologyInfo *>(queryItem->dataPtr);
if (this->failRetTopology) {
return false;
}
topologyArg->maxSlices = maxSlices;
topologyArg->maxSubslices = maxSubslices;
topologyArg->maxEusPerSubslice = maxEuPerSubslice;
topologyArg->subsliceStride = static_cast<uint16_t>(std::ceil(maxSubslices / 8.0));
topologyArg->euStride = static_cast<uint16_t>(std::ceil(maxEuPerSubslice / 8.0));
topologyArg->subsliceOffset = static_cast<uint16_t>(std::ceil(maxSlices / 8.0));
topologyArg->euOffset = static_cast<uint16_t>(std::ceil(maxSubslices / 8.0)) * maxSlices;
int threadData = (threadsPerEu == 8) ? 0xff : 0x7f;
uint8_t *data = topologyArg->data;
for (uint32_t sliceId = 0; sliceId < maxSlices; sliceId++) {
data[0] |= 1 << (sliceId % 8);
if (sliceId == 7 || sliceId == maxSlices - 1) {
data++;
}
}
DEBUG_BREAK_IF(ptrDiff(data, topologyArg->data) != topologyArg->subsliceOffset);
data = ptrOffset(topologyArg->data, topologyArg->subsliceOffset);
for (uint32_t sliceId = 0; sliceId < maxSlices; sliceId++) {
for (uint32_t i = 0; i < maxSubslices; i++) {
data[0] |= 1 << (i % 8);
if (i == 7 || i == maxSubslices - 1) {
data++;
}
}
}
DEBUG_BREAK_IF(ptrDiff(data, topologyArg->data) != topologyArg->euOffset);
auto size = dataSize - topologyArg->euOffset;
memset(ptrOffset(topologyArg->data, topologyArg->euOffset), threadData, size);
}
} break;
default:
queryItem->length = -EINVAL;
break;
}
return true;
}

84
shared/test/common/os_interface/linux/drm_mock_extended.h Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright (C) 2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/helpers/hw_info.h"
#include "shared/source/helpers/ptr_math.h"
#include "shared/source/os_interface/linux/cache_info.h"
#include "shared/source/os_interface/linux/i915_prelim.h"
#include "shared/source/os_interface/linux/memory_info.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/libult/linux/drm_mock.h"
#include "shared/test/common/os_interface/linux/drm_mock_device_blob.h"
#include <array>
using namespace NEO;
class DrmMockExtended : public DrmMock {
public:
using Drm::cacheInfo;
using Drm::engineInfo;
using Drm::memoryInfo;
using Drm::pageFaultSupported;
using Drm::rootDeviceEnvironment;
using DrmMock::DrmMock;
DrmMockExtended(RootDeviceEnvironment &rootDeviceEnvironment) : DrmMockExtended(rootDeviceEnvironment, defaultHwInfo.get()) {}
DrmMockExtended(RootDeviceEnvironment &rootDeviceEnvironmentIn, const HardwareInfo *inputHwInfo);
int handleRemainingRequests(DrmIoctl request, void *arg) override;
static constexpr uint32_t maxEngineCount = 9u;
ContextEnginesLoadBalance<maxEngineCount> receivedContextEnginesLoadBalance{};
ContextParamEngines<1 + maxEngineCount> receivedContextParamEngines{};
int storedRetValForSetParamEngines = 0;
uint16_t closIndex = 0;
uint16_t maxNumWays = 32;
uint32_t allocNumWays = 0;
uint32_t i915QuerySuccessCount = std::numeric_limits<uint32_t>::max();
BcsInfoMask supportedCopyEnginesMask = 1;
std::array<uint64_t, 9> copyEnginesCapsMap = {{PRELIM_I915_COPY_CLASS_CAP_SATURATE_LMEM,
PRELIM_I915_COPY_CLASS_CAP_SATURATE_PCIE,
PRELIM_I915_COPY_CLASS_CAP_SATURATE_PCIE,
PRELIM_I915_COPY_CLASS_CAP_SATURATE_LINK,
PRELIM_I915_COPY_CLASS_CAP_SATURATE_LINK,
PRELIM_I915_COPY_CLASS_CAP_SATURATE_LINK,
PRELIM_I915_COPY_CLASS_CAP_SATURATE_LINK,
PRELIM_I915_COPY_CLASS_CAP_SATURATE_LINK,
PRELIM_I915_COPY_CLASS_CAP_SATURATE_LINK}};
bool failQueryDistanceInfo = false;
bool vmAdviseCalled = false;
uint32_t vmAdviseFlags = 0u;
uint32_t vmAdviseHandle = 0u;
MemoryClassInstance vmAdviseRegion = {};
int vmAdviseRetValue = 0;
// PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT
prelim_drm_i915_gem_create_ext createExt{};
prelim_drm_i915_gem_create_ext_setparam setparamRegion{};
MemoryClassInstance memRegions{};
std::vector<MemoryClassInstance> allMemRegions;
int gemCreateExtRetVal = 0;
// DRM_IOCTL_I915_GEM_MMAP_OFFSET
int mmapOffsetRetVal = 0;
// Debugger ioctls
prelim_drm_i915_debugger_open_param inputDebuggerOpen = {};
int debuggerOpenRetval = 10; // debugFd
protected:
virtual bool handleQueryItem(QueryItem *queryItem);
};