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

Move I915_PARAM values to DrmParam enum class 

Related-To: NEO-6852
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski 2022-06-06 15:48:31 +00:00 committed by Compute-Runtime-Automation
parent 973bcb9dbc
commit 695958bd10
17 changed files with 222 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
shared/source/os_interface/linux/CMakeLists.txt
View File

@ -53,8 +53,6 @@ set(NEO_CORE_OS_INTERFACE_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/ioctl_helper.cpp
${CMAKE_CURRENT_SOURCE_DIR}/ioctl_helper_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}ioctl_helper_getter.cpp
${CMAKE_CURRENT_SOURCE_DIR}/ioctl_strings.h
${CMAKE_CURRENT_SOURCE_DIR}/ioctl_strings_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/engine_info.h
${CMAKE_CURRENT_SOURCE_DIR}/engine_info.cpp
${CMAKE_CURRENT_SOURCE_DIR}/memory_info.h
@ -119,11 +117,9 @@ if("${BRANCH_TYPE}" STREQUAL "")
if(NOT NEO_ENABLE_i915_PRELIM_DETECTION)
list(APPEND NEO_CORE_OS_INTERFACE_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/ioctl_helper_getter_upstream.cpp
${CMAKE_CURRENT_SOURCE_DIR}/ioctl_strings_upstream.cpp
)
list(REMOVE_ITEM NEO_CORE_OS_INTERFACE_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/ioctl_helper_getter.cpp
${CMAKE_CURRENT_SOURCE_DIR}/ioctl_strings_prelim.cpp
)
endif()
endif()

138
shared/source/os_interface/linux/drm_neo.cpp
View File

@ -27,7 +27,6 @@
#include "shared/source/os_interface/linux/drm_wrappers.h"
#include "shared/source/os_interface/linux/hw_device_id.h"
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "shared/source/os_interface/linux/ioctl_strings.h"
#include "shared/source/os_interface/linux/os_context_linux.h"
#include "shared/source/os_interface/linux/os_inc.h"
#include "shared/source/os_interface/linux/pci_path.h"
@ -44,111 +43,6 @@
namespace NEO {
namespace IoctlToStringHelper {
std::string getIoctlParamString(int param) {
switch (param) {
case I915_PARAM_CHIPSET_ID:
return "I915_PARAM_CHIPSET_ID";
case I915_PARAM_REVISION:
return "I915_PARAM_REVISION";
case I915_PARAM_HAS_EXEC_SOFTPIN:
return "I915_PARAM_HAS_EXEC_SOFTPIN";
case I915_PARAM_HAS_POOLED_EU:
return "I915_PARAM_HAS_POOLED_EU";
case I915_PARAM_HAS_SCHEDULER:
return "I915_PARAM_HAS_SCHEDULER";
case I915_PARAM_EU_TOTAL:
return "I915_PARAM_EU_TOTAL";
case I915_PARAM_SUBSLICE_TOTAL:
return "I915_PARAM_SUBSLICE_TOTAL";
case I915_PARAM_MIN_EU_IN_POOL:
return "I915_PARAM_MIN_EU_IN_POOL";
case I915_PARAM_CS_TIMESTAMP_FREQUENCY:
return "I915_PARAM_CS_TIMESTAMP_FREQUENCY";
default:
return getIoctlParamStringRemaining(param);
}
}
std::string getIoctlString(DrmIoctl ioctlRequest) {
switch (ioctlRequest) {
case DrmIoctl::GemExecbuffer2:
return "DRM_IOCTL_I915_GEM_EXECBUFFER2";
case DrmIoctl::GemWait:
return "DRM_IOCTL_I915_GEM_WAIT";
case DrmIoctl::GemClose:
return "DRM_IOCTL_GEM_CLOSE";
case DrmIoctl::GemUserptr:
return "DRM_IOCTL_I915_GEM_USERPTR";
case DrmIoctl::Getparam:
return "DRM_IOCTL_I915_GETPARAM";
case DrmIoctl::GemCreate:
return "DRM_IOCTL_I915_GEM_CREATE";
case DrmIoctl::GemSetDomain:
return "DRM_IOCTL_I915_GEM_SET_DOMAIN";
case DrmIoctl::GemSetTiling:
return "DRM_IOCTL_I915_GEM_SET_TILING";
case DrmIoctl::GemGetTiling:
return "DRM_IOCTL_I915_GEM_GET_TILING";
case DrmIoctl::GemContextCreateExt:
return "DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT";
case DrmIoctl::GemContextDestroy:
return "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY";
case DrmIoctl::RegRead:
return "DRM_IOCTL_I915_REG_READ";
case DrmIoctl::GetResetStats:
return "DRM_IOCTL_I915_GET_RESET_STATS";
case DrmIoctl::GemContextGetparam:
return "DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM";
case DrmIoctl::GemContextSetparam:
return "DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM";
case DrmIoctl::Query:
return "DRM_IOCTL_I915_QUERY";
case DrmIoctl::GemMmap:
return "DRM_IOCTL_I915_GEM_MMAP";
case DrmIoctl::PrimeFdToHandle:
return "DRM_IOCTL_PRIME_FD_TO_HANDLE";
case DrmIoctl::PrimeHandleToFd:
return "DRM_IOCTL_PRIME_HANDLE_TO_FD";
case DrmIoctl::GemVmBind:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_BIND";
case DrmIoctl::GemVmUnbind:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND";
case DrmIoctl::GemWaitUserFence:
return "PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE";
case DrmIoctl::GemCreateExt:
return "DRM_IOCTL_I915_GEM_CREATE_EXT";
case DrmIoctl::DG1GemCreateExt:
return "DG1_DRM_IOCTL_I915_GEM_CREATE_EXT";
case DrmIoctl::GemVmAdvise:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE";
case DrmIoctl::GemVmPrefetch:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH";
case DrmIoctl::UuidRegister:
return "PRELIM_DRM_IOCTL_I915_UUID_REGISTER";
case DrmIoctl::UuidUnregister:
return "PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER";
case DrmIoctl::DebuggerOpen:
return "PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN";
case DrmIoctl::GemClosReserve:
return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE";
case DrmIoctl::GemClosFree:
return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE";
case DrmIoctl::GemCacheReserve:
return "PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE";
case DrmIoctl::GemMmapOffset:
return "DRM_IOCTL_I915_GEM_MMAP_OFFSET";
case DrmIoctl::GemVmCreate:
return "DRM_IOCTL_I915_GEM_VM_CREATE";
case DrmIoctl::GemVmDestroy:
return "DRM_IOCTL_I915_GEM_VM_DESTROY";
}
UNRECOVERABLE_IF(true);
return "";
}
} // namespace IoctlToStringHelper
Drm::Drm(std::unique_ptr<HwDeviceIdDrm> &&hwDeviceIdIn, RootDeviceEnvironment &rootDeviceEnvironment)
: DriverModel(DriverModelType::DRM),
hwDeviceId(std::move(hwDeviceIdIn)), rootDeviceEnvironment(rootDeviceEnvironment) {
@ -175,7 +69,7 @@ int Drm::ioctl(DrmIoctl request, void *arg) {
auto printIoctl = DebugManager.flags.PrintIoctlEntries.get();
if (printIoctl) {
printf("IOCTL %s called\n", IoctlToStringHelper::getIoctlString(request).c_str());
printf("IOCTL %s called\n", getIoctlString(request).c_str());
}
if (measureTime) {
@ -206,10 +100,10 @@ int Drm::ioctl(DrmIoctl request, void *arg) {
if (printIoctl) {
if (ret == 0) {
printf("IOCTL %s returns %d\n",
IoctlToStringHelper::getIoctlString(request).c_str(), ret);
getIoctlString(request).c_str(), ret);
} else {
printf("IOCTL %s returns %d, errno %d(%s)\n",
IoctlToStringHelper::getIoctlString(request).c_str(), ret, returnedErrno, strerror(returnedErrno));
getIoctlString(request).c_str(), ret, returnedErrno, strerror(returnedErrno));
}
}
@ -218,15 +112,15 @@ int Drm::ioctl(DrmIoctl request, void *arg) {
return ret;
}
int Drm::getParamIoctl(int param, int *dstValue) {
int Drm::getParamIoctl(DrmParam param, int *dstValue) {
GetParam getParam{};
getParam.param = param;
getParam.param = getDrmParamValue(param, ioctlHelper.get());
getParam.value = dstValue;
int retVal = ioctl(DrmIoctl::Getparam, &getParam);
if (DebugManager.flags.PrintIoctlEntries.get()) {
printf("DRM_IOCTL_I915_GETPARAM: param: %s, output value: %d, retCode:% d\n",
IoctlToStringHelper::getIoctlParamString(param).c_str(),
getDrmParamString(param).c_str(),
*getParam.value,
retVal);
}
@ -234,15 +128,15 @@ int Drm::getParamIoctl(int param, int *dstValue) {
}
int Drm::getDeviceID(int &devId) {
return getParamIoctl(I915_PARAM_CHIPSET_ID, &devId);
return getParamIoctl(DrmParam::ParamChipsetId, &devId);
}
int Drm::getDeviceRevID(int &revId) {
return getParamIoctl(I915_PARAM_REVISION, &revId);
return getParamIoctl(DrmParam::ParamRevision, &revId);
}
int Drm::getExecSoftPin(int &execSoftPin) {
return getParamIoctl(I915_PARAM_HAS_EXEC_SOFTPIN, &execSoftPin);
return getParamIoctl(DrmParam::ParamHasExecSoftpin, &execSoftPin);
}
int Drm::enableTurboBoost() {
@ -254,7 +148,7 @@ int Drm::enableTurboBoost() {
}
int Drm::getEnabledPooledEu(int &enabled) {
return getParamIoctl(I915_PARAM_HAS_POOLED_EU, &enabled);
return getParamIoctl(DrmParam::ParamHasPooledEu, &enabled);
}
std::string Drm::getSysFsPciPath() {
@ -303,7 +197,7 @@ bool Drm::isGpuHangDetected(OsContext &osContext) {
void Drm::checkPreemptionSupport() {
int value = 0;
auto ret = getParamIoctl(I915_PARAM_HAS_SCHEDULER, &value);
auto ret = getParamIoctl(DrmParam::ParamHasScheduler, &value);
preemptionSupported = ((0 == ret) && (value & I915_SCHEDULER_CAP_PREEMPTION));
}
@ -449,15 +343,15 @@ std::unique_lock<std::mutex> Drm::lockBindFenceMutex() {
}
int Drm::getEuTotal(int &euTotal) {
return getParamIoctl(I915_PARAM_EU_TOTAL, &euTotal);
return getParamIoctl(DrmParam::ParamEuTotal, &euTotal);
}
int Drm::getSubsliceTotal(int &subsliceTotal) {
return getParamIoctl(I915_PARAM_SUBSLICE_TOTAL, &subsliceTotal);
return getParamIoctl(DrmParam::ParamSubsliceTotal, &subsliceTotal);
}
int Drm::getMinEuInPool(int &minEUinPool) {
return getParamIoctl(I915_PARAM_MIN_EU_IN_POOL, &minEUinPool);
return getParamIoctl(DrmParam::ParamMinEuInPool, &minEUinPool);
}
int Drm::getErrno() {
@ -657,7 +551,7 @@ void Drm::printIoctlStatistics() {
printf("%41s %15s %10s %20s %20s %20s", "Request", "Total time(ns)", "Count", "Avg time per ioctl", "Min", "Max\n");
for (const auto &ioctlData : this->ioctlStatistics) {
printf("%41s %15llu %10lu %20f %20lld %20lld\n",
IoctlToStringHelper::getIoctlString(ioctlData.first).c_str(),
getIoctlString(ioctlData.first).c_str(),
ioctlData.second.totalTime,
static_cast<unsigned long>(ioctlData.second.count),
ioctlData.second.totalTime / static_cast<double>(ioctlData.second.count),
@ -840,7 +734,7 @@ int Drm::waitHandle(uint32_t waitHandle, int64_t timeout) {
int Drm::getTimestampFrequency(int &frequency) {
frequency = 0;
return getParamIoctl(I915_PARAM_CS_TIMESTAMP_FREQUENCY, &frequency);
return getParamIoctl(DrmParam::ParamCsTimestampFrequency, &frequency);
}
bool Drm::queryEngineInfo() {

2
shared/source/os_interface/linux/drm_neo.h
View File

@ -342,6 +342,6 @@ class Drm : public DriverModel {
bool vmBindPatIndexProgrammingSupported = false;
private:
int getParamIoctl(int param, int *dstValue);
int getParamIoctl(DrmParam param, int *dstValue);
};
} // namespace NEO

12
shared/source/os_interface/linux/drm_wrappers.cpp
View File

@ -181,4 +181,16 @@ unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest, IoctlHelper *ioctlHelpe
return ioctlHelper->getIoctlRequestValue(ioctlRequest);
}
}
int getDrmParamValue(DrmParam drmParam, IoctlHelper *ioctlHelper) {
switch (drmParam) {
case DrmParam::ParamChipsetId:
return I915_PARAM_CHIPSET_ID;
case DrmParam::ParamRevision:
return I915_PARAM_REVISION;
default:
UNRECOVERABLE_IF(!ioctlHelper);
return ioctlHelper->getDrmParamValue(drmParam);
}
}
} // namespace NEO

17
shared/source/os_interface/linux/drm_wrappers.h
View File

@ -8,6 +8,8 @@
#pragma once
#include <cstddef>
#include <cstdint>
#include <string>
namespace NEO {
class IoctlHelper;
@ -244,6 +246,17 @@ enum class DrmParam {
EngineClassVideoEnhance,
EngineClassInvalid,
EngineClassInvalidNone,
ParamChipsetId,
ParamRevision,
ParamHasExecSoftpin,
ParamHasPooledEu,
ParamHasScheduler,
ParamEuTotal,
ParamSubsliceTotal,
ParamMinEuInPool,
ParamCsTimestampFrequency,
ParamHasVmBind,
ParamHasPageFault,
QueryEngineInfo,
QueryHwconfigTable,
QueryComputeSlices,
@ -251,4 +264,8 @@ enum class DrmParam {
};
unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest, IoctlHelper *ioctlHelper);
int getDrmParamValue(DrmParam drmParam, IoctlHelper *ioctlHelper);
std::string getDrmParamString(DrmParam param);
std::string getIoctlString(DrmIoctl ioctlRequest);
} // namespace NEO

122
shared/source/os_interface/linux/ioctl_helper.cpp
View File

@ -196,6 +196,20 @@ int IoctlHelper::getDrmParamValueBase(DrmParam drmParam) const {
return I915_ENGINE_CLASS_INVALID;
case DrmParam::EngineClassInvalidNone:
return I915_ENGINE_CLASS_INVALID_NONE;
case DrmParam::ParamHasExecSoftpin:
return I915_PARAM_HAS_EXEC_SOFTPIN;
case DrmParam::ParamHasPooledEu:
return I915_PARAM_HAS_POOLED_EU;
case DrmParam::ParamHasScheduler:
return I915_PARAM_HAS_SCHEDULER;
case DrmParam::ParamEuTotal:
return I915_PARAM_EU_TOTAL;
case DrmParam::ParamSubsliceTotal:
return I915_PARAM_SUBSLICE_TOTAL;
case DrmParam::ParamMinEuInPool:
return I915_PARAM_MIN_EU_IN_POOL;
case DrmParam::ParamCsTimestampFrequency:
return I915_PARAM_CS_TIMESTAMP_FREQUENCY;
case DrmParam::QueryEngineInfo:
return DRM_I915_QUERY_ENGINE_INFO;
case DrmParam::QueryMemoryRegions:
@ -205,4 +219,112 @@ int IoctlHelper::getDrmParamValueBase(DrmParam drmParam) const {
return 0;
}
}
std::string getDrmParamString(DrmParam drmParam) {
switch (drmParam) {
case DrmParam::ParamChipsetId:
return "I915_PARAM_CHIPSET_ID";
case DrmParam::ParamRevision:
return "I915_PARAM_REVISION";
case DrmParam::ParamHasExecSoftpin:
return "I915_PARAM_HAS_EXEC_SOFTPIN";
case DrmParam::ParamHasPooledEu:
return "I915_PARAM_HAS_POOLED_EU";
case DrmParam::ParamHasScheduler:
return "I915_PARAM_HAS_SCHEDULER";
case DrmParam::ParamEuTotal:
return "I915_PARAM_EU_TOTAL";
case DrmParam::ParamSubsliceTotal:
return "I915_PARAM_SUBSLICE_TOTAL";
case DrmParam::ParamMinEuInPool:
return "I915_PARAM_MIN_EU_IN_POOL";
case DrmParam::ParamCsTimestampFrequency:
return "I915_PARAM_CS_TIMESTAMP_FREQUENCY";
case DrmParam::ParamHasVmBind:
return "PRELIM_I915_PARAM_HAS_VM_BIND";
case DrmParam::ParamHasPageFault:
return "PRELIM_I915_PARAM_HAS_PAGE_FAULT";
default:
UNRECOVERABLE_IF(true);
return "";
}
}
std::string getIoctlString(DrmIoctl ioctlRequest) {
switch (ioctlRequest) {
case DrmIoctl::GemExecbuffer2:
return "DRM_IOCTL_I915_GEM_EXECBUFFER2";
case DrmIoctl::GemWait:
return "DRM_IOCTL_I915_GEM_WAIT";
case DrmIoctl::GemClose:
return "DRM_IOCTL_GEM_CLOSE";
case DrmIoctl::GemUserptr:
return "DRM_IOCTL_I915_GEM_USERPTR";
case DrmIoctl::Getparam:
return "DRM_IOCTL_I915_GETPARAM";
case DrmIoctl::GemCreate:
return "DRM_IOCTL_I915_GEM_CREATE";
case DrmIoctl::GemSetDomain:
return "DRM_IOCTL_I915_GEM_SET_DOMAIN";
case DrmIoctl::GemSetTiling:
return "DRM_IOCTL_I915_GEM_SET_TILING";
case DrmIoctl::GemGetTiling:
return "DRM_IOCTL_I915_GEM_GET_TILING";
case DrmIoctl::GemContextCreateExt:
return "DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT";
case DrmIoctl::GemContextDestroy:
return "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY";
case DrmIoctl::RegRead:
return "DRM_IOCTL_I915_REG_READ";
case DrmIoctl::GetResetStats:
return "DRM_IOCTL_I915_GET_RESET_STATS";
case DrmIoctl::GemContextGetparam:
return "DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM";
case DrmIoctl::GemContextSetparam:
return "DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM";
case DrmIoctl::Query:
return "DRM_IOCTL_I915_QUERY";
case DrmIoctl::GemMmap:
return "DRM_IOCTL_I915_GEM_MMAP";
case DrmIoctl::PrimeFdToHandle:
return "DRM_IOCTL_PRIME_FD_TO_HANDLE";
case DrmIoctl::PrimeHandleToFd:
return "DRM_IOCTL_PRIME_HANDLE_TO_FD";
case DrmIoctl::GemVmBind:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_BIND";
case DrmIoctl::GemVmUnbind:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND";
case DrmIoctl::GemWaitUserFence:
return "PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE";
case DrmIoctl::GemCreateExt:
return "DRM_IOCTL_I915_GEM_CREATE_EXT";
case DrmIoctl::DG1GemCreateExt:
return "DG1_DRM_IOCTL_I915_GEM_CREATE_EXT";
case DrmIoctl::GemVmAdvise:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE";
case DrmIoctl::GemVmPrefetch:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH";
case DrmIoctl::UuidRegister:
return "PRELIM_DRM_IOCTL_I915_UUID_REGISTER";
case DrmIoctl::UuidUnregister:
return "PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER";
case DrmIoctl::DebuggerOpen:
return "PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN";
case DrmIoctl::GemClosReserve:
return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE";
case DrmIoctl::GemClosFree:
return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE";
case DrmIoctl::GemCacheReserve:
return "PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE";
case DrmIoctl::GemMmapOffset:
return "DRM_IOCTL_I915_GEM_MMAP_OFFSET";
case DrmIoctl::GemVmCreate:
return "DRM_IOCTL_I915_GEM_VM_CREATE";
case DrmIoctl::GemVmDestroy:
return "DRM_IOCTL_I915_GEM_VM_DESTROY";
}
UNRECOVERABLE_IF(true);
return "";
}
} // namespace NEO

6
shared/source/os_interface/linux/ioctl_helper.h
View File

@ -88,7 +88,7 @@ class IoctlHelper {
virtual uint16_t getWaitUserFenceSoftFlag() = 0;
virtual int execBuffer(Drm *drm, ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) = 0;
virtual bool completionFenceExtensionSupported(const bool isVmBindAvailable) = 0;
virtual std::optional<int> getHasPageFaultParamId() = 0;
virtual std::optional<DrmParam> getHasPageFaultParamId() = 0;
virtual std::unique_ptr<uint8_t[]> createVmControlExtRegion(const std::optional<MemoryClassInstance> &regionInstanceClass) = 0;
virtual uint32_t getFlagsForVmCreate(bool disableScratch, bool enablePageFault, bool useVmBind) = 0;
virtual uint32_t createContextWithAccessCounters(Drm *drm, GemContextCreateExt &gcc) = 0;
@ -147,7 +147,7 @@ class IoctlHelperUpstream : public IoctlHelper {
uint16_t getWaitUserFenceSoftFlag() override;
int execBuffer(Drm *drm, ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) override;
bool completionFenceExtensionSupported(const bool isVmBindAvailable) override;
std::optional<int> getHasPageFaultParamId() override;
std::optional<DrmParam> getHasPageFaultParamId() override;
std::unique_ptr<uint8_t[]> createVmControlExtRegion(const std::optional<MemoryClassInstance> &regionInstanceClass) override;
uint32_t getFlagsForVmCreate(bool disableScratch, bool enablePageFault, bool useVmBind) override;
uint32_t createContextWithAccessCounters(Drm *drm, GemContextCreateExt &gcc) override;
@ -207,7 +207,7 @@ class IoctlHelperPrelim20 : public IoctlHelper {
uint16_t getWaitUserFenceSoftFlag() override;
int execBuffer(Drm *drm, ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) override;
bool completionFenceExtensionSupported(const bool isVmBindAvailable) override;
std::optional<int> getHasPageFaultParamId() override;
std::optional<DrmParam> getHasPageFaultParamId() override;
std::unique_ptr<uint8_t[]> createVmControlExtRegion(const std::optional<MemoryClassInstance> &regionInstanceClass) override;
uint32_t getFlagsForVmCreate(bool disableScratch, bool enablePageFault, bool useVmBind) override;
uint32_t createContextWithAccessCounters(Drm *drm, GemContextCreateExt &gcc) override;

8
shared/source/os_interface/linux/ioctl_helper_prelim.cpp
View File

@ -296,8 +296,8 @@ uint32_t IoctlHelperPrelim20::queryDistances(Drm *drm, std::vector<QueryItem> &q
return ret;
}
std::optional<int> IoctlHelperPrelim20::getHasPageFaultParamId() {
return PRELIM_I915_PARAM_HAS_PAGE_FAULT;
std::optional<DrmParam> IoctlHelperPrelim20::getHasPageFaultParamId() {
return DrmParam::ParamHasPageFault;
};
bool IoctlHelperPrelim20::getEuStallProperties(std::array<uint64_t, 10u> &properties, uint64_t dssBufferSize, uint64_t samplingRate, uint64_t pollPeriod, uint64_t engineInstance) {
@ -551,6 +551,10 @@ int IoctlHelperPrelim20::getDrmParamValue(DrmParam drmParam) const {
switch (drmParam) {
case DrmParam::EngineClassCompute:
return PRELIM_I915_ENGINE_CLASS_COMPUTE;
case DrmParam::ParamHasVmBind:
return PRELIM_I915_PARAM_HAS_VM_BIND;
case DrmParam::ParamHasPageFault:
return PRELIM_I915_PARAM_HAS_PAGE_FAULT;
case DrmParam::QueryHwconfigTable:
return PRELIM_DRM_I915_QUERY_HWCONFIG_TABLE;
case DrmParam::QueryComputeSlices:

2
shared/source/os_interface/linux/ioctl_helper_upstream.cpp
View File

@ -122,7 +122,7 @@ bool IoctlHelperUpstream::completionFenceExtensionSupported(const bool isVmBindA
return false;
}
std::optional<int> IoctlHelperUpstream::getHasPageFaultParamId() {
std::optional<DrmParam> IoctlHelperUpstream::getHasPageFaultParamId() {
return std::nullopt;
};

20
shared/source/os_interface/linux/ioctl_strings.h
View File

@ -1,20 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/os_interface/linux/drm_wrappers.h"
#include <string>
namespace NEO {
namespace IoctlToStringHelper {
std::string getIoctlParamString(int param);
std::string getIoctlParamStringRemaining(int param);
std::string getIoctlString(DrmIoctl ioctlRequest);
} // namespace IoctlToStringHelper
} // namespace NEO

26
shared/source/os_interface/linux/ioctl_strings_prelim.cpp
View File

@ -1,26 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "third_party/uapi/prelim/drm/i915_drm.h"
#include <string>
#include <sys/ioctl.h>
namespace NEO {
namespace IoctlToStringHelper {
std::string getIoctlParamStringRemaining(int param) {
switch (param) {
case PRELIM_I915_PARAM_HAS_VM_BIND:
return "PRELIM_I915_PARAM_HAS_VM_BIND";
default:
return std::to_string(param);
}
}
} // namespace IoctlToStringHelper
} // namespace NEO

18
shared/source/os_interface/linux/ioctl_strings_upstream.cpp
View File

@ -1,18 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include <string>
namespace NEO {
namespace IoctlToStringHelper {
std::string getIoctlParamStringRemaining(int param) {
return std::to_string(param);
}
} // namespace IoctlToStringHelper
} // namespace NEO

12
shared/test/common/libult/linux/drm_mock.cpp
View File

@ -295,15 +295,3 @@ int DrmMockEngine::handleRemainingRequests(DrmIoctl request, void *arg) {
}
return -1;
}
std::map<int, const char *> ioctlParamCodeStringMap = {
{I915_PARAM_CHIPSET_ID, "I915_PARAM_CHIPSET_ID"},
{I915_PARAM_REVISION, "I915_PARAM_REVISION"},
{I915_PARAM_HAS_EXEC_SOFTPIN, "I915_PARAM_HAS_EXEC_SOFTPIN"},
{I915_PARAM_HAS_POOLED_EU, "I915_PARAM_HAS_POOLED_EU"},
{I915_PARAM_HAS_SCHEDULER, "I915_PARAM_HAS_SCHEDULER"},
{I915_PARAM_EU_TOTAL, "I915_PARAM_EU_TOTAL"},
{I915_PARAM_SUBSLICE_TOTAL, "I915_PARAM_SUBSLICE_TOTAL"},
{I915_PARAM_MIN_EU_IN_POOL, "I915_PARAM_MIN_EU_IN_POOL"},
{I915_PARAM_CS_TIMESTAMP_FREQUENCY, "I915_PARAM_CS_TIMESTAMP_FREQUENCY"},
{static_cast<int>(101010101), "101010101"}};

1
shared/test/common/os_interface/linux/device_command_stream_fixture_impl.h
View File

@ -6,7 +6,6 @@
*/
#pragma once
#include "shared/source/os_interface/linux/ioctl_strings.h"
#include "shared/test/common/os_interface/linux/device_command_stream_fixture.h"
class DrmMockCustomImpl : public DrmMockCustom {

30
shared/test/unit_test/os_interface/linux/drm_tests.cpp
View File

@ -8,7 +8,6 @@
#include "shared/source/helpers/file_io.h"
#include "shared/source/helpers/hw_info.h"
#include "shared/source/os_interface/device_factory.h"
#include "shared/source/os_interface/linux/ioctl_strings.h"
#include "shared/source/os_interface/linux/os_context_linux.h"
#include "shared/source/os_interface/linux/os_inc.h"
#include "shared/source/os_interface/os_interface.h"
@ -1183,6 +1182,14 @@ TEST(DrmWrapperTest, WhenGettingDrmIoctlGetparamValueThenIoctlHelperIsNotNeeded)
EXPECT_THROW(getIoctlRequestValue(DrmIoctl::DG1GemCreateExt, nullptr), std::runtime_error);
}
TEST(DrmWrapperTest, WhenGettingChipsetIdParamValueThenIoctlHelperIsNotNeeded) {
EXPECT_EQ(getDrmParamValue(DrmParam::ParamChipsetId, nullptr), static_cast<int>(I915_PARAM_CHIPSET_ID));
}
TEST(DrmWrapperTest, WhenGettingRevisionParamValueThenIoctlHelperIsNotNeeded) {
EXPECT_EQ(getDrmParamValue(DrmParam::ParamRevision, nullptr), static_cast<int>(I915_PARAM_REVISION));
}
TEST(DrmWrapperTest, WhenGettingIoctlStringValueThenProperStringIsReturned) {
std::map<DrmIoctl, const char *> ioctlCodeStringMap = {
{DrmIoctl::GemClose, "DRM_IOCTL_GEM_CLOSE"},
@ -1221,9 +1228,28 @@ TEST(DrmWrapperTest, WhenGettingIoctlStringValueThenProperStringIsReturned) {
{DrmIoctl::GemVmDestroy, "DRM_IOCTL_I915_GEM_VM_DESTROY"},
{DrmIoctl::PrimeHandleToFd, "DRM_IOCTL_PRIME_HANDLE_TO_FD"}};
for (auto &ioctlCodeString : ioctlCodeStringMap) {
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(ioctlCodeString.first).c_str(), ioctlCodeString.second);
EXPECT_STREQ(getIoctlString(ioctlCodeString.first).c_str(), ioctlCodeString.second);
}
}
TEST(DrmWrapperTest, WhenGettingDrmParamValueStringThenProperStringIsReturned) {
std::map<DrmParam, const char *> ioctlCodeStringMap = {
{DrmParam::ParamChipsetId, "I915_PARAM_CHIPSET_ID"},
{DrmParam::ParamRevision, "I915_PARAM_REVISION"},
{DrmParam::ParamHasExecSoftpin, "I915_PARAM_HAS_EXEC_SOFTPIN"},
{DrmParam::ParamHasPooledEu, "I915_PARAM_HAS_POOLED_EU"},
{DrmParam::ParamHasScheduler, "I915_PARAM_HAS_SCHEDULER"},
{DrmParam::ParamEuTotal, "I915_PARAM_EU_TOTAL"},
{DrmParam::ParamSubsliceTotal, "I915_PARAM_SUBSLICE_TOTAL"},
{DrmParam::ParamMinEuInPool, "I915_PARAM_MIN_EU_IN_POOL"},
{DrmParam::ParamCsTimestampFrequency, "I915_PARAM_CS_TIMESTAMP_FREQUENCY"},
{DrmParam::ParamHasVmBind, "PRELIM_I915_PARAM_HAS_VM_BIND"},
{DrmParam::ParamHasPageFault, "PRELIM_I915_PARAM_HAS_PAGE_FAULT"}};
for (auto &ioctlCodeString : ioctlCodeStringMap) {
EXPECT_STREQ(getDrmParamString(ioctlCodeString.first).c_str(), ioctlCodeString.second);
}
EXPECT_THROW(getDrmParamString(DrmParam::EngineClassRender), std::runtime_error);
}
TEST(IoctlHelperTest, whenGettingDrmParamValueThenProperValueIsReturned) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();

18
shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp
View File

@ -7,7 +7,6 @@
#include "shared/source/helpers/string.h"
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "shared/source/os_interface/linux/ioctl_strings.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/test_macros/test.h"
@ -15,7 +14,6 @@
using namespace NEO;
extern std::map<int, const char *> ioctlParamCodeStringMap;
extern std::vector<uint8_t> getRegionInfo(const std::vector<MemoryRegion> &inputRegions);
extern std::vector<uint8_t> getEngineInfo(const std::vector<EngineCapabilities> &inputEngines);
@ -64,19 +62,21 @@ TEST_F(IoctlPrelimHelperTests, whenGettingIoctlRequestValueThenPropertValueIsRet
TEST_F(IoctlPrelimHelperTests, whenGettingDrmParamValueThenPropertValueIsReturned) {
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::EngineClassCompute), static_cast<int>(PRELIM_I915_ENGINE_CLASS_COMPUTE));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamHasExecSoftpin), static_cast<int>(I915_PARAM_HAS_EXEC_SOFTPIN));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamHasPooledEu), static_cast<int>(I915_PARAM_HAS_POOLED_EU));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamHasScheduler), static_cast<int>(I915_PARAM_HAS_SCHEDULER));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamEuTotal), static_cast<int>(I915_PARAM_EU_TOTAL));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamSubsliceTotal), static_cast<int>(I915_PARAM_SUBSLICE_TOTAL));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamMinEuInPool), static_cast<int>(I915_PARAM_MIN_EU_IN_POOL));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamCsTimestampFrequency), static_cast<int>(I915_PARAM_CS_TIMESTAMP_FREQUENCY));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamHasVmBind), static_cast<int>(PRELIM_I915_PARAM_HAS_VM_BIND));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamHasPageFault), static_cast<int>(PRELIM_I915_PARAM_HAS_PAGE_FAULT));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::QueryEngineInfo), static_cast<int>(DRM_I915_QUERY_ENGINE_INFO));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::QueryHwconfigTable), static_cast<int>(PRELIM_DRM_I915_QUERY_HWCONFIG_TABLE));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::QueryMemoryRegions), static_cast<int>(DRM_I915_QUERY_MEMORY_REGIONS));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::QueryComputeSlices), static_cast<int>(PRELIM_DRM_I915_QUERY_COMPUTE_SLICES));
}
TEST_F(IoctlPrelimHelperTests, givenIoctlParamWhenParseToStringThenProperStringIsReturned) {
for (auto &ioctlParamCodeString : ioctlParamCodeStringMap) {
EXPECT_STREQ(IoctlToStringHelper::getIoctlParamString(ioctlParamCodeString.first).c_str(), ioctlParamCodeString.second);
}
EXPECT_STREQ(IoctlToStringHelper::getIoctlParamString(PRELIM_I915_PARAM_HAS_VM_BIND).c_str(), "PRELIM_I915_PARAM_HAS_VM_BIND");
}
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenTranslateToMemoryRegionsThenReturnSameData) {
std::vector<MemoryRegion> expectedMemRegions(2);
expectedMemRegions[0].region.memoryClass = PRELIM_I915_MEMORY_CLASS_SYSTEM;

15
shared/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp
View File

@ -6,7 +6,6 @@
*/
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "shared/source/os_interface/linux/ioctl_strings.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/mocks/mock_execution_environment.h"
@ -14,7 +13,6 @@
#include "shared/test/unit_test/os_interface/linux/drm_mock_impl.h"
using namespace NEO;
extern std::map<int, const char *> ioctlParamCodeStringMap;
TEST(IoctlHelperUpstreamTest, whenGettingVmBindAvailabilityThenFalseIsReturned) {
IoctlHelperUpstream ioctlHelper{};
@ -23,12 +21,6 @@ TEST(IoctlHelperUpstreamTest, whenGettingVmBindAvailabilityThenFalseIsReturned)
EXPECT_FALSE(ioctlHelper.isVmBindAvailable(drm.get()));
}
TEST(IoctlHelperUpstreamTest, givenIoctlParamWhenParseToStringThenProperStringIsReturned) {
for (auto ioctlParamCodeString : ioctlParamCodeStringMap) {
EXPECT_STREQ(IoctlToStringHelper::getIoctlParamString(ioctlParamCodeString.first).c_str(), ioctlParamCodeString.second);
}
}
TEST(IoctlHelperUpstreamTest, whenGettingIoctlRequestValueThenPropertValueIsReturned) {
IoctlHelperUpstream ioctlHelper{};
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemExecbuffer2), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_EXECBUFFER2));
@ -61,6 +53,13 @@ TEST(IoctlHelperUpstreamTest, whenGettingIoctlRequestValueThenPropertValueIsRetu
TEST(IoctlHelperUpstreamTest, whenGettingDrmParamValueThenPropertValueIsReturned) {
IoctlHelperUpstream ioctlHelper{};
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::EngineClassCompute), 4);
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamHasExecSoftpin), static_cast<int>(I915_PARAM_HAS_EXEC_SOFTPIN));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamHasPooledEu), static_cast<int>(I915_PARAM_HAS_POOLED_EU));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamHasScheduler), static_cast<int>(I915_PARAM_HAS_SCHEDULER));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamEuTotal), static_cast<int>(I915_PARAM_EU_TOTAL));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamSubsliceTotal), static_cast<int>(I915_PARAM_SUBSLICE_TOTAL));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamMinEuInPool), static_cast<int>(I915_PARAM_MIN_EU_IN_POOL));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::ParamCsTimestampFrequency), static_cast<int>(I915_PARAM_CS_TIMESTAMP_FREQUENCY));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::QueryEngineInfo), static_cast<int>(DRM_I915_QUERY_ENGINE_INFO));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::QueryHwconfigTable), static_cast<int>(DRM_I915_QUERY_HWCONFIG_TABLE));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::QueryMemoryRegions), static_cast<int>(DRM_I915_QUERY_MEMORY_REGIONS));