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()
endif() endif()
if(IS_DIRECTORY "${INSTRUMENTATION_SOURCE_DIR}") 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") add_subdirectory("${INSTRUMENTATION_SOURCE_DIR}" "${IGDRCL_BUILD_DIR}/instrumentation")
set(INSTRUMENTATION_LIB_NAME "instrumentation_umd") set(INSTRUMENTATION_LIB_NAME "instrumentation_umd")
set(HAVE_INSTRUMENTATION TRUE) set(HAVE_INSTRUMENTATION TRUE)
@ -428,11 +428,16 @@ endif()
add_subdirectory(third_party/gtest) add_subdirectory(third_party/gtest)
message(STATUS "AUB_STREAM_DIR = ${AUB_STREAM_DIR}" ) message(STATUS "AUB_STREAM_DIR = ${AUB_STREAM_DIR}" )
if(DEFINED AUB_STREAM_DIR) if(DEFINED AUB_STREAM_DIR)
set(AUB_STREAM_PROJECT_NAME "aub_stream") set(AUB_STREAM_PROJECT_NAME "aub_stream")
add_subdirectory(${AUB_STREAM_DIR} ${CMAKE_BINARY_DIR}/aub_stream EXCLUDE_FROM_ALL) 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() endif()
message(STATUS "Engine node dir: ${ENGINE_NODE_DIR}")
add_definitions(-DGMM_OCL) 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) create_project_source_tree(ocloc ${IGDRCL_SOURCE_DIR}/runtime)
set(CLOC_INCLUDES set(CLOC_INCLUDES
${ENGINE_NODE_DIR}
${IGC_OCL_ADAPTOR_DIR} ${IGC_OCL_ADAPTOR_DIR}
${CIF_BASE_DIR} ${CIF_BASE_DIR}
${HW_SRC_INCLUDE_PATH} ${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 target_include_directories(${NEO_STATIC_LIB_NAME} PUBLIC
${ENGINE_NODE_DIR}
${KHRONOS_HEADERS_DIR} ${KHRONOS_HEADERS_DIR}
${KHRONOS_GL_HEADERS_DIR} ${KHRONOS_GL_HEADERS_DIR}
${CIF_BASE_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 # 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") set_target_properties(${BUILTINS_BINARIES_LIB_NAME} PROPERTIES FOLDER "built_ins")
target_include_directories(${BUILTINS_BINARIES_LIB_NAME} PRIVATE target_include_directories(${BUILTINS_BINARIES_LIB_NAME} PRIVATE
${ENGINE_NODE_DIR}
${KHRONOS_HEADERS_DIR} ${KHRONOS_HEADERS_DIR}
${KHRONOS_GL_HEADERS_DIR} ${KHRONOS_GL_HEADERS_DIR}
${UMKM_SHAREDDATA_INCLUDE_PATHS} ${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 # Copyright (C) 2017-2019 Intel Corporation
# 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:
# #
# The above copyright notice and this permission notice shall be included # SPDX-License-Identifier: MIT
# in all copies or substantial portions of the Software.
# #
# 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 add_library(${BUILTINS_SOURCES_LIB_NAME} OBJECT
CMakeLists.txt 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") set_target_properties(${BUILTINS_SOURCES_LIB_NAME} PROPERTIES FOLDER "built_ins")
target_include_directories(${BUILTINS_SOURCES_LIB_NAME} PRIVATE target_include_directories(${BUILTINS_SOURCES_LIB_NAME} PRIVATE
${ENGINE_NODE_DIR}
${KHRONOS_HEADERS_DIR} ${KHRONOS_HEADERS_DIR}
${KHRONOS_GL_HEADERS_DIR} ${KHRONOS_GL_HEADERS_DIR}
${UMKM_SHAREDDATA_INCLUDE_PATHS} ${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 # SPDX-License-Identifier: MIT
# #
@ -44,6 +44,7 @@ apply_macro_for_each_gen("SUPPORTED")
add_library(${BIKSIM_LIB_NAME} OBJECT ${BUILTIN_KERNELS_SIMULATION_SRCS}) add_library(${BIKSIM_LIB_NAME} OBJECT ${BUILTIN_KERNELS_SIMULATION_SRCS})
target_include_directories(${BIKSIM_LIB_NAME} BEFORE PRIVATE target_include_directories(${BIKSIM_LIB_NAME} BEFORE PRIVATE
${ENGINE_NODE_DIR}
${UMKM_SHAREDDATA_INCLUDE_PATHS} ${UMKM_SHAREDDATA_INCLUDE_PATHS}
${KHRONOS_HEADERS_DIR} ${KHRONOS_HEADERS_DIR}
${KHRONOS_GL_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)) { if (clPriority & static_cast<cl_queue_priority_khr>(CL_QUEUE_PRIORITY_LOW_KHR)) {
priority = QueuePriority::LOW; 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)) { } else if (clPriority & static_cast<cl_queue_priority_khr>(CL_QUEUE_PRIORITY_MED_KHR)) {
priority = QueuePriority::MEDIUM; priority = QueuePriority::MEDIUM;
} else if (clPriority & static_cast<cl_queue_priority_khr>(CL_QUEUE_PRIORITY_HIGH_KHR)) { } 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}/create_command_stream_impl.h
${CMAKE_CURRENT_SOURCE_DIR}/csr_definitions.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}/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.h
${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_simulated_common_hw.inl ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_simulated_common_hw.inl
${CMAKE_CURRENT_SOURCE_DIR}/device_command_stream.h ${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); uint64_t getPPGTTAdditionalBits(GraphicsAllocation *gfxAllocation);
void getGTTData(void *memory, AubGTTData &data); void getGTTData(void *memory, AubGTTData &data);
uint32_t getMemoryBankForGtt() const; uint32_t getMemoryBankForGtt() const;
static const AubMemDump::LrcaHelper &getCsTraits(EngineType engineType); static const AubMemDump::LrcaHelper &getCsTraits(aub_stream::EngineType engineType);
void initEngineMMIO(); void initEngineMMIO();
void submitLRCA(const MiContextDescriptorReg &contextDescriptor); void submitLRCA(const MiContextDescriptorReg &contextDescriptor);
void setupContext(OsContext &osContext) override; 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> 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]; 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) { for (auto &engine : engines) {
if (engine.osContext->getEngineType() == engineType && if (engine.osContext->getEngineType() == engineType &&
engine.osContext->isLowPriority() == lowPriority) { 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; deviceInfo.force32BitAddressess = value;
} }
EngineControl &getEngine(EngineType engineType, bool lowPriority); EngineControl &getEngine(aub_stream::EngineType engineType, bool lowPriority);
EngineControl &getDefaultEngine(); EngineControl &getDefaultEngine();
const char *getProductAbbrev() const; 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/gen_common/aub_mapper_base.h"
#include "runtime/memory_manager/memory_constants.h" #include "runtime/memory_manager/memory_constants.h"
#include "engine_node.h"
namespace NEO { namespace NEO {
struct CNLFamily; struct CNLFamily;
@ -18,10 +20,10 @@ struct AUBFamilyMapper<CNLFamily> {
using AubTraits = AubMemDump::Traits<device, MemoryConstants::GfxAddressBits>; 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 globalMMIO;
static const MMIOList *perEngineMMIO[EngineType::NUM_ENGINES]; static const MMIOList *perEngineMMIO[aub_stream::NUM_ENGINES];
typedef AubMemDump::AubDump<AubTraits> AUB; 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::LrcaHelperVcs vcs(0x012000);
static const AubMemDump::LrcaHelperVecs vecs(0x01a000); 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, &rcs,
&bcs, &bcs,
&vcs, &vcs,
@ -73,7 +73,7 @@ static const MMIOList mmioListVECS = {
MMIOPair(AubMemDump::computeRegisterOffset(vecs.mmioBase, 0x229c), 0xffff8280), 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, &mmioListRCS,
&mmioListBCS, &mmioListBCS,
&mmioListVCS, &mmioListVCS,

2
runtime/gen10/hw_info_cnl.inl
View File

@ -47,7 +47,7 @@ const RuntimeCapabilityTable CNL::capabilityTable{
MemoryConstants::pageSize, // requiredPreemptionSurfaceSize MemoryConstants::pageSize, // requiredPreemptionSurfaceSize
&isSimulationCNL, // isSimulation &isSimulationCNL, // isSimulation
PreemptionMode::MidThread, // defaultPreemptionMode PreemptionMode::MidThread, // defaultPreemptionMode
EngineType::ENGINE_RCS, // defaultEngineType aub_stream::ENGINE_RCS, // defaultEngineType
0, // maxRenderFrequency 0, // maxRenderFrequency
21, // clVersionSupport 21, // clVersionSupport
CmdServicesMemTraceVersion::DeviceValues::Cnl, // aubDeviceId 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/gen_common/aub_mapper_base.h"
#include "runtime/memory_manager/memory_constants.h" #include "runtime/memory_manager/memory_constants.h"
#include "engine_node.h"
namespace NEO { namespace NEO {
struct BDWFamily; struct BDWFamily;
@ -18,10 +20,10 @@ struct AUBFamilyMapper<BDWFamily> {
using AubTraits = AubMemDump::Traits<device, MemoryConstants::GfxAddressBits>; 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 globalMMIO;
static const MMIOList *perEngineMMIO[EngineType::NUM_ENGINES]; static const MMIOList *perEngineMMIO[aub_stream::NUM_ENGINES];
typedef AubMemDump::AubDump<AubTraits> AUB; 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::LrcaHelperVcs vcs(0x012000);
static const AubMemDump::LrcaHelperVecs vecs(0x01a000); 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, &rcs,
&bcs, &bcs,
&vcs, &vcs,
@ -58,7 +58,7 @@ static const MMIOList mmioListVECS = {
MMIOPair(AubMemDump::computeRegisterOffset(vecs.mmioBase, 0x229c), 0xffff8280), 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, &mmioListRCS,
&mmioListBCS, &mmioListBCS,
&mmioListVCS, &mmioListVCS,

2
runtime/gen8/hw_info_bdw.inl
View File

@ -48,7 +48,7 @@ const RuntimeCapabilityTable BDW::capabilityTable{
MemoryConstants::pageSize, // requiredPreemptionSurfaceSize MemoryConstants::pageSize, // requiredPreemptionSurfaceSize
&isSimulationBDW, // isSimulation &isSimulationBDW, // isSimulation
PreemptionMode::Disabled, // defaultPreemptionMode PreemptionMode::Disabled, // defaultPreemptionMode
EngineType::ENGINE_RCS, // defaultEngineType aub_stream::ENGINE_RCS, // defaultEngineType
0, // maxRenderFrequency 0, // maxRenderFrequency
21, // clVersionSupport 21, // clVersionSupport
CmdServicesMemTraceVersion::DeviceValues::Bdw, // aubDeviceId 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/gen_common/aub_mapper_base.h"
#include "runtime/memory_manager/memory_constants.h" #include "runtime/memory_manager/memory_constants.h"
#include "engine_node.h"
namespace NEO { namespace NEO {
struct SKLFamily; struct SKLFamily;
@ -18,10 +20,10 @@ struct AUBFamilyMapper<SKLFamily> {
using AubTraits = AubMemDump::Traits<device, MemoryConstants::GfxAddressBits>; 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 globalMMIO;
static const MMIOList *perEngineMMIO[EngineType::NUM_ENGINES]; static const MMIOList *perEngineMMIO[aub_stream::NUM_ENGINES];
typedef AubMemDump::AubDump<AubTraits> AUB; 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::LrcaHelperVcs vcs(0x012000);
static const AubMemDump::LrcaHelperVecs vecs(0x01a000); 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, &rcs,
&bcs, &bcs,
&vcs, &vcs,
@ -70,7 +70,7 @@ static const MMIOList mmioListVECS = {
MMIOPair(AubMemDump::computeRegisterOffset(vecs.mmioBase, 0x229c), 0xffff8280), 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, &mmioListRCS,
&mmioListBCS, &mmioListBCS,
&mmioListVCS, &mmioListVCS,

2
runtime/gen9/hw_info_bxt.inl
View File

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

2
runtime/gen9/hw_info_cfl.inl
View File

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

2
runtime/gen9/hw_info_glk.inl
View File

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

2
runtime/gen9/hw_info_kbl.inl
View File

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

2
runtime/gen9/hw_info_skl.inl
View File

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

1
runtime/helpers/completion_stamp.h
View File

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

8
runtime/helpers/hw_helper.h
View File

@ -39,7 +39,7 @@ class HwHelper {
virtual uint32_t getConfigureAddressSpaceMode() = 0; virtual uint32_t getConfigureAddressSpaceMode() = 0;
virtual bool isLocalMemoryEnabled(const HardwareInfo &hwInfo) const = 0; virtual bool isLocalMemoryEnabled(const HardwareInfo &hwInfo) const = 0;
virtual bool isPageTableManagerSupported(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 supportsYTiling() const = 0;
virtual bool obtainRenderBufferCompressionPreference(const HardwareInfo &hwInfo) const = 0; virtual bool obtainRenderBufferCompressionPreference(const HardwareInfo &hwInfo) const = 0;
static bool renderCompressedBuffersSupported(const HardwareInfo &hwInfo); static bool renderCompressedBuffersSupported(const HardwareInfo &hwInfo);
@ -58,7 +58,7 @@ class HwHelper {
uint32_t surfaceType, uint32_t surfaceType,
bool forceNonAuxMode) = 0; bool forceNonAuxMode) = 0;
virtual size_t getScratchSpaceOffsetFor64bit() = 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 bool getEnableLocalMemory(const HardwareInfo &hwInfo) const = 0;
virtual std::string getExtensions() const = 0; virtual std::string getExtensions() const = 0;
@ -103,7 +103,7 @@ class HwHelperHw : public HwHelper {
return sizeof(RENDER_SURFACE_STATE); 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; size_t getMaxBarrierRegisterPerSlice() const override;
@ -144,7 +144,7 @@ class HwHelperHw : public HwHelper {
size_t getScratchSpaceOffsetFor64bit() override; 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; 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> 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]; return *AUBFamilyMapper<Family>::csTraits[engineType];
} }
@ -168,10 +168,10 @@ size_t HwHelperHw<Family>::getScratchSpaceOffsetFor64bit() {
} }
template <typename Family> template <typename Family>
const std::vector<EngineType> HwHelperHw<Family>::getGpgpuEngineInstances() const { const std::vector<aub_stream::EngineType> HwHelperHw<Family>::getGpgpuEngineInstances() const {
constexpr std::array<EngineType, 2> gpgpuEngineInstances = {{ENGINE_RCS, constexpr std::array<aub_stream::EngineType, 2> gpgpuEngineInstances = {{aub_stream::ENGINE_RCS,
ENGINE_RCS}}; // low priority aub_stream::ENGINE_RCS}}; // low priority
return std::vector<EngineType>(gpgpuEngineInstances.begin(), gpgpuEngineInstances.end()); return std::vector<aub_stream::EngineType>(gpgpuEngineInstances.begin(), gpgpuEngineInstances.end());
} }
template <typename Family> 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; return ret;
} }
EngineType getChosenEngineType(const HardwareInfo &hwInfo) { aub_stream::EngineType getChosenEngineType(const HardwareInfo &hwInfo) {
return DebugManager.flags.NodeOrdinal.get() == -1 return DebugManager.flags.NodeOrdinal.get() == -1
? hwInfo.capabilityTable.defaultEngineType ? hwInfo.capabilityTable.defaultEngineType
: static_cast<EngineType>(DebugManager.flags.NodeOrdinal.get()); : static_cast<aub_stream::EngineType>(DebugManager.flags.NodeOrdinal.get());
} }
} // namespace NEO } // namespace NEO

4
runtime/helpers/hw_info.h
View File

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

2
runtime/memory_manager/memory_manager.cpp
View File

@ -199,7 +199,7 @@ bool MemoryManager::isMemoryBudgetExhausted() const {
return false; return false;
} }
OsContext *MemoryManager::createAndRegisterOsContext(CommandStreamReceiver *commandStreamReceiver, EngineType engineType, OsContext *MemoryManager::createAndRegisterOsContext(CommandStreamReceiver *commandStreamReceiver, aub_stream::EngineType engineType,
DeviceBitfield deviceBitfield, PreemptionMode preemptionMode, bool lowPriority) { DeviceBitfield deviceBitfield, PreemptionMode preemptionMode, bool lowPriority) {
auto contextId = ++latestContextId; auto contextId = ++latestContextId;
auto osContext = OsContext::create(executionEnvironment.osInterface.get(), contextId, deviceBitfield, engineType, preemptionMode, lowPriority); 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); ::alignedFree(ptr);
} }
OsContext *createAndRegisterOsContext(CommandStreamReceiver *commandStreamReceiver, EngineType engineType, OsContext *createAndRegisterOsContext(CommandStreamReceiver *commandStreamReceiver, aub_stream::EngineType engineType,
DeviceBitfield deviceBitfield, PreemptionMode preemptionMode, bool lowPriority); DeviceBitfield deviceBitfield, PreemptionMode preemptionMode, bool lowPriority);
uint32_t getRegisteredEnginesCount() const { return static_cast<uint32_t>(registeredEngines.size()); } uint32_t getRegisteredEnginesCount() const { return static_cast<uint32_t>(registeredEngines.size()); }
CommandStreamReceiver *getDefaultCommandStreamReceiver(uint32_t deviceId) const; CommandStreamReceiver *getDefaultCommandStreamReceiver(uint32_t deviceId) const;

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

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

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

@ -13,7 +13,7 @@ namespace NEO {
class DrmEngineMapper { class DrmEngineMapper {
public: public:
static unsigned int engineNodeMap(EngineType engineType); static unsigned int engineNodeMap(aub_stream::EngineType engineType);
}; };
} // namespace NEO } // 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; outHwInfo->capabilityTable.ftrSupportsCoherency = false;
hwHelper.adjustDefaultEngineType(outHwInfo); hwHelper.adjustDefaultEngineType(outHwInfo);
outHwInfo->capabilityTable.defaultEngineType = DebugManager.flags.NodeOrdinal.get() == -1 outHwInfo->capabilityTable.defaultEngineType = getChosenEngineType(*outHwInfo);
? outHwInfo->capabilityTable.defaultEngineType
: static_cast<EngineType>(DebugManager.flags.NodeOrdinal.get());
outHwInfo->capabilityTable.instrumentationEnabled = false; outHwInfo->capabilityTable.instrumentationEnabled = false;
outHwInfo->capabilityTable.ftrRenderCompressedBuffers = false; outHwInfo->capabilityTable.ftrRenderCompressedBuffers = false;

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

@ -15,7 +15,7 @@
namespace NEO { namespace NEO {
OsContext *OsContext::create(OSInterface *osInterface, uint32_t contextId, DeviceBitfield deviceBitfield, 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) { if (osInterface) {
return new OsContextLinux(*osInterface->get()->getDrm(), contextId, deviceBitfield, engineType, preemptionMode, lowPriority); 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, 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) { : OsContext(contextId, deviceBitfield, engineType, preemptionMode, lowPriority), drm(drm) {
engineFlag = DrmEngineMapper::engineNodeMap(engineType); 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() = delete;
~OsContextLinux() override; ~OsContextLinux() override;
OsContextLinux(Drm &drm, uint32_t contextId, DeviceBitfield deviceBitfield, 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; } unsigned int getEngineFlag() const { return engineFlag; }
uint32_t getDrmContextId() const { return drmContextId; } 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; OsContext() = delete;
static OsContext *create(OSInterface *osInterface, uint32_t contextId, DeviceBitfield deviceBitfield, 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 getContextId() const { return contextId; }
uint32_t getNumSupportedDevices() const { return numSupportedDevices; } uint32_t getNumSupportedDevices() const { return numSupportedDevices; }
DeviceBitfield getDeviceBitfield() const { return deviceBitfield; } DeviceBitfield getDeviceBitfield() const { return deviceBitfield; }
PreemptionMode getPreemptionMode() const { return preemptionMode; } PreemptionMode getPreemptionMode() const { return preemptionMode; }
EngineType &getEngineType() { return engineType; } aub_stream::EngineType &getEngineType() { return engineType; }
bool isLowPriority() const { return lowPriority; } bool isLowPriority() const { return lowPriority; }
protected: 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), : contextId(contextId),
deviceBitfield(deviceBitfield), deviceBitfield(deviceBitfield),
preemptionMode(preemptionMode), preemptionMode(preemptionMode),
@ -43,7 +43,7 @@ class OsContext : public ReferenceTrackedObject<OsContext> {
const DeviceBitfield deviceBitfield; const DeviceBitfield deviceBitfield;
const PreemptionMode preemptionMode; const PreemptionMode preemptionMode;
const uint32_t numSupportedDevices; const uint32_t numSupportedDevices;
EngineType engineType = EngineType::ENGINE_RCS; aub_stream::EngineType engineType = aub_stream::ENGINE_RCS;
const bool lowPriority; const bool lowPriority;
}; };
} // namespace NEO } // 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; outHwInfo->capabilityTable.ftrSvm = outHwInfo->pSkuTable->ftrSVM;
hwHelper.adjustDefaultEngineType(outHwInfo); hwHelper.adjustDefaultEngineType(outHwInfo);
const auto nodeOrdinal = DebugManager.flags.NodeOrdinal.get(); outHwInfo->capabilityTable.defaultEngineType = getChosenEngineType(*outHwInfo);
outHwInfo->capabilityTable.defaultEngineType = nodeOrdinal == -1
? outHwInfo->capabilityTable.defaultEngineType
: static_cast<EngineType>(nodeOrdinal);
hwHelper.setCapabilityCoherencyFlag(outHwInfo, outHwInfo->capabilityTable.ftrSupportsCoherency); hwHelper.setCapabilityCoherencyFlag(outHwInfo, outHwInfo->capabilityTable.ftrSupportsCoherency);

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

@ -14,7 +14,7 @@
namespace NEO { namespace NEO {
OsContext *OsContext::create(OSInterface *osInterface, uint32_t contextId, DeviceBitfield deviceBitfield, 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) { if (osInterface) {
return new OsContextWin(*osInterface->get()->getWddm(), contextId, deviceBitfield, engineType, preemptionMode, lowPriority); 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, 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) { : OsContext(contextId, deviceBitfield, engineType, preemptionMode, lowPriority), wddm(wddm), residencyController(wddm, contextId) {
UNRECOVERABLE_IF(!wddm.isInitialized()); 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() override;
OsContextWin(Wddm &wddm, uint32_t contextId, DeviceBitfield deviceBitfield, 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; } D3DKMT_HANDLE getWddmContextHandle() const { return wddmContextHandle; }
void setWddmContextHandle(D3DKMT_HANDLE wddmContextHandle) { this->wddmContextHandle = 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 { namespace NEO {
GPUNODE_ORDINAL WddmEngineMapper::engineNodeMap(EngineType engineType) { GPUNODE_ORDINAL WddmEngineMapper::engineNodeMap(aub_stream::EngineType engineType) {
if (EngineType::ENGINE_RCS == engineType) { if (aub_stream::ENGINE_RCS == engineType) {
return GPUNODE_3D; return GPUNODE_3D;
} }
UNRECOVERABLE_IF(true); UNRECOVERABLE_IF(true);

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

@ -15,7 +15,7 @@ namespace NEO {
class WddmEngineMapper { class WddmEngineMapper {
public: public:
static GPUNODE_ORDINAL engineNodeMap(EngineType engineType); static GPUNODE_ORDINAL engineNodeMap(aub_stream::EngineType engineType);
}; };
} // namespace NEO } // 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 # 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) add_dependencies(${SCHEDULER_BINARY_LIB_NAME} scheduler)
target_include_directories(${SCHEDULER_BINARY_LIB_NAME} PRIVATE target_include_directories(${SCHEDULER_BINARY_LIB_NAME} PRIVATE
${ENGINE_NODE_DIR}
${KHRONOS_HEADERS_DIR} ${KHRONOS_HEADERS_DIR}
${UMKM_SHAREDDATA_INCLUDE_PATHS} ${UMKM_SHAREDDATA_INCLUDE_PATHS}
${IGDRCL__IGC_INCLUDE_DIR} ${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 #pragma once
#include <cstdint> #include <cstdint>
namespace NEO { namespace aub_stream {
enum EngineType : uint32_t { enum EngineType : uint32_t {
ENGINE_RCS = 0, ENGINE_RCS = 0,
@ -18,4 +18,4 @@ enum EngineType : uint32_t {
NUM_ENGINES 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 target_include_directories(igdrcl_tests PRIVATE
${IGDRCL_SOURCE_DIR}/unit_tests/mocks${BRANCH_DIR_SUFFIX} ${IGDRCL_SOURCE_DIR}/unit_tests/mocks${BRANCH_DIR_SUFFIX}
${ENGINE_NODE_DIR}
${KHRONOS_GL_HEADERS_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 commandQueueObj = castToObject<CommandQueue>(cmdQ);
auto &osContext = commandQueueObj->getCommandStreamReceiver().getOsContext(); auto &osContext = commandQueueObj->getCommandStreamReceiver().getOsContext();
EXPECT_EQ(EngineType::ENGINE_RCS, osContext.getEngineType()); EXPECT_EQ(aub_stream::ENGINE_RCS, osContext.getEngineType());
EXPECT_TRUE(osContext.isLowPriority()); EXPECT_TRUE(osContext.isLowPriority());
clReleaseCommandQueue(cmdQ); clReleaseCommandQueue(cmdQ);

2
unit_tests/aub/aub_helper_tests.inl
View File

@ -126,7 +126,7 @@ HWTEST_F(AubHelperHwTest, GivenEnabledLocalMemoryWhenGetMemTraceForPtEntryIsCall
} }
HWTEST_F(AubHelperHwTest, giverLrcaHelperWhenContextIsInitializedThenContextFlagsAreSet) { 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); MockLrcaHelper lrcaHelper(csTraits.mmioBase);
std::unique_ptr<void, std::function<void(void *)>> lrcaBase(alignedMalloc(csTraits.sizeLRCA, csTraits.alignLRCA), alignedFree); 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> template <typename FamilyType>
void testNoopIdXcs(EngineType engineType) { void testNoopIdXcs(aub_stream::EngineType engineType) {
pCommandStreamReceiver->getOsContext().getEngineType() = engineType; pCommandStreamReceiver->getOsContext().getEngineType() = engineType;
typedef typename FamilyType::MI_NOOP MI_NOOP; typedef typename FamilyType::MI_NOOP MI_NOOP;
@ -84,19 +84,19 @@ HWTEST_F(AUBcommandstreamTests, testFlushTwice) {
} }
HWTEST_F(AUBcommandstreamTests, testNoopIdRcs) { HWTEST_F(AUBcommandstreamTests, testNoopIdRcs) {
testNoopIdXcs<FamilyType>(EngineType::ENGINE_RCS); testNoopIdXcs<FamilyType>(aub_stream::ENGINE_RCS);
} }
HWTEST_F(AUBcommandstreamTests, testNoopIdBcs) { HWTEST_F(AUBcommandstreamTests, testNoopIdBcs) {
testNoopIdXcs<FamilyType>(EngineType::ENGINE_BCS); testNoopIdXcs<FamilyType>(aub_stream::ENGINE_BCS);
} }
HWTEST_F(AUBcommandstreamTests, testNoopIdVcs) { HWTEST_F(AUBcommandstreamTests, testNoopIdVcs) {
testNoopIdXcs<FamilyType>(EngineType::ENGINE_VCS); testNoopIdXcs<FamilyType>(aub_stream::ENGINE_VCS);
} }
HWTEST_F(AUBcommandstreamTests, testNoopIdVecs) { HWTEST_F(AUBcommandstreamTests, testNoopIdVecs) {
testNoopIdXcs<FamilyType>(EngineType::ENGINE_VECS); testNoopIdXcs<FamilyType>(aub_stream::ENGINE_VECS);
} }
TEST_F(AUBcommandstreamTests, makeResident) { 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::AUBCommandStreamReceiverHw;
using NEO::AUBFamilyMapper; using NEO::AUBFamilyMapper;
using NEO::DeviceFixture; using NEO::DeviceFixture;
using NEO::EngineType;
using NEO::folderAUB; using NEO::folderAUB;
std::string getAubFileName(const NEO::Device *pDevice, const std::string baseName) { std::string getAubFileName(const NEO::Device *pDevice, const std::string baseName) {
@ -189,19 +188,19 @@ HWTEST_F(AubMemDumpTests, writeVerifySevenBytesGGTT) {
} }
HWTEST_F(AubMemDumpTests, simpleRCS) { HWTEST_F(AubMemDumpTests, simpleRCS) {
setupAUB<FamilyType>(pDevice, EngineType::ENGINE_RCS); setupAUB<FamilyType>(pDevice, aub_stream::ENGINE_RCS);
} }
HWTEST_F(AubMemDumpTests, simpleBCS) { HWTEST_F(AubMemDumpTests, simpleBCS) {
setupAUB<FamilyType>(pDevice, EngineType::ENGINE_BCS); setupAUB<FamilyType>(pDevice, aub_stream::ENGINE_BCS);
} }
HWTEST_F(AubMemDumpTests, simpleVCS) { HWTEST_F(AubMemDumpTests, simpleVCS) {
setupAUB<FamilyType>(pDevice, EngineType::ENGINE_VCS); setupAUB<FamilyType>(pDevice, aub_stream::ENGINE_VCS);
} }
HWTEST_F(AubMemDumpTests, simpleVECS) { HWTEST_F(AubMemDumpTests, simpleVECS) {
setupAUB<FamilyType>(pDevice, EngineType::ENGINE_VECS); setupAUB<FamilyType>(pDevice, aub_stream::ENGINE_VECS);
} }
TEST(AubMemDumpBasic, givenDebugOverrideMmioWhenMmioNotMatchThenDoNotAlterValue) { 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); extern std::string getAubFileName(const NEO::Device *pDevice, const std::string baseName);
template <typename FamilyType> 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; typedef typename NEO::AUBFamilyMapper<FamilyType>::AUB AUB;
const auto &csTraits = NEO::CommandStreamReceiverSimulatedCommonHw<FamilyType>::getCsTraits(engineType); const auto &csTraits = NEO::CommandStreamReceiverSimulatedCommonHw<FamilyType>::getCsTraits(engineType);
auto mmioBase = csTraits.mmioBase; 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; uint32_t deviceIndex = 0;
auto &hwHelper = HwHelper::get(hwInfo.pPlatform->eRenderCoreFamily); 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(); const ::testing::TestInfo *const testInfo = ::testing::UnitTest::GetInstance()->current_test_info();
std::stringstream strfilename; 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 static constexpr auto gpuBatchBufferAddr = 0x800400001000; // 48-bit GPU address
GEN10TEST_F(Gen10AubBatchBufferTests, givenSimpleRCSWithBatchBufferWhenItHasMSBSetInGpuAddressThenAUBShouldBeSetupSuccessfully) { 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" #include "unit_tests/aub_tests/command_stream/aub_mem_dump_tests.h"
template <typename FamilyType> 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; typedef typename NEO::AUBFamilyMapper<FamilyType>::AUB AUB;
const auto &csTraits = NEO::AUBCommandStreamReceiverHw<FamilyType>::getCsTraits(engineType); const auto &csTraits = NEO::AUBCommandStreamReceiverHw<FamilyType>::getCsTraits(engineType);
auto mmioBase = csTraits.mmioBase; 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 static constexpr auto gpuBatchBufferAddr = 0x800400001000ull; // 48-bit GPU address
GEN9TEST_F(AubBatchBufferTests, givenSimpleRCSWithBatchBufferWhenItHasMSBSetInGpuAddressThenAUBShouldBeSetupSuccessfully) { 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" #include "unit_tests/aub_tests/command_stream/aub_mem_dump_tests.h"
template <typename FamilyType> 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; typedef typename NEO::AUBFamilyMapper<FamilyType>::AUB AUB;
const auto &csTraits = NEO::CommandStreamReceiverSimulatedCommonHw<FamilyType>::getCsTraits(engineType); const auto &csTraits = NEO::CommandStreamReceiverSimulatedCommonHw<FamilyType>::getCsTraits(engineType);
auto mmioBase = csTraits.mmioBase; 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) { HWTEST_F(AubCommandStreamReceiverTests, givenAubCsrWhenOsContextIsSetThenCreateHardwareContext) {
uint32_t deviceIndex = 3; 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"; std::string fileName = "file_name.aub";
MockAubManager *mockManager = new MockAubManager(); MockAubManager *mockManager = new MockAubManager();
MockAubCenter *mockAubCenter = new MockAubCenter(platformDevices[0], false, fileName, CommandStreamReceiverType::CSR_AUB); MockAubCenter *mockAubCenter = new MockAubCenter(platformDevices[0], false, fileName, CommandStreamReceiverType::CSR_AUB);
@ -186,7 +186,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCsrWhenOsContextIsSetThenCreateH
} }
HWTEST_F(AubCommandStreamReceiverTests, givenAubCsrWhenLowPriorityOsContextIsSetThenDontCreateHardwareContext) { 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"; std::string fileName = "file_name.aub";
MockAubManager *mockManager = new MockAubManager(); MockAubManager *mockManager = new MockAubManager();
MockAubCenter *mockAubCenter = new MockAubCenter(platformDevices[0], false, fileName, CommandStreamReceiverType::CSR_AUB); MockAubCenter *mockAubCenter = new MockAubCenter(platformDevices[0], false, fileName, CommandStreamReceiverType::CSR_AUB);
@ -777,7 +777,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenOsContextWithMultipleDevicesSupport
DeviceBitfield deviceBitfield; DeviceBitfield deviceBitfield;
deviceBitfield.set(0); deviceBitfield.set(0);
deviceBitfield.set(1); 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); auto aubCsr = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>("", true, *pDevice->executionEnvironment);
aubCsr->setupContext(osContext); aubCsr->setupContext(osContext);
@ -1088,7 +1088,7 @@ TEST_F(HardwareContextContainerTests, givenOsContextWithMultipleDevicesSupported
DeviceBitfield deviceBitfield; DeviceBitfield deviceBitfield;
deviceBitfield.set(0); deviceBitfield.set(0);
deviceBitfield.set(1); 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); HardwareContextController hwContextControler(aubManager, osContext, 0);
EXPECT_EQ(2u, hwContextControler.hardwareContexts.size()); EXPECT_EQ(2u, hwContextControler.hardwareContexts.size());
@ -1104,7 +1104,7 @@ TEST_F(HardwareContextContainerTests, givenMultipleHwContextWhenSingleMethodIsCa
DeviceBitfield deviceBitfield; DeviceBitfield deviceBitfield;
deviceBitfield.set(0); deviceBitfield.set(0);
deviceBitfield.set(1); 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); HardwareContextController hwContextContainer(aubManager, osContext, 0);
EXPECT_EQ(2u, hwContextContainer.hardwareContexts.size()); EXPECT_EQ(2u, hwContextContainer.hardwareContexts.size());
@ -1145,7 +1145,7 @@ TEST_F(HardwareContextContainerTests, givenMultipleHwContextWhenSingleMethodIsCa
DeviceBitfield deviceBitfield; DeviceBitfield deviceBitfield;
deviceBitfield.set(0); deviceBitfield.set(0);
deviceBitfield.set(1); 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); HardwareContextController hwContextContainer(aubManager, osContext, 0);
EXPECT_EQ(2u, hwContextContainer.hardwareContexts.size()); 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); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment); 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.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get()); auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
@ -914,7 +914,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenGraphicsAllocationWritableWhenDumpA
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment); 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.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get()); auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
@ -941,7 +941,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenGraphicsAllocationNonWritableWhenDu
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment); 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.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get()); auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
@ -969,7 +969,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenGraphicsAllocationNotDumpableWhenDu
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment); 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.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get()); auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
@ -998,7 +998,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenGraphicsAllocationDumpableWhenDumpA
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment); 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.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get()); auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
@ -1026,7 +1026,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenGraphicsAllocationWritableWhenDumpA
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment); 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.setupContext(osContext);
aubCsr.latestSentTaskCount = 1; 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); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment); 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.setupContext(osContext);
auto hardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get()); auto hardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
aubCsr.stream = aubStream.get(); aubCsr.stream = aubStream.get();
@ -282,7 +282,7 @@ HWTEST_F(AubFileStreamTests, givenNoNewTasksAndHardwareContextPresentWhenCalling
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment); 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.setupContext(osContext);
auto hardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get()); auto hardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
aubCsr.stream = aubStream.get(); aubCsr.stream = aubStream.get();
@ -365,7 +365,7 @@ HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenFlushIsCalledThenI
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment); 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.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get()); auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
aubCsr.stream = aubStream.get(); aubCsr.stream = aubStream.get();
@ -394,7 +394,7 @@ HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenFlushIsCalledWithZ
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment); 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.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get()); auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
aubCsr.stream = aubStream.get(); aubCsr.stream = aubStream.get();
@ -418,7 +418,7 @@ HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenMakeResidentIsCall
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment); 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.setupContext(osContext);
MockGraphicsAllocation allocation(reinterpret_cast<void *>(0x1000), 0x1000); MockGraphicsAllocation allocation(reinterpret_cast<void *>(0x1000), 0x1000);
@ -434,7 +434,7 @@ HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenExpectMemoryEqualI
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment); 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.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get()); auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get());
@ -450,7 +450,7 @@ HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenExpectMemoryNotEqu
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockAubCsr<FamilyType> aubCsr("", true, *pDevice->executionEnvironment); 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.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(aubCsr.hardwareContextController->hardwareContexts[0].get()); 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; bool wasCalled = false;
FlushStamp flushStampToReturn = 1; FlushStamp flushStampToReturn = 1;
BatchBuffer *receivedBatchBuffer = nullptr; BatchBuffer *receivedBatchBuffer = nullptr;
EngineType receivedEngine = EngineType::ENGINE_RCS; aub_stream::EngineType receivedEngine = aub_stream::ENGINE_RCS;
ResidencyContainer *receivedAllocationsForResidency = nullptr; ResidencyContainer *receivedAllocationsForResidency = nullptr;
} flushParametrization; } 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) { HWTEST_F(TbxCommandStreamTests, DISABLED_getCsTraits) {
TbxCommandStreamReceiverHw<FamilyType> *tbxCsr = (TbxCommandStreamReceiverHw<FamilyType> *)pCommandStreamReceiver; TbxCommandStreamReceiverHw<FamilyType> *tbxCsr = (TbxCommandStreamReceiverHw<FamilyType> *)pCommandStreamReceiver;
tbxCsr->getCsTraits(EngineType::ENGINE_RCS); tbxCsr->getCsTraits(aub_stream::ENGINE_RCS);
tbxCsr->getCsTraits(EngineType::ENGINE_BCS); tbxCsr->getCsTraits(aub_stream::ENGINE_BCS);
tbxCsr->getCsTraits(EngineType::ENGINE_VCS); tbxCsr->getCsTraits(aub_stream::ENGINE_VCS);
tbxCsr->getCsTraits(EngineType::ENGINE_VECS); tbxCsr->getCsTraits(aub_stream::ENGINE_VECS);
} }
TEST(TbxCommandStreamReceiverTest, givenNullFactoryEntryWhenTbxCsrIsCreatedThenNullptrIsReturned) { TEST(TbxCommandStreamReceiverTest, givenNullFactoryEntryWhenTbxCsrIsCreatedThenNullptrIsReturned) {
@ -349,7 +349,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverWhenFlushIsCalledTh
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockTbxCsr<FamilyType> tbxCsr(*pDevice->executionEnvironment); 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); tbxCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(tbxCsr.hardwareContextController->hardwareContexts[0].get()); auto mockHardwareContext = static_cast<MockHardwareContext *>(tbxCsr.hardwareContextController->hardwareContexts[0].get());
@ -379,7 +379,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverInBatchedModeWhenFl
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockTbxCsr<FamilyType> tbxCsr(*pDevice->executionEnvironment); 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); tbxCsr.setupContext(osContext);
auto commandBuffer = pDevice->executionEnvironment->memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}); auto commandBuffer = pDevice->executionEnvironment->memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
@ -401,7 +401,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverWhenFlushIsCalledWi
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockTbxCsr<FamilyType> tbxCsr(*pDevice->executionEnvironment); 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); tbxCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(tbxCsr.hardwareContextController->hardwareContexts[0].get()); auto mockHardwareContext = static_cast<MockHardwareContext *>(tbxCsr.hardwareContextController->hardwareContexts[0].get());
@ -423,7 +423,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverWhenMakeResidentIsC
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockTbxCsr<FamilyType> tbxCsr(*pDevice->executionEnvironment); 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); tbxCsr.setupContext(osContext);
MockGraphicsAllocation allocation(reinterpret_cast<void *>(0x1000), 0x1000); MockGraphicsAllocation allocation(reinterpret_cast<void *>(0x1000), 0x1000);
@ -439,7 +439,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverWhenMakeCoherentIsC
pDevice->executionEnvironment->aubCenter.reset(mockAubCenter); pDevice->executionEnvironment->aubCenter.reset(mockAubCenter);
MockTbxCsr<FamilyType> tbxCsr(*pDevice->executionEnvironment); 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); tbxCsr.setupContext(osContext);
auto mockHardwareContext = static_cast<MockHardwareContext *>(tbxCsr.hardwareContextController->hardwareContexts[0].get()); 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_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) { TEST_F(DeviceTest, WhenGetOSTimeThenNotNull) {
@ -102,8 +102,8 @@ TEST_F(DeviceTest, retainAndRelease) {
TEST_F(DeviceTest, getEngineTypeDefault) { TEST_F(DeviceTest, getEngineTypeDefault) {
auto pTestDevice = std::unique_ptr<Device>(createWithUsDeviceId(0)); auto pTestDevice = std::unique_ptr<Device>(createWithUsDeviceId(0));
EngineType actualEngineType = pDevice->getDefaultEngine().osContext->getEngineType(); auto actualEngineType = pDevice->getDefaultEngine().osContext->getEngineType();
EngineType defaultEngineType = pDevice->getHardwareInfo().capabilityTable.defaultEngineType; auto defaultEngineType = pDevice->getHardwareInfo().capabilityTable.defaultEngineType;
EXPECT_EQ(&pDevice->getDefaultEngine().commandStreamReceiver->getOsContext(), pDevice->getDefaultEngine().osContext); EXPECT_EQ(&pDevice->getDefaultEngine().commandStreamReceiver->getOsContext(), pDevice->getDefaultEngine().osContext);
EXPECT_EQ(defaultEngineType, actualEngineType); 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->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(1u, outHwInfo.pSysInfo->SliceCount); 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(GTTYPE_GT2, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(2u, outHwInfo.pSysInfo->SliceCount); 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(GTTYPE_GT1, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGT1); 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->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(3u, outHwInfo.pSysInfo->SliceCount); 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(GTTYPE_GT2_5, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(1u, outHwInfo.pSysInfo->SliceCount); 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(GTTYPE_GT2, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount); EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); 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(GTTYPE_GT1, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGT1); 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->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(2u, outHwInfo.pSysInfo->SliceCount); 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(GTTYPE_GT3, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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((uint32_t)drm->StoredMinEUinPool, outHwInfo.pSysInfo->EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.pSysInfo->EUCount - outHwInfo.pSysInfo->EuCountPerPoolMin), outHwInfo.pSysInfo->EuCountPerPoolMax); EXPECT_EQ((outHwInfo.pSysInfo->EUCount - outHwInfo.pSysInfo->EuCountPerPoolMin), outHwInfo.pSysInfo->EuCountPerPoolMax);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGttCacheInvalidation); 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 //constant sysInfo/ftr flags
EXPECT_EQ(1u, outHwInfo.pSysInfo->VEBoxInfo.Instances.Bits.VEBox0Enabled); 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((uint32_t)drm->StoredMinEUinPool, outHwInfo.pSysInfo->EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.pSysInfo->EUCount - outHwInfo.pSysInfo->EuCountPerPoolMin), outHwInfo.pSysInfo->EuCountPerPoolMax); EXPECT_EQ((outHwInfo.pSysInfo->EUCount - outHwInfo.pSysInfo->EuCountPerPoolMin), outHwInfo.pSysInfo->EuCountPerPoolMax);
EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGttCacheInvalidation); 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(GTTYPE_GTC, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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((unsigned int)drm->StoredHasPooledEU, outHwInfo.pSkuTable->ftrPooledEuEnabled);
EXPECT_EQ((uint32_t)drm->StoredMinEUinPool, outHwInfo.pSysInfo->EuCountPerPoolMin); EXPECT_EQ((uint32_t)drm->StoredMinEUinPool, outHwInfo.pSysInfo->EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.pSysInfo->EUCount - outHwInfo.pSysInfo->EuCountPerPoolMin), outHwInfo.pSysInfo->EuCountPerPoolMax); 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(GTTYPE_GTX, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount); EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); 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(GTTYPE_GT2, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(1u, outHwInfo.pSysInfo->SliceCount); 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(GTTYPE_GT1, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGT1); 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->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(2u, outHwInfo.pSysInfo->SliceCount); 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(GTTYPE_GT3, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount); EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); 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(GTTYPE_GTA, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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((unsigned int)drm->StoredHasPooledEU, outHwInfo.pSkuTable->ftrPooledEuEnabled);
EXPECT_EQ((uint32_t)drm->StoredMinEUinPool, outHwInfo.pSysInfo->EuCountPerPoolMin); EXPECT_EQ((uint32_t)drm->StoredMinEUinPool, outHwInfo.pSysInfo->EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.pSysInfo->EUCount - outHwInfo.pSysInfo->EuCountPerPoolMin), outHwInfo.pSysInfo->EuCountPerPoolMax); 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(GTTYPE_GTC, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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((unsigned int)drm->StoredHasPooledEU, outHwInfo.pSkuTable->ftrPooledEuEnabled);
EXPECT_EQ((uint32_t)drm->StoredMinEUinPool, outHwInfo.pSysInfo->EuCountPerPoolMin); EXPECT_EQ((uint32_t)drm->StoredMinEUinPool, outHwInfo.pSysInfo->EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.pSysInfo->EUCount - outHwInfo.pSysInfo->EuCountPerPoolMin), outHwInfo.pSysInfo->EuCountPerPoolMax); 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(GTTYPE_GTX, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount); EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); 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(GTTYPE_GT2, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(1u, outHwInfo.pSysInfo->SliceCount); 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(GTTYPE_GT1, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGT1); 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((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount); EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); 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(GTTYPE_GT1_5, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(2u, outHwInfo.pSysInfo->SliceCount); 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(GTTYPE_GT3, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(2u, outHwInfo.pSysInfo->SliceCount); 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(GTTYPE_GT4, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount); EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); 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(GTTYPE_GT2, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(1u, outHwInfo.pSysInfo->SliceCount); 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(GTTYPE_GT1, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGT1); 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((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount); EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); 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(GTTYPE_GT1_5, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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((unsigned short)drm->StoredDeviceRevID, outHwInfo.pPlatform->usRevId);
EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount); EXPECT_EQ((uint32_t)drm->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); 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(GTTYPE_GT3, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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->StoredEUVal, outHwInfo.pSysInfo->EUCount);
EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount); EXPECT_EQ((uint32_t)drm->StoredSSVal, outHwInfo.pSysInfo->SubSliceCount);
EXPECT_EQ(2u, outHwInfo.pSysInfo->SliceCount); 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(GTTYPE_GT4, outHwInfo.pPlatform->eGTType);
EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1); 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() { void whenGetGpgpuEnginesThenReturnTwoRcsEngines() {
auto gpgpuEngines = HwHelperHw<FamilyType>::get().getGpgpuEngineInstances(); auto gpgpuEngines = HwHelperHw<FamilyType>::get().getGpgpuEngineInstances();
EXPECT_EQ(2u, gpgpuEngines.size()); EXPECT_EQ(2u, gpgpuEngines.size());
EXPECT_EQ(ENGINE_RCS, gpgpuEngines[0]); EXPECT_EQ(aub_stream::ENGINE_RCS, gpgpuEngines[0]);
EXPECT_EQ(ENGINE_RCS, gpgpuEngines[1]); 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); auto &helper = HwHelper::get(renderCoreFamily);
EXPECT_NE(nullptr, &helper); EXPECT_NE(nullptr, &helper);
auto &csTraits = helper.getCsTraits(EngineType::ENGINE_RCS); auto &csTraits = helper.getCsTraits(aub_stream::ENGINE_RCS);
EXPECT_STREQ("RCS", csTraits.name); EXPECT_STREQ("RCS", csTraits.name);
} }
@ -246,18 +246,18 @@ TEST(HwInfoTest, givenHwInfoWhenIsNotCoreThenPlatformTypeIsLp) {
TEST(HwInfoTest, givenHwInfoWhenChosenEngineTypeQueriedThenDefaultIsReturned) { TEST(HwInfoTest, givenHwInfoWhenChosenEngineTypeQueriedThenDefaultIsReturned) {
HardwareInfo hwInfo; HardwareInfo hwInfo;
hwInfo.capabilityTable.defaultEngineType = EngineType::ENGINE_RCS; hwInfo.capabilityTable.defaultEngineType = aub_stream::ENGINE_RCS;
auto engineType = getChosenEngineType(hwInfo); auto engineType = getChosenEngineType(hwInfo);
EXPECT_EQ(EngineType::ENGINE_RCS, engineType); EXPECT_EQ(aub_stream::ENGINE_RCS, engineType);
} }
TEST(HwInfoTest, givenNodeOrdinalSetWhenChosenEngineTypeQueriedThenSetValueIsReturned) { TEST(HwInfoTest, givenNodeOrdinalSetWhenChosenEngineTypeQueriedThenSetValueIsReturned) {
DebugManagerStateRestore dbgRestore; DebugManagerStateRestore dbgRestore;
DebugManager.flags.NodeOrdinal.set(EngineType::ENGINE_VECS); DebugManager.flags.NodeOrdinal.set(aub_stream::ENGINE_VECS);
HardwareInfo hwInfo; HardwareInfo hwInfo;
hwInfo.capabilityTable.defaultEngineType = EngineType::ENGINE_RCS; hwInfo.capabilityTable.defaultEngineType = aub_stream::ENGINE_RCS;
auto engineType = getChosenEngineType(hwInfo); auto engineType = getChosenEngineType(hwInfo);
EXPECT_EQ(EngineType::ENGINE_VECS, engineType); EXPECT_EQ(aub_stream::ENGINE_VECS, engineType);
} }
HWTEST_F(HwHelperTest, givenCreatedSurfaceStateBufferWhenNoAllocationProvidedThenUseArgumentsasInput) { 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::LrcaHelperVcs vcs(0x010000);
static AubMemDump::LrcaHelperVecs vecs(0x018000); 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, &rcs,
&bcs, &bcs,
&vcs, &vcs,
@ -80,7 +80,7 @@ bool HwHelperHw<GENX>::setupPreemptionRegisters(HardwareInfo *pHwInfo, bool enab
} }
template <> 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]; return *AUBFamilyMapper<GENX>::csTraits[engineType];
} }

4
unit_tests/libult/mock_gfx_family.h
View File

@ -535,9 +535,9 @@ struct GENX {
template <> template <>
struct AUBFamilyMapper<GENX> { 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 globalMMIO;
static const MMIOList *perEngineMMIO[EngineType::NUM_ENGINES]; static const MMIOList *perEngineMMIO[aub_stream::NUM_ENGINES];
}; };
} // namespace NEO } // namespace NEO

2
unit_tests/mocks/mock_os_context.h
View File

@ -12,7 +12,7 @@ namespace NEO {
class MockOsContext : public OsContext { class MockOsContext : public OsContext {
public: public:
MockOsContext(uint32_t contextId, DeviceBitfield deviceBitfield, 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) {} : OsContext(contextId, deviceBitfield, engineType, preemptionMode, lowPriority) {}
}; };
} // namespace NEO } // namespace NEO

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

@ -13,11 +13,11 @@
using namespace NEO; using namespace NEO;
TEST(DrmMapperTests, engineNodeMapPass) { 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; unsigned int expected = I915_EXEC_RENDER;
EXPECT_EQ(expected, flag); EXPECT_EQ(expected, flag);
} }
TEST(DrmMapperTests, engineNodeMapNegative) { 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; 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(drmContextId1, osContext1.getDrmContextId());
EXPECT_EQ(0u, drmMock.receivedDestroyContextId); EXPECT_EQ(0u, drmMock.receivedDestroyContextId);
{ {
drmMock.StoredCtxId = drmContextId2; 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(drmContextId2, osContext2.getDrmContextId());
EXPECT_EQ(0u, drmMock.receivedDestroyContextId); EXPECT_EQ(0u, drmMock.receivedDestroyContextId);
} }
@ -195,17 +195,17 @@ TEST(DrmTest, givenDrmPreemptionEnabledAndLowPriorityEngineWhenCreatingOsContext
drmMock.StoredCtxId = 123; drmMock.StoredCtxId = 123;
drmMock.preemptionSupported = false; drmMock.preemptionSupported = false;
OsContextLinux osContext1(drmMock, 0u, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, false); OsContextLinux osContext1(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
OsContextLinux osContext2(drmMock, 0u, 1, EngineType::ENGINE_RCS, PreemptionMode::Disabled, true); OsContextLinux osContext2(drmMock, 0u, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, true);
EXPECT_EQ(0u, drmMock.receivedContextParamRequestCount); EXPECT_EQ(0u, drmMock.receivedContextParamRequestCount);
drmMock.preemptionSupported = true; 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); 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(1u, drmMock.receivedContextParamRequestCount);
EXPECT_EQ(drmMock.StoredCtxId, drmMock.receivedContextParamRequest.ctx_id); EXPECT_EQ(drmMock.StoredCtxId, drmMock.receivedContextParamRequest.ctx_id);
EXPECT_EQ(static_cast<uint64_t>(I915_CONTEXT_PARAM_PRIORITY), drmMock.receivedContextParamRequest.param); 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; using namespace NEO;
TEST(WddmMapperTests, givenRcsEngineTypeWhenAskedForNodeOrdinalThenReturn3d) { 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; GPUNODE_ORDINAL expected = GPUNODE_3D;
EXPECT_EQ(expected, gpuNode); EXPECT_EQ(expected, gpuNode);
} }
TEST(WddmMapperTests, givenNotSupportedEngineWhenAskedForNodeThenAbort) { 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) { TEST(WddmAllocationTest, givenAllocationIsTrimCandidateInOneOsContextWhenGettingTrimCandidatePositionThenReturnItsPositionAndUnusedPositionInOtherContexts) {
WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; 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); allocation.setTrimCandidateListPosition(osContext.getContextId(), 700u);
EXPECT_EQ(trimListUnusedPosition, allocation.getTrimCandidateListPosition(0u)); EXPECT_EQ(trimListUnusedPosition, allocation.getTrimCandidateListPosition(0u));
EXPECT_EQ(700u, allocation.getTrimCandidateListPosition(1u)); EXPECT_EQ(700u, allocation.getTrimCandidateListPosition(1u));
@ -1344,16 +1344,16 @@ TEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWithNoRegisteredOsContextsWh
} }
TEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWithRegisteredOsContextWhenCallingIsMemoryBudgetExhaustedThenReturnFalse) { TEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWithRegisteredOsContextWhenCallingIsMemoryBudgetExhaustedThenReturnFalse) {
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, ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false); memoryManager->createAndRegisterOsContext(nullptr, aub_stream::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);
EXPECT_FALSE(memoryManager->isMemoryBudgetExhausted()); EXPECT_FALSE(memoryManager->isMemoryBudgetExhausted());
} }
TEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWithRegisteredOsContextWithExhaustedMemoryBudgetWhenCallingIsMemoryBudgetExhaustedThenReturnTrue) { TEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWithRegisteredOsContextWithExhaustedMemoryBudgetWhenCallingIsMemoryBudgetExhaustedThenReturnTrue) {
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, ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false); memoryManager->createAndRegisterOsContext(nullptr, aub_stream::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);
auto osContext = static_cast<OsContextWin *>(memoryManager->getRegisteredEngines()[1].osContext); auto osContext = static_cast<OsContextWin *>(memoryManager->getRegisteredEngines()[1].osContext);
osContext->getResidencyController().setMemoryBudgetExhausted(); osContext->getResidencyController().setMemoryBudgetExhausted();
EXPECT_TRUE(memoryManager->isMemoryBudgetExhausted()); EXPECT_TRUE(memoryManager->isMemoryBudgetExhausted());
@ -1572,7 +1572,7 @@ TEST(WddmMemoryManagerCleanupTest, givenUsedTagAllocationInWddmMemoryManagerWhen
executionEnvironment.commandStreamReceivers.resize(1); executionEnvironment.commandStreamReceivers.resize(1);
executionEnvironment.commandStreamReceivers[0].push_back(std::unique_ptr<CommandStreamReceiver>(csr)); executionEnvironment.commandStreamReceivers[0].push_back(std::unique_ptr<CommandStreamReceiver>(csr));
executionEnvironment.memoryManager = std::make_unique<WddmMemoryManager>(executionEnvironment); 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); csr->setupContext(*osContext);
EXPECT_EQ(csr, executionEnvironment.memoryManager->getDefaultCommandStreamReceiver(0)); EXPECT_EQ(csr, executionEnvironment.memoryManager->getDefaultCommandStreamReceiver(0));