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

Move EngineType to aub_stream. 

Change-Id: Ieaa75aaf4aca4487833754eb38ff709adcbf0f11
Signed-off-by: Piotr Fusik <piotr.fusik@intel.com>
This commit is contained in:
Piotr Fusik 2019-03-27 10:06:29 +01:00
parent 4296588aa9
commit d4a0c4852b
78 changed files with 188 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
CMakeLists.txt
View File

@ -363,7 +363,7 @@ if(NOT INSTRUMENTATION_LIB_NAME)
endif()
endif()
if(IS_DIRECTORY "${INSTRUMENTATION_SOURCE_DIR}")
message(STATUS "Intrumentation source dir is: ${INSTRUMENTATION_SOURCE_DIR}")
message(STATUS "Instrumentation source dir is: ${INSTRUMENTATION_SOURCE_DIR}")
add_subdirectory("${INSTRUMENTATION_SOURCE_DIR}" "${IGDRCL_BUILD_DIR}/instrumentation")
set(INSTRUMENTATION_LIB_NAME "instrumentation_umd")
set(HAVE_INSTRUMENTATION TRUE)
@ -428,11 +428,16 @@ endif()
add_subdirectory(third_party/gtest)
message(STATUS "AUB_STREAM_DIR = ${AUB_STREAM_DIR}" )
if(DEFINED AUB_STREAM_DIR)
set(AUB_STREAM_PROJECT_NAME "aub_stream")
add_subdirectory(${AUB_STREAM_DIR} ${CMAKE_BINARY_DIR}/aub_stream EXCLUDE_FROM_ALL)
set(ENGINE_NODE_DIR ${AUB_STREAM_DIR}/aub_mem_dump${BRANCH_DIR_SUFFIX}/includes)
else()
set(ENGINE_NODE_DIR ${AUB_STREAM_HEADERS_DIR})
endif()
message(STATUS "Engine node dir: ${ENGINE_NODE_DIR}")
add_definitions(-DGMM_OCL)

1
offline_compiler/CMakeLists.txt
View File

@ -75,6 +75,7 @@ add_subdirectories()
create_project_source_tree(ocloc ${IGDRCL_SOURCE_DIR}/runtime)
set(CLOC_INCLUDES
${ENGINE_NODE_DIR}
${IGC_OCL_ADAPTOR_DIR}
${CIF_BASE_DIR}
${HW_SRC_INCLUDE_PATH}

1
runtime/CMakeLists.txt
View File

@ -58,6 +58,7 @@ target_include_directories(${NEO_STATIC_LIB_NAME} PRIVATE
)
target_include_directories(${NEO_STATIC_LIB_NAME} PUBLIC
${ENGINE_NODE_DIR}
${KHRONOS_HEADERS_DIR}
${KHRONOS_GL_HEADERS_DIR}
${CIF_BASE_DIR}

3
runtime/built_ins/builtins_binary.cmake
View File

@ -1,5 +1,5 @@
#
# Copyright (C) 2018 Intel Corporation
# Copyright (C) 2018-2019 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@ -51,6 +51,7 @@ set_target_properties(${BUILTINS_BINARIES_LIB_NAME} PROPERTIES POSITION_INDEPEND
set_target_properties(${BUILTINS_BINARIES_LIB_NAME} PROPERTIES FOLDER "built_ins")
target_include_directories(${BUILTINS_BINARIES_LIB_NAME} PRIVATE
${ENGINE_NODE_DIR}
${KHRONOS_HEADERS_DIR}
${KHRONOS_GL_HEADERS_DIR}
${UMKM_SHAREDDATA_INCLUDE_PATHS}

19
runtime/built_ins/registry/CMakeLists.txt
View File

@ -1,22 +1,8 @@
# Copyright (c) 2017, Intel Corporation
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
# Copyright (C) 2017-2019 Intel Corporation
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
# SPDX-License-Identifier: MIT
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.
add_library(${BUILTINS_SOURCES_LIB_NAME} OBJECT
CMakeLists.txt
@ -29,6 +15,7 @@ set_target_properties(${BUILTINS_SOURCES_LIB_NAME} PROPERTIES POSITION_INDEPENDE
set_target_properties(${BUILTINS_SOURCES_LIB_NAME} PROPERTIES FOLDER "built_ins")
target_include_directories(${BUILTINS_SOURCES_LIB_NAME} PRIVATE
${ENGINE_NODE_DIR}
${KHRONOS_HEADERS_DIR}
${KHRONOS_GL_HEADERS_DIR}
${UMKM_SHAREDDATA_INCLUDE_PATHS}

3
runtime/builtin_kernels_simulation/CMakeLists.txt
View File

@ -1,5 +1,5 @@
#
# Copyright (C) 2017-2018 Intel Corporation
# Copyright (C) 2017-2019 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@ -44,6 +44,7 @@ apply_macro_for_each_gen("SUPPORTED")
add_library(${BIKSIM_LIB_NAME} OBJECT ${BUILTIN_KERNELS_SIMULATION_SRCS})
target_include_directories(${BIKSIM_LIB_NAME} BEFORE PRIVATE
${ENGINE_NODE_DIR}
${UMKM_SHAREDDATA_INCLUDE_PATHS}
${KHRONOS_HEADERS_DIR}
${KHRONOS_GL_HEADERS_DIR}

2
runtime/command_queue/command_queue_hw.h
View File

@ -36,7 +36,7 @@ class CommandQueueHw : public CommandQueue {
if (clPriority & static_cast<cl_queue_priority_khr>(CL_QUEUE_PRIORITY_LOW_KHR)) {
priority = QueuePriority::LOW;
this->engine = &device->getEngine(EngineType::ENGINE_RCS, true);
this->engine = &device->getEngine(aub_stream::ENGINE_RCS, true);
} else if (clPriority & static_cast<cl_queue_priority_khr>(CL_QUEUE_PRIORITY_MED_KHR)) {
priority = QueuePriority::MEDIUM;
} else if (clPriority & static_cast<cl_queue_priority_khr>(CL_QUEUE_PRIORITY_HIGH_KHR)) {

1
runtime/command_stream/CMakeLists.txt
View File

@ -23,7 +23,6 @@ set(RUNTIME_SRCS_COMMAND_STREAM
${CMAKE_CURRENT_SOURCE_DIR}/create_command_stream_impl.h
${CMAKE_CURRENT_SOURCE_DIR}/csr_definitions.h
${CMAKE_CURRENT_SOURCE_DIR}/definitions${BRANCH_DIR_SUFFIX}/command_stream_receiver_simulated_hw.h
${CMAKE_CURRENT_SOURCE_DIR}/definitions${BRANCH_DIR_SUFFIX}/engine_node.h
${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_simulated_common_hw.h
${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_simulated_common_hw.inl
${CMAKE_CURRENT_SOURCE_DIR}/device_command_stream.h

2
runtime/command_stream/command_stream_receiver_simulated_common_hw.h
View File

@ -42,7 +42,7 @@ class CommandStreamReceiverSimulatedCommonHw : public CommandStreamReceiverHw<Gf
uint64_t getPPGTTAdditionalBits(GraphicsAllocation *gfxAllocation);
void getGTTData(void *memory, AubGTTData &data);
uint32_t getMemoryBankForGtt() const;
static const AubMemDump::LrcaHelper &getCsTraits(EngineType engineType);
static const AubMemDump::LrcaHelper &getCsTraits(aub_stream::EngineType engineType);
void initEngineMMIO();
void submitLRCA(const MiContextDescriptorReg &contextDescriptor);
void setupContext(OsContext &osContext) override;

2
runtime/command_stream/command_stream_receiver_simulated_common_hw.inl
View File

@ -56,7 +56,7 @@ uint32_t CommandStreamReceiverSimulatedCommonHw<GfxFamily>::getMemoryBankForGtt(
}
template <typename GfxFamily>
const AubMemDump::LrcaHelper &CommandStreamReceiverSimulatedCommonHw<GfxFamily>::getCsTraits(EngineType engineType) {
const AubMemDump::LrcaHelper &CommandStreamReceiverSimulatedCommonHw<GfxFamily>::getCsTraits(aub_stream::EngineType engineType) {
return *AUBFamilyMapper<GfxFamily>::csTraits[engineType];
}

2
runtime/device/device.cpp
View File

@ -278,7 +278,7 @@ void Device::initMaxPowerSavingMode() {
}
}
EngineControl &Device::getEngine(EngineType engineType, bool lowPriority) {
EngineControl &Device::getEngine(aub_stream::EngineType engineType, bool lowPriority) {
for (auto &engine : engines) {
if (engine.osContext->getEngineType() == engineType &&
engine.osContext->isLowPriority() == lowPriority) {

2
runtime/device/device.h
View File

@ -72,7 +72,7 @@ class Device : public BaseObject<_cl_device_id> {
deviceInfo.force32BitAddressess = value;
}
EngineControl &getEngine(EngineType engineType, bool lowPriority);
EngineControl &getEngine(aub_stream::EngineType engineType, bool lowPriority);
EngineControl &getDefaultEngine();
const char *getProductAbbrev() const;

6
runtime/gen10/aub_mapper.h
View File

@ -9,6 +9,8 @@
#include "runtime/gen_common/aub_mapper_base.h"
#include "runtime/memory_manager/memory_constants.h"
#include "engine_node.h"
namespace NEO {
struct CNLFamily;
@ -18,10 +20,10 @@ struct AUBFamilyMapper<CNLFamily> {
using AubTraits = AubMemDump::Traits<device, MemoryConstants::GfxAddressBits>;
static const AubMemDump::LrcaHelper *const csTraits[EngineType::NUM_ENGINES];
static const AubMemDump::LrcaHelper *const csTraits[aub_stream::NUM_ENGINES];
static const MMIOList globalMMIO;
static const MMIOList *perEngineMMIO[EngineType::NUM_ENGINES];
static const MMIOList *perEngineMMIO[aub_stream::NUM_ENGINES];
typedef AubMemDump::AubDump<AubTraits> AUB;
};

4
runtime/gen10/aub_mem_dump_gen10.cpp
View File

@ -35,7 +35,7 @@ static const AubMemDump::LrcaHelperBcs bcs(0x022000);
static const AubMemDump::LrcaHelperVcs vcs(0x012000);
static const AubMemDump::LrcaHelperVecs vecs(0x01a000);
const AubMemDump::LrcaHelper *const AUBFamilyMapper<Family>::csTraits[EngineType::NUM_ENGINES] = {
const AubMemDump::LrcaHelper *const AUBFamilyMapper<Family>::csTraits[aub_stream::NUM_ENGINES] = {
&rcs,
&bcs,
&vcs,
@ -73,7 +73,7 @@ static const MMIOList mmioListVECS = {
MMIOPair(AubMemDump::computeRegisterOffset(vecs.mmioBase, 0x229c), 0xffff8280),
};
const MMIOList *AUBFamilyMapper<Family>::perEngineMMIO[EngineType::NUM_ENGINES] = {
const MMIOList *AUBFamilyMapper<Family>::perEngineMMIO[aub_stream::NUM_ENGINES] = {
&mmioListRCS,
&mmioListBCS,
&mmioListVCS,

2
runtime/gen10/hw_info_cnl.inl
View File

@ -47,7 +47,7 @@ const RuntimeCapabilityTable CNL::capabilityTable{
MemoryConstants::pageSize, // requiredPreemptionSurfaceSize
&isSimulationCNL, // isSimulation
PreemptionMode::MidThread, // defaultPreemptionMode
EngineType::ENGINE_RCS, // defaultEngineType
aub_stream::ENGINE_RCS, // defaultEngineType
0, // maxRenderFrequency
21, // clVersionSupport
CmdServicesMemTraceVersion::DeviceValues::Cnl, // aubDeviceId

6
runtime/gen8/aub_mapper.h
View File

@ -9,6 +9,8 @@
#include "runtime/gen_common/aub_mapper_base.h"
#include "runtime/memory_manager/memory_constants.h"
#include "engine_node.h"
namespace NEO {
struct BDWFamily;
@ -18,10 +20,10 @@ struct AUBFamilyMapper<BDWFamily> {
using AubTraits = AubMemDump::Traits<device, MemoryConstants::GfxAddressBits>;
static const AubMemDump::LrcaHelper *const csTraits[EngineType::NUM_ENGINES];
static const AubMemDump::LrcaHelper *const csTraits[aub_stream::NUM_ENGINES];
static const MMIOList globalMMIO;
static const MMIOList *perEngineMMIO[EngineType::NUM_ENGINES];
static const MMIOList *perEngineMMIO[aub_stream::NUM_ENGINES];
typedef AubMemDump::AubDump<AubTraits> AUB;
};

4
runtime/gen8/aub_mem_dump_gen8.cpp
View File

@ -33,7 +33,7 @@ static const AubMemDump::LrcaHelperBcs bcs(0x022000);
static const AubMemDump::LrcaHelperVcs vcs(0x012000);
static const AubMemDump::LrcaHelperVecs vecs(0x01a000);
const AubMemDump::LrcaHelper *const AUBFamilyMapper<Family>::csTraits[EngineType::NUM_ENGINES] = {
const AubMemDump::LrcaHelper *const AUBFamilyMapper<Family>::csTraits[aub_stream::NUM_ENGINES] = {
&rcs,
&bcs,
&vcs,
@ -58,7 +58,7 @@ static const MMIOList mmioListVECS = {
MMIOPair(AubMemDump::computeRegisterOffset(vecs.mmioBase, 0x229c), 0xffff8280),
};
const MMIOList *AUBFamilyMapper<Family>::perEngineMMIO[EngineType::NUM_ENGINES] = {
const MMIOList *AUBFamilyMapper<Family>::perEngineMMIO[aub_stream::NUM_ENGINES] = {
&mmioListRCS,
&mmioListBCS,
&mmioListVCS,

2
runtime/gen8/hw_info_bdw.inl
View File

@ -48,7 +48,7 @@ const RuntimeCapabilityTable BDW::capabilityTable{
MemoryConstants::pageSize, // requiredPreemptionSurfaceSize
&isSimulationBDW, // isSimulation
PreemptionMode::Disabled, // defaultPreemptionMode
EngineType::ENGINE_RCS, // defaultEngineType
aub_stream::ENGINE_RCS, // defaultEngineType
0, // maxRenderFrequency
21, // clVersionSupport
CmdServicesMemTraceVersion::DeviceValues::Bdw, // aubDeviceId

6
runtime/gen9/aub_mapper.h
View File

@ -9,6 +9,8 @@
#include "runtime/gen_common/aub_mapper_base.h"
#include "runtime/memory_manager/memory_constants.h"
#include "engine_node.h"
namespace NEO {
struct SKLFamily;
@ -18,10 +20,10 @@ struct AUBFamilyMapper<SKLFamily> {
using AubTraits = AubMemDump::Traits<device, MemoryConstants::GfxAddressBits>;
static const AubMemDump::LrcaHelper *const csTraits[EngineType::NUM_ENGINES];
static const AubMemDump::LrcaHelper *const csTraits[aub_stream::NUM_ENGINES];
static const MMIOList globalMMIO;
static const MMIOList *perEngineMMIO[EngineType::NUM_ENGINES];
static const MMIOList *perEngineMMIO[aub_stream::NUM_ENGINES];
typedef AubMemDump::AubDump<AubTraits> AUB;
};

4
runtime/gen9/aub_mem_dump_gen9.cpp
View File

@ -33,7 +33,7 @@ static const AubMemDump::LrcaHelperBcs bcs(0x022000);
static const AubMemDump::LrcaHelperVcs vcs(0x012000);
static const AubMemDump::LrcaHelperVecs vecs(0x01a000);
const AubMemDump::LrcaHelper *const AUBFamilyMapper<Family>::csTraits[EngineType::NUM_ENGINES] = {
const AubMemDump::LrcaHelper *const AUBFamilyMapper<Family>::csTraits[aub_stream::NUM_ENGINES] = {
&rcs,
&bcs,
&vcs,
@ -70,7 +70,7 @@ static const MMIOList mmioListVECS = {
MMIOPair(AubMemDump::computeRegisterOffset(vecs.mmioBase, 0x229c), 0xffff8280),
};
const MMIOList *AUBFamilyMapper<Family>::perEngineMMIO[EngineType::NUM_ENGINES] = {
const MMIOList *AUBFamilyMapper<Family>::perEngineMMIO[aub_stream::NUM_ENGINES] = {
&mmioListRCS,
&mmioListBCS,
&mmioListVCS,

2
runtime/gen9/hw_info_bxt.inl
View File

@ -45,7 +45,7 @@ const RuntimeCapabilityTable BXT::capabilityTable{
MemoryConstants::pageSize, // requiredPreemptionSurfaceSize
&isSimulationBXT, // isSimulation
PreemptionMode::MidThread, // defaultPreemptionMode
EngineType::ENGINE_RCS, // defaultEngineType
aub_stream::ENGINE_RCS, // defaultEngineType
0, // maxRenderFrequency
12, // clVersionSupport
CmdServicesMemTraceVersion::DeviceValues::Bxt, // aubDeviceId

2
runtime/gen9/hw_info_cfl.inl
View File

@ -40,7 +40,7 @@ const RuntimeCapabilityTable CFL::capabilityTable{
MemoryConstants::pageSize, // requiredPreemptionSurfaceSize
&isSimulationCFL, // isSimulation
PreemptionMode::MidThread, // defaultPreemptionMode
EngineType::ENGINE_RCS, // defaultEngineType
aub_stream::ENGINE_RCS, // defaultEngineType
0, // maxRenderFrequency
21, // clVersionSupport
CmdServicesMemTraceVersion::DeviceValues::Cfl, // aubDeviceId

2
runtime/gen9/hw_info_glk.inl
View File

@ -40,7 +40,7 @@ const RuntimeCapabilityTable GLK::capabilityTable{
MemoryConstants::pageSize, // requiredPreemptionSurfaceSize
&isSimulationGLK, // isSimulation
PreemptionMode::MidThread, // defaultPreemptionMode
EngineType::ENGINE_RCS, // defaultEngineType
aub_stream::ENGINE_RCS, // defaultEngineType
0, // maxRenderFrequency
12, // clVersionSupport
CmdServicesMemTraceVersion::DeviceValues::Glk, // aubDeviceId

2
runtime/gen9/hw_info_kbl.inl
View File

@ -40,7 +40,7 @@ const RuntimeCapabilityTable KBL::capabilityTable{
MemoryConstants::pageSize, // requiredPreemptionSurfaceSize
&isSimulationKBL, // isSimulation
PreemptionMode::MidThread, // defaultPreemptionMode
EngineType::ENGINE_RCS, // defaultEngineType
aub_stream::ENGINE_RCS, // defaultEngineType
0, // maxRenderFrequency
21, // clVersionSupport
CmdServicesMemTraceVersion::DeviceValues::Kbl, // aubDeviceId

2
runtime/gen9/hw_info_skl.inl
View File

@ -48,7 +48,7 @@ const RuntimeCapabilityTable SKL::capabilityTable{
MemoryConstants::pageSize, // requiredPreemptionSurfaceSize
&isSimulationSKL, // isSimulation
PreemptionMode::MidThread, // defaultPreemptionMode
EngineType::ENGINE_RCS, // defaultEngineType
aub_stream::ENGINE_RCS, // defaultEngineType
0, // maxRenderFrequency
21, // clVersionSupport
CmdServicesMemTraceVersion::DeviceValues::Skl, // aubDeviceId

1
runtime/helpers/completion_stamp.h
View File

@ -6,7 +6,6 @@
*/
#pragma once
#include "engine_node.h"
#include <cstdint>

8
runtime/helpers/hw_helper.h
View File

@ -39,7 +39,7 @@ class HwHelper {
virtual uint32_t getConfigureAddressSpaceMode() = 0;
virtual bool isLocalMemoryEnabled(const HardwareInfo &hwInfo) const = 0;
virtual bool isPageTableManagerSupported(const HardwareInfo &hwInfo) const = 0;
virtual const AubMemDump::LrcaHelper &getCsTraits(EngineType engineType) const = 0;
virtual const AubMemDump::LrcaHelper &getCsTraits(aub_stream::EngineType engineType) const = 0;
virtual bool supportsYTiling() const = 0;
virtual bool obtainRenderBufferCompressionPreference(const HardwareInfo &hwInfo) const = 0;
static bool renderCompressedBuffersSupported(const HardwareInfo &hwInfo);
@ -58,7 +58,7 @@ class HwHelper {
uint32_t surfaceType,
bool forceNonAuxMode) = 0;
virtual size_t getScratchSpaceOffsetFor64bit() = 0;
virtual const std::vector<EngineType> getGpgpuEngineInstances() const = 0;
virtual const std::vector<aub_stream::EngineType> getGpgpuEngineInstances() const = 0;
virtual bool getEnableLocalMemory(const HardwareInfo &hwInfo) const = 0;
virtual std::string getExtensions() const = 0;
@ -103,7 +103,7 @@ class HwHelperHw : public HwHelper {
return sizeof(RENDER_SURFACE_STATE);
}
const AubMemDump::LrcaHelper &getCsTraits(EngineType engineType) const override;
const AubMemDump::LrcaHelper &getCsTraits(aub_stream::EngineType engineType) const override;
size_t getMaxBarrierRegisterPerSlice() const override;
@ -144,7 +144,7 @@ class HwHelperHw : public HwHelper {
size_t getScratchSpaceOffsetFor64bit() override;
const std::vector<EngineType> getGpgpuEngineInstances() const override;
const std::vector<aub_stream::EngineType> getGpgpuEngineInstances() const override;
bool getEnableLocalMemory(const HardwareInfo &hwInfo) const override;

10
runtime/helpers/hw_helper_common.inl
View File

@ -77,7 +77,7 @@ size_t HwHelperHw<Family>::getMaxBarrierRegisterPerSlice() const {
}
template <typename Family>
const AubMemDump::LrcaHelper &HwHelperHw<Family>::getCsTraits(EngineType engineType) const {
const AubMemDump::LrcaHelper &HwHelperHw<Family>::getCsTraits(aub_stream::EngineType engineType) const {
return *AUBFamilyMapper<Family>::csTraits[engineType];
}
@ -168,10 +168,10 @@ size_t HwHelperHw<Family>::getScratchSpaceOffsetFor64bit() {
}
template <typename Family>
const std::vector<EngineType> HwHelperHw<Family>::getGpgpuEngineInstances() const {
constexpr std::array<EngineType, 2> gpgpuEngineInstances = {{ENGINE_RCS,
ENGINE_RCS}}; // low priority
return std::vector<EngineType>(gpgpuEngineInstances.begin(), gpgpuEngineInstances.end());
const std::vector<aub_stream::EngineType> HwHelperHw<Family>::getGpgpuEngineInstances() const {
constexpr std::array<aub_stream::EngineType, 2> gpgpuEngineInstances = {{aub_stream::ENGINE_RCS,
aub_stream::ENGINE_RCS}}; // low priority
return std::vector<aub_stream::EngineType>(gpgpuEngineInstances.begin(), gpgpuEngineInstances.end());
}
template <typename Family>

4
runtime/helpers/hw_info.cpp
View File

@ -46,9 +46,9 @@ bool getHwInfoForPlatformString(const char *str, const HardwareInfo *&hwInfoIn)
return ret;
}
EngineType getChosenEngineType(const HardwareInfo &hwInfo) {
aub_stream::EngineType getChosenEngineType(const HardwareInfo &hwInfo) {
return DebugManager.flags.NodeOrdinal.get() == -1
? hwInfo.capabilityTable.defaultEngineType
: static_cast<EngineType>(DebugManager.flags.NodeOrdinal.get());
: static_cast<aub_stream::EngineType>(DebugManager.flags.NodeOrdinal.get());
}
} // namespace NEO

4
runtime/helpers/hw_info.h
View File

@ -32,7 +32,7 @@ struct RuntimeCapabilityTable {
size_t requiredPreemptionSurfaceSize;
bool (*isSimulation)(unsigned short);
PreemptionMode defaultPreemptionMode;
EngineType defaultEngineType;
aub_stream::EngineType defaultEngineType;
uint32_t maxRenderFrequency;
unsigned int clVersionSupport;
uint32_t aubDeviceId;
@ -101,5 +101,5 @@ struct EnableGfxFamilyHw {
const char *getPlatformType(const HardwareInfo &hwInfo);
bool getHwInfoForPlatformString(const char *str, const HardwareInfo *&hwInfoIn);
EngineType getChosenEngineType(const HardwareInfo &hwInfo);
aub_stream::EngineType getChosenEngineType(const HardwareInfo &hwInfo);
} // namespace NEO

2
runtime/memory_manager/memory_manager.cpp
View File

@ -199,7 +199,7 @@ bool MemoryManager::isMemoryBudgetExhausted() const {
return false;
}
OsContext *MemoryManager::createAndRegisterOsContext(CommandStreamReceiver *commandStreamReceiver, EngineType engineType,
OsContext *MemoryManager::createAndRegisterOsContext(CommandStreamReceiver *commandStreamReceiver, aub_stream::EngineType engineType,
DeviceBitfield deviceBitfield, PreemptionMode preemptionMode, bool lowPriority) {
auto contextId = ++latestContextId;
auto osContext = OsContext::create(executionEnvironment.osInterface.get(), contextId, deviceBitfield, engineType, preemptionMode, lowPriority);

2
runtime/memory_manager/memory_manager.h
View File

@ -175,7 +175,7 @@ class MemoryManager {
::alignedFree(ptr);
}
OsContext *createAndRegisterOsContext(CommandStreamReceiver *commandStreamReceiver, EngineType engineType,
OsContext *createAndRegisterOsContext(CommandStreamReceiver *commandStreamReceiver, aub_stream::EngineType engineType,
DeviceBitfield deviceBitfield, PreemptionMode preemptionMode, bool lowPriority);
uint32_t getRegisteredEnginesCount() const { return static_cast<uint32_t>(registeredEngines.size()); }
CommandStreamReceiver *getDefaultCommandStreamReceiver(uint32_t deviceId) const;

4
runtime/os_interface/linux/drm_engine_mapper.cpp
View File

@ -12,8 +12,8 @@
namespace NEO {
unsigned int DrmEngineMapper::engineNodeMap(EngineType engineType) {
if (EngineType::ENGINE_RCS == engineType) {
unsigned int DrmEngineMapper::engineNodeMap(aub_stream::EngineType engineType) {
if (aub_stream::ENGINE_RCS == engineType) {
return I915_EXEC_RENDER;
}
UNRECOVERABLE_IF(true);

2
runtime/os_interface/linux/drm_engine_mapper.h
View File

@ -13,7 +13,7 @@ namespace NEO {
class DrmEngineMapper {
public:
static unsigned int engineNodeMap(EngineType engineType);
static unsigned int engineNodeMap(aub_stream::EngineType engineType);
};
} // namespace NEO

4
runtime/os_interface/linux/hw_info_config.cpp
View File

@ -153,9 +153,7 @@ int HwInfoConfig::configureHwInfo(const HardwareInfo *inHwInfo, HardwareInfo *ou
outHwInfo->capabilityTable.ftrSupportsCoherency = false;
hwHelper.adjustDefaultEngineType(outHwInfo);
outHwInfo->capabilityTable.defaultEngineType = DebugManager.flags.NodeOrdinal.get() == -1
? outHwInfo->capabilityTable.defaultEngineType
: static_cast<EngineType>(DebugManager.flags.NodeOrdinal.get());
outHwInfo->capabilityTable.defaultEngineType = getChosenEngineType(*outHwInfo);
outHwInfo->capabilityTable.instrumentationEnabled = false;
outHwInfo->capabilityTable.ftrRenderCompressedBuffers = false;

4
runtime/os_interface/linux/os_context_linux.cpp
View File

@ -15,7 +15,7 @@
namespace NEO {
OsContext *OsContext::create(OSInterface *osInterface, uint32_t contextId, DeviceBitfield deviceBitfield,
EngineType engineType, PreemptionMode preemptionMode, bool lowPriority) {
aub_stream::EngineType engineType, PreemptionMode preemptionMode, bool lowPriority) {
if (osInterface) {
return new OsContextLinux(*osInterface->get()->getDrm(), contextId, deviceBitfield, engineType, preemptionMode, lowPriority);
}
@ -23,7 +23,7 @@ OsContext *OsContext::create(OSInterface *osInterface, uint32_t contextId, Devic
}
OsContextLinux::OsContextLinux(Drm &drm, uint32_t contextId, DeviceBitfield deviceBitfield,
EngineType engineType, PreemptionMode preemptionMode, bool lowPriority)
aub_stream::EngineType engineType, PreemptionMode preemptionMode, bool lowPriority)
: OsContext(contextId, deviceBitfield, engineType, preemptionMode, lowPriority), drm(drm) {
engineFlag = DrmEngineMapper::engineNodeMap(engineType);

2
runtime/os_interface/linux/os_context_linux.h
View File

@ -15,7 +15,7 @@ class OsContextLinux : public OsContext {
OsContextLinux() = delete;
~OsContextLinux() override;
OsContextLinux(Drm &drm, uint32_t contextId, DeviceBitfield deviceBitfield,
EngineType engineType, PreemptionMode preemptionMode, bool lowPriority);
aub_stream::EngineType engineType, PreemptionMode preemptionMode, bool lowPriority);
unsigned int getEngineFlag() const { return engineFlag; }
uint32_t getDrmContextId() const { return drmContextId; }

8
runtime/os_interface/os_context.h
View File

@ -22,16 +22,16 @@ class OsContext : public ReferenceTrackedObject<OsContext> {
OsContext() = delete;
static OsContext *create(OSInterface *osInterface, uint32_t contextId, DeviceBitfield deviceBitfield,
EngineType engineType, PreemptionMode preemptionMode, bool lowPriority);
aub_stream::EngineType engineType, PreemptionMode preemptionMode, bool lowPriority);
uint32_t getContextId() const { return contextId; }
uint32_t getNumSupportedDevices() const { return numSupportedDevices; }
DeviceBitfield getDeviceBitfield() const { return deviceBitfield; }
PreemptionMode getPreemptionMode() const { return preemptionMode; }
EngineType &getEngineType() { return engineType; }
aub_stream::EngineType &getEngineType() { return engineType; }
bool isLowPriority() const { return lowPriority; }
protected:
OsContext(uint32_t contextId, DeviceBitfield deviceBitfield, EngineType engineType, PreemptionMode preemptionMode, bool lowPriority)
OsContext(uint32_t contextId, DeviceBitfield deviceBitfield, aub_stream::EngineType engineType, PreemptionMode preemptionMode, bool lowPriority)
: contextId(contextId),
deviceBitfield(deviceBitfield),
preemptionMode(preemptionMode),
@ -43,7 +43,7 @@ class OsContext : public ReferenceTrackedObject<OsContext> {
const DeviceBitfield deviceBitfield;
const PreemptionMode preemptionMode;
const uint32_t numSupportedDevices;
EngineType engineType = EngineType::ENGINE_RCS;
aub_stream::EngineType engineType = aub_stream::ENGINE_RCS;
const bool lowPriority;
};
} // namespace NEO

5
runtime/os_interface/windows/hw_info_config.cpp
View File

@ -26,10 +26,7 @@ int HwInfoConfig::configureHwInfo(const HardwareInfo *inHwInfo, HardwareInfo *ou
outHwInfo->capabilityTable.ftrSvm = outHwInfo->pSkuTable->ftrSVM;
hwHelper.adjustDefaultEngineType(outHwInfo);
const auto nodeOrdinal = DebugManager.flags.NodeOrdinal.get();
outHwInfo->capabilityTable.defaultEngineType = nodeOrdinal == -1
? outHwInfo->capabilityTable.defaultEngineType
: static_cast<EngineType>(nodeOrdinal);
outHwInfo->capabilityTable.defaultEngineType = getChosenEngineType(*outHwInfo);
hwHelper.setCapabilityCoherencyFlag(outHwInfo, outHwInfo->capabilityTable.ftrSupportsCoherency);

4
runtime/os_interface/windows/os_context_win.cpp
View File

@ -14,7 +14,7 @@
namespace NEO {
OsContext *OsContext::create(OSInterface *osInterface, uint32_t contextId, DeviceBitfield deviceBitfield,
EngineType engineType, PreemptionMode preemptionMode, bool lowPriority) {
aub_stream::EngineType engineType, PreemptionMode preemptionMode, bool lowPriority) {
if (osInterface) {
return new OsContextWin(*osInterface->get()->getWddm(), contextId, deviceBitfield, engineType, preemptionMode, lowPriority);
}
@ -22,7 +22,7 @@ OsContext *OsContext::create(OSInterface *osInterface, uint32_t contextId, Devic
}
OsContextWin::OsContextWin(Wddm &wddm, uint32_t contextId, DeviceBitfield deviceBitfield,
EngineType engineType, PreemptionMode preemptionMode, bool lowPriority)
aub_stream::EngineType engineType, PreemptionMode preemptionMode, bool lowPriority)
: OsContext(contextId, deviceBitfield, engineType, preemptionMode, lowPriority), wddm(wddm), residencyController(wddm, contextId) {
UNRECOVERABLE_IF(!wddm.isInitialized());

2
runtime/os_interface/windows/os_context_win.h
View File

@ -18,7 +18,7 @@ class OsContextWin : public OsContext {
~OsContextWin() override;
OsContextWin(Wddm &wddm, uint32_t contextId, DeviceBitfield deviceBitfield,
EngineType engineType, PreemptionMode preemptionMode, bool lowPriority);
aub_stream::EngineType engineType, PreemptionMode preemptionMode, bool lowPriority);
D3DKMT_HANDLE getWddmContextHandle() const { return wddmContextHandle; }
void setWddmContextHandle(D3DKMT_HANDLE wddmContextHandle) { this->wddmContextHandle = wddmContextHandle; }

4
runtime/os_interface/windows/wddm_engine_mapper.cpp
View File

@ -11,8 +11,8 @@
namespace NEO {
GPUNODE_ORDINAL WddmEngineMapper::engineNodeMap(EngineType engineType) {
if (EngineType::ENGINE_RCS == engineType) {
GPUNODE_ORDINAL WddmEngineMapper::engineNodeMap(aub_stream::EngineType engineType) {
if (aub_stream::ENGINE_RCS == engineType) {
return GPUNODE_3D;
}
UNRECOVERABLE_IF(true);

2
runtime/os_interface/windows/wddm_engine_mapper.h
View File

@ -15,7 +15,7 @@ namespace NEO {
class WddmEngineMapper {
public:
static GPUNODE_ORDINAL engineNodeMap(EngineType engineType);
static GPUNODE_ORDINAL engineNodeMap(aub_stream::EngineType engineType);
};
} // namespace NEO

3
runtime/scheduler/scheduler_binary.cmake
View File

@ -1,5 +1,5 @@
#
# Copyright (C) 2018 Intel Corporation
# Copyright (C) 2018-2019 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@ -89,6 +89,7 @@ set_target_properties(${SCHEDULER_BINARY_LIB_NAME} PROPERTIES FOLDER "scheduler"
add_dependencies(${SCHEDULER_BINARY_LIB_NAME} scheduler)
target_include_directories(${SCHEDULER_BINARY_LIB_NAME} PRIVATE
${ENGINE_NODE_DIR}
${KHRONOS_HEADERS_DIR}
${UMKM_SHAREDDATA_INCLUDE_PATHS}
${IGDRCL__IGC_INCLUDE_DIR}

4
runtime/command_stream/definitions/engine_node.h → third_party/aub_stream/headers/engine_node.h vendored
View File

@ -8,7 +8,7 @@
#pragma once
#include <cstdint>
namespace NEO {
namespace aub_stream {
enum EngineType : uint32_t {
ENGINE_RCS = 0,
@ -18,4 +18,4 @@ enum EngineType : uint32_t {
NUM_ENGINES
};
} // namespace NEO
} // namespace aub_stream

1
unit_tests/CMakeLists.txt
View File

@ -136,6 +136,7 @@ endif()
target_include_directories(igdrcl_tests PRIVATE
${IGDRCL_SOURCE_DIR}/unit_tests/mocks${BRANCH_DIR_SUFFIX}
${ENGINE_NODE_DIR}
${KHRONOS_GL_HEADERS_DIR}
)

2
unit_tests/api/cl_create_command_queue_with_properties_tests.cpp
View File

@ -361,7 +361,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenLowPriorityWhenCreatingComman
auto commandQueueObj = castToObject<CommandQueue>(cmdQ);
auto &osContext = commandQueueObj->getCommandStreamReceiver().getOsContext();
EXPECT_EQ(EngineType::ENGINE_RCS, osContext.getEngineType());
EXPECT_EQ(aub_stream::ENGINE_RCS, osContext.getEngineType());
EXPECT_TRUE(osContext.isLowPriority());
clReleaseCommandQueue(cmdQ);

2
unit_tests/aub/aub_helper_tests.inl
View File

@ -126,7 +126,7 @@ HWTEST_F(AubHelperHwTest, GivenEnabledLocalMemoryWhenGetMemTraceForPtEntryIsCall
}
HWTEST_F(AubHelperHwTest, giverLrcaHelperWhenContextIsInitializedThenContextFlagsAreSet) {
const auto &csTraits = CommandStreamReceiverSimulatedCommonHw<FamilyType>::getCsTraits(EngineType::ENGINE_RCS);
const auto &csTraits = CommandStreamReceiverSimulatedCommonHw<FamilyType>::getCsTraits(aub_stream::ENGINE_RCS);
MockLrcaHelper lrcaHelper(csTraits.mmioBase);
std::unique_ptr<void, std::function<void(void *)>> lrcaBase(alignedMalloc(csTraits.sizeLRCA, csTraits.alignLRCA), alignedFree);

10
unit_tests/aub_tests/command_stream/aub_command_stream_tests.cpp
View File

@ -40,7 +40,7 @@ struct AUBFixture : public AUBCommandStreamFixture,
}
template <typename FamilyType>
void testNoopIdXcs(EngineType engineType) {
void testNoopIdXcs(aub_stream::EngineType engineType) {
pCommandStreamReceiver->getOsContext().getEngineType() = engineType;
typedef typename FamilyType::MI_NOOP MI_NOOP;
@ -84,19 +84,19 @@ HWTEST_F(AUBcommandstreamTests, testFlushTwice) {
}
HWTEST_F(AUBcommandstreamTests, testNoopIdRcs) {
testNoopIdXcs<FamilyType>(EngineType::ENGINE_RCS);
testNoopIdXcs<FamilyType>(aub_stream::ENGINE_RCS);
}
HWTEST_F(AUBcommandstreamTests, testNoopIdBcs) {
testNoopIdXcs<FamilyType>(EngineType::ENGINE_BCS);
testNoopIdXcs<FamilyType>(aub_stream::ENGINE_BCS);
}
HWTEST_F(AUBcommandstreamTests, testNoopIdVcs) {
testNoopIdXcs<FamilyType>(EngineType::ENGINE_VCS);
testNoopIdXcs<FamilyType>(aub_stream::ENGINE_VCS);
}
HWTEST_F(AUBcommandstreamTests, testNoopIdVecs) {
testNoopIdXcs<FamilyType>(EngineType::ENGINE_VECS);
testNoopIdXcs<FamilyType>(aub_stream::ENGINE_VECS);
}
TEST_F(AUBcommandstreamTests, makeResident) {

9
unit_tests/aub_tests/command_stream/aub_mem_dump_tests.cpp
View File

@ -17,7 +17,6 @@ using NEO::AUBCommandStreamReceiver;
using NEO::AUBCommandStreamReceiverHw;
using NEO::AUBFamilyMapper;
using NEO::DeviceFixture;
using NEO::EngineType;
using NEO::folderAUB;
std::string getAubFileName(const NEO::Device *pDevice, const std::string baseName) {
@ -189,19 +188,19 @@ HWTEST_F(AubMemDumpTests, writeVerifySevenBytesGGTT) {
}
HWTEST_F(AubMemDumpTests, simpleRCS) {
setupAUB<FamilyType>(pDevice, EngineType::ENGINE_RCS);
setupAUB<FamilyType>(pDevice, aub_stream::ENGINE_RCS);
}
HWTEST_F(AubMemDumpTests, simpleBCS) {
setupAUB<FamilyType>(pDevice, EngineType::ENGINE_BCS);
setupAUB<FamilyType>(pDevice, aub_stream::ENGINE_BCS);
}
HWTEST_F(AubMemDumpTests, simpleVCS) {
setupAUB<FamilyType>(pDevice, EngineType::ENGINE_VCS);
setupAUB<FamilyType>(pDevice, aub_stream::ENGINE_VCS);
}
HWTEST_F(AubMemDumpTests, simpleVECS) {
setupAUB<FamilyType>(pDevice, EngineType::ENGINE_VECS);
setupAUB<FamilyType>(pDevice, aub_stream::ENGINE_VECS);
}
TEST(AubMemDumpBasic, givenDebugOverrideMmioWhenMmioNotMatchThenDoNotAlterValue) {

2
unit_tests/aub_tests/command_stream/aub_mem_dump_tests.h
View File

@ -23,7 +23,7 @@ extern const char *fileSeparator;
extern std::string getAubFileName(const NEO::Device *pDevice, const std::string baseName);
template <typename FamilyType>
void setupAUB(const NEO::Device *pDevice, NEO::EngineType engineType) {
void setupAUB(const NEO::Device *pDevice, aub_stream::EngineType engineType) {
typedef typename NEO::AUBFamilyMapper<FamilyType>::AUB AUB;
const auto &csTraits = NEO::CommandStreamReceiverSimulatedCommonHw<FamilyType>::getCsTraits(engineType);
auto mmioBase = csTraits.mmioBase;

2
unit_tests/aub_tests/fixtures/aub_fixture.h
View File

@ -29,7 +29,7 @@ class AUBFixture : public CommandQueueHwFixture {
uint32_t deviceIndex = 0;
auto &hwHelper = HwHelper::get(hwInfo.pPlatform->eRenderCoreFamily);
EngineType engineType = getChosenEngineType(hwInfo);
auto engineType = getChosenEngineType(hwInfo);
const ::testing::TestInfo *const testInfo = ::testing::UnitTest::GetInstance()->current_test_info();
std::stringstream strfilename;

2
unit_tests/aub_tests/gen10/batch_buffer/aub_batch_buffer_tests_gen10.cpp
View File

@ -14,5 +14,5 @@ using Gen10AubBatchBufferTests = Test<NEO::DeviceFixture>;
static constexpr auto gpuBatchBufferAddr = 0x800400001000; // 48-bit GPU address
GEN10TEST_F(Gen10AubBatchBufferTests, givenSimpleRCSWithBatchBufferWhenItHasMSBSetInGpuAddressThenAUBShouldBeSetupSuccessfully) {
setupAUBWithBatchBuffer<FamilyType>(pDevice, NEO::EngineType::ENGINE_RCS, gpuBatchBufferAddr);
setupAUBWithBatchBuffer<FamilyType>(pDevice, aub_stream::ENGINE_RCS, gpuBatchBufferAddr);
}

2
unit_tests/aub_tests/gen10/batch_buffer/aub_batch_buffer_tests_gen10.h
View File

@ -10,7 +10,7 @@
#include "unit_tests/aub_tests/command_stream/aub_mem_dump_tests.h"
template <typename FamilyType>
void setupAUBWithBatchBuffer(const NEO::Device *pDevice, NEO::EngineType engineType, uint64_t gpuBatchBufferAddr) {
void setupAUBWithBatchBuffer(const NEO::Device *pDevice, aub_stream::EngineType engineType, uint64_t gpuBatchBufferAddr) {
typedef typename NEO::AUBFamilyMapper<FamilyType>::AUB AUB;
const auto &csTraits = NEO::AUBCommandStreamReceiverHw<FamilyType>::getCsTraits(engineType);
auto mmioBase = csTraits.mmioBase;

2
unit_tests/aub_tests/gen9/batch_buffer/aub_batch_buffer_tests.cpp
View File

@ -14,5 +14,5 @@ using AubBatchBufferTests = Test<NEO::DeviceFixture>;
static constexpr auto gpuBatchBufferAddr = 0x800400001000ull; // 48-bit GPU address
GEN9TEST_F(AubBatchBufferTests, givenSimpleRCSWithBatchBufferWhenItHasMSBSetInGpuAddressThenAUBShouldBeSetupSuccessfully) {
setupAUBWithBatchBuffer<FamilyType>(pDevice, NEO::EngineType::ENGINE_RCS, gpuBatchBufferAddr);
setupAUBWithBatchBuffer<FamilyType>(pDevice, aub_stream::ENGINE_RCS, gpuBatchBufferAddr);
}

2
unit_tests/aub_tests/gen9/batch_buffer/aub_batch_buffer_tests.h
View File

@ -10,7 +10,7 @@
#include "unit_tests/aub_tests/command_stream/aub_mem_dump_tests.h"
template <typename FamilyType>
void setupAUBWithBatchBuffer(const NEO::Device *pDevice, NEO::EngineType engineType, uint64_t gpuBatchBufferAddr) {
void setupAUBWithBatchBuffer(const NEO::Device *pDevice, aub_stream::EngineType engineType, uint64_t gpuBatchBufferAddr) {
typedef typename NEO::AUBFamilyMapper<FamilyType>::AUB AUB;
const auto &csTraits = NEO::CommandStreamReceiverSimulatedCommonHw<FamilyType>::getCsTraits(engineType);
auto mmioBase = csTraits.mmioBase;

12
unit_tests/command_stream/aub_command_stream_receiver_1_tests.cpp
View File

@ -168,7 +168,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWithAubMana
HWTEST_F(AubCommandStreamReceiverTests, givenAubCsrWhenOsContextIsSetThenCreateHardwareContext) {
uint32_t deviceIndex = 3;
MockOsContext osContext(0, 8, EngineType::ENGINE_BCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 8, aub_stream::ENGINE_BCS, PreemptionMode::Disabled, false);
std::string fileName = "file_name.aub";
MockAubManager *mockManager = new MockAubManager();
MockAubCenter *mockAubCenter = new MockAubCenter(platformDevices[0], false, fileName, CommandStreamReceiverType::CSR_AUB);
@ -186,7 +186,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCsrWhenOsContextIsSetThenCreateH
}
HWTEST_F(AubCommandStreamReceiverTests, givenAubCsrWhenLowPriorityOsContextIsSetThenDontCreateHardwareContext) {
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, true);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, true);
std::string fileName = "file_name.aub";
MockAubManager *mockManager = new MockAubManager();
MockAubCenter *mockAubCenter = new MockAubCenter(platformDevices[0], false, fileName, CommandStreamReceiverType::CSR_AUB);
@ -777,7 +777,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenOsContextWithMultipleDevicesSupport
DeviceBitfield deviceBitfield;
deviceBitfield.set(0);
deviceBitfield.set(1);
MockOsContext osContext(1, deviceBitfield, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(1, deviceBitfield, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
auto aubCsr = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>("", true, *pDevice->executionEnvironment);
aubCsr->setupContext(osContext);
@ -1088,7 +1088,7 @@ TEST_F(HardwareContextContainerTests, givenOsContextWithMultipleDevicesSupported
DeviceBitfield deviceBitfield;
deviceBitfield.set(0);
deviceBitfield.set(1);
MockOsContext osContext(1, deviceBitfield, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(1, deviceBitfield, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
HardwareContextController hwContextControler(aubManager, osContext, 0);
EXPECT_EQ(2u, hwContextControler.hardwareContexts.size());
@ -1104,7 +1104,7 @@ TEST_F(HardwareContextContainerTests, givenMultipleHwContextWhenSingleMethodIsCa
DeviceBitfield deviceBitfield;
deviceBitfield.set(0);
deviceBitfield.set(1);
MockOsContext osContext(1, deviceBitfield, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(1, deviceBitfield, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
HardwareContextController hwContextContainer(aubManager, osContext, 0);
EXPECT_EQ(2u, hwContextContainer.hardwareContexts.size());
@ -1145,7 +1145,7 @@ TEST_F(HardwareContextContainerTests, givenMultipleHwContextWhenSingleMethodIsCa
DeviceBitfield deviceBitfield;
deviceBitfield.set(0);
deviceBitfield.set(1);
MockOsContext osContext(1, deviceBitfield, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(1, deviceBitfield, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
HardwareContextController hwContextContainer(aubManager, osContext, 0);
EXPECT_EQ(2u, hwContextContainer.hardwareContexts.size());

12
unit_tests/command_stream/aub_command_stream_receiver_2_tests.cpp
View File

@ -889,7 +889,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenGraphicsAllocationWritableWhenDumpA
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
aubCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
@ -914,7 +914,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenGraphicsAllocationWritableWhenDumpA
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
aubCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
@ -941,7 +941,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenGraphicsAllocationNonWritableWhenDu
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
aubCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
@ -969,7 +969,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenGraphicsAllocationNotDumpableWhenDu
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
aubCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
@ -998,7 +998,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenGraphicsAllocationDumpableWhenDumpA
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
aubCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
@ -1026,7 +1026,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenGraphicsAllocationWritableWhenDumpA
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
aubCsr.setupContext(osContext);
aubCsr.latestSentTaskCount = 1;

14
unit_tests/command_stream/aub_file_stream_tests.cpp
View File

@ -262,7 +262,7 @@ HWTEST_F(AubFileStreamTests, givenNewTasksAndHardwareContextPresentWhenCallingPo
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
aubCsr.setupContext(osContext);
auto hardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
aubCsr.stream = aubStream.get();
@ -282,7 +282,7 @@ HWTEST_F(AubFileStreamTests, givenNoNewTasksAndHardwareContextPresentWhenCalling
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
aubCsr.setupContext(osContext);
auto hardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
aubCsr.stream = aubStream.get();
@ -365,7 +365,7 @@ HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenFlushIsCalledThenI
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
aubCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
aubCsr.stream = aubStream.get();
@ -394,7 +394,7 @@ HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenFlushIsCalledWithZ
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
aubCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
aubCsr.stream = aubStream.get();
@ -418,7 +418,7 @@ HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenMakeResidentIsCall
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
aubCsr.setupContext(osContext);
MockGraphicsAllocation allocation(reinterpret_cast<void *>(0x1000), 0x1000);
@ -434,7 +434,7 @@ HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenExpectMemoryEqualI
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
aubCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
@ -450,7 +450,7 @@ HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenExpectMemoryNotEqu
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
aubCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());

2
unit_tests/command_stream/command_stream_receiver_with_aub_dump_tests.cpp
View File

@ -65,7 +65,7 @@ struct MyMockCsr : UltCommandStreamReceiver<DEFAULT_TEST_FAMILY_NAME> {
bool wasCalled = false;
FlushStamp flushStampToReturn = 1;
BatchBuffer *receivedBatchBuffer = nullptr;
EngineType receivedEngine = EngineType::ENGINE_RCS;
aub_stream::EngineType receivedEngine = aub_stream::ENGINE_RCS;
ResidencyContainer *receivedAllocationsForResidency = nullptr;
} flushParametrization;

18
unit_tests/command_stream/tbx_command_stream_tests.cpp
View File

@ -117,10 +117,10 @@ HWTEST_F(TbxCommandStreamTests, DISABLED_flushUntilTailRingBufferLargerThanSizeR
HWTEST_F(TbxCommandStreamTests, DISABLED_getCsTraits) {
TbxCommandStreamReceiverHw<FamilyType> *tbxCsr = (TbxCommandStreamReceiverHw<FamilyType> *)pCommandStreamReceiver;
tbxCsr->getCsTraits(EngineType::ENGINE_RCS);
tbxCsr->getCsTraits(EngineType::ENGINE_BCS);
tbxCsr->getCsTraits(EngineType::ENGINE_VCS);
tbxCsr->getCsTraits(EngineType::ENGINE_VECS);
tbxCsr->getCsTraits(aub_stream::ENGINE_RCS);
tbxCsr->getCsTraits(aub_stream::ENGINE_BCS);
tbxCsr->getCsTraits(aub_stream::ENGINE_VCS);
tbxCsr->getCsTraits(aub_stream::ENGINE_VECS);
}
TEST(TbxCommandStreamReceiverTest, givenNullFactoryEntryWhenTbxCsrIsCreatedThenNullptrIsReturned) {
@ -349,7 +349,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverWhenFlushIsCalledTh
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockTbxCsr<FamilyType> tbxCsr(*pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
tbxCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(tbxCsr.hardwareContextController->hardwareContexts[0].get());
@ -379,7 +379,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverInBatchedModeWhenFl
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockTbxCsr<FamilyType> tbxCsr(*pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
tbxCsr.setupContext(osContext);
auto commandBuffer = pDevice->executionEnvironment->memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
@ -401,7 +401,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverWhenFlushIsCalledWi
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockTbxCsr<FamilyType> tbxCsr(*pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
tbxCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(tbxCsr.hardwareContextController->hardwareContexts[0].get());
@ -423,7 +423,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverWhenMakeResidentIsC
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockTbxCsr<FamilyType> tbxCsr(*pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
tbxCsr.setupContext(osContext);
MockGraphicsAllocation allocation(reinterpret_cast<void *>(0x1000), 0x1000);
@ -439,7 +439,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverWhenMakeCoherentIsC
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockTbxCsr<FamilyType> tbxCsr(*pDevice->executionEnvironment);
MockOsContext osContext(0, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
tbxCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(tbxCsr.hardwareContextController->hardwareContexts[0].get());

6
unit_tests/device/device_tests.cpp
View File

@ -64,7 +64,7 @@ TEST_F(DeviceTest, givenDeviceWhenAskedForSpecificEngineThenRetrunIt) {
EXPECT_EQ(deviceEngine.osContext->isLowPriority(), lowPriority);
}
EXPECT_THROW(pDevice->getEngine(EngineType::ENGINE_VCS, false), std::exception);
EXPECT_THROW(pDevice->getEngine(aub_stream::ENGINE_VCS, false), std::exception);
}
TEST_F(DeviceTest, WhenGetOSTimeThenNotNull) {
@ -102,8 +102,8 @@ TEST_F(DeviceTest, retainAndRelease) {
TEST_F(DeviceTest, getEngineTypeDefault) {
auto pTestDevice = std::unique_ptr<Device>(createWithUsDeviceId(0));
EngineType actualEngineType = pDevice->getDefaultEngine().osContext->getEngineType();
EngineType defaultEngineType = pDevice->getHardwareInfo().capabilityTable.defaultEngineType;
auto actualEngineType = pDevice->getDefaultEngine().osContext->getEngineType();
auto defaultEngineType = pDevice->getHardwareInfo().capabilityTable.defaultEngineType;
EXPECT_EQ(&pDevice->getDefaultEngine().commandStreamReceiver->getOsContext(), pDevice->getDefaultEngine().osContext);
EXPECT_EQ(defaultEngineType, actualEngineType);

6
unit_tests/gen10/linux/hw_info_config_tests_gen10.cpp
View File

@ -30,7 +30,7 @@ CNLTEST_F(HwInfoConfigTestLinuxCnl, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(1u, outHwInfo.pSysInfo->SliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT2, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);
@ -81,7 +81,7 @@ CNLTEST_F(HwInfoConfigTestLinuxCnl, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(2u, outHwInfo.pSysInfo->SliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGT1);
@ -105,7 +105,7 @@ CNLTEST_F(HwInfoConfigTestLinuxCnl, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(3u, outHwInfo.pSysInfo->SliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT2_5, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);

6
unit_tests/gen8/bdw/linux/hw_info_config_tests_bdw.cpp
View File

@ -29,7 +29,7 @@ BDWTEST_F(HwInfoConfigTestLinuxBdw, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(1u, outHwInfo.pSysInfo->SliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT2, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);
@ -53,7 +53,7 @@ BDWTEST_F(HwInfoConfigTestLinuxBdw, configureHwInfo) {
EXPECT_EQ((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGT1);
@ -77,7 +77,7 @@ BDWTEST_F(HwInfoConfigTestLinuxBdw, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(2u, outHwInfo.pSysInfo->SliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT3, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);

6
unit_tests/gen9/bxt/linux/hw_info_config_tests.cpp
View File

@ -35,7 +35,7 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->StoredMinEUinPool, outHwInfo.pSysInfo->EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.pSysInfo->EUCount - outHwInfo.pSysInfo->EuCountPerPoolMin), outHwInfo.pSysInfo->EuCountPerPoolMax);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGttCacheInvalidation);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
//constant sysInfo/ftr flags
EXPECT_EQ(1u, outHwInfo.pSysInfo->VEBoxInfo.Instances.Bits.VEBox0Enabled);
@ -88,7 +88,7 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->StoredMinEUinPool, outHwInfo.pSysInfo->EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.pSysInfo->EUCount - outHwInfo.pSysInfo->EuCountPerPoolMin), outHwInfo.pSysInfo->EuCountPerPoolMax);
EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGttCacheInvalidation);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GTC, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);
@ -114,7 +114,7 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, configureHwInfo) {
EXPECT_EQ((unsigned int)drm->StoredHasPooledEU, outHwInfo.pSkuTable->ftrPooledEuEnabled);
EXPECT_EQ((uint32_t)drm->StoredMinEUinPool, outHwInfo.pSysInfo->EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.pSysInfo->EUCount - outHwInfo.pSysInfo->EuCountPerPoolMin), outHwInfo.pSysInfo->EuCountPerPoolMax);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GTX, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);

6
unit_tests/gen9/cfl/linux/hw_info_config_tests_cfl.cpp
View File

@ -27,7 +27,7 @@ CFLTEST_F(HwInfoConfigTestLinuxCfl, configureHwInfo) {
EXPECT_EQ((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT2, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);
@ -75,7 +75,7 @@ CFLTEST_F(HwInfoConfigTestLinuxCfl, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(1u, outHwInfo.pSysInfo->SliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGT1);
@ -99,7 +99,7 @@ CFLTEST_F(HwInfoConfigTestLinuxCfl, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(2u, outHwInfo.pSysInfo->SliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT3, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);

6
unit_tests/gen9/glk/linux/hw_info_config_tests_glk.cpp
View File

@ -32,7 +32,7 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, configureHwInfo) {
EXPECT_EQ((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GTA, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);
@ -80,7 +80,7 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, configureHwInfo) {
EXPECT_EQ((unsigned int)drm->StoredHasPooledEU, outHwInfo.pSkuTable->ftrPooledEuEnabled);
EXPECT_EQ((uint32_t)drm->StoredMinEUinPool, outHwInfo.pSysInfo->EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.pSysInfo->EUCount - outHwInfo.pSysInfo->EuCountPerPoolMin), outHwInfo.pSysInfo->EuCountPerPoolMax);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GTC, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);
@ -106,7 +106,7 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, configureHwInfo) {
EXPECT_EQ((unsigned int)drm->StoredHasPooledEU, outHwInfo.pSkuTable->ftrPooledEuEnabled);
EXPECT_EQ((uint32_t)drm->StoredMinEUinPool, outHwInfo.pSysInfo->EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.pSysInfo->EUCount - outHwInfo.pSysInfo->EuCountPerPoolMin), outHwInfo.pSysInfo->EuCountPerPoolMax);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GTX, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);

10
unit_tests/gen9/kbl/linux/hw_info_config_tests_kbl.cpp
View File

@ -27,7 +27,7 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, configureHwInfo) {
EXPECT_EQ((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT2, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);
@ -75,7 +75,7 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(1u, outHwInfo.pSysInfo->SliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGT1);
@ -97,7 +97,7 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, configureHwInfo) {
EXPECT_EQ((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT1_5, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);
@ -121,7 +121,7 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(2u, outHwInfo.pSysInfo->SliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT3, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);
@ -145,7 +145,7 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(2u, outHwInfo.pSysInfo->SliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT4, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);

10
unit_tests/gen9/skl/linux/hw_info_config_tests_skl.cpp
View File

@ -27,7 +27,7 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, configureHwInfo) {
EXPECT_EQ((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT2, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);
@ -77,7 +77,7 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(1u, outHwInfo.pSysInfo->SliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGT1);
@ -99,7 +99,7 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, configureHwInfo) {
EXPECT_EQ((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT1_5, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);
@ -121,7 +121,7 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, configureHwInfo) {
EXPECT_EQ((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT3, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);
@ -145,7 +145,7 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(2u, outHwInfo.pSysInfo->SliceCount);
EXPECT_EQ(EngineType::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT4, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);

4
unit_tests/helpers/get_gpgpu_engines_tests.inl
View File

@ -14,6 +14,6 @@ template <typename FamilyType>
void whenGetGpgpuEnginesThenReturnTwoRcsEngines() {
auto gpgpuEngines = HwHelperHw<FamilyType>::get().getGpgpuEngineInstances();
EXPECT_EQ(2u, gpgpuEngines.size());
EXPECT_EQ(ENGINE_RCS, gpgpuEngines[0]);
EXPECT_EQ(ENGINE_RCS, gpgpuEngines[1]);
EXPECT_EQ(aub_stream::ENGINE_RCS, gpgpuEngines[0]);
EXPECT_EQ(aub_stream::ENGINE_RCS, gpgpuEngines[1]);
}

12
unit_tests/helpers/hw_helper_tests.cpp
View File

@ -112,7 +112,7 @@ TEST_F(HwHelperTest, givenEngineTypeRcsWhenCsTraitsAreQueiredThenCorrectNameInTr
auto &helper = HwHelper::get(renderCoreFamily);
EXPECT_NE(nullptr, &helper);
auto &csTraits = helper.getCsTraits(EngineType::ENGINE_RCS);
auto &csTraits = helper.getCsTraits(aub_stream::ENGINE_RCS);
EXPECT_STREQ("RCS", csTraits.name);
}
@ -246,18 +246,18 @@ TEST(HwInfoTest, givenHwInfoWhenIsNotCoreThenPlatformTypeIsLp) {
TEST(HwInfoTest, givenHwInfoWhenChosenEngineTypeQueriedThenDefaultIsReturned) {
HardwareInfo hwInfo;
hwInfo.capabilityTable.defaultEngineType = EngineType::ENGINE_RCS;
hwInfo.capabilityTable.defaultEngineType = aub_stream::ENGINE_RCS;
auto engineType = getChosenEngineType(hwInfo);
EXPECT_EQ(EngineType::ENGINE_RCS, engineType);
EXPECT_EQ(aub_stream::ENGINE_RCS, engineType);
}
TEST(HwInfoTest, givenNodeOrdinalSetWhenChosenEngineTypeQueriedThenSetValueIsReturned) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.NodeOrdinal.set(EngineType::ENGINE_VECS);
DebugManager.flags.NodeOrdinal.set(aub_stream::ENGINE_VECS);
HardwareInfo hwInfo;
hwInfo.capabilityTable.defaultEngineType = EngineType::ENGINE_RCS;
hwInfo.capabilityTable.defaultEngineType = aub_stream::ENGINE_RCS;
auto engineType = getChosenEngineType(hwInfo);
EXPECT_EQ(EngineType::ENGINE_VECS, engineType);
EXPECT_EQ(aub_stream::ENGINE_VECS, engineType);
}
HWTEST_F(HwHelperTest, givenCreatedSurfaceStateBufferWhenNoAllocationProvidedThenUseArgumentsasInput) {

4
unit_tests/libult/mock_gfx_family.cpp
View File

@ -25,7 +25,7 @@ static AubMemDump::LrcaHelperBcs bcs(0x020000);
static AubMemDump::LrcaHelperVcs vcs(0x010000);
static AubMemDump::LrcaHelperVecs vecs(0x018000);
const AubMemDump::LrcaHelper *AUBFamilyMapper<GENX>::csTraits[EngineType::NUM_ENGINES] = {
const AubMemDump::LrcaHelper *AUBFamilyMapper<GENX>::csTraits[aub_stream::NUM_ENGINES] = {
&rcs,
&bcs,
&vcs,
@ -80,7 +80,7 @@ bool HwHelperHw<GENX>::setupPreemptionRegisters(HardwareInfo *pHwInfo, bool enab
}
template <>
const AubMemDump::LrcaHelper &HwHelperHw<GENX>::getCsTraits(EngineType engineType) const {
const AubMemDump::LrcaHelper &HwHelperHw<GENX>::getCsTraits(aub_stream::EngineType engineType) const {
return *AUBFamilyMapper<GENX>::csTraits[engineType];
}

4
unit_tests/libult/mock_gfx_family.h
View File

@ -535,9 +535,9 @@ struct GENX {
template <>
struct AUBFamilyMapper<GENX> {
static const AubMemDump::LrcaHelper *csTraits[EngineType::NUM_ENGINES];
static const AubMemDump::LrcaHelper *csTraits[aub_stream::NUM_ENGINES];
static const MMIOList globalMMIO;
static const MMIOList *perEngineMMIO[EngineType::NUM_ENGINES];
static const MMIOList *perEngineMMIO[aub_stream::NUM_ENGINES];
};
} // namespace NEO

2
unit_tests/mocks/mock_os_context.h
View File

@ -12,7 +12,7 @@ namespace NEO {
class MockOsContext : public OsContext {
public:
MockOsContext(uint32_t contextId, DeviceBitfield deviceBitfield,
EngineType engineType, PreemptionMode preemptionMode, bool lowPriority)
aub_stream::EngineType engineType, PreemptionMode preemptionMode, bool lowPriority)
: OsContext(contextId, deviceBitfield, engineType, preemptionMode, lowPriority) {}
};
} // namespace NEO

4
unit_tests/os_interface/linux/drm_mapper_tests.cpp
View File

@ -13,11 +13,11 @@
using namespace NEO;
TEST(DrmMapperTests, engineNodeMapPass) {
unsigned int flag = DrmEngineMapper::engineNodeMap(EngineType::ENGINE_RCS);
unsigned int flag = DrmEngineMapper::engineNodeMap(aub_stream::ENGINE_RCS);
unsigned int expected = I915_EXEC_RENDER;
EXPECT_EQ(expected, flag);
}
TEST(DrmMapperTests, engineNodeMapNegative) {
EXPECT_THROW(DrmEngineMapper::engineNodeMap(EngineType::ENGINE_BCS), std::exception);
EXPECT_THROW(DrmEngineMapper::engineNodeMap(aub_stream::ENGINE_BCS), std::exception);
}

12
unit_tests/os_interface/linux/drm_tests.cpp
View File

@ -172,14 +172,14 @@ TEST(DrmTest, givenDrmWhenOsContextIsCreatedThenCreateAndDestroyNewDrmOsContext)
{
drmMock.StoredCtxId = drmContextId1;
OsContextLinux osContext1(drmMock, 0u, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
OsContextLinux osContext1(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
EXPECT_EQ(drmContextId1, osContext1.getDrmContextId());
EXPECT_EQ(0u, drmMock.receivedDestroyContextId);
{
drmMock.StoredCtxId = drmContextId2;
OsContextLinux osContext2(drmMock, 0u, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
OsContextLinux osContext2(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
EXPECT_EQ(drmContextId2, osContext2.getDrmContextId());
EXPECT_EQ(0u, drmMock.receivedDestroyContextId);
}
@ -195,17 +195,17 @@ TEST(DrmTest, givenDrmPreemptionEnabledAndLowPriorityEngineWhenCreatingOsContext
drmMock.StoredCtxId = 123;
drmMock.preemptionSupported = false;
OsContextLinux osContext1(drmMock, 0u, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
OsContextLinux osContext2(drmMock, 0u, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, true);
OsContextLinux osContext1(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
OsContextLinux osContext2(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, true);
EXPECT_EQ(0u, drmMock.receivedContextParamRequestCount);
drmMock.preemptionSupported = true;
OsContextLinux osContext3(drmMock, 0u, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false);
OsContextLinux osContext3(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
EXPECT_EQ(0u, drmMock.receivedContextParamRequestCount);
OsContextLinux osContext4(drmMock, 0u, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, true);
OsContextLinux osContext4(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, true);
EXPECT_EQ(1u, drmMock.receivedContextParamRequestCount);
EXPECT_EQ(drmMock.StoredCtxId, drmMock.receivedContextParamRequest.ctx_id);
EXPECT_EQ(static_cast<uint64_t>(I915_CONTEXT_PARAM_PRIORITY), drmMock.receivedContextParamRequest.param);

4
unit_tests/os_interface/windows/wddm_mapper_tests.cpp
View File

@ -11,11 +11,11 @@
using namespace NEO;
TEST(WddmMapperTests, givenRcsEngineTypeWhenAskedForNodeOrdinalThenReturn3d) {
GPUNODE_ORDINAL gpuNode = WddmEngineMapper::engineNodeMap(EngineType::ENGINE_RCS);
GPUNODE_ORDINAL gpuNode = WddmEngineMapper::engineNodeMap(aub_stream::ENGINE_RCS);
GPUNODE_ORDINAL expected = GPUNODE_3D;
EXPECT_EQ(expected, gpuNode);
}
TEST(WddmMapperTests, givenNotSupportedEngineWhenAskedForNodeThenAbort) {
EXPECT_THROW(WddmEngineMapper::engineNodeMap(EngineType::ENGINE_BCS), std::exception);
EXPECT_THROW(WddmEngineMapper::engineNodeMap(aub_stream::ENGINE_BCS), std::exception);
}

16
unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp
View File

@ -69,7 +69,7 @@ TEST(WddmMemoryManager, NonAssignable) {
TEST(WddmAllocationTest, givenAllocationIsTrimCandidateInOneOsContextWhenGettingTrimCandidatePositionThenReturnItsPositionAndUnusedPositionInOtherContexts) {
WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false};
MockOsContext osContext(1u, 1, ENGINE_RCS, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
MockOsContext osContext(1u, 1, aub_stream::ENGINE_RCS, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
allocation.setTrimCandidateListPosition(osContext.getContextId(), 700u);
EXPECT_EQ(trimListUnusedPosition, allocation.getTrimCandidateListPosition(0u));
EXPECT_EQ(700u, allocation.getTrimCandidateListPosition(1u));
@ -1344,16 +1344,16 @@ TEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWithNoRegisteredOsContextsWh
}
TEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWithRegisteredOsContextWhenCallingIsMemoryBudgetExhaustedThenReturnFalse) {
memoryManager->createAndRegisterOsContext(nullptr, ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(nullptr, ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(nullptr, ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(nullptr, aub_stream::ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(nullptr, aub_stream::ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(nullptr, aub_stream::ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
EXPECT_FALSE(memoryManager->isMemoryBudgetExhausted());
}
TEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWithRegisteredOsContextWithExhaustedMemoryBudgetWhenCallingIsMemoryBudgetExhaustedThenReturnTrue) {
memoryManager->createAndRegisterOsContext(nullptr, ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(nullptr, ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(nullptr, ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(nullptr, aub_stream::ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(nullptr, aub_stream::ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(nullptr, aub_stream::ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
auto osContext = static_cast<OsContextWin *>(memoryManager->getRegisteredEngines()[1].osContext);
osContext->getResidencyController().setMemoryBudgetExhausted();
EXPECT_TRUE(memoryManager->isMemoryBudgetExhausted());
@ -1572,7 +1572,7 @@ TEST(WddmMemoryManagerCleanupTest, givenUsedTagAllocationInWddmMemoryManagerWhen
executionEnvironment.commandStreamReceivers.resize(1);
executionEnvironment.commandStreamReceivers[0].push_back(std::unique_ptr<CommandStreamReceiver>(csr));
executionEnvironment.memoryManager = std::make_unique<WddmMemoryManager>(executionEnvironment);
auto osContext = executionEnvironment.memoryManager->createAndRegisterOsContext(csr, ENGINE_RCS, 1, preemptionMode, false);
auto osContext = executionEnvironment.memoryManager->createAndRegisterOsContext(csr, aub_stream::ENGINE_RCS, 1, preemptionMode, false);
csr->setupContext(*osContext);
EXPECT_EQ(csr, executionEnvironment.memoryManager->getDefaultCommandStreamReceiver(0));