intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-06 19:32:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: remove not needed code

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2025-10-07 14:53:00 +00:00
committed by Compute-Runtime-Automation
parent fd2c7fdc1a
commit b807b43b35
74 changed files with 49 additions and 1014 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@@ -933,7 +933,6 @@ include_directories(${NEO_SHARED_DIRECTORY}/command_stream/definitions${BRANCH_D
include_directories(${NEO_SHARED_DIRECTORY}/debug_settings/definitions${BRANCH_DIR_SUFFIX}) include_directories(${NEO_SHARED_DIRECTORY}/debug_settings/definitions${BRANCH_DIR_SUFFIX})
include_directories(${NEO_SHARED_DIRECTORY}/dll/devices${BRANCH_DIR_SUFFIX}) include_directories(${NEO_SHARED_DIRECTORY}/dll/devices${BRANCH_DIR_SUFFIX})
include_directories(${NEO_SHARED_DIRECTORY}/kernel/definitions${BRANCH_DIR_SUFFIX}) include_directories(${NEO_SHARED_DIRECTORY}/kernel/definitions${BRANCH_DIR_SUFFIX})
include_directories(${NEO_SHARED_DIRECTORY}/gen_common${BRANCH_DIR_SUFFIX})
include_directories(${NEO_SHARED_DIRECTORY}/gmm_helper/${DRIVER_MODEL}) include_directories(${NEO_SHARED_DIRECTORY}/gmm_helper/${DRIVER_MODEL})
if(WIN32) if(WIN32)
include_directories(${NEO_SHARED_DIRECTORY}/os_interface/windows/wddm/definitions) include_directories(${NEO_SHARED_DIRECTORY}/os_interface/windows/wddm/definitions)

5
level_zero/core/test/aub_tests/fixtures/aub_fixture.cpp
View File

@@ -60,14 +60,13 @@ void AUBFixtureL0::setUp(const NEO::HardwareInfo *hardwareInfo, bool debuggingEn
executionEnvironment->setDebuggingMode(NEO::DebuggingMode::online); executionEnvironment->setDebuggingMode(NEO::DebuggingMode::online);
} }
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<NEO::GfxCoreHelper>();
auto 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;
strfilename << NEO::ApiSpecificConfig::getAubPrefixForSpecificApi(); strfilename << NEO::ApiSpecificConfig::getAubPrefixForSpecificApi();
strfilename << testInfo->test_case_name() << "_" << testInfo->name() << "_" << gfxCoreHelper.getCsTraits(engineType).name; strfilename << testInfo->test_case_name() << "_" << testInfo->name() << "_" << NEO::EngineHelpers::engineTypeToString(engineType);
aubFileName = strfilename.str(); aubFileName = strfilename.str();
NEO::ultHwConfig.aubTestName = aubFileName.c_str(); NEO::ultHwConfig.aubTestName = aubFileName.c_str();
@@ -139,4 +138,4 @@ ze_module_handle_t AUBFixtureL0::createModuleFromFile(const std::string &fileNam
return moduleHandle; return moduleHandle;
} }
} // namespace L0 } // namespace L0

2
opencl/test/unit_test/aub_mem_dump/cl_aub_alloc_dump_tests.cpp
View File

@@ -5,7 +5,7 @@
* *
*/ */
#include "shared/source/aub_mem_dump/aub_alloc_dump.h" #include "shared/source/aub_mem_dump/aub_alloc_dump.inl"
#include "shared/source/gmm_helper/gmm_helper.h" #include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/test/common/mocks/mock_allocation_properties.h" #include "shared/test/common/mocks/mock_allocation_properties.h"
#include "shared/test/common/mocks/mock_gmm.h" #include "shared/test/common/mocks/mock_gmm.h"

4
opencl/test/unit_test/aub_tests/command_stream/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
# #
# Copyright (C) 2018-2022 Intel Corporation # Copyright (C) 2018-2025 Intel Corporation
# #
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
@@ -9,8 +9,6 @@ target_sources(igdrcl_aub_tests PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/aub_command_stream_fixture.cpp ${CMAKE_CURRENT_SOURCE_DIR}/aub_command_stream_fixture.cpp
${CMAKE_CURRENT_SOURCE_DIR}/aub_command_stream_fixture.h ${CMAKE_CURRENT_SOURCE_DIR}/aub_command_stream_fixture.h
${CMAKE_CURRENT_SOURCE_DIR}/aub_command_stream_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/aub_command_stream_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/aub_mem_dump_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/aub_mem_dump_tests.h
${CMAKE_CURRENT_SOURCE_DIR}/aub_mi_atomic_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/aub_mi_atomic_tests.cpp
) )

