intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-04 23:56:39 +08:00
Code Issues Packages Projects Releases Wiki Activity

Move ioctl strings to ioctl helper

Browse Source 
move ioctl helper prelim tests with drm to separated file

Related-To: NEO-6591
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2022-02-11 17:45:20 +00:00
committed by Compute-Runtime-Automation
parent bd3e296278
commit 173c86d6f1
12 changed files with 588 additions and 514 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -39,161 +39,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(unsigned long request) {
switch (request) {
case DRM_IOCTL_I915_GEM_EXECBUFFER2:
return "DRM_IOCTL_I915_GEM_EXECBUFFER2";
case DRM_IOCTL_I915_GEM_WAIT:
return "DRM_IOCTL_I915_GEM_WAIT";
case DRM_IOCTL_GEM_CLOSE:
return "DRM_IOCTL_GEM_CLOSE";
case DRM_IOCTL_I915_GEM_USERPTR:
return "DRM_IOCTL_I915_GEM_USERPTR";
case DRM_IOCTL_I915_INIT:
return "DRM_IOCTL_I915_INIT";
case DRM_IOCTL_I915_FLUSH:
return "DRM_IOCTL_I915_FLUSH";
case DRM_IOCTL_I915_FLIP:
return "DRM_IOCTL_I915_FLIP";
case DRM_IOCTL_I915_BATCHBUFFER:
return "DRM_IOCTL_I915_BATCHBUFFER";
case DRM_IOCTL_I915_IRQ_EMIT:
return "DRM_IOCTL_I915_IRQ_EMIT";
case DRM_IOCTL_I915_IRQ_WAIT:
return "DRM_IOCTL_I915_IRQ_WAIT";
case DRM_IOCTL_I915_GETPARAM:
return "DRM_IOCTL_I915_GETPARAM";
case DRM_IOCTL_I915_SETPARAM:
return "DRM_IOCTL_I915_SETPARAM";
case DRM_IOCTL_I915_ALLOC:
return "DRM_IOCTL_I915_ALLOC";
case DRM_IOCTL_I915_FREE:
return "DRM_IOCTL_I915_FREE";
case DRM_IOCTL_I915_INIT_HEAP:
return "DRM_IOCTL_I915_INIT_HEAP";
case DRM_IOCTL_I915_CMDBUFFER:
return "DRM_IOCTL_I915_CMDBUFFER";
case DRM_IOCTL_I915_DESTROY_HEAP:
return "DRM_IOCTL_I915_DESTROY_HEAP";
case DRM_IOCTL_I915_SET_VBLANK_PIPE:
return "DRM_IOCTL_I915_SET_VBLANK_PIPE";
case DRM_IOCTL_I915_GET_VBLANK_PIPE:
return "DRM_IOCTL_I915_GET_VBLANK_PIPE";
case DRM_IOCTL_I915_VBLANK_SWAP:
return "DRM_IOCTL_I915_VBLANK_SWAP";
case DRM_IOCTL_I915_HWS_ADDR:
return "DRM_IOCTL_I915_HWS_ADDR";
case DRM_IOCTL_I915_GEM_INIT:
return "DRM_IOCTL_I915_GEM_INIT";
case DRM_IOCTL_I915_GEM_EXECBUFFER:
return "DRM_IOCTL_I915_GEM_EXECBUFFER";
case DRM_IOCTL_I915_GEM_EXECBUFFER2_WR:
return "DRM_IOCTL_I915_GEM_EXECBUFFER2_WR";
case DRM_IOCTL_I915_GEM_PIN:
return "DRM_IOCTL_I915_GEM_PIN";
case DRM_IOCTL_I915_GEM_UNPIN:
return "DRM_IOCTL_I915_GEM_UNPIN";
case DRM_IOCTL_I915_GEM_BUSY:
return "DRM_IOCTL_I915_GEM_BUSY";
case DRM_IOCTL_I915_GEM_SET_CACHING:
return "DRM_IOCTL_I915_GEM_SET_CACHING";
case DRM_IOCTL_I915_GEM_GET_CACHING:
return "DRM_IOCTL_I915_GEM_GET_CACHING";
case DRM_IOCTL_I915_GEM_THROTTLE:
return "DRM_IOCTL_I915_GEM_THROTTLE";
case DRM_IOCTL_I915_GEM_ENTERVT:
return "DRM_IOCTL_I915_GEM_ENTERVT";
case DRM_IOCTL_I915_GEM_LEAVEVT:
return "DRM_IOCTL_I915_GEM_LEAVEVT";
case DRM_IOCTL_I915_GEM_CREATE:
return "DRM_IOCTL_I915_GEM_CREATE";
case DRM_IOCTL_I915_GEM_PREAD:
return "DRM_IOCTL_I915_GEM_PREAD";
case DRM_IOCTL_I915_GEM_PWRITE:
return "DRM_IOCTL_I915_GEM_PWRITE";
case DRM_IOCTL_I915_GEM_SET_DOMAIN:
return "DRM_IOCTL_I915_GEM_SET_DOMAIN";
case DRM_IOCTL_I915_GEM_SW_FINISH:
return "DRM_IOCTL_I915_GEM_SW_FINISH";
case DRM_IOCTL_I915_GEM_SET_TILING:
return "DRM_IOCTL_I915_GEM_SET_TILING";
case DRM_IOCTL_I915_GEM_GET_TILING:
return "DRM_IOCTL_I915_GEM_GET_TILING";
case DRM_IOCTL_I915_GEM_GET_APERTURE:
return "DRM_IOCTL_I915_GEM_GET_APERTURE";
case DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID:
return "DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID";
case DRM_IOCTL_I915_GEM_MADVISE:
return "DRM_IOCTL_I915_GEM_MADVISE";
case DRM_IOCTL_I915_OVERLAY_PUT_IMAGE:
return "DRM_IOCTL_I915_OVERLAY_PUT_IMAGE";
case DRM_IOCTL_I915_OVERLAY_ATTRS:
return "DRM_IOCTL_I915_OVERLAY_ATTRS";
case DRM_IOCTL_I915_SET_SPRITE_COLORKEY:
return "DRM_IOCTL_I915_SET_SPRITE_COLORKEY";
case DRM_IOCTL_I915_GET_SPRITE_COLORKEY:
return "DRM_IOCTL_I915_GET_SPRITE_COLORKEY";
case DRM_IOCTL_I915_GEM_CONTEXT_CREATE:
return "DRM_IOCTL_I915_GEM_CONTEXT_CREATE";
case DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT:
return "DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT";
case DRM_IOCTL_I915_GEM_CONTEXT_DESTROY:
return "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY";
case DRM_IOCTL_I915_REG_READ:
return "DRM_IOCTL_I915_REG_READ";
case DRM_IOCTL_I915_GET_RESET_STATS:
return "DRM_IOCTL_I915_GET_RESET_STATS";
case DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM:
return "DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM";
case DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM:
return "DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM";
case DRM_IOCTL_I915_PERF_OPEN:
return "DRM_IOCTL_I915_PERF_OPEN";
case DRM_IOCTL_I915_PERF_ADD_CONFIG:
return "DRM_IOCTL_I915_PERF_ADD_CONFIG";
case DRM_IOCTL_I915_PERF_REMOVE_CONFIG:
return "DRM_IOCTL_I915_PERF_REMOVE_CONFIG";
case DRM_IOCTL_I915_QUERY:
return "DRM_IOCTL_I915_QUERY";
case DRM_IOCTL_I915_GEM_MMAP:
return "DRM_IOCTL_I915_GEM_MMAP";
case DRM_IOCTL_PRIME_FD_TO_HANDLE:
return "DRM_IOCTL_PRIME_FD_TO_HANDLE";
case DRM_IOCTL_PRIME_HANDLE_TO_FD:
return "DRM_IOCTL_PRIME_HANDLE_TO_FD";
default:
return getIoctlStringRemaining(request);
}
}
} // namespace IoctlToStringHelper
Drm::Drm(std::unique_ptr<HwDeviceIdDrm> &&hwDeviceIdIn, RootDeviceEnvironment &rootDeviceEnvironment)
: DriverModel(DriverModelType::DRM),
hwDeviceId(std::move(hwDeviceIdIn)), rootDeviceEnvironment(rootDeviceEnvironment) {
@@ -213,7 +58,7 @@ int Drm::ioctl(unsigned long 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", ioctlHelper->getIoctlString(request).c_str());
}
if (measureTime) {
@@ -244,10 +89,10 @@ int Drm::ioctl(unsigned long request, void *arg) {
if (printIoctl) {
if (ret == 0) {
printf("IOCTL %s returns %d\n",
IoctlToStringHelper::getIoctlString(request).c_str(), ret);
ioctlHelper->getIoctlString(request).c_str(), ret);
} else {
printf("IOCTL %s returns %d, errno %d(%s)\n",
IoctlToStringHelper::getIoctlString(request).c_str(), ret, returnedErrno, strerror(returnedErrno));
ioctlHelper->getIoctlString(request).c_str(), ret, returnedErrno, strerror(returnedErrno));
}
}
@@ -264,7 +109,7 @@ int Drm::getParamIoctl(int param, int *dstValue) {
int retVal = ioctl(DRM_IOCTL_I915_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(),
ioctlHelper->getIoctlParamString(param).c_str(),
*getParam.value,
retVal);
}
@@ -669,7 +514,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(),
ioctlHelper->getIoctlString(ioctlData.first).c_str(),
ioctlData.second.totalTime,
static_cast<unsigned long>(ioctlData.second.count),
ioctlData.second.totalTime / static_cast<double>(ioctlData.second.count),

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

@@ -56,13 +56,6 @@ struct DeviceDescriptor { // NOLINT(clang-analyzer-optin.performance.Padding)
extern const DeviceDescriptor deviceDescriptorTable[];
namespace IoctlToStringHelper {
std::string getIoctlParamString(int param);
std::string getIoctlParamStringRemaining(int param);
std::string getIoctlString(unsigned long request);
std::string getIoctlStringRemaining(unsigned long request);
} // namespace IoctlToStringHelper
class Drm : public DriverModel {
friend DeviceFactory;

11
shared/source/os_interface/linux/drm_query.cpp
View File

@@ -5,23 +5,12 @@
*
*/
#include "shared/source/helpers/string.h"
#include "shared/source/os_interface/linux/sys_calls.h"
#include "drm_neo.h"
namespace NEO {
namespace IoctlToStringHelper {
std::string getIoctlStringRemaining(unsigned long request) {
return std::to_string(request);
}
std::string getIoctlParamStringRemaining(int param) {
return std::to_string(param);
}
} // namespace IoctlToStringHelper
int Drm::createDrmVirtualMemory(uint32_t &drmVmId) {
drm_i915_gem_vm_control ctl = {};
auto ret = SysCalls::ioctl(getFileDescriptor(), DRM_IOCTL_I915_GEM_VM_CREATE, &ctl);

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -15,4 +15,155 @@ uint32_t IoctlHelper::ioctl(Drm *drm, unsigned long request, void *arg) {
return drm->ioctl(request, arg);
}
std::string IoctlHelper::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 std::to_string(param);
}
}
std::string IoctlHelper::getIoctlString(unsigned long request) {
switch (request) {
case DRM_IOCTL_I915_GEM_EXECBUFFER2:
return "DRM_IOCTL_I915_GEM_EXECBUFFER2";
case DRM_IOCTL_I915_GEM_WAIT:
return "DRM_IOCTL_I915_GEM_WAIT";
case DRM_IOCTL_GEM_CLOSE:
return "DRM_IOCTL_GEM_CLOSE";
case DRM_IOCTL_I915_GEM_USERPTR:
return "DRM_IOCTL_I915_GEM_USERPTR";
case DRM_IOCTL_I915_INIT:
return "DRM_IOCTL_I915_INIT";
case DRM_IOCTL_I915_FLUSH:
return "DRM_IOCTL_I915_FLUSH";
case DRM_IOCTL_I915_FLIP:
return "DRM_IOCTL_I915_FLIP";
case DRM_IOCTL_I915_BATCHBUFFER:
return "DRM_IOCTL_I915_BATCHBUFFER";
case DRM_IOCTL_I915_IRQ_EMIT:
return "DRM_IOCTL_I915_IRQ_EMIT";
case DRM_IOCTL_I915_IRQ_WAIT:
return "DRM_IOCTL_I915_IRQ_WAIT";
case DRM_IOCTL_I915_GETPARAM:
return "DRM_IOCTL_I915_GETPARAM";
case DRM_IOCTL_I915_SETPARAM:
return "DRM_IOCTL_I915_SETPARAM";
case DRM_IOCTL_I915_ALLOC:
return "DRM_IOCTL_I915_ALLOC";
case DRM_IOCTL_I915_FREE:
return "DRM_IOCTL_I915_FREE";
case DRM_IOCTL_I915_INIT_HEAP:
return "DRM_IOCTL_I915_INIT_HEAP";
case DRM_IOCTL_I915_CMDBUFFER:
return "DRM_IOCTL_I915_CMDBUFFER";
case DRM_IOCTL_I915_DESTROY_HEAP:
return "DRM_IOCTL_I915_DESTROY_HEAP";
case DRM_IOCTL_I915_SET_VBLANK_PIPE:
return "DRM_IOCTL_I915_SET_VBLANK_PIPE";
case DRM_IOCTL_I915_GET_VBLANK_PIPE:
return "DRM_IOCTL_I915_GET_VBLANK_PIPE";
case DRM_IOCTL_I915_VBLANK_SWAP:
return "DRM_IOCTL_I915_VBLANK_SWAP";
case DRM_IOCTL_I915_HWS_ADDR:
return "DRM_IOCTL_I915_HWS_ADDR";
case DRM_IOCTL_I915_GEM_INIT:
return "DRM_IOCTL_I915_GEM_INIT";
case DRM_IOCTL_I915_GEM_EXECBUFFER:
return "DRM_IOCTL_I915_GEM_EXECBUFFER";
case DRM_IOCTL_I915_GEM_EXECBUFFER2_WR:
return "DRM_IOCTL_I915_GEM_EXECBUFFER2_WR";
case DRM_IOCTL_I915_GEM_PIN:
return "DRM_IOCTL_I915_GEM_PIN";
case DRM_IOCTL_I915_GEM_UNPIN:
return "DRM_IOCTL_I915_GEM_UNPIN";
case DRM_IOCTL_I915_GEM_BUSY:
return "DRM_IOCTL_I915_GEM_BUSY";
case DRM_IOCTL_I915_GEM_SET_CACHING:
return "DRM_IOCTL_I915_GEM_SET_CACHING";
case DRM_IOCTL_I915_GEM_GET_CACHING:
return "DRM_IOCTL_I915_GEM_GET_CACHING";
case DRM_IOCTL_I915_GEM_THROTTLE:
return "DRM_IOCTL_I915_GEM_THROTTLE";
case DRM_IOCTL_I915_GEM_ENTERVT:
return "DRM_IOCTL_I915_GEM_ENTERVT";
case DRM_IOCTL_I915_GEM_LEAVEVT:
return "DRM_IOCTL_I915_GEM_LEAVEVT";
case DRM_IOCTL_I915_GEM_CREATE:
return "DRM_IOCTL_I915_GEM_CREATE";
case DRM_IOCTL_I915_GEM_PREAD:
return "DRM_IOCTL_I915_GEM_PREAD";
case DRM_IOCTL_I915_GEM_PWRITE:
return "DRM_IOCTL_I915_GEM_PWRITE";
case DRM_IOCTL_I915_GEM_SET_DOMAIN:
return "DRM_IOCTL_I915_GEM_SET_DOMAIN";
case DRM_IOCTL_I915_GEM_SW_FINISH:
return "DRM_IOCTL_I915_GEM_SW_FINISH";
case DRM_IOCTL_I915_GEM_SET_TILING:
return "DRM_IOCTL_I915_GEM_SET_TILING";
case DRM_IOCTL_I915_GEM_GET_TILING:
return "DRM_IOCTL_I915_GEM_GET_TILING";
case DRM_IOCTL_I915_GEM_GET_APERTURE:
return "DRM_IOCTL_I915_GEM_GET_APERTURE";
case DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID:
return "DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID";
case DRM_IOCTL_I915_GEM_MADVISE:
return "DRM_IOCTL_I915_GEM_MADVISE";
case DRM_IOCTL_I915_OVERLAY_PUT_IMAGE:
return "DRM_IOCTL_I915_OVERLAY_PUT_IMAGE";
case DRM_IOCTL_I915_OVERLAY_ATTRS:
return "DRM_IOCTL_I915_OVERLAY_ATTRS";
case DRM_IOCTL_I915_SET_SPRITE_COLORKEY:
return "DRM_IOCTL_I915_SET_SPRITE_COLORKEY";
case DRM_IOCTL_I915_GET_SPRITE_COLORKEY:
return "DRM_IOCTL_I915_GET_SPRITE_COLORKEY";
case DRM_IOCTL_I915_GEM_CONTEXT_CREATE:
return "DRM_IOCTL_I915_GEM_CONTEXT_CREATE";
case DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT:
return "DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT";
case DRM_IOCTL_I915_GEM_CONTEXT_DESTROY:
return "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY";
case DRM_IOCTL_I915_REG_READ:
return "DRM_IOCTL_I915_REG_READ";
case DRM_IOCTL_I915_GET_RESET_STATS:
return "DRM_IOCTL_I915_GET_RESET_STATS";
case DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM:
return "DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM";
case DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM:
return "DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM";
case DRM_IOCTL_I915_PERF_OPEN:
return "DRM_IOCTL_I915_PERF_OPEN";
case DRM_IOCTL_I915_PERF_ADD_CONFIG:
return "DRM_IOCTL_I915_PERF_ADD_CONFIG";
case DRM_IOCTL_I915_PERF_REMOVE_CONFIG:
return "DRM_IOCTL_I915_PERF_REMOVE_CONFIG";
case DRM_IOCTL_I915_QUERY:
return "DRM_IOCTL_I915_QUERY";
case DRM_IOCTL_I915_GEM_MMAP:
return "DRM_IOCTL_I915_GEM_MMAP";
case DRM_IOCTL_PRIME_FD_TO_HANDLE:
return "DRM_IOCTL_PRIME_FD_TO_HANDLE";
case DRM_IOCTL_PRIME_HANDLE_TO_FD:
return "DRM_IOCTL_PRIME_HANDLE_TO_FD";
default:
return std::to_string(request);
}
}
} // namespace NEO

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

@@ -62,6 +62,8 @@ class IoctlHelper {
virtual ~IoctlHelper() {}
static IoctlHelper *get(const PRODUCT_FAMILY productFamily, const std::string &prelimVersion);
static uint32_t ioctl(Drm *drm, unsigned long request, void *arg);
virtual std::string getIoctlString(unsigned long request);
virtual std::string getIoctlParamString(int param);
virtual IoctlHelper *clone() = 0;
virtual uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle) = 0;
@@ -131,6 +133,8 @@ class IoctlHelperImpl : public IoctlHelperUpstream {
class IoctlHelperPrelim20 : public IoctlHelper {
public:
std::string getIoctlString(unsigned long request) override;
std::string getIoctlParamString(int param) override;
IoctlHelper *clone() override;
uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle) override;

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

@@ -19,6 +19,54 @@
namespace NEO {
std::string IoctlHelperPrelim20::getIoctlString(unsigned long request) {
switch (request) {
case PRELIM_DRM_IOCTL_I915_GEM_VM_BIND:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_BIND";
case PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND";
case PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE:
return "PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE";
case PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT:
return "PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT";
case PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE";
case PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH";
case PRELIM_DRM_IOCTL_I915_UUID_REGISTER:
return "PRELIM_DRM_IOCTL_I915_UUID_REGISTER";
case PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER:
return "PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER";
case PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN:
return "PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN";
case PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE:
return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE";
case PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE:
return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE";
case PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE:
return "PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE";
case DRM_IOCTL_I915_GEM_MMAP_GTT:
return "DRM_IOCTL_I915_GEM_MMAP_GTT";
case DRM_IOCTL_I915_GEM_MMAP_OFFSET:
return "DRM_IOCTL_I915_GEM_MMAP_OFFSET";
case DRM_IOCTL_I915_GEM_VM_CREATE:
return "DRM_IOCTL_I915_GEM_VM_CREATE";
case DRM_IOCTL_I915_GEM_VM_DESTROY:
return "DRM_IOCTL_I915_GEM_VM_DESTROY";
default:
return IoctlHelper::getIoctlString(request);
}
}
std::string IoctlHelperPrelim20::getIoctlParamString(int param) {
switch (param) {
case PRELIM_I915_PARAM_HAS_VM_BIND:
return "PRELIM_I915_PARAM_HAS_VM_BIND";
default:
return IoctlHelper::getIoctlParamString(param);
}
}
IoctlHelper *IoctlHelperPrelim20::clone() {
return new IoctlHelperPrelim20{};
}

3
shared/test/common/libult/linux/drm_mock.h
View File

@@ -286,6 +286,3 @@ class DrmMockResources : public DrmMock {
size_t registeredDataSize;
uint32_t currentCookie = 2;
};
extern std::map<unsigned long, const char *> ioctlCodeStringMap;
extern std::map<int, const char *> ioctlParamCodeStringMap;

1
shared/test/unit_test/os_interface/linux/CMakeLists.txt
View File

@@ -21,6 +21,7 @@ if(NEO_ENABLE_i915_PRELIM_DETECTION)
list(APPEND NEO_CORE_OS_INTERFACE_TESTS_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/drm_cache_info_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_query_topology_prelim_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_with_prelim_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/ioctl_helper_tests_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/prelim_helper_func.cpp
)

12
shared/test/unit_test/os_interface/linux/drm_query_tests.cpp
View File

@@ -60,18 +60,6 @@ HWTEST2_F(HwConfigTopologyQuery, WhenGettingTopologyFailsThenSetMaxValuesBasedOn
EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount);
}
TEST(DrmQueryTest, givenIoctlWhenParseToStringThenProperStringIsReturned) {
for (auto ioctlCodeString : ioctlCodeStringMap) {
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(ioctlCodeString.first).c_str(), ioctlCodeString.second);
}
}
TEST(DrmQueryTest, givenIoctlParamWhenParseToStringThenProperStringIsReturned) {
for (auto ioctlParamCodeString : ioctlParamCodeStringMap) {
EXPECT_STREQ(IoctlToStringHelper::getIoctlParamString(ioctlParamCodeString.first).c_str(), ioctlParamCodeString.second);
}
}
TEST(DrmQueryTest, WhenCallingQueryPageFaultSupportThenReturnFalse) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);

315
shared/test/unit_test/os_interface/linux/drm_with_prelim_tests.cpp Normal file
View File

@@ -0,0 +1,315 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/libult/linux/drm_mock.h"
#include "shared/test/common/mocks/linux/mock_drm_allocation.h"
#include "shared/test/common/test_macros/test.h"
using namespace NEO;
extern int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal, int queryDistanceIoctlRetVal);
class DrmPrelimMock : public DrmMock {
public:
DrmPrelimMock(RootDeviceEnvironment &rootDeviceEnvironment) : DrmPrelimMock(rootDeviceEnvironment, defaultHwInfo.get()) {}
DrmPrelimMock(RootDeviceEnvironment &rootDeviceEnvironment, HardwareInfo *inputHwInfo) : DrmMock(rootDeviceEnvironment) {
rootDeviceEnvironment.setHwInfo(inputHwInfo);
rootDeviceEnvironment.getMutableHardwareInfo()->platform.eProductFamily = IGFX_UNKNOWN;
}
int ioctlRetVal = 0;
int queryDistanceIoctlRetVal = 0;
void getPrelimVersion(std::string &prelimVersion) override {
prelimVersion = "2.0";
}
int handleRemainingRequests(unsigned long request, void *arg) override {
return handlePrelimRequests(request, arg, ioctlRetVal, queryDistanceIoctlRetVal);
}
};
class IoctlHelperPrelimFixture : public ::testing::Test {
public:
void SetUp() override {
executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
drm = std::make_unique<DrmPrelimMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm->setupIoctlHelper(executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->platform.eProductFamily);
}
std::unique_ptr<ExecutionEnvironment> executionEnvironment;
std::unique_ptr<DrmPrelimMock> drm;
};
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCreateGemExtThenReturnSuccess) {
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
EXPECT_EQ(1u, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCreateGemExtWithDebugFlagThenPrintDebugInfo) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.PrintBOCreateDestroyResult.set(true);
testing::internal::CaptureStdout();
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
std::string output = testing::internal::GetCapturedStdout();
std::string expectedOutput("Performing GEM_CREATE_EXT with { size: 1024, param: 0x1000000010001, memory class: 1, memory instance: 0 }\nGEM_CREATE_EXT has returned: 0 BO-1 with size: 1024\n");
EXPECT_EQ(expectedOutput, output);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCallIoctlThenProperIoctlRegistered) {
drm_i915_gem_context_create_ext arg{};
auto ret = IoctlHelper::ioctl(drm.get(), DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT, &arg);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenClosAllocThenReturnCorrectRegion) {
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closAlloc(drm.get());
EXPECT_EQ(CacheRegion::Region1, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsAndInvalidIoctlReturnValWhenClosAllocThenReturnNone) {
drm->ioctlRetVal = -1;
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closAlloc(drm.get());
EXPECT_EQ(CacheRegion::None, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenClosFreeThenReturnCorrectRegion) {
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closFree(drm.get(), CacheRegion::Region2);
EXPECT_EQ(CacheRegion::Region2, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsAndInvalidIoctlReturnValWhenClosFreeThenReturnNone) {
drm->ioctlRetVal = -1;
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closFree(drm.get(), CacheRegion::Region2);
EXPECT_EQ(CacheRegion::None, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenClosAllocWaysThenReturnCorrectRegion) {
auto ioctlHelper = drm->getIoctlHelper();
auto numWays = ioctlHelper->closAllocWays(drm.get(), CacheRegion::Region2, 3, 10);
EXPECT_EQ(10u, numWays);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsAndInvalidIoctlReturnValWhenClosAllocWaysThenReturnNone) {
drm->ioctlRetVal = -1;
auto ioctlHelper = drm->getIoctlHelper();
auto numWays = ioctlHelper->closAllocWays(drm.get(), CacheRegion::Region2, 3, 10);
EXPECT_EQ(0u, numWays);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenWaitUserFenceThenCorrectValueReturned) {
uint64_t gpuAddress = 0x1020304000ull;
uint64_t value = 0x98765ull;
auto ioctlHelper = drm->getIoctlHelper();
for (uint32_t i = 0u; i < 4; i++) {
auto ret = ioctlHelper->waitUserFence(drm.get(), 10u, gpuAddress, value, i, -1, 0u);
EXPECT_EQ(0, ret);
}
}
TEST_F(IoctlHelperPrelimFixture, givenDrmAllocationWhenSetMemAdviseFailsThenDontUpdateMemAdviceFlags) {
drm->ioctlRetVal = -1;
MockBufferObject bo(drm.get(), 0, 0, 1);
MockDrmAllocation allocation(AllocationType::BUFFER, MemoryPool::LocalMemory);
allocation.bufferObjects[0] = &bo;
MemAdviseFlags memAdviseFlags{};
memAdviseFlags.non_atomic = 1;
allocation.setMemAdvise(drm.get(), memAdviseFlags);
EXPECT_EQ(1u, drm->ioctlCallsCount);
EXPECT_NE(memAdviseFlags.memadvise_flags, allocation.enabledMemAdviseFlags.memadvise_flags);
}
TEST_F(IoctlHelperPrelimFixture, givenDrmAllocationWhenSetMemAdviseWithNonAtomicIsCalledThenUpdateTheCorrespondingVmAdviceForBufferObject) {
MockBufferObject bo(drm.get(), 0, 0, 1);
MockDrmAllocation allocation(AllocationType::BUFFER, MemoryPool::LocalMemory);
allocation.bufferObjects[0] = &bo;
MemAdviseFlags memAdviseFlags{};
for (auto nonAtomic : {true, false}) {
memAdviseFlags.non_atomic = nonAtomic;
EXPECT_TRUE(allocation.setMemAdvise(drm.get(), memAdviseFlags));
EXPECT_EQ(memAdviseFlags.memadvise_flags, allocation.enabledMemAdviseFlags.memadvise_flags);
}
EXPECT_EQ(2u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenDrmAllocationWhenSetMemAdviseWithDevicePreferredLocationIsCalledThenUpdateTheCorrespondingVmAdviceForBufferObject) {
MockBufferObject bo(drm.get(), 0, 0, 1);
MockDrmAllocation allocation(AllocationType::BUFFER, MemoryPool::LocalMemory);
allocation.bufferObjects[0] = &bo;
MemAdviseFlags memAdviseFlags{};
for (auto devicePreferredLocation : {true, false}) {
memAdviseFlags.device_preferred_location = devicePreferredLocation;
EXPECT_TRUE(allocation.setMemAdvise(drm.get(), memAdviseFlags));
EXPECT_EQ(memAdviseFlags.memadvise_flags, allocation.enabledMemAdviseFlags.memadvise_flags);
}
EXPECT_EQ(2u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenAppendDrmContextFlagsThenCorrectFlagsSet) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.DirectSubmissionDrmContext.set(-1);
uint32_t ioctlVal = (1u << 31);
drm_i915_gem_context_create_ext ctx{};
drm->appendDrmContextFlags(ctx, true);
EXPECT_EQ(ioctlVal, ctx.flags);
ctx.flags = 0u;
DebugManager.flags.DirectSubmissionDrmContext.set(0);
drm->appendDrmContextFlags(ctx, true);
EXPECT_EQ(0u, ctx.flags);
DebugManager.flags.DirectSubmissionDrmContext.set(1);
drm->appendDrmContextFlags(ctx, false);
EXPECT_EQ(ioctlVal, ctx.flags);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenQueryDistancesThenCorrectDistanceSet) {
std::vector<DistanceInfo> distances(3);
distances[0].engine = {I915_ENGINE_CLASS_RENDER, 0};
distances[0].region = {I915_MEMORY_CLASS_DEVICE, 0};
distances[1].engine = {I915_ENGINE_CLASS_RENDER, 1};
distances[1].region = {I915_MEMORY_CLASS_DEVICE, 1};
distances[2].engine = {I915_ENGINE_CLASS_COPY, 4};
distances[2].region = {I915_MEMORY_CLASS_DEVICE, 2};
std::vector<drm_i915_query_item> queryItems(distances.size());
auto ret = drm->getIoctlHelper()->queryDistances(drm.get(), queryItems, distances);
EXPECT_EQ(0u, ret);
EXPECT_EQ(0, distances[0].distance);
EXPECT_EQ(0, distances[1].distance);
EXPECT_EQ(100, distances[2].distance);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimWhenQueryEngineInfoWithDeviceMemoryThenDistancesUsedAndMultileValuesSet) {
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 2}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
EXPECT_TRUE(drm->queryEngineInfo());
EXPECT_EQ(3u, drm->ioctlCallsCount);
auto hwInfo = drm->getRootDeviceEnvironment().getHardwareInfo();
auto engineInfo = drm->getEngineInfo();
auto &multiTileArchInfo = const_cast<GT_MULTI_TILE_ARCH_INFO &>(hwInfo->gtSystemInfo.MultiTileArchInfo);
EXPECT_TRUE(multiTileArchInfo.IsValid);
EXPECT_EQ(3, multiTileArchInfo.TileCount);
EXPECT_EQ(7, multiTileArchInfo.TileMask);
EXPECT_EQ(1024u, drm->memoryInfo->getMemoryRegionSize(1));
EXPECT_EQ(1024u, drm->memoryInfo->getMemoryRegionSize(2));
EXPECT_EQ(0u, drm->memoryInfo->getMemoryRegionSize(4));
std::vector<EngineClassInstance> engines;
engineInfo->getListOfEnginesOnATile(0u, engines);
EXPECT_EQ(3u, engines.size());
engines.clear();
engineInfo->getListOfEnginesOnATile(1u, engines);
EXPECT_EQ(3u, engines.size());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimWhenQueryEngineInfoThenCorrectCCSFlagsSet) {
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
EXPECT_TRUE(drm->queryEngineInfo());
EXPECT_EQ(3u, drm->ioctlCallsCount);
auto hwInfo = drm->getRootDeviceEnvironment().getHardwareInfo();
auto ccsInfo = hwInfo->gtSystemInfo.CCSInfo;
EXPECT_TRUE(ccsInfo.IsValid);
EXPECT_EQ(1u, ccsInfo.NumberOfCCSEnabled);
EXPECT_EQ(1u, ccsInfo.Instances.CCSEnableMask);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimWhenSysmanQueryEngineInfoThenAdditionalEnginesUsed) {
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 2}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
EXPECT_TRUE(drm->sysmanQueryEngineInfo());
EXPECT_EQ(3u, drm->ioctlCallsCount);
auto engineInfo = drm->getEngineInfo();
std::vector<EngineClassInstance> engines;
engineInfo->getListOfEnginesOnATile(0u, engines);
EXPECT_EQ(5u, engines.size());
engines.clear();
engineInfo->getListOfEnginesOnATile(1u, engines);
EXPECT_EQ(5u, engines.size());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimWhenQueryEngineInfoAndFailIoctlThenFalseReturned) {
drm->queryDistanceIoctlRetVal = -1;
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 2}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
EXPECT_FALSE(drm->queryEngineInfo());
EXPECT_EQ(3u, drm->ioctlCallsCount);
auto engineInfo = drm->getEngineInfo();
EXPECT_EQ(nullptr, engineInfo);
}

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

@@ -5,92 +5,64 @@
*
*/
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/libult/linux/drm_mock.h"
#include "shared/test/common/mocks/linux/mock_drm_allocation.h"
#include "shared/test/common/test_macros/test.h"
#include "third_party/uapi/prelim/drm/i915_drm.h"
using namespace NEO;
extern int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal, int queryDistanceIoctlRetVal);
extern std::map<unsigned long, const char *> ioctlCodeStringMap;
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);
class DrmPrelimMock : public DrmMock {
public:
DrmPrelimMock(RootDeviceEnvironment &rootDeviceEnvironment) : DrmPrelimMock(rootDeviceEnvironment, defaultHwInfo.get()) {}
DrmPrelimMock(RootDeviceEnvironment &rootDeviceEnvironment, HardwareInfo *inputHwInfo) : DrmMock(rootDeviceEnvironment) {
rootDeviceEnvironment.setHwInfo(inputHwInfo);
rootDeviceEnvironment.getMutableHardwareInfo()->platform.eProductFamily = IGFX_UNKNOWN;
}
int ioctlRetVal = 0;
int queryDistanceIoctlRetVal = 0;
void getPrelimVersion(std::string &prelimVersion) override {
prelimVersion = "2.0";
}
int handleRemainingRequests(unsigned long request, void *arg) override {
return handlePrelimRequests(request, arg, ioctlRetVal, queryDistanceIoctlRetVal);
}
struct IoctlPrelimHelperTests : ::testing::Test {
IoctlHelperPrelim20 ioctlHelper{};
};
class IoctlHelperPrelimFixture : public ::testing::Test {
public:
void SetUp() override {
executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
drm = std::make_unique<DrmPrelimMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm->setupIoctlHelper(executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->platform.eProductFamily);
TEST_F(IoctlPrelimHelperTests, givenIoctlWhenParseToStringThenProperStringIsReturned) {
for (auto &ioctlCodeString : ioctlCodeStringMap) {
EXPECT_STREQ(ioctlHelper.getIoctlString(ioctlCodeString.first).c_str(), ioctlCodeString.second);
}
std::unique_ptr<ExecutionEnvironment> executionEnvironment;
std::unique_ptr<DrmPrelimMock> drm;
};
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCreateGemExtThenReturnSuccess) {
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
EXPECT_EQ(1u, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
EXPECT_STREQ(ioctlHelper.getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_VM_BIND).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_VM_BIND");
EXPECT_STREQ(ioctlHelper.getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND");
EXPECT_STREQ(ioctlHelper.getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE");
EXPECT_STREQ(ioctlHelper.getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT");
EXPECT_STREQ(ioctlHelper.getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE");
EXPECT_STREQ(ioctlHelper.getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH");
EXPECT_STREQ(ioctlHelper.getIoctlString(PRELIM_DRM_IOCTL_I915_UUID_REGISTER).c_str(), "PRELIM_DRM_IOCTL_I915_UUID_REGISTER");
EXPECT_STREQ(ioctlHelper.getIoctlString(PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER).c_str(), "PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER");
EXPECT_STREQ(ioctlHelper.getIoctlString(PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN).c_str(), "PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN");
EXPECT_STREQ(ioctlHelper.getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE");
EXPECT_STREQ(ioctlHelper.getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE");
EXPECT_STREQ(ioctlHelper.getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE");
EXPECT_STREQ(ioctlHelper.getIoctlString(DRM_IOCTL_I915_GEM_MMAP_GTT).c_str(), "DRM_IOCTL_I915_GEM_MMAP_GTT");
EXPECT_STREQ(ioctlHelper.getIoctlString(DRM_IOCTL_I915_GEM_MMAP_OFFSET).c_str(), "DRM_IOCTL_I915_GEM_MMAP_OFFSET");
EXPECT_STREQ(ioctlHelper.getIoctlString(DRM_IOCTL_I915_GEM_VM_CREATE).c_str(), "DRM_IOCTL_I915_GEM_VM_CREATE");
EXPECT_STREQ(ioctlHelper.getIoctlString(DRM_IOCTL_I915_GEM_VM_DESTROY).c_str(), "DRM_IOCTL_I915_GEM_VM_DESTROY");
EXPECT_STREQ(ioctlHelper.getIoctlString(DRM_IOCTL_I915_GEM_VM_DESTROY).c_str(), "DRM_IOCTL_I915_GEM_VM_DESTROY");
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCreateGemExtWithDebugFlagThenPrintDebugInfo) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.PrintBOCreateDestroyResult.set(true);
testing::internal::CaptureStdout();
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
std::string output = testing::internal::GetCapturedStdout();
std::string expectedOutput("Performing GEM_CREATE_EXT with { size: 1024, param: 0x1000000010001, memory class: 1, memory instance: 0 }\nGEM_CREATE_EXT has returned: 0 BO-1 with size: 1024\n");
EXPECT_EQ(expectedOutput, output);
TEST_F(IoctlPrelimHelperTests, givenIoctlParamWhenParseToStringThenProperStringIsReturned) {
for (auto &ioctlParamCodeString : ioctlParamCodeStringMap) {
EXPECT_STREQ(ioctlHelper.getIoctlParamString(ioctlParamCodeString.first).c_str(), ioctlParamCodeString.second);
}
EXPECT_STREQ(ioctlHelper.getIoctlParamString(PRELIM_I915_PARAM_HAS_VM_BIND).c_str(), "PRELIM_I915_PARAM_HAS_VM_BIND");
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenTranslateToMemoryRegionsThenReturnSameData) {
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenTranslateToMemoryRegionsThenReturnSameData) {
std::vector<MemoryRegion> expectedMemRegions(2);
expectedMemRegions[0].region.memoryClass = I915_MEMORY_CLASS_SYSTEM;
expectedMemRegions[0].region.memoryClass = PRELIM_I915_MEMORY_CLASS_SYSTEM;
expectedMemRegions[0].region.memoryInstance = 0;
expectedMemRegions[0].probedSize = 1024;
expectedMemRegions[1].region.memoryClass = I915_MEMORY_CLASS_DEVICE;
expectedMemRegions[1].region.memoryClass = PRELIM_I915_MEMORY_CLASS_DEVICE;
expectedMemRegions[1].region.memoryInstance = 0;
expectedMemRegions[1].probedSize = 1024;
auto regionInfo = getRegionInfo(expectedMemRegions);
auto ioctlHelper = drm->getIoctlHelper();
auto memRegions = ioctlHelper->translateToMemoryRegions(regionInfo);
auto memRegions = ioctlHelper.translateToMemoryRegions(regionInfo);
EXPECT_EQ(2u, memRegions.size());
for (uint32_t i = 0; i < memRegions.size(); i++) {
EXPECT_EQ(expectedMemRegions[i].region.memoryClass, memRegions[i].region.memoryClass);
@@ -100,175 +72,30 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenTranslateToMemoryRegionsThenRet
}
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCallIoctlThenProperIoctlRegistered) {
drm_i915_gem_context_create_ext arg{};
auto ret = IoctlHelper::ioctl(drm.get(), DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT, &arg);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenGetHwConfigIoctlValThenCorrectValueReturned) {
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_I915_QUERY_HWCONFIG_TABLE), ioctlHelper.getHwConfigIoctlVal());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenClosAllocThenReturnCorrectRegion) {
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closAlloc(drm.get());
EXPECT_EQ(CacheRegion::Region1, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenGetDirectSubmissionFlagThenCorrectValueReturned) {
EXPECT_EQ(PRELIM_I915_CONTEXT_CREATE_FLAGS_ULLS, ioctlHelper.getDirectSubmissionFlag());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsAndInvalidIoctlReturnValWhenClosAllocThenReturnNone) {
drm->ioctlRetVal = -1;
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closAlloc(drm.get());
EXPECT_EQ(CacheRegion::None, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenGetMemRegionsIoctlValThenCorrectValueReturned) {
EXPECT_EQ(PRELIM_DRM_I915_QUERY_MEMORY_REGIONS, ioctlHelper.getMemRegionsIoctlVal());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenClosFreeThenReturnCorrectRegion) {
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closFree(drm.get(), CacheRegion::Region2);
EXPECT_EQ(CacheRegion::Region2, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenGetEngineInfoIoctlValThenCorrectValueReturned) {
EXPECT_EQ(PRELIM_DRM_I915_QUERY_ENGINE_INFO, ioctlHelper.getEngineInfoIoctlVal());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsAndInvalidIoctlReturnValWhenClosFreeThenReturnNone) {
drm->ioctlRetVal = -1;
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closFree(drm.get(), CacheRegion::Region2);
EXPECT_EQ(CacheRegion::None, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenClosAllocWaysThenReturnCorrectRegion) {
auto ioctlHelper = drm->getIoctlHelper();
auto numWays = ioctlHelper->closAllocWays(drm.get(), CacheRegion::Region2, 3, 10);
EXPECT_EQ(10u, numWays);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsAndInvalidIoctlReturnValWhenClosAllocWaysThenReturnNone) {
drm->ioctlRetVal = -1;
auto ioctlHelper = drm->getIoctlHelper();
auto numWays = ioctlHelper->closAllocWays(drm.get(), CacheRegion::Region2, 3, 10);
EXPECT_EQ(0u, numWays);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenWaitUserFenceThenCorrectValueReturned) {
uint64_t gpuAddress = 0x1020304000ull;
uint64_t value = 0x98765ull;
auto ioctlHelper = drm->getIoctlHelper();
for (uint32_t i = 0u; i < 4; i++) {
auto ret = ioctlHelper->waitUserFence(drm.get(), 10u, gpuAddress, value, i, -1, 0u);
EXPECT_EQ(0, ret);
}
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenGetHwConfigIoctlValThenCorrectValueReturned) {
uint32_t ioctlVal = (1 << 16) | 6;
EXPECT_EQ(ioctlVal, drm->getIoctlHelper()->getHwConfigIoctlVal());
}
TEST_F(IoctlHelperPrelimFixture, givenDrmAllocationWhenSetMemAdviseFailsThenDontUpdateMemAdviceFlags) {
drm->ioctlRetVal = -1;
MockBufferObject bo(drm.get(), 0, 0, 1);
MockDrmAllocation allocation(AllocationType::BUFFER, MemoryPool::LocalMemory);
allocation.bufferObjects[0] = &bo;
MemAdviseFlags memAdviseFlags{};
memAdviseFlags.non_atomic = 1;
allocation.setMemAdvise(drm.get(), memAdviseFlags);
EXPECT_EQ(1u, drm->ioctlCallsCount);
EXPECT_NE(memAdviseFlags.memadvise_flags, allocation.enabledMemAdviseFlags.memadvise_flags);
}
TEST_F(IoctlHelperPrelimFixture, givenDrmAllocationWhenSetMemAdviseWithNonAtomicIsCalledThenUpdateTheCorrespondingVmAdviceForBufferObject) {
MockBufferObject bo(drm.get(), 0, 0, 1);
MockDrmAllocation allocation(AllocationType::BUFFER, MemoryPool::LocalMemory);
allocation.bufferObjects[0] = &bo;
MemAdviseFlags memAdviseFlags{};
for (auto nonAtomic : {true, false}) {
memAdviseFlags.non_atomic = nonAtomic;
EXPECT_TRUE(allocation.setMemAdvise(drm.get(), memAdviseFlags));
EXPECT_EQ(memAdviseFlags.memadvise_flags, allocation.enabledMemAdviseFlags.memadvise_flags);
}
EXPECT_EQ(2u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenDrmAllocationWhenSetMemAdviseWithDevicePreferredLocationIsCalledThenUpdateTheCorrespondingVmAdviceForBufferObject) {
MockBufferObject bo(drm.get(), 0, 0, 1);
MockDrmAllocation allocation(AllocationType::BUFFER, MemoryPool::LocalMemory);
allocation.bufferObjects[0] = &bo;
MemAdviseFlags memAdviseFlags{};
for (auto devicePreferredLocation : {true, false}) {
memAdviseFlags.device_preferred_location = devicePreferredLocation;
EXPECT_TRUE(allocation.setMemAdvise(drm.get(), memAdviseFlags));
EXPECT_EQ(memAdviseFlags.memadvise_flags, allocation.enabledMemAdviseFlags.memadvise_flags);
}
EXPECT_EQ(2u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenGetDirectSubmissionFlagThenCorrectValueReturned) {
uint32_t ioctlVal = (1u << 31);
EXPECT_EQ(ioctlVal, drm->getIoctlHelper()->getDirectSubmissionFlag());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenAppendDrmContextFlagsThenCorrectFlagsSet) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.DirectSubmissionDrmContext.set(-1);
uint32_t ioctlVal = (1u << 31);
drm_i915_gem_context_create_ext ctx{};
drm->appendDrmContextFlags(ctx, true);
EXPECT_EQ(ioctlVal, ctx.flags);
ctx.flags = 0u;
DebugManager.flags.DirectSubmissionDrmContext.set(0);
drm->appendDrmContextFlags(ctx, true);
EXPECT_EQ(0u, ctx.flags);
DebugManager.flags.DirectSubmissionDrmContext.set(1);
drm->appendDrmContextFlags(ctx, false);
EXPECT_EQ(ioctlVal, ctx.flags);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenGetMemRegionsIoctlValThenCorrectValueReturned) {
int32_t ioctlVal = (1 << 16) | 4;
EXPECT_EQ(ioctlVal, drm->getIoctlHelper()->getMemRegionsIoctlVal());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenGetEngineInfoIoctlValThenCorrectValueReturned) {
int32_t ioctlVal = (1 << 16) | 13;
EXPECT_EQ(ioctlVal, drm->getIoctlHelper()->getEngineInfoIoctlVal());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenTranslateToEngineCapsThenReturnSameData) {
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenTranslateToEngineCapsThenReturnSameData) {
std::vector<EngineCapabilities> expectedEngines(2);
expectedEngines[0] = {{I915_ENGINE_CLASS_RENDER, 0}, 0};
expectedEngines[1] = {{I915_ENGINE_CLASS_COPY, 1}, 0};
auto engineInfo = getEngineInfo(expectedEngines);
auto ioctlHelper = drm->getIoctlHelper();
auto engines = ioctlHelper->translateToEngineCaps(engineInfo);
auto engines = ioctlHelper.translateToEngineCaps(engineInfo);
EXPECT_EQ(2u, engines.size());
for (uint32_t i = 0; i < engines.size(); i++) {
EXPECT_EQ(expectedEngines[i].engine.engineClass, engines[i].engine.engineClass);
@@ -277,106 +104,6 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenTranslateToEngineCapsThenReturn
}
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenQueryDistancesThenCorrectDistanceSet) {
std::vector<DistanceInfo> distances(3);
distances[0].engine = {I915_ENGINE_CLASS_RENDER, 0};
distances[0].region = {I915_MEMORY_CLASS_DEVICE, 0};
distances[1].engine = {I915_ENGINE_CLASS_RENDER, 1};
distances[1].region = {I915_MEMORY_CLASS_DEVICE, 1};
distances[2].engine = {I915_ENGINE_CLASS_COPY, 4};
distances[2].region = {I915_MEMORY_CLASS_DEVICE, 2};
std::vector<drm_i915_query_item> queryItems(distances.size());
auto ret = drm->getIoctlHelper()->queryDistances(drm.get(), queryItems, distances);
EXPECT_EQ(0u, ret);
EXPECT_EQ(0, distances[0].distance);
EXPECT_EQ(0, distances[1].distance);
EXPECT_EQ(100, distances[2].distance);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimWhenQueryEngineInfoWithDeviceMemoryThenDistancesUsedAndMultileValuesSet) {
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 2}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
EXPECT_TRUE(drm->queryEngineInfo());
EXPECT_EQ(3u, drm->ioctlCallsCount);
auto hwInfo = drm->getRootDeviceEnvironment().getHardwareInfo();
auto engineInfo = drm->getEngineInfo();
auto &multiTileArchInfo = const_cast<GT_MULTI_TILE_ARCH_INFO &>(hwInfo->gtSystemInfo.MultiTileArchInfo);
EXPECT_TRUE(multiTileArchInfo.IsValid);
EXPECT_EQ(3, multiTileArchInfo.TileCount);
EXPECT_EQ(7, multiTileArchInfo.TileMask);
EXPECT_EQ(1024u, drm->memoryInfo->getMemoryRegionSize(1));
EXPECT_EQ(1024u, drm->memoryInfo->getMemoryRegionSize(2));
EXPECT_EQ(0u, drm->memoryInfo->getMemoryRegionSize(4));
std::vector<EngineClassInstance> engines;
engineInfo->getListOfEnginesOnATile(0u, engines);
EXPECT_EQ(3u, engines.size());
engines.clear();
engineInfo->getListOfEnginesOnATile(1u, engines);
EXPECT_EQ(3u, engines.size());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimWhenQueryEngineInfoThenCorrectCCSFlagsSet) {
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
EXPECT_TRUE(drm->queryEngineInfo());
EXPECT_EQ(3u, drm->ioctlCallsCount);
auto hwInfo = drm->getRootDeviceEnvironment().getHardwareInfo();
auto ccsInfo = hwInfo->gtSystemInfo.CCSInfo;
EXPECT_TRUE(ccsInfo.IsValid);
EXPECT_EQ(1u, ccsInfo.NumberOfCCSEnabled);
EXPECT_EQ(1u, ccsInfo.Instances.CCSEnableMask);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimWhenSysmanQueryEngineInfoThenAdditionalEnginesUsed) {
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 2}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
EXPECT_TRUE(drm->sysmanQueryEngineInfo());
EXPECT_EQ(3u, drm->ioctlCallsCount);
auto engineInfo = drm->getEngineInfo();
std::vector<EngineClassInstance> engines;
engineInfo->getListOfEnginesOnATile(0u, engines);
EXPECT_EQ(5u, engines.size());
engines.clear();
engineInfo->getListOfEnginesOnATile(1u, engines);
EXPECT_EQ(5u, engines.size());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimWhenQueryEngineInfoAndFailIoctlThenFalseReturned) {
drm->queryDistanceIoctlRetVal = -1;
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 2}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
EXPECT_FALSE(drm->queryEngineInfo());
EXPECT_EQ(3u, drm->ioctlCallsCount);
auto engineInfo = drm->getEngineInfo();
EXPECT_EQ(nullptr, engineInfo);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenGettingFlagForWaitUserFenceSoftThenProperFlagIsReturned) {
auto ioctlHelper = drm->getIoctlHelper();
EXPECT_EQ((1u << 15), ioctlHelper->getWaitUserFenceSoftFlag());
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenGettingFlagForWaitUserFenceSoftThenProperFlagIsReturned) {
EXPECT_EQ(PRELIM_I915_UFENCE_WAIT_SOFT, ioctlHelper.getWaitUserFenceSoftFlag());
}

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

@@ -13,6 +13,22 @@
#include "shared/test/unit_test/os_interface/linux/drm_mock_impl.h"
using namespace NEO;
extern std::map<unsigned long, const char *> ioctlCodeStringMap;
extern std::map<int, const char *> ioctlParamCodeStringMap;
TEST(IoctlHelperUpstreamTest, givenIoctlWhenParseToStringThenProperStringIsReturned) {
IoctlHelperUpstream ioctlHelper{};
for (auto ioctlCodeString : ioctlCodeStringMap) {
EXPECT_STREQ(ioctlHelper.getIoctlString(ioctlCodeString.first).c_str(), ioctlCodeString.second);
}
}
TEST(IoctlHelperUpstreamTest, givenIoctlParamWhenParseToStringThenProperStringIsReturned) {
IoctlHelperUpstream ioctlHelper{};
for (auto ioctlParamCodeString : ioctlParamCodeStringMap) {
EXPECT_STREQ(ioctlHelper.getIoctlParamString(ioctlParamCodeString.first).c_str(), ioctlParamCodeString.second);
}
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenCreateGemExtThenReturnCorrectValue) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();