59
opencl/test/unit_test/aub_tests/command_stream/aub_command_stream_tests.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2018-2023 Intel Corporation * Copyright (C) 2018-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -24,46 +24,7 @@
using namespace NEO; using namespace NEO;
struct AUBCommandStreamNoopFixture : public AUBCommandStreamFixture { using AUBcommandstreamTests = Test<AUBCommandStreamFixture>;
void setUp() {
AUBCommandStreamFixture::setUp();
}
void tearDown() {
AUBCommandStreamFixture::tearDown();
}
template <typename FamilyType>
void testNoopIdXcs(aub_stream::EngineType engineType) {
static_cast<MockOsContext &>(pCommandStreamReceiver->getOsContext()).engineType = engineType;
typedef typename FamilyType::MI_NOOP MI_NOOP;
auto pCmd = (MI_NOOP *)pCS->getSpace(sizeof(MI_NOOP) * 4);
uint32_t noopId = 0xbaadd;
auto noop = FamilyType::cmdInitNoop;
*pCmd++ = noop;
*pCmd++ = noop;
*pCmd++ = noop;
noop.TheStructure.Common.IdentificationNumberRegisterWriteEnable = true;
noop.TheStructure.Common.IdentificationNumber = noopId;
*pCmd++ = noop;
CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(*pCS, nullptr);
EncodeNoop<FamilyType>::alignToCacheLine(*pCS);
BatchBuffer batchBuffer = BatchBufferHelper::createDefaultBatchBuffer(pCS->getGraphicsAllocation(), pCS, pCS->getUsed());
ResidencyContainer allocationsForResidency;
pCommandStreamReceiver->flush(batchBuffer, allocationsForResidency);
AUBCommandStreamFixture::getSimulatedCsr<FamilyType>()->pollForCompletionImpl();
auto mmioBase = CommandStreamReceiverSimulatedCommonHw<FamilyType>::getCsTraits(engineType).mmioBase;
AUBCommandStreamFixture::expectMMIO<FamilyType>(AubMemDump::computeRegisterOffset(mmioBase, 0x2094), noopId);
}
};
using AUBcommandstreamTests = Test<AUBCommandStreamNoopFixture>;
HWTEST_F(AUBcommandstreamTests, WhenFlushingTwiceThenCompletes) { HWTEST_F(AUBcommandstreamTests, WhenFlushingTwiceThenCompletes) {
CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(*pCS, nullptr); CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(*pCS, nullptr);
@@ -79,22 +40,6 @@ HWTEST_F(AUBcommandstreamTests, WhenFlushingTwiceThenCompletes) {
AUBCommandStreamFixture::getSimulatedCsr<FamilyType>()->pollForCompletion(); AUBCommandStreamFixture::getSimulatedCsr<FamilyType>()->pollForCompletion();
} }
HWTEST_F(AUBcommandstreamTests, GivenRcsWhenTestingNoopIdThenAubIsCorrect) {
testNoopIdXcs<FamilyType>(aub_stream::ENGINE_RCS);
}
HWTEST_F(AUBcommandstreamTests, GivenBcsWhenTestingNoopIdThenAubIsCorrect) {
testNoopIdXcs<FamilyType>(aub_stream::ENGINE_BCS);
}
HWTEST_F(AUBcommandstreamTests, GivenVcsWhenTestingNoopIdThenAubIsCorrect) {
testNoopIdXcs<FamilyType>(aub_stream::ENGINE_VCS);
}
HWTEST_F(AUBcommandstreamTests, GivenVecsWhenTestingNoopIdThenAubIsCorrect) {
testNoopIdXcs<FamilyType>(aub_stream::ENGINE_VECS);
}
HWTEST_F(AUBcommandstreamTests, WhenCreatingResidentAllocationThenAllocationIsResident) { HWTEST_F(AUBcommandstreamTests, WhenCreatingResidentAllocationThenAllocationIsResident) {
uint8_t buffer[0x10000]; uint8_t buffer[0x10000];
size_t size = sizeof(buffer); size_t size = sizeof(buffer);

22
opencl/test/unit_test/aub_tests/command_stream/aub_mem_dump_tests.cpp
View File

@@ -1,22 +0,0 @@
/*
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "aub_mem_dump_tests.h"
#include "shared/source/aub/aub_helper.h"
#include "shared/test/common/mocks/mock_aub_csr.h"
std::string getAubFileName(const NEO::Device *pDevice, const std::string baseName) {
const auto pGtSystemInfo = &pDevice->getHardwareInfo().gtSystemInfo;
auto releaseHelper = pDevice->getReleaseHelper();
std::stringstream strfilename;
uint32_t subSlicesPerSlice = pGtSystemInfo->SubSliceCount / pGtSystemInfo->SliceCount;
const auto deviceConfig = AubHelper::getDeviceConfigString(releaseHelper, 1, pGtSystemInfo->SliceCount, subSlicesPerSlice, pGtSystemInfo->MaxEuPerSubSlice);
strfilename << hardwarePrefix[pDevice->getHardwareInfo().platform.eProductFamily] << "_" << deviceConfig << "_" << baseName;
return strfilename.str();
}

25
opencl/test/unit_test/aub_tests/command_stream/aub_mem_dump_tests.h
View File

@@ -1,25 +0,0 @@
/*
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/aub_mem_dump/aub_mem_dump.h"
#include "shared/source/command_stream/aub_command_stream_receiver.h"
#include "shared/source/command_stream/command_stream_receiver_simulated_common_hw.h"
#include "shared/source/device/device.h"
#include "shared/source/helpers/aligned_memory.h"
#include "shared/source/helpers/api_specific_config.h"
#include "shared/source/helpers/ptr_math.h"
#include "shared/source/os_interface/product_helper.h"
#include "shared/test/common/test_macros/hw_test.h"
#include "aub_mapper_common.h"
namespace Os {
extern const char *fileSeparator;
}
extern std::string getAubFileName(const NEO::Device *pDevice, const std::string baseName);

3
opencl/test/unit_test/aub_tests/fixtures/aub_fixture.h
View File

@@ -40,13 +40,12 @@ class AUBFixture : public CommandQueueHwFixture {
executionEnvironment->rootDeviceEnvironments[0]->memoryOperationsInterface = std::make_unique<MockMemoryOperationsHandler>(); executionEnvironment->rootDeviceEnvironments[0]->memoryOperationsInterface = std::make_unique<MockMemoryOperationsHandler>();
executionEnvironment->calculateMaxOsContextCount(); executionEnvironment->calculateMaxOsContextCount();
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
auto 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;
strfilename << ApiSpecificConfig::getAubPrefixForSpecificApi(); strfilename << ApiSpecificConfig::getAubPrefixForSpecificApi();
strfilename << testInfo->test_case_name() << "_" << testInfo->name() << "_" << gfxCoreHelper.getCsTraits(engineType).name; strfilename << testInfo->test_case_name() << "_" << testInfo->name() << "_" << EngineHelpers::engineTypeToString(engineType);
aubFileName = strfilename.str(); aubFileName = strfilename.str();
ultHwConfig.aubTestName = aubFileName.c_str(); ultHwConfig.aubTestName = aubFileName.c_str();

13
opencl/test/unit_test/aub_tests/gen12lp/CMakeLists.txt
View File

@@ -1,13 +0,0 @@
#
# Copyright (C) 2019-2021 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
if(TESTS_GEN12LP)
target_sources(igdrcl_aub_tests PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/aub_mem_dump_tests_gen12lp.cpp
)
add_subdirectories()
endif()

34
opencl/test/unit_test/aub_tests/gen12lp/aub_mem_dump_tests_gen12lp.cpp
View File

@@ -1,34 +0,0 @@
/*
* Copyright (C) 2019-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_stream/aub_command_stream_receiver_hw.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/ult_hw_config.h"
#include "shared/test/common/mocks/mock_device.h"
#include "opencl/test/unit_test/aub_tests/command_stream/aub_mem_dump_tests.h"
#include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
namespace NEO {
using Gen12LPAubMemDumpTests = Test<ClDeviceFixture>;
GEN12LPTEST_F(Gen12LPAubMemDumpTests, whenAubCsrIsCreatedThenCreateHardwareContext) {
DebugManagerStateRestore restore;
VariableBackup<UltHwConfig> backup(&ultHwConfig);
ultHwConfig.useHwCsr = true;
std::unique_ptr<MockDevice> device(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
auto &baseCsr = device->getGpgpuCommandStreamReceiver();
auto &aubCsr = static_cast<AUBCommandStreamReceiverHw<FamilyType> &>(baseCsr);
EXPECT_NE(nullptr, aubCsr.hardwareContextController.get());
EXPECT_NE(0u, aubCsr.hardwareContextController->hardwareContexts.size());
}
} // namespace NEO

5
opencl/test/unit_test/aub_tests/xe2_hpg_core/lnl/copy_engine_aub_tests_lnl.cpp
View File

@@ -1,11 +1,12 @@
/* /*
* Copyright (C) 2024 Intel Corporation * Copyright (C) 2024-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
*/ */
#include "shared/source/xe2_hpg_core/hw_cmds_lnl.h" #include "shared/source/xe2_hpg_core/hw_cmds_base.h"
#include "shared/source/xe2_hpg_core/hw_info_lnl.h"
#include "shared/test/common/test_macros/header/per_product_test_definitions.h" #include "shared/test/common/test_macros/header/per_product_test_definitions.h"
#include "shared/test/common/test_macros/test.h" #include "shared/test/common/test_macros/test.h"

3
opencl/test/unit_test/aub_tests/xe_hpc_core/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
# #
# Copyright (C) 2022 Intel Corporation # Copyright (C) 2022-2025 Intel Corporation
# #
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
@@ -7,7 +7,6 @@
if(TESTS_XE_HPC_CORE) if(TESTS_XE_HPC_CORE)
target_sources(igdrcl_aub_tests PRIVATE target_sources(igdrcl_aub_tests PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/aub_mem_dump_tests_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/copy_engine_aub_tests_xe_hpc_core.cpp ${CMAKE_CURRENT_SOURCE_DIR}/copy_engine_aub_tests_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/enqueue_kernel_aub_tests_xe_hpc_core.cpp ${CMAKE_CURRENT_SOURCE_DIR}/enqueue_kernel_aub_tests_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/system_memfence_aub_tests_xe_hpc_core.cpp ${CMAKE_CURRENT_SOURCE_DIR}/system_memfence_aub_tests_xe_hpc_core.cpp

31
opencl/test/unit_test/aub_tests/xe_hpc_core/aub_mem_dump_tests_xe_hpc_core.cpp
View File

@@ -1,31 +0,0 @@
/*
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_stream/aub_command_stream_receiver_hw.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/ult_hw_config.h"
#include "shared/test/common/helpers/variable_backup.h"
#include "shared/test/common/mocks/mock_device.h"
#include "opencl/test/unit_test/aub_tests/command_stream/aub_mem_dump_tests.h"
#include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
using XeHpcCoreAubMemDumpTests = Test<NEO::ClDeviceFixture>;
XE_HPC_CORETEST_F(XeHpcCoreAubMemDumpTests, whenAubCsrIsCreatedThenCreateHardwareContext) {
DebugManagerStateRestore restore;
VariableBackup<UltHwConfig> backup(&ultHwConfig);
ultHwConfig.useHwCsr = true;
std::unique_ptr<MockDevice> device(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
auto &baseCsr = device->getGpgpuCommandStreamReceiver();
auto &aubCsr = static_cast<AUBCommandStreamReceiverHw<FamilyType> &>(baseCsr);
EXPECT_NE(nullptr, aubCsr.hardwareContextController.get());
EXPECT_NE(0u, aubCsr.hardwareContextController->hardwareContexts.size());
}

1
opencl/test/unit_test/aub_tests/xe_hpg_core/CMakeLists.txt
View File

@@ -7,7 +7,6 @@
if(TESTS_XE_HPG_CORE) if(TESTS_XE_HPG_CORE)
target_sources(igdrcl_aub_tests PRIVATE target_sources(igdrcl_aub_tests PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/aub_mem_dump_tests_xe_hpg_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/aub_tests_stateless_compression_in_sba_xe_hpg_core.cpp ${CMAKE_CURRENT_SOURCE_DIR}/aub_tests_stateless_compression_in_sba_xe_hpg_core.cpp
) )
add_subdirectories() add_subdirectories()

34
opencl/test/unit_test/aub_tests/xe_hpg_core/aub_mem_dump_tests_xe_hpg_core.cpp
View File

@@ -1,34 +0,0 @@
/*
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_stream/aub_command_stream_receiver_hw.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/ult_hw_config.h"
#include "shared/test/common/helpers/variable_backup.h"
#include "shared/test/common/mocks/mock_device.h"
#include "opencl/test/unit_test/aub_tests/command_stream/aub_mem_dump_tests.h"
#include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
namespace NEO {
extern bool overrideCommandStreamReceiverCreation;
using XeHpgCoreAubMemDumpTests = Test<ClDeviceFixture>;
XE_HPG_CORETEST_F(XeHpgCoreAubMemDumpTests, whenAubCsrIsCreatedThenCreateHardwareContext) {
DebugManagerStateRestore restore;
VariableBackup<UltHwConfig> backup(&ultHwConfig);
ultHwConfig.useHwCsr = true;
std::unique_ptr<MockDevice> device(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
auto &baseCsr = device->getGpgpuCommandStreamReceiver();
auto &aubCsr = static_cast<AUBCommandStreamReceiverHw<FamilyType> &>(baseCsr);
EXPECT_NE(nullptr, aubCsr.hardwareContextController.get());
EXPECT_NE(0u, aubCsr.hardwareContextController->hardwareContexts.size());
}
} // namespace NEO

1
opencl/test/unit_test/aub_tests/xe_hpg_core/aub_tests_stateless_compression_in_sba_xe_hpg_core.cpp
View File

@@ -6,6 +6,7 @@
*/ */
#include "shared/source/memory_manager/unified_memory_manager.h" #include "shared/source/memory_manager/unified_memory_manager.h"
#include "shared/source/xe_hpg_core/hw_cmds_xe_hpg_core_base.h"
#include "shared/source/xe_hpg_core/hw_info_xe_hpg_core.h" #include "shared/source/xe_hpg_core/hw_info_xe_hpg_core.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h" #include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/test_macros/header/per_product_test_definitions.h" #include "shared/test/common/test_macros/header/per_product_test_definitions.h"

1
shared/source/aub/CMakeLists.txt
View File

@@ -12,7 +12,6 @@ set(NEO_CORE_AUB
${CMAKE_CURRENT_SOURCE_DIR}/aub_helper.h ${CMAKE_CURRENT_SOURCE_DIR}/aub_helper.h
${CMAKE_CURRENT_SOURCE_DIR}/aub_helper_add_mmio.cpp ${CMAKE_CURRENT_SOURCE_DIR}/aub_helper_add_mmio.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}aub_helper_extra.cpp ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}aub_helper_extra.cpp
${CMAKE_CURRENT_SOURCE_DIR}/aub_mapper_base.h
${CMAKE_CURRENT_SOURCE_DIR}/aub_subcapture.cpp ${CMAKE_CURRENT_SOURCE_DIR}/aub_subcapture.cpp
${CMAKE_CURRENT_SOURCE_DIR}/aub_subcapture.h ${CMAKE_CURRENT_SOURCE_DIR}/aub_subcapture.h
) )

7
shared/source/aub/aub_helper.h
View File

@@ -6,10 +6,11 @@
*/ */
#pragma once #pragma once
#include "shared/source/aub/aub_mapper_base.h"
#include "shared/source/helpers/non_copyable_or_moveable.h" #include "shared/source/helpers/non_copyable_or_moveable.h"
#include "shared/source/memory_manager/graphics_allocation.h" #include "shared/source/memory_manager/graphics_allocation.h"
#include "aubstream/aubstream.h"
#include <string> #include <string>
namespace NEO { namespace NEO {
@@ -24,10 +25,10 @@ class AubHelper : public NonCopyableAndNonMovableClass {
static uint64_t getPTEntryBits(uint64_t pdEntryBits); static uint64_t getPTEntryBits(uint64_t pdEntryBits);
static uint64_t getPerTileLocalMemorySize(const HardwareInfo *pHwInfo, const ReleaseHelper *releaseHelper); static uint64_t getPerTileLocalMemorySize(const HardwareInfo *pHwInfo, const ReleaseHelper *releaseHelper);
static const std::string getDeviceConfigString(const ReleaseHelper *releaseHelper, uint32_t tileCount, uint32_t sliceCount, uint32_t subSliceCount, uint32_t euPerSubSliceCount); static const std::string getDeviceConfigString(const ReleaseHelper *releaseHelper, uint32_t tileCount, uint32_t sliceCount, uint32_t subSliceCount, uint32_t euPerSubSliceCount);
static MMIOList getAdditionalMmioList(); static aub_stream::MMIOList getAdditionalMmioList();
static void setTbxConfiguration(); static void setTbxConfiguration();
static MMIOList splitMMIORegisters(const std::string &registers, char delimiter); static aub_stream::MMIOList splitMMIORegisters(const std::string &registers, char delimiter);
}; };
} // namespace NEO } // namespace NEO

8
shared/source/aub/aub_helper_add_mmio.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2019-2023 Intel Corporation * Copyright (C) 2019-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -14,12 +14,12 @@
namespace NEO { namespace NEO {
MMIOList AubHelper::getAdditionalMmioList() { aub_stream::MMIOList AubHelper::getAdditionalMmioList() {
return splitMMIORegisters(debugManager.flags.AubDumpAddMmioRegistersList.get(), ';'); return splitMMIORegisters(debugManager.flags.AubDumpAddMmioRegistersList.get(), ';');
} }
MMIOList AubHelper::splitMMIORegisters(const std::string &registers, char delimiter) { aub_stream::MMIOList AubHelper::splitMMIORegisters(const std::string &registers, char delimiter) {
MMIOList result; aub_stream::MMIOList result;
bool firstElementInPair = false; bool firstElementInPair = false;
std::string token; std::string token;
uint32_t registerOffset = 0; uint32_t registerOffset = 0;

22
shared/source/aub/aub_mapper_base.h
View File

@@ -1,22 +0,0 @@
/*
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/aub_mem_dump/aub_mem_dump.h"
#include <vector>
namespace NEO {
template <typename GfxFamily>
struct AUBFamilyMapper {
};
using MMIOPair = std::pair<uint32_t, uint32_t>;
using MMIOList = std::vector<MMIOPair>;
} // namespace NEO

2
shared/source/aub_mem_dump/CMakeLists.txt
View File

@@ -8,10 +8,8 @@ set(NEO_CORE_AUB_MEM_DUMP
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/aub_alloc_dump.h ${CMAKE_CURRENT_SOURCE_DIR}/aub_alloc_dump.h
${CMAKE_CURRENT_SOURCE_DIR}/aub_alloc_dump.inl ${CMAKE_CURRENT_SOURCE_DIR}/aub_alloc_dump.inl
${CMAKE_CURRENT_SOURCE_DIR}/aub_data.h
${CMAKE_CURRENT_SOURCE_DIR}/aub_header.h ${CMAKE_CURRENT_SOURCE_DIR}/aub_header.h
${CMAKE_CURRENT_SOURCE_DIR}/aub_mem_dump.h ${CMAKE_CURRENT_SOURCE_DIR}/aub_mem_dump.h
${CMAKE_CURRENT_SOURCE_DIR}/aub_mem_dump.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}context_flags.cpp ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}context_flags.cpp
${CMAKE_CURRENT_SOURCE_DIR}/page_table_entry_bits.h ${CMAKE_CURRENT_SOURCE_DIR}/page_table_entry_bits.h
) )

13
shared/source/aub_mem_dump/aub_data.h
View File

@@ -1,13 +0,0 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
struct AubGTTData {
bool present;
bool localMemory;
};

141
shared/source/aub_mem_dump/aub_mem_dump.cpp
View File

@@ -1,141 +0,0 @@
/*
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/aub_mem_dump/aub_mem_dump.h"
#include "shared/source/aub/aub_helper.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/helpers/debug_helpers.h"
#include "shared/source/helpers/ptr_math.h"
namespace AubMemDump {
const uint64_t pageMask = ~(4096ull - 1);
void LrcaHelper::setRingTail(void *pLRCIn, uint32_t ringTail) const {
auto pLRCA = ptrOffset(reinterpret_cast<uint32_t *>(pLRCIn),
offsetContext + offsetRingRegisters + offsetRingTail);
*pLRCA++ = AubMemDump::computeRegisterOffset(mmioBase, 0x2030);
*pLRCA++ = ringTail;
}
void LrcaHelper::setRingHead(void *pLRCIn, uint32_t ringHead) const {
auto pLRCA = ptrOffset(reinterpret_cast<uint32_t *>(pLRCIn),
offsetContext + offsetRingRegisters + offsetRingHead);
*pLRCA++ = AubMemDump::computeRegisterOffset(mmioBase, 0x2034);
*pLRCA++ = ringHead;
}
void LrcaHelper::setRingBase(void *pLRCIn, uint32_t ringBase) const {
auto pLRCA = ptrOffset(reinterpret_cast<uint32_t *>(pLRCIn),
offsetContext + offsetRingRegisters + offsetRingBase);
*pLRCA++ = AubMemDump::computeRegisterOffset(mmioBase, 0x2038);
*pLRCA++ = ringBase;
}
void LrcaHelper::setRingCtrl(void *pLRCIn, uint32_t ringCtrl) const {
auto pLRCA = ptrOffset(reinterpret_cast<uint32_t *>(pLRCIn),
offsetContext + offsetRingRegisters + offsetRingCtrl);
*pLRCA++ = AubMemDump::computeRegisterOffset(mmioBase, 0x203c);
*pLRCA++ = ringCtrl;
}
void LrcaHelper::setPDP0(void *pLRCIn, uint64_t address) const {
auto pLRCA = ptrOffset(reinterpret_cast<uint32_t *>(pLRCIn),
offsetContext + offsetPageTableRegisters + offsetPDP0);
*pLRCA++ = AubMemDump::computeRegisterOffset(mmioBase, 0x2274);
*pLRCA++ = address >> 32;
*pLRCA++ = AubMemDump::computeRegisterOffset(mmioBase, 0x2270);
*pLRCA++ = address & 0xffffffff;
}
void LrcaHelper::setPDP1(void *pLRCIn, uint64_t address) const {
auto pLRCA = ptrOffset(reinterpret_cast<uint32_t *>(pLRCIn),
offsetContext + offsetPageTableRegisters + offsetPDP1);
*pLRCA++ = AubMemDump::computeRegisterOffset(mmioBase, 0x227c);
*pLRCA++ = address >> 32;
*pLRCA++ = AubMemDump::computeRegisterOffset(mmioBase, 0x2278);
*pLRCA++ = address & 0xffffffff;
}
void LrcaHelper::setPDP2(void *pLRCIn, uint64_t address) const {
auto pLRCA = ptrOffset(reinterpret_cast<uint32_t *>(pLRCIn),
offsetContext + offsetPageTableRegisters + offsetPDP2);
*pLRCA++ = AubMemDump::computeRegisterOffset(mmioBase, 0x2284);
*pLRCA++ = address >> 32;
*pLRCA++ = AubMemDump::computeRegisterOffset(mmioBase, 0x2280);
*pLRCA++ = address & 0xffffffff;
}
void LrcaHelper::setPDP3(void *pLRCIn, uint64_t address) const {
auto pLRCA = ptrOffset(reinterpret_cast<uint32_t *>(pLRCIn),
offsetContext + offsetPageTableRegisters + offsetPDP3);
*pLRCA++ = AubMemDump::computeRegisterOffset(mmioBase, 0x228c);
*pLRCA++ = address >> 32;
*pLRCA++ = AubMemDump::computeRegisterOffset(mmioBase, 0x2288);
*pLRCA++ = address & 0xffffffff;
}
void LrcaHelper::setPML4(void *pLRCIn, uint64_t address) const {
setPDP0(pLRCIn, address);
}
void LrcaHelper::initialize(void *pLRCIn) const {
auto pLRCABase = reinterpret_cast<uint32_t *>(pLRCIn);
// Initialize to known but benign garbage
for (size_t i = 0; i < sizeLRCA / sizeof(uint32_t); i++) {
pLRCABase[i] = 0x1;
}
auto pLRCA = ptrOffset(pLRCABase, offsetContext);
// Initialize the ring context of the LRCA
auto pLRI = ptrOffset(pLRCA, offsetLRI0);
auto numRegs = numRegsLRI0;
*pLRI++ = 0x11001000 | (2 * numRegs - 1);
uint32_t ctxSrCtlValue = 0x00010001; // Inhibit context-restore
setContextSaveRestoreFlags(ctxSrCtlValue);
while (numRegs-- > 0) {
*pLRI++ = AubMemDump::computeRegisterOffset(mmioBase, 0x2244); // CTXT_SR_CTL
*pLRI++ = ctxSrCtlValue;
}
// Initialize the other LRI
DEBUG_BREAK_IF(offsetLRI1 != 0x21 * sizeof(uint32_t));
pLRI = ptrOffset(pLRCA, offsetLRI1);
numRegs = numRegsLRI1;
*pLRI++ = 0x11001000 | (2 * numRegs - 1);
while (numRegs-- > 0) {
*pLRI++ = AubMemDump::computeRegisterOffset(mmioBase, 0x20d8); // DEBUG
*pLRI++ = 0x00200020;
}
DEBUG_BREAK_IF(offsetLRI2 != 0x41 * sizeof(uint32_t));
pLRI = ptrOffset(pLRCA, offsetLRI2);
numRegs = numRegsLRI2;
*pLRI++ = 0x11000000 | (2 * numRegs - 1);
while (numRegs-- > 0) {
*pLRI++ = AubMemDump::computeRegisterOffset(mmioBase, 0x2094); // NOP ID
*pLRI++ = 0x00000000;
}
setRingHead(pLRCIn, 0);
setRingTail(pLRCIn, 0);
setRingBase(pLRCIn, 0);
setRingCtrl(pLRCIn, 0);
setPDP0(pLRCIn, 0);
setPDP1(pLRCIn, 0);
setPDP2(pLRCIn, 0);
setPDP3(pLRCIn, 0);
}
} // namespace AubMemDump

106
shared/source/aub_mem_dump/aub_mem_dump.h
View File

@@ -6,123 +6,19 @@
*/ */
#pragma once #pragma once
#include "shared/source/aub_mem_dump/aub_data.h"
#include "shared/source/aub_mem_dump/aub_header.h" #include "shared/source/aub_mem_dump/aub_header.h"
#include <fstream>
#include <string>
namespace NEO {
class AubHelper;
}
namespace AubMemDump { namespace AubMemDump {
inline constexpr uint32_t rcsRegisterBase = 0x2000;
#ifndef BIT #ifndef BIT
#define BIT(x) (((uint64_t)1) << (x)) #define BIT(x) (((uint64_t)1) << (x))
#endif #endif
inline uint32_t computeRegisterOffset(uint32_t mmioBase, uint32_t rcsRegisterOffset) {
return mmioBase + rcsRegisterOffset - rcsRegisterBase;
}
typedef CmdServicesMemTraceVersion::SteppingValues SteppingValues; typedef CmdServicesMemTraceVersion::SteppingValues SteppingValues;
typedef CmdServicesMemTraceMemoryWrite::DataTypeHintValues DataTypeHintValues; typedef CmdServicesMemTraceMemoryWrite::DataTypeHintValues DataTypeHintValues;
struct LrcaHelper { struct LrcaHelper {
LrcaHelper(uint32_t base) : mmioBase(base) { static void setContextSaveRestoreFlags(uint32_t &value);
}
std::string name = "XCS";
uint32_t mmioBase = 0;
size_t sizeLRCA = 0x2000;
uint32_t alignLRCA = 0x1000;
uint32_t offsetContext = 0x1000;
uint32_t offsetLRI0 = 0x01 * sizeof(uint32_t);
uint32_t numRegsLRI0 = 14;
uint32_t numNoops0 = 3;
uint32_t offsetLRI1 = offsetLRI0 + (1 + numRegsLRI0 * 2 + numNoops0) * sizeof(uint32_t); // offsetLRI == 0x21 * sizeof(uint32_t);
uint32_t numRegsLRI1 = 9;
uint32_t numNoops1 = 13;
uint32_t offsetLRI2 = offsetLRI1 + (1 + numRegsLRI1 * 2 + numNoops1) * sizeof(uint32_t); // offsetLR2 == 0x41 * sizeof(uint32_t);
uint32_t numRegsLRI2 = 1;
uint32_t offsetRingRegisters = offsetLRI0 + (3 * sizeof(uint32_t));
uint32_t offsetRingHead = 0x0 * sizeof(uint32_t);
uint32_t offsetRingTail = 0x2 * sizeof(uint32_t);
uint32_t offsetRingBase = 0x4 * sizeof(uint32_t);
uint32_t offsetRingCtrl = 0x6 * sizeof(uint32_t);
uint32_t offsetPageTableRegisters = offsetLRI1 + (3 * sizeof(uint32_t));
uint32_t offsetPDP0 = 0xc * sizeof(uint32_t);
uint32_t offsetPDP1 = 0x8 * sizeof(uint32_t);
uint32_t offsetPDP2 = 0x4 * sizeof(uint32_t);
uint32_t offsetPDP3 = 0x0 * sizeof(uint32_t);
void initialize(void *pLRCIn) const;
void setRingHead(void *pLRCIn, uint32_t ringHead) const;
void setRingTail(void *pLRCIn, uint32_t ringTail) const;
void setRingBase(void *pLRCIn, uint32_t ringBase) const;
void setRingCtrl(void *pLRCIn, uint32_t ringCtrl) const;
void setPDP0(void *pLRCIn, uint64_t address) const;
void setPDP1(void *pLRCIn, uint64_t address) const;
void setPDP2(void *pLRCIn, uint64_t address) const;
void setPDP3(void *pLRCIn, uint64_t address) const;
void setPML4(void *pLRCIn, uint64_t address) const;
MOCKABLE_VIRTUAL void setContextSaveRestoreFlags(uint32_t &value) const;
}; };
struct LrcaHelperRcs : public LrcaHelper {
LrcaHelperRcs(uint32_t base) : LrcaHelper(base) {
sizeLRCA = 0x11000;
name = "RCS";
}
};
struct LrcaHelperBcs : public LrcaHelper {
LrcaHelperBcs(uint32_t base) : LrcaHelper(base) {
name = "BCS";
}
};
struct LrcaHelperVcs : public LrcaHelper {
LrcaHelperVcs(uint32_t base) : LrcaHelper(base) {
name = "VCS";
}
};
struct LrcaHelperVecs : public LrcaHelper {
LrcaHelperVecs(uint32_t base) : LrcaHelper(base) {
name = "VECS";
}
};
struct LrcaHelperCcs : public LrcaHelper {
LrcaHelperCcs(uint32_t base) : LrcaHelper(base) {
name = "CCS";
}
};
struct LrcaHelperLinkBcs : public LrcaHelperBcs {
LrcaHelperLinkBcs(uint32_t base, uint32_t engineId) : LrcaHelperBcs(base) {
name = "BCS" + std::to_string(engineId);
}
};
struct LrcaHelperCccs : public LrcaHelper {
LrcaHelperCccs(uint32_t base) : LrcaHelper(base) {
name = "CCCS";
}
};
extern const uint64_t pageMask;
} // namespace AubMemDump } // namespace AubMemDump

48
shared/source/aub_mem_dump/aub_mem_dump_pvc_and_later.inl
View File

@@ -7,54 +7,6 @@
#include "shared/source/aub_mem_dump/aub_alloc_dump.inl" #include "shared/source/aub_mem_dump/aub_alloc_dump.inl"
#include "shared/source/aub_mem_dump/aub_mem_dump.h" #include "shared/source/aub_mem_dump/aub_mem_dump.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/gen_common/reg_configs_common.h"
#include "shared/source/helpers/array_count.h"
#include "shared/source/helpers/completion_stamp.h"
#include "shared/source/helpers/gfx_core_helper.h"
#include "aub_mapper_common.h"
#include "config.h"
namespace NEO {
static const AubMemDump::LrcaHelperRcs rcs(0x002000);
static const AubMemDump::LrcaHelperBcs bcs(0x022000);
static const AubMemDump::LrcaHelperVcs vcs(0x1c0000);
static const AubMemDump::LrcaHelperVecs vecs(0x1c8000);
static const AubMemDump::LrcaHelperCcs ccs(0x1a000);
static const AubMemDump::LrcaHelperCcs ccs1(0x1c000);
static const AubMemDump::LrcaHelperCcs ccs2(0x1e000);
static const AubMemDump::LrcaHelperCcs ccs3(0x26000);
static const AubMemDump::LrcaHelperCccs cccs(-1);
static const AubMemDump::LrcaHelperLinkBcs linkBcs1(-1, 1);
static const AubMemDump::LrcaHelperLinkBcs linkBcs2(-1, 2);
static const AubMemDump::LrcaHelperLinkBcs linkBcs3(-1, 3);
static const AubMemDump::LrcaHelperLinkBcs linkBcs4(-1, 4);
static const AubMemDump::LrcaHelperLinkBcs linkBcs5(-1, 5);
static const AubMemDump::LrcaHelperLinkBcs linkBcs6(-1, 6);
static const AubMemDump::LrcaHelperLinkBcs linkBcs7(-1, 7);
static const AubMemDump::LrcaHelperLinkBcs linkBcs8(-1, 8);
const AubMemDump::LrcaHelper *const AUBFamilyMapper<Family>::csTraits[aub_stream::NUM_ENGINES] = {
&rcs,
&bcs,
&vcs,
&vecs,
&ccs,
&ccs1,
&ccs2,
&ccs3,
&cccs,
&linkBcs1,
&linkBcs2,
&linkBcs3,
&linkBcs4,
&linkBcs5,
&linkBcs6,
&linkBcs7,
&linkBcs8};
} // namespace NEO
namespace AubAllocDump { namespace AubAllocDump {
using namespace NEO; using namespace NEO;

31
shared/source/aub_mem_dump/aub_mem_dump_xehp_and_later.inl
View File

@@ -7,37 +7,6 @@
#include "shared/source/aub_mem_dump/aub_alloc_dump.inl" #include "shared/source/aub_mem_dump/aub_alloc_dump.inl"
#include "shared/source/aub_mem_dump/aub_mem_dump.h" #include "shared/source/aub_mem_dump/aub_mem_dump.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/gen_common/reg_configs_common.h"
#include "shared/source/helpers/array_count.h"
#include "shared/source/helpers/completion_stamp.h"
#include "shared/source/helpers/gfx_core_helper.h"
#include "aub_mapper_common.h"
#include "config.h"
namespace NEO {
static const AubMemDump::LrcaHelperRcs rcs(0x002000);
static const AubMemDump::LrcaHelperBcs bcs(0x022000);
static const AubMemDump::LrcaHelperVcs vcs(0x1c0000);
static const AubMemDump::LrcaHelperVecs vecs(0x1c8000);
static const AubMemDump::LrcaHelperCcs ccs(0x1a000);
static const AubMemDump::LrcaHelperCcs ccs1(0x1c000);
static const AubMemDump::LrcaHelperCcs ccs2(0x1e000);
static const AubMemDump::LrcaHelperCcs ccs3(0x26000);
const AubMemDump::LrcaHelper *const AUBFamilyMapper<Family>::csTraits[aub_stream::NUM_ENGINES] = {
&rcs,
&bcs,
&vcs,
&vecs,
&ccs,
&ccs1,
&ccs2,
&ccs3};
} // namespace NEO
namespace AubAllocDump { namespace AubAllocDump {
using namespace NEO; using namespace NEO;

6
shared/source/aub_mem_dump/context_flags.cpp
View File

@@ -1,13 +1,13 @@
/* /*
* Copyright (C) 2020-2021 Intel Corporation * Copyright (C) 2020-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
*/ */
#include "shared/source/aub_mem_dump//aub_mem_dump.h" #include "shared/source/aub_mem_dump/aub_mem_dump.h"
namespace AubMemDump { namespace AubMemDump {
void LrcaHelper::setContextSaveRestoreFlags(uint32_t &ctxSrCtlValue) const { void LrcaHelper::setContextSaveRestoreFlags(uint32_t &ctxSrCtlValue) {
} }
} // namespace AubMemDump } // namespace AubMemDump

6
shared/source/command_stream/command_stream_receiver_simulated_common_hw.h
View File

@@ -10,7 +10,6 @@
#include "shared/source/helpers/hardware_context_controller.h" #include "shared/source/helpers/hardware_context_controller.h"
#include "shared/source/memory_manager/memory_banks.h" #include "shared/source/memory_manager/memory_banks.h"
#include "aub_mapper_common.h"
#include "aubstream/hardware_context.h" #include "aubstream/hardware_context.h"
namespace aub_stream { namespace aub_stream {
@@ -38,13 +37,8 @@ class CommandStreamReceiverSimulatedCommonHw : public CommandStreamReceiverHw<Gf
uint32_t rootDeviceIndex, uint32_t rootDeviceIndex,
const DeviceBitfield deviceBitfield); const DeviceBitfield deviceBitfield);
~CommandStreamReceiverSimulatedCommonHw() override; ~CommandStreamReceiverSimulatedCommonHw() override;
uint64_t getGTTBits() const {
return 0u;
}
uint64_t getPPGTTAdditionalBits(GraphicsAllocation *gfxAllocation); uint64_t getPPGTTAdditionalBits(GraphicsAllocation *gfxAllocation);
void getGTTData(void *memory, AubGTTData &data);
uint32_t getMemoryBankForGtt() const; uint32_t getMemoryBankForGtt() const;
static const AubMemDump::LrcaHelper &getCsTraits(aub_stream::EngineType engineType);
void setupContext(OsContext &osContext) override; void setupContext(OsContext &osContext) override;
virtual bool expectMemoryEqual(void *gfxAddress, const void *srcAddress, size_t length); virtual bool expectMemoryEqual(void *gfxAddress, const void *srcAddress, size_t length);
virtual bool expectMemoryNotEqual(void *gfxAddress, const void *srcAddress, size_t length); virtual bool expectMemoryNotEqual(void *gfxAddress, const void *srcAddress, size_t length);

4
shared/source/command_stream/command_stream_receiver_simulated_common_hw_base.inl
View File

@@ -6,6 +6,7 @@
*/ */
#include "shared/source/aub/aub_helper.h" #include "shared/source/aub/aub_helper.h"
#include "shared/source/aub_mem_dump/aub_mem_dump.h"
#include "shared/source/aub_mem_dump/page_table_entry_bits.h" #include "shared/source/aub_mem_dump/page_table_entry_bits.h"
#include "shared/source/command_stream/command_stream_receiver_simulated_common_hw.h" #include "shared/source/command_stream/command_stream_receiver_simulated_common_hw.h"
#include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/debug_settings/debug_settings_manager.h"
@@ -29,9 +30,8 @@ template <typename GfxFamily>
void CommandStreamReceiverSimulatedCommonHw<GfxFamily>::setupContext(OsContext &osContext) { void CommandStreamReceiverSimulatedCommonHw<GfxFamily>::setupContext(OsContext &osContext) {
CommandStreamReceiverHw<GfxFamily>::setupContext(osContext); CommandStreamReceiverHw<GfxFamily>::setupContext(osContext);
auto engineType = osContext.getEngineType();
uint32_t flags = 0; uint32_t flags = 0;
getCsTraits(engineType).setContextSaveRestoreFlags(flags); AubMemDump::LrcaHelper::setContextSaveRestoreFlags(flags);
if (osContext.isPartOfContextGroup()) { if (osContext.isPartOfContextGroup()) {
constexpr uint32_t contextGroupBit = aub_stream::hardwareContextFlags::contextGroup; constexpr uint32_t contextGroupBit = aub_stream::hardwareContextFlags::contextGroup;

11
shared/source/command_stream/command_stream_receiver_simulated_common_hw_xehp_and_later.inl
View File

@@ -24,12 +24,6 @@ uint64_t CommandStreamReceiverSimulatedCommonHw<GfxFamily>::getPPGTTAdditionalBi
return BIT(PageTableEntry::presentBit) | BIT(PageTableEntry::writableBit); return BIT(PageTableEntry::presentBit) | BIT(PageTableEntry::writableBit);
} }
template <typename GfxFamily>
void CommandStreamReceiverSimulatedCommonHw<GfxFamily>::getGTTData(void *memory, AubGTTData &data) {
data.present = true;
data.localMemory = this->localMemoryEnabled;
}
template <typename GfxFamily> template <typename GfxFamily>
uint32_t CommandStreamReceiverSimulatedCommonHw<GfxFamily>::getMemoryBankForGtt() const { uint32_t CommandStreamReceiverSimulatedCommonHw<GfxFamily>::getMemoryBankForGtt() const {
auto deviceIndex = getDeviceIndex(); auto deviceIndex = getDeviceIndex();
@@ -38,9 +32,4 @@ uint32_t CommandStreamReceiverSimulatedCommonHw<GfxFamily>::getMemoryBankForGtt(
} }
return MemoryBanks::getBank(deviceIndex); return MemoryBanks::getBank(deviceIndex);
} }
template <typename GfxFamily>
const AubMemDump::LrcaHelper &CommandStreamReceiverSimulatedCommonHw<GfxFamily>::getCsTraits(aub_stream::EngineType engineType) {
return *AUBFamilyMapper<GfxFamily>::csTraits[engineType];
}
} // namespace NEO } // namespace NEO

1
shared/source/command_stream/command_stream_receiver_simulated_hw.h
View File

@@ -7,6 +7,7 @@
#pragma once #pragma once
#include "shared/source/aub/aub_helper.h" #include "shared/source/aub/aub_helper.h"
#include "shared/source/aub_mem_dump/aub_mem_dump.h"
#include "shared/source/command_stream/command_stream_receiver_simulated_common_hw.h" #include "shared/source/command_stream/command_stream_receiver_simulated_common_hw.h"
#include "shared/source/gmm_helper/cache_settings_helper.h" #include "shared/source/gmm_helper/cache_settings_helper.h"
#include "shared/source/gmm_helper/gmm.h" #include "shared/source/gmm_helper/gmm.h"

2
shared/source/enable_cores.cmake
View File

@@ -8,12 +8,10 @@ set(CORE_SRCS_COREX_H_BASE
hw_cmds.h hw_cmds.h
hw_info.h hw_info.h
hw_cmds_base.h hw_cmds_base.h
aub_mapper.h
) )
set(CORE_RUNTIME_SRCS_COREX_CPP_BASE set(CORE_RUNTIME_SRCS_COREX_CPP_BASE
aub_command_stream_receiver aub_command_stream_receiver
aub_mem_dump
command_encoder command_encoder
command_stream_receiver_hw command_stream_receiver_hw
command_stream_receiver_simulated_common_hw command_stream_receiver_simulated_common_hw

1
shared/source/gen12lp/aub_command_stream_receiver_gen12lp.cpp
View File

@@ -9,6 +9,7 @@
#include "shared/source/command_stream/aub_command_stream_receiver.h" #include "shared/source/command_stream/aub_command_stream_receiver.h"
#include "shared/source/command_stream/aub_command_stream_receiver_hw.h" #include "shared/source/command_stream/aub_command_stream_receiver_hw.h"
#include "shared/source/command_stream/aub_command_stream_receiver_hw_base.inl" #include "shared/source/command_stream/aub_command_stream_receiver_hw_base.inl"
#include "shared/source/gen12lp/hw_cmds_base.h"
#include "shared/source/helpers/array_count.h" #include "shared/source/helpers/array_count.h"
#include "shared/source/helpers/populate_factory.h" #include "shared/source/helpers/populate_factory.h"
#include "shared/source/memory_manager/memory_pool.h" #include "shared/source/memory_manager/memory_pool.h"

23
shared/source/gen12lp/aub_mapper.h
View File

@@ -1,23 +0,0 @@
/*
* Copyright (C) 2019-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/aub/aub_mapper_base.h"
#include "shared/source/gen12lp/hw_cmds.h"
#include "shared/source/helpers/constants.h"
#include "aubstream/engine_node.h"
namespace NEO {
struct Gen12LpFamily;
template <>
struct AUBFamilyMapper<Gen12LpFamily> {
static const AubMemDump::LrcaHelper *const csTraits[aub_stream::NUM_ENGINES];
};
} // namespace NEO

42
shared/source/gen12lp/aub_mem_dump_gen12lp.cpp
View File

@@ -1,42 +0,0 @@
/*
* Copyright (C) 2019-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/aub_mem_dump/aub_alloc_dump.inl"
#include "shared/source/aub_mem_dump/aub_mem_dump.h"
#include "shared/source/gen12lp/aub_mapper.h"
#include "shared/source/gen12lp/hw_cmds_base.h"
#include "shared/source/gen_common/reg_configs_common.h"
#include "shared/source/helpers/completion_stamp.h"
#include "shared/source/helpers/gfx_core_helper.h"
#include "config.h"
namespace NEO {
using Family = Gen12LpFamily;
static const AubMemDump::LrcaHelperRcs rcs(0x002000);
static const AubMemDump::LrcaHelperBcs bcs(0x022000);
static const AubMemDump::LrcaHelperVcs vcs(0x1c0000);
static const AubMemDump::LrcaHelperVecs vecs(0x1c8000);
static const AubMemDump::LrcaHelperCcs ccs(0x1a000);
const AubMemDump::LrcaHelper *const AUBFamilyMapper<Family>::csTraits[aub_stream::NUM_ENGINES] = {
&rcs,
&bcs,
&vcs,
&vecs,
&ccs};
} // namespace NEO
namespace AubAllocDump {
using namespace NEO;
template SurfaceInfo *getDumpSurfaceInfo<Family>(GraphicsAllocation &gfxAllocation, const GmmHelper &gmmHelper, DumpFormat dumpFormat);
template uint32_t getImageSurfaceTypeFromGmmResourceType<Family>(GMM_RESOURCE_TYPE gmmResourceType);
} // namespace AubAllocDump

14
shared/source/gen12lp/command_stream_receiver_simulated_common_hw_gen12lp.cpp
View File

@@ -6,6 +6,7 @@
*/ */
#include "shared/source/command_stream/command_stream_receiver_simulated_common_hw_base.inl" #include "shared/source/command_stream/command_stream_receiver_simulated_common_hw_base.inl"
#include "shared/source/gen12lp/hw_cmds_base.h"
namespace NEO { namespace NEO {
typedef Gen12LpFamily Family; typedef Gen12LpFamily Family;
@@ -15,24 +16,11 @@ uint32_t CommandStreamReceiverSimulatedCommonHw<GfxFamily>::getMemoryBankForGtt(
return MemoryBanks::getBank(getDeviceIndex()); return MemoryBanks::getBank(getDeviceIndex());
} }
template <typename GfxFamily>
const AubMemDump::LrcaHelper &CommandStreamReceiverSimulatedCommonHw<GfxFamily>::getCsTraits(aub_stream::EngineType engineType) {
return *AUBFamilyMapper<GfxFamily>::csTraits[engineType];
}
template <> template <>
uint64_t CommandStreamReceiverSimulatedCommonHw<Family>::getPPGTTAdditionalBits(GraphicsAllocation *gfxAllocation) { uint64_t CommandStreamReceiverSimulatedCommonHw<Family>::getPPGTTAdditionalBits(GraphicsAllocation *gfxAllocation) {
return BIT(PageTableEntry::presentBit) | BIT(PageTableEntry::writableBit) | return BIT(PageTableEntry::presentBit) | BIT(PageTableEntry::writableBit) |
((gfxAllocation && gfxAllocation->getMemoryPool() == MemoryPool::localMemory) ? BIT(PageTableEntry::localMemoryBit) : 0); ((gfxAllocation && gfxAllocation->getMemoryPool() == MemoryPool::localMemory) ? BIT(PageTableEntry::localMemoryBit) : 0);
} }
template <>
void CommandStreamReceiverSimulatedCommonHw<Family>::getGTTData(void *memory, AubGTTData &data) {
data = {};
data.present = true;
data.localMemory = this->isLocalMemoryEnabled();
}
template class CommandStreamReceiverSimulatedCommonHw<Family>; template class CommandStreamReceiverSimulatedCommonHw<Family>;
} // namespace NEO } // namespace NEO

1
shared/source/gen12lp/gfx_core_helper_gen12lp.cpp
View File

@@ -5,7 +5,6 @@
* *
*/ */
#include "shared/source/gen12lp/aub_mapper.h"
#include "shared/source/gen12lp/hw_cmds_base.h" #include "shared/source/gen12lp/hw_cmds_base.h"
using Family = NEO::Gen12LpFamily; using Family = NEO::Gen12LpFamily;

3
shared/source/gen_common/CMakeLists.txt
View File

@@ -1,11 +1,10 @@
# #
# Copyright (C) 2020-2024 Intel Corporation # Copyright (C) 2020-2025 Intel Corporation
# #
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
set(NEO_CORE_GEN_COMMON set(NEO_CORE_GEN_COMMON
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}aub_mapper_common.h
${CMAKE_CURRENT_SOURCE_DIR}/reg_configs_common.h ${CMAKE_CURRENT_SOURCE_DIR}/reg_configs_common.h
) )

23
shared/source/gen_common/aub_mapper_common.h
View File

@@ -1,23 +0,0 @@
/*
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#ifdef SUPPORT_GEN12LP
#include "shared/source/gen12lp/aub_mapper.h"
#endif
#ifdef SUPPORT_XE_HPG_CORE
#include "shared/source/xe_hpg_core/aub_mapper.h"
#endif
#ifdef SUPPORT_XE_HPC_CORE
#include "shared/source/xe_hpc_core/aub_mapper.h"
#endif
#ifdef SUPPORT_XE2_HPG_CORE
#include "shared/source/xe2_hpg_core/aub_mapper.h"
#endif
#ifdef SUPPORT_XE3_CORE
#include "shared/source/xe3_core/aub_mapper.h"
#endif

3
shared/source/helpers/gfx_core_helper.h
View File

@@ -65,7 +65,6 @@ class GfxCoreHelper {
virtual bool isLocalMemoryEnabled(const HardwareInfo &hwInfo) const = 0; virtual bool isLocalMemoryEnabled(const HardwareInfo &hwInfo) const = 0;
virtual bool is1MbAlignmentSupported(const HardwareInfo &hwInfo, bool isCompressionEnabled) const = 0; virtual bool is1MbAlignmentSupported(const HardwareInfo &hwInfo, bool isCompressionEnabled) const = 0;
virtual bool isFenceAllocationRequired(const HardwareInfo &hwInfo, const ProductHelper &productHelper) const = 0; virtual bool isFenceAllocationRequired(const HardwareInfo &hwInfo, const ProductHelper &productHelper) const = 0;
virtual const AubMemDump::LrcaHelper &getCsTraits(aub_stream::EngineType engineType) const = 0;
virtual bool hvAlign4Required() const = 0; virtual bool hvAlign4Required() const = 0;
virtual bool isBufferSizeSuitableForCompression(const size_t size) const = 0; virtual bool isBufferSizeSuitableForCompression(const size_t size) const = 0;
virtual bool checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) const = 0; virtual bool checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) const = 0;
@@ -265,8 +264,6 @@ class GfxCoreHelperHw : public GfxCoreHelper {
uint32_t getRenderSurfaceStatePitch(void *renderSurfaceState, const ProductHelper &productHelper) const override; uint32_t getRenderSurfaceStatePitch(void *renderSurfaceState, const ProductHelper &productHelper) const override;
const AubMemDump::LrcaHelper &getCsTraits(aub_stream::EngineType engineType) const override;
size_t getMaxBarrierRegisterPerSlice() const override; size_t getMaxBarrierRegisterPerSlice() const override;
size_t getPaddingForISAAllocation() const override; size_t getPaddingForISAAllocation() const override;

5
shared/source/helpers/gfx_core_helper_base.inl
View File

@@ -80,11 +80,6 @@ uint32_t GfxCoreHelperHw<Family>::getPitchAlignmentForImage(const RootDeviceEnvi
return 4u; return 4u;
} }
template <typename Family>
const AubMemDump::LrcaHelper &GfxCoreHelperHw<Family>::getCsTraits(aub_stream::EngineType engineType) const {
return *AUBFamilyMapper<Family>::csTraits[engineType];
}
template <typename GfxFamily> template <typename GfxFamily>
inline bool GfxCoreHelperHw<GfxFamily>::checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) const { inline bool GfxCoreHelperHw<GfxFamily>::checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) const {
return true; return true;

2
shared/source/xe2_hpg_core/aub_command_stream_receiver_xe2_hpg_core.cpp
View File

@@ -9,9 +9,9 @@
#include "shared/source/command_stream/aub_command_stream_receiver_hw_xehp_and_later.inl" #include "shared/source/command_stream/aub_command_stream_receiver_hw_xehp_and_later.inl"
#include "shared/source/helpers/array_count.h" #include "shared/source/helpers/array_count.h"
#include "shared/source/helpers/populate_factory.h" #include "shared/source/helpers/populate_factory.h"
#include "shared/source/xe2_hpg_core/hw_cmds_base.h"
namespace NEO { namespace NEO {
struct Xe2HpgCoreFamily;
using Family = Xe2HpgCoreFamily; using Family = Xe2HpgCoreFamily;
static auto gfxCore = IGFX_XE2_HPG_CORE; static auto gfxCore = IGFX_XE2_HPG_CORE;

23
shared/source/xe2_hpg_core/aub_mapper.h
View File

@@ -1,23 +0,0 @@
/*
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/aub/aub_mapper_base.h"
#include "shared/source/helpers/constants.h"
#include "shared/source/xe2_hpg_core/hw_cmds.h"
#include "aubstream/engine_node.h"
namespace NEO {
struct Xe2HpgCoreFamily;
template <>
struct AUBFamilyMapper<Xe2HpgCoreFamily> {
static const AubMemDump::LrcaHelper *const csTraits[aub_stream::NUM_ENGINES];
};
} // namespace NEO

14
shared/source/xe2_hpg_core/aub_mem_dump_xe2_hpg_core.cpp
View File

@@ -1,14 +0,0 @@
/*
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
namespace NEO {
struct Xe2HpgCoreFamily;
using Family = NEO::Xe2HpgCoreFamily;
} // namespace NEO
#include "shared/source/aub_mem_dump/aub_mem_dump_pvc_and_later.inl"

3
shared/source/xe2_hpg_core/command_stream_receiver_simulated_common_hw_xe2_hpg_core.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2024 Intel Corporation * Copyright (C) 2024-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -8,6 +8,7 @@
#include "shared/source/command_stream/command_stream_receiver_simulated_common_hw_xehp_and_later.inl" #include "shared/source/command_stream/command_stream_receiver_simulated_common_hw_xehp_and_later.inl"
#include "shared/source/gmm_helper/gmm_helper.h" #include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/source/helpers/ptr_math.h" #include "shared/source/helpers/ptr_math.h"
#include "shared/source/xe2_hpg_core/hw_cmds_base.h"
namespace NEO { namespace NEO {
using Family = Xe2HpgCoreFamily; using Family = Xe2HpgCoreFamily;

1
shared/source/xe2_hpg_core/gfx_core_helper_xe2_hpg_core.cpp
View File

@@ -5,7 +5,6 @@
* *
*/ */
#include "shared/source/xe2_hpg_core/aub_mapper.h"
#include "shared/source/xe2_hpg_core/hw_cmds.h" #include "shared/source/xe2_hpg_core/hw_cmds.h"
using Family = NEO::Xe2HpgCoreFamily; using Family = NEO::Xe2HpgCoreFamily;

1
shared/source/xe3_core/aub_command_stream_receiver_xe3_core.cpp
View File

@@ -9,6 +9,7 @@
#include "shared/source/command_stream/aub_command_stream_receiver_hw_xehp_and_later.inl" #include "shared/source/command_stream/aub_command_stream_receiver_hw_xehp_and_later.inl"
#include "shared/source/helpers/array_count.h" #include "shared/source/helpers/array_count.h"
#include "shared/source/helpers/populate_factory.h" #include "shared/source/helpers/populate_factory.h"
#include "shared/source/xe3_core/hw_cmds_base.h"
namespace NEO { namespace NEO {

23
shared/source/xe3_core/aub_mapper.h
View File

@@ -1,23 +0,0 @@
/*
* Copyright (C) 2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/aub/aub_mapper_base.h"
#include "shared/source/helpers/constants.h"
#include "shared/source/xe3_core/hw_cmds_base.h"
#include "aubstream/engine_node.h"
namespace NEO {
struct Xe3CoreFamily;
template <>
struct AUBFamilyMapper<Xe3CoreFamily> {
static const AubMemDump::LrcaHelper *const csTraits[aub_stream::NUM_ENGINES];
};
} // namespace NEO

14
shared/source/xe3_core/aub_mem_dump_xe3_core.cpp
View File

@@ -1,14 +0,0 @@
/*
* Copyright (C) 2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
namespace NEO {
struct Xe3CoreFamily;
using Family = NEO::Xe3CoreFamily;
} // namespace NEO
#include "shared/source/aub_mem_dump/aub_mem_dump_pvc_and_later.inl"

1
shared/source/xe3_core/command_stream_receiver_simulated_common_hw_xe3_core.cpp
View File

@@ -8,6 +8,7 @@
#include "shared/source/command_stream/command_stream_receiver_simulated_common_hw_xehp_and_later.inl" #include "shared/source/command_stream/command_stream_receiver_simulated_common_hw_xehp_and_later.inl"
#include "shared/source/gmm_helper/gmm_helper.h" #include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/source/helpers/ptr_math.h" #include "shared/source/helpers/ptr_math.h"
#include "shared/source/xe3_core/hw_cmds_base.h"
namespace NEO { namespace NEO {
using Family = Xe3CoreFamily; using Family = Xe3CoreFamily;

1
shared/source/xe3_core/gfx_core_helper_xe3_core.cpp
View File

@@ -5,7 +5,6 @@
* *
*/ */
#include "shared/source/xe3_core/aub_mapper.h"
#include "shared/source/xe3_core/hw_cmds_base.h" #include "shared/source/xe3_core/hw_cmds_base.h"
using Family = NEO::Xe3CoreFamily; using Family = NEO::Xe3CoreFamily;

1
shared/source/xe_hpc_core/aub_command_stream_receiver_xe_hpc_core.cpp
View File

@@ -9,6 +9,7 @@
#include "shared/source/command_stream/aub_command_stream_receiver_hw_xehp_and_later.inl" #include "shared/source/command_stream/aub_command_stream_receiver_hw_xehp_and_later.inl"
#include "shared/source/helpers/array_count.h" #include "shared/source/helpers/array_count.h"
#include "shared/source/helpers/populate_factory.h" #include "shared/source/helpers/populate_factory.h"
#include "shared/source/xe_hpc_core/hw_cmds_xe_hpc_core_base.h"
namespace NEO { namespace NEO {
struct XeHpcCoreFamily; struct XeHpcCoreFamily;

23
shared/source/xe_hpc_core/aub_mapper.h
View File

@@ -1,23 +0,0 @@
/*
* Copyright (C) 2021-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/aub/aub_mapper_base.h"
#include "shared/source/helpers/constants.h"
#include "shared/source/xe_hpc_core/hw_cmds.h"
#include "aubstream/engine_node.h"
namespace NEO {
struct XeHpcCoreFamily;
template <>
struct AUBFamilyMapper<XeHpcCoreFamily> {
static const AubMemDump::LrcaHelper *const csTraits[aub_stream::NUM_ENGINES];
};
} // namespace NEO

14
shared/source/xe_hpc_core/aub_mem_dump_xe_hpc_core.cpp
View File

@@ -1,14 +0,0 @@
/*
* Copyright (C) 2021-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
namespace NEO {
struct XeHpcCoreFamily;
using Family = NEO::XeHpcCoreFamily;
} // namespace NEO
#include "shared/source/aub_mem_dump/aub_mem_dump_pvc_and_later.inl"

3
shared/source/xe_hpc_core/command_stream_receiver_simulated_common_hw_xe_hpc_core.cpp
View File

@@ -1,11 +1,12 @@
/* /*
* Copyright (C) 2021-2023 Intel Corporation * Copyright (C) 2021-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
*/ */
#include "shared/source/command_stream/command_stream_receiver_simulated_common_hw_xehp_and_later.inl" #include "shared/source/command_stream/command_stream_receiver_simulated_common_hw_xehp_and_later.inl"
#include "shared/source/xe_hpc_core/hw_cmds_xe_hpc_core_base.h"
namespace NEO { namespace NEO {
using Family = XeHpcCoreFamily; using Family = XeHpcCoreFamily;

1
shared/source/xe_hpc_core/gfx_core_helper_xe_hpc_core.cpp
View File

@@ -5,7 +5,6 @@
* *
*/ */
#include "shared/source/xe_hpc_core/aub_mapper.h"
#include "shared/source/xe_hpc_core/hw_cmds_xe_hpc_core_base.h" #include "shared/source/xe_hpc_core/hw_cmds_xe_hpc_core_base.h"
using Family = NEO::XeHpcCoreFamily; using Family = NEO::XeHpcCoreFamily;

1
shared/source/xe_hpg_core/aub_command_stream_receiver_xe_hpg_core.cpp
View File

@@ -9,6 +9,7 @@
#include "shared/source/command_stream/aub_command_stream_receiver_hw_xehp_and_later.inl" #include "shared/source/command_stream/aub_command_stream_receiver_hw_xehp_and_later.inl"
#include "shared/source/helpers/array_count.h" #include "shared/source/helpers/array_count.h"
#include "shared/source/helpers/populate_factory.h" #include "shared/source/helpers/populate_factory.h"
#include "shared/source/xe_hpg_core/hw_cmds_xe_hpg_core_base.h"
namespace NEO { namespace NEO {
struct XeHpgCoreFamily; struct XeHpgCoreFamily;

23
shared/source/xe_hpg_core/aub_mapper.h
View File

@@ -1,23 +0,0 @@
/*
* Copyright (C) 2021-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/aub/aub_mapper_base.h"
#include "shared/source/helpers/constants.h"
#include "shared/source/xe_hpg_core/hw_cmds.h"
#include "aubstream/engine_node.h"
namespace NEO {
struct XeHpgCoreFamily;
template <>
struct AUBFamilyMapper<XeHpgCoreFamily> {
static const AubMemDump::LrcaHelper *const csTraits[aub_stream::NUM_ENGINES];
};
} // namespace NEO

14
shared/source/xe_hpg_core/aub_mem_dump_xe_hpg_core.cpp
View File

@@ -1,14 +0,0 @@
/*
* Copyright (C) 2021-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
namespace NEO {
struct XeHpgCoreFamily;
using Family = NEO::XeHpgCoreFamily;
} // namespace NEO
#include "shared/source/aub_mem_dump/aub_mem_dump_xehp_and_later.inl"

3
shared/source/xe_hpg_core/command_stream_receiver_simulated_common_hw_xe_hpg_core.cpp
View File

@@ -1,11 +1,12 @@
/* /*
* Copyright (C) 2021-2022 Intel Corporation * Copyright (C) 2021-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
*/ */
#include "shared/source/command_stream/command_stream_receiver_simulated_common_hw_xehp_and_later.inl" #include "shared/source/command_stream/command_stream_receiver_simulated_common_hw_xehp_and_later.inl"
#include "shared/source/xe_hpg_core/hw_cmds_xe_hpg_core_base.h"
namespace NEO { namespace NEO {
typedef XeHpgCoreFamily Family; typedef XeHpgCoreFamily Family;

1
shared/source/xe_hpg_core/gfx_core_helper_xe_hpg_core.cpp
View File

@@ -8,7 +8,6 @@
#include "shared/source/execution_environment/root_device_environment.h" #include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/memory_manager/compression_selector.h" #include "shared/source/memory_manager/compression_selector.h"
#include "shared/source/release_helper/release_helper.h" #include "shared/source/release_helper/release_helper.h"
#include "shared/source/xe_hpg_core/aub_mapper.h"
#include "shared/source/xe_hpg_core/hw_cmds_xe_hpg_core_base.h" #include "shared/source/xe_hpg_core/hw_cmds_xe_hpg_core_base.h"
using Family = NEO::XeHpgCoreFamily; using Family = NEO::XeHpgCoreFamily;

4
shared/test/common/fixtures/aub_fixtures/multicontext_aub_fixture.cpp
View File

@@ -76,8 +76,8 @@ void MulticontextAubFixture::setUp(uint32_t numberOfTiles, EnabledCommandStreame
std::stringstream strfilename; std::stringstream strfilename;
strfilename << ApiSpecificConfig::getAubPrefixForSpecificApi(); strfilename << ApiSpecificConfig::getAubPrefixForSpecificApi();
strfilename << testInfo->test_case_name() << "_" << testInfo->name() << "_"; strfilename << testInfo->test_case_name() << "_" << testInfo->name() << "_";
auto firstEngineName = gfxCoreHelper.getCsTraits(firstEngine).name; auto firstEngineName = EngineHelpers::engineTypeToString(firstEngine);
auto secondEngineName = gfxCoreHelper.getCsTraits(aub_stream::ENGINE_CCS).name; auto secondEngineName = EngineHelpers::engineTypeToString(aub_stream::ENGINE_CCS);
if (EnabledCommandStreamers::single == enabledCommandStreamers) { // name_RCS.aub or name_CCCS.aub or name_CCS.aub if (EnabledCommandStreamers::single == enabledCommandStreamers) { // name_RCS.aub or name_CCCS.aub or name_CCS.aub
strfilename << firstEngineName; strfilename << firstEngineName;
} else if (EnabledCommandStreamers::dual == enabledCommandStreamers) { // name_RCS_CCS.aub or name_CCCS_CCS.aub or name_CCS0_1.aub } else if (EnabledCommandStreamers::dual == enabledCommandStreamers) { // name_RCS_CCS.aub or name_CCCS_CCS.aub or name_CCS0_1.aub

11
shared/test/unit_test/aub/aub_helper_tests.cpp
View File

@@ -18,7 +18,6 @@
#include "shared/test/common/helpers/debug_manager_state_restore.h" #include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h" #include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/test_macros/hw_test.h" #include "shared/test/common/test_macros/hw_test.h"
#include "shared/test/unit_test/mocks/mock_lrca_helper.h"
using namespace NEO; using namespace NEO;
@@ -144,13 +143,3 @@ HWTEST_F(AubHelperTest, WhenHBMSizePerTileInGigabytesIsNotSetThenGetMemBankSizeR
sysInfo.MultiTileArchInfo.TileCount = 4; sysInfo.MultiTileArchInfo.TileCount = 4;
EXPECT_EQ(8 * MemoryConstants::gigaByte, AubHelper::getPerTileLocalMemorySize(&hwInfo, releaseHelper.get())); EXPECT_EQ(8 * MemoryConstants::gigaByte, AubHelper::getPerTileLocalMemorySize(&hwInfo, releaseHelper.get()));
} }
HWTEST_F(AubHelperTest, givenLrcaHelperWhenContextIsInitializedThenContextFlagsAreSet) {
const auto &csTraits = CommandStreamReceiverSimulatedCommonHw<FamilyType>::getCsTraits(aub_stream::ENGINE_RCS);
MockLrcaHelper lrcaHelper(csTraits.mmioBase);
std::unique_ptr<void, std::function<void(void *)>> lrcaBase(alignedMalloc(csTraits.sizeLRCA, csTraits.alignLRCA), alignedFree);
lrcaHelper.initialize(lrcaBase.get());
ASSERT_NE(0u, lrcaHelper.setContextSaveRestoreFlagsCalled);
}

3
shared/test/unit_test/aub_mem_dump/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
# #
# Copyright (C) 2021-2022 Intel Corporation # Copyright (C) 2021-2025 Intel Corporation
# #
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
@@ -7,5 +7,4 @@
target_sources(neo_shared_tests PRIVATE target_sources(neo_shared_tests PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/aub_alloc_dump_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/aub_alloc_dump_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/lrca_helper_tests.cpp
) )

2
shared/test/unit_test/aub_mem_dump/aub_alloc_dump_tests.cpp
View File

@@ -5,7 +5,7 @@
* *
*/ */
#include "shared/source/aub_mem_dump/aub_alloc_dump.h" #include "shared/source/aub_mem_dump/aub_alloc_dump.inl"
#include "shared/source/gmm_helper/gmm_helper.h" #include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/test/common/fixtures/device_fixture.h" #include "shared/test/common/fixtures/device_fixture.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h" #include "shared/test/common/helpers/debug_manager_state_restore.h"

31
shared/test/unit_test/aub_mem_dump/lrca_helper_tests.cpp
View File

@@ -1,31 +0,0 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/aub_mem_dump/aub_mem_dump.h"
#include "shared/test/common/test_macros/test.h"
#include <memory>
using namespace AubMemDump;
TEST(LrcaHelper, WhenLrcaHelperIsInitializedThenLrcaIncludesDebugModeLri) {
LrcaHelper helper(0x2000);
auto lrcaBufferSize = helper.sizeLRCA / sizeof(uint32_t);
auto lrca = std::unique_ptr<uint32_t[]>(new uint32_t[lrcaBufferSize]);
helper.initialize(lrca.get());
bool debugModeLriFound = false;
for (uint32_t i = 0; i < lrcaBufferSize; i += 2) {
if (lrca[i] == 0x20d8 && lrca[i + 1] == 0x00200020) {
debugModeLriFound = true;
break;
}
}
EXPECT_TRUE(debugModeLriFound);
}

13
shared/test/unit_test/command_stream/aub_command_stream_receiver_2_tests.cpp
View File

@@ -605,19 +605,6 @@ HWTEST_F(AubCommandStreamReceiverNoHostPtrTests, givenAubCommandStreamReceiverWh
memoryManager->freeGraphicsMemory(gfxAllocation); memoryManager->freeGraphicsMemory(gfxAllocation);
} }
HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenGetGTTDataIsCalledThenLocalMemoryIsSetAccordingToCsrFeature) {
std::unique_ptr<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>("", true, *pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield()));
AubGTTData data = {};
aubCsr->getGTTData(nullptr, data);
EXPECT_TRUE(data.present);
if (aubCsr->localMemoryEnabled) {
EXPECT_TRUE(data.localMemory);
} else {
EXPECT_FALSE(data.localMemory);
}
}
HWTEST_F(AubCommandStreamReceiverTests, whenGetMemoryBankForGttIsCalledThenCorrectBankIsReturned) { HWTEST_F(AubCommandStreamReceiverTests, whenGetMemoryBankForGttIsCalledThenCorrectBankIsReturned) {
std::unique_ptr<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>("", true, *pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield())); std::unique_ptr<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>("", true, *pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield()));
aubCsr->localMemoryEnabled = false; aubCsr->localMemoryEnabled = false;

16
shared/test/unit_test/command_stream/aub_command_stream_receiver_tests_xehp_and_later.cpp
View File

@@ -180,19 +180,3 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterAubCommandStreamReceiverTests, whenPhys
EXPECT_EQ(expectedBankSize, allocator->getBankSize()); EXPECT_EQ(expectedBankSize, allocator->getBankSize());
EXPECT_EQ(4u, allocator->getNumberOfBanks()); EXPECT_EQ(4u, allocator->getNumberOfBanks());
} }
using XeHPAndLaterAubCommandStreamReceiverTests2 = GfxCoreHelperTest;
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterAubCommandStreamReceiverTests2, givenLocalMemoryEnabledInCSRWhenGetGTTDataIsCalledThenLocalMemoryIsSet) {
DebugManagerStateRestore debugRestorer;
debugManager.flags.EnableLocalMemory.set(1);
hardwareInfo.featureTable.flags.ftrLocalMemory = true;
std::unique_ptr<MockDevice> device(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hardwareInfo));
std::unique_ptr<MockAubCsrXeHPAndLater<FamilyType>> aubCsr(std::make_unique<MockAubCsrXeHPAndLater<FamilyType>>("", true, *device->executionEnvironment, device->getRootDeviceIndex(), device->getDeviceBitfield()));
EXPECT_TRUE(aubCsr->localMemoryEnabled);
AubGTTData data = {false, false};
aubCsr->getGTTData(nullptr, data);
EXPECT_TRUE(data.localMemory);
}

17
shared/test/unit_test/command_stream/tbx_command_stream_receiver_tests_xehp_and_later.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2021-2024 Intel Corporation * Copyright (C) 2021-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -89,21 +89,6 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterTbxCommandStreamReceiverTests, givenAub
EXPECT_EQ(3u | (1 << 11), bits); EXPECT_EQ(3u | (1 << 11), bits);
} }
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterTbxCommandStreamReceiverTests, givenLocalMemoryFeatureWhenGetGTTDataIsCalledThenLocalMemoryIsSet) {
setUpImpl<FamilyType>();
DebugManagerStateRestore debugRestorer;
debugManager.flags.EnableLocalMemory.set(1);
hardwareInfo.featureTable.flags.ftrLocalMemory = true;
std::unique_ptr<MockDevice> device(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hardwareInfo));
auto tbxCsr = std::make_unique<MockTbxCommandStreamReceiverHw<FamilyType>>(*device->executionEnvironment, device->getRootDeviceIndex(), device->getDeviceBitfield());
tbxCsr->setupContext(*device->getDefaultEngine().osContext);
AubGTTData data = {false, false};
tbxCsr->getGTTData(nullptr, data);
EXPECT_TRUE(data.localMemory);
}
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterTbxCommandStreamReceiverTests, givenLocalMemoryEnabledWhenGetMemoryBankForGttIsCalledThenCorrectBankForDeviceIsReturned) { HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterTbxCommandStreamReceiverTests, givenLocalMemoryEnabledWhenGetMemoryBankForGttIsCalledThenCorrectBankForDeviceIsReturned) {
setUpImpl<FamilyType>(); setUpImpl<FamilyType>();
DebugManagerStateRestore debugRestorer; DebugManagerStateRestore debugRestorer;

1
shared/test/unit_test/gen12lp/aub_command_stream_receiver_tests_gen12lp.inl
View File

@@ -7,6 +7,7 @@
#include "shared/source/aub_mem_dump/page_table_entry_bits.h" #include "shared/source/aub_mem_dump/page_table_entry_bits.h"
#include "shared/source/command_stream/aub_command_stream_receiver_hw.h" #include "shared/source/command_stream/aub_command_stream_receiver_hw.h"
#include "shared/source/gen12lp/hw_info.h"
#include "shared/source/os_interface/os_context.h" #include "shared/source/os_interface/os_context.h"
#include "shared/test/common/fixtures/device_fixture.h" #include "shared/test/common/fixtures/device_fixture.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h" #include "shared/test/common/helpers/debug_manager_state_restore.h"

1
shared/test/unit_test/gen12lp/coherency_tests_gen12lp.inl
View File

@@ -6,6 +6,7 @@
*/ */
#include "shared/source/command_stream/command_stream_receiver_hw.h" #include "shared/source/command_stream/command_stream_receiver_hw.h"
#include "shared/source/gen12lp/hw_cmds_base.h"
#include "shared/source/helpers/ptr_math.h" #include "shared/source/helpers/ptr_math.h"
#include "shared/test/common/cmd_parse/hw_parse.h" #include "shared/test/common/cmd_parse/hw_parse.h"
#include "shared/test/common/helpers/dispatch_flags_helper.h" #include "shared/test/common/helpers/dispatch_flags_helper.h"

8
shared/test/unit_test/helpers/gfx_core_helper_tests.cpp
View File

@@ -141,14 +141,6 @@ TEST_F(GfxCoreHelperTest, givenDebuggingInactiveWhenSipKernelTypeIsQueriedThenCs
EXPECT_EQ(SipKernelType::csr, sipType); EXPECT_EQ(SipKernelType::csr, sipType);
} }
TEST_F(GfxCoreHelperTest, givenEngineTypeRcsWhenCsTraitsAreQueiredThenCorrectNameInTraitsIsReturned) {
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_NE(nullptr, &gfxCoreHelper);
auto &csTraits = gfxCoreHelper.getCsTraits(aub_stream::ENGINE_RCS);
EXPECT_STREQ("RCS", csTraits.name.c_str());
}
TEST_F(GfxCoreHelperTest, whenGetGpuTimeStampInNSIsCalledThenTimestampIsMaskedBasedOnResolution) { TEST_F(GfxCoreHelperTest, whenGetGpuTimeStampInNSIsCalledThenTimestampIsMaskedBasedOnResolution) {
auto &gfxCoreHelper = getHelper<GfxCoreHelper>(); auto &gfxCoreHelper = getHelper<GfxCoreHelper>();

3
shared/test/unit_test/mocks/CMakeLists.txt
View File

@@ -11,10 +11,9 @@ target_sources(neo_shared_tests PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/mock_csr_simulated_common_hw.h ${CMAKE_CURRENT_SOURCE_DIR}/mock_csr_simulated_common_hw.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_dispatch_kernel_encoder_interface.h ${CMAKE_CURRENT_SOURCE_DIR}/mock_dispatch_kernel_encoder_interface.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_gmm_resource_info.cpp ${CMAKE_CURRENT_SOURCE_DIR}/mock_gmm_resource_info.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_lrca_helper.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_physical_address_allocator.h ${CMAKE_CURRENT_SOURCE_DIR}/mock_physical_address_allocator.h
) )
if(WIN32) if(WIN32)
target_sources(neo_shared_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/windows/mock_wddm_direct_submission.h) target_sources(neo_shared_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/windows/mock_wddm_direct_submission.h)
endif() endif()

19
shared/test/unit_test/mocks/mock_lrca_helper.h
View File

@@ -1,19 +0,0 @@
/*
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/aub_mem_dump/aub_mem_dump.h"
struct MockLrcaHelper : AubMemDump::LrcaHelper {
mutable uint32_t setContextSaveRestoreFlagsCalled = 0;
MockLrcaHelper(uint32_t base) : AubMemDump::LrcaHelper(base) {}
void setContextSaveRestoreFlags(uint32_t &value) const override {
setContextSaveRestoreFlagsCalled++;
AubMemDump::LrcaHelper::setContextSaveRestoreFlags(value);
}
};