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

refactor: remove not needed code

Browse Source 
Signed-off-by: Mrozek, Michal <michal.mrozek@intel.com>
This commit is contained in:
Mrozek, Michal
2024-05-29 11:33:38 +00:00
committed by Compute-Runtime-Automation
parent 79b9e73311
commit 38d7e02c28
23 changed files with 3 additions and 853 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -32,9 +32,6 @@ set(NEO_CORE_COMMAND_STREAM
${CMAKE_CURRENT_SOURCE_DIR}/definitions${BRANCH_DIR_SUFFIX}command_stream_receiver_hw_ext.inl
${CMAKE_CURRENT_SOURCE_DIR}/definitions${BRANCH_DIR_SUFFIX}stream_properties.inl
${CMAKE_CURRENT_SOURCE_DIR}/device_command_stream.h
${CMAKE_CURRENT_SOURCE_DIR}/experimental_command_buffer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/experimental_command_buffer.h
${CMAKE_CURRENT_SOURCE_DIR}/experimental_command_buffer.inl
${CMAKE_CURRENT_SOURCE_DIR}/linear_stream.cpp
${CMAKE_CURRENT_SOURCE_DIR}/linear_stream.h
${CMAKE_CURRENT_SOURCE_DIR}/preemption.cpp

5
shared/source/command_stream/command_stream_receiver.cpp
View File

@@ -10,7 +10,6 @@
#include "shared/source/built_ins/built_ins.h"
#include "shared/source/command_container/implicit_scaling.h"
#include "shared/source/command_stream/aub_subcapture_status.h"
#include "shared/source/command_stream/experimental_command_buffer.h"
#include "shared/source/command_stream/preemption.h"
#include "shared/source/command_stream/scratch_space_controller.h"
#include "shared/source/command_stream/submission_status.h"
@@ -740,10 +739,6 @@ void CommandStreamReceiver::releaseIndirectHeap(IndirectHeap::Type heapType) {
}
}
void CommandStreamReceiver::setExperimentalCmdBuffer(std::unique_ptr<ExperimentalCommandBuffer> &&cmdBuffer) {
experimentalCmdBuffer = std::move(cmdBuffer);
}
void *CommandStreamReceiver::asyncDebugBreakConfirmation(void *arg) {
auto self = reinterpret_cast<CommandStreamReceiver *>(arg);

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

@@ -530,7 +530,6 @@ class CommandStreamReceiver {
std::unique_ptr<FlushStampTracker> flushStamp;
std::unique_ptr<SubmissionAggregator> submissionAggregator;
std::unique_ptr<FlatBatchBufferHelper> flatBatchBufferHelper;
std::unique_ptr<ExperimentalCommandBuffer> experimentalCmdBuffer;
std::unique_ptr<InternalAllocationStorage> internalAllocationStorage;
std::atomic<uint32_t> preallocatedAmount{0};
std::atomic<uint32_t> requestedPreallocationsAmount{0};

13
shared/source/command_stream/command_stream_receiver_hw_base.inl
View File

@@ -8,7 +8,6 @@
#include "shared/source/built_ins/sip.h"
#include "shared/source/command_container/encode_surface_state.h"
#include "shared/source/command_stream/command_stream_receiver_hw.h"
#include "shared/source/command_stream/experimental_command_buffer.h"
#include "shared/source/command_stream/linear_stream.h"
#include "shared/source/command_stream/preemption.h"
#include "shared/source/command_stream/scratch_space_controller_base.h"
@@ -524,11 +523,6 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
programSamplerCacheFlushBetweenRedescribedSurfaceReads(commandStreamCSR);
}
if (experimentalCmdBuffer.get() != nullptr) {
size_t startingOffset = experimentalCmdBuffer->programExperimentalCommandBuffer<GfxFamily>();
experimentalCmdBuffer->injectBufferStart<GfxFamily>(commandStreamCSR, startingOffset);
}
if (stateCacheFlushRequired) {
device.getBindlessHeapsHelper()->clearStateDirtyForContext(getOsContext().getContextId());
MemorySynchronizationCommands<GfxFamily>::addStateCacheFlush(commandStreamCSR, device.getRootDeviceEnvironment());
@@ -558,10 +552,6 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
makeResident(*debugSurface);
}
if (experimentalCmdBuffer.get() != nullptr) {
experimentalCmdBuffer->makeResidentAllocations();
}
if (workPartitionAllocation) {
makeResident(*workPartitionAllocation);
}
@@ -799,9 +789,6 @@ size_t CommandStreamReceiverHw<GfxFamily>::getRequiredCmdStreamSize(const Dispat
size += sizeof(typename GfxFamily::PIPE_CONTROL);
}
}
if (experimentalCmdBuffer.get() != nullptr) {
size += experimentalCmdBuffer->getRequiredInjectionSize<GfxFamily>();
}
size += TimestampPacketHelper::getRequiredCmdStreamSize<GfxFamily>(dispatchFlags.csrDependencies, false);
size += TimestampPacketHelper::getRequiredCmdStreamSizeForMultiRootDeviceSyncNodesContainer<GfxFamily>(dispatchFlags.csrDependencies);

68
shared/source/command_stream/experimental_command_buffer.cpp
View File

@@ -1,68 +0,0 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_stream/experimental_command_buffer.h"
#include "shared/source/command_stream/command_stream_receiver.h"
#include "shared/source/command_stream/linear_stream.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/helpers/constants.h"
#include "shared/source/memory_manager/allocation_properties.h"
#include "shared/source/memory_manager/internal_allocation_storage.h"
#include "shared/source/memory_manager/memory_manager.h"
#include "shared/source/os_interface/os_context.h"
#include <cstring>
#include <type_traits>
namespace NEO {
ExperimentalCommandBuffer::ExperimentalCommandBuffer(CommandStreamReceiver *csr, double profilingTimerResolution) : commandStreamReceiver(csr),
currentStream(nullptr),
timerResolution(profilingTimerResolution) {
auto rootDeviceIndex = csr->getRootDeviceIndex();
timestamps = csr->getMemoryManager()->allocateGraphicsMemoryWithProperties({rootDeviceIndex, MemoryConstants::pageSize, AllocationType::internalHostMemory, csr->getOsContext().getDeviceBitfield()});
memset(timestamps->getUnderlyingBuffer(), 0, timestamps->getUnderlyingBufferSize());
experimentalAllocation = csr->getMemoryManager()->allocateGraphicsMemoryWithProperties({rootDeviceIndex, MemoryConstants::pageSize, AllocationType::internalHostMemory, csr->getOsContext().getDeviceBitfield()});
memset(experimentalAllocation->getUnderlyingBuffer(), 0, experimentalAllocation->getUnderlyingBufferSize());
}
ExperimentalCommandBuffer::~ExperimentalCommandBuffer() {
auto timestamp = static_cast<uint64_t *>(timestamps->getUnderlyingBuffer());
for (uint32_t i = 0; i < timestampsOffset / (2 * sizeof(uint64_t)); i++) {
auto stop = static_cast<uint64_t>(*(timestamp + 1) * timerResolution);
auto start = static_cast<uint64_t>(*timestamp * timerResolution);
auto delta = stop - start;
PRINT_DEBUG_STRING(defaultPrint, stdout, "#%u: delta %llu start %llu stop %llu\n", i, delta, start, stop);
timestamp += 2;
}
MemoryManager *memoryManager = commandStreamReceiver->getMemoryManager();
memoryManager->freeGraphicsMemory(timestamps);
memoryManager->freeGraphicsMemory(experimentalAllocation);
if (currentStream.get()) {
memoryManager->freeGraphicsMemory(currentStream->getGraphicsAllocation());
currentStream->replaceGraphicsAllocation(nullptr);
}
}
void ExperimentalCommandBuffer::getCS(size_t minRequiredSize) {
if (!currentStream) {
currentStream.reset(new LinearStream(nullptr));
}
minRequiredSize += CSRequirements::minCommandQueueCommandStreamSize;
constexpr static auto additionalAllocationSize = CSRequirements::minCommandQueueCommandStreamSize + CSRequirements::csOverfetchSize;
commandStreamReceiver->ensureCommandBufferAllocation(*currentStream, minRequiredSize, additionalAllocationSize);
}
void ExperimentalCommandBuffer::makeResidentAllocations() {
commandStreamReceiver->makeResident(*currentStream->getGraphicsAllocation());
commandStreamReceiver->makeResident(*timestamps);
commandStreamReceiver->makeResident(*experimentalAllocation);
}
} // namespace NEO

68
shared/source/command_stream/experimental_command_buffer.h
View File

@@ -1,68 +0,0 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include <cstdint>
#include <memory>
namespace NEO {
class CommandStreamReceiver;
class GraphicsAllocation;
class LinearStream;
class MemoryManager;
class ExperimentalCommandBuffer : NonCopyableOrMovableClass {
public:
virtual ~ExperimentalCommandBuffer();
ExperimentalCommandBuffer(CommandStreamReceiver *csr, double profilingTimerResolution);
template <typename GfxFamily>
void injectBufferStart(LinearStream &parentStream, size_t cmdBufferOffset);
template <typename GfxFamily>
size_t getRequiredInjectionSize() noexcept;
template <typename GfxFamily>
size_t programExperimentalCommandBuffer();
void makeResidentAllocations();
protected:
template <typename GfxFamily>
size_t getTotalExperimentalSize() noexcept;
void getCS(size_t minRequiredSize);
template <typename GfxFamily>
void addTimeStampPipeControl();
template <typename GfxFamily>
size_t getTimeStampPipeControlSize() noexcept;
template <typename GfxFamily>
void addExperimentalCommands();
template <typename GfxFamily>
size_t getExperimentalCommandsSize() noexcept;
CommandStreamReceiver *commandStreamReceiver;
std::unique_ptr<LinearStream> currentStream;
GraphicsAllocation *timestamps;
uint32_t timestampsOffset = 0;
GraphicsAllocation *experimentalAllocation;
uint32_t experimentalAllocationOffset = 0;
bool defaultPrint = true;
double timerResolution;
};
} // namespace NEO

110
shared/source/command_stream/experimental_command_buffer.inl
View File

@@ -1,110 +0,0 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_container/command_encoder.h"
#include "shared/source/command_stream/command_stream_receiver_hw.h"
#include "shared/source/command_stream/experimental_command_buffer.h"
#include "shared/source/command_stream/linear_stream.h"
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/helpers/gfx_core_helper.h"
#include "shared/source/helpers/pipe_control_args.h"
#include "shared/source/memory_manager/graphics_allocation.h"
namespace NEO {
template <typename GfxFamily>
void ExperimentalCommandBuffer::injectBufferStart(LinearStream &parentStream, size_t cmdBufferOffset) {
using MI_BATCH_BUFFER_START = typename GfxFamily::MI_BATCH_BUFFER_START;
auto pCmd = parentStream.getSpaceForCmd<MI_BATCH_BUFFER_START>();
auto commandStreamReceiverHw = static_cast<CommandStreamReceiverHw<GfxFamily> *>(commandStreamReceiver);
commandStreamReceiverHw->addBatchBufferStart(pCmd, currentStream->getGraphicsAllocation()->getGpuAddress() + cmdBufferOffset, true);
}
template <typename GfxFamily>
size_t ExperimentalCommandBuffer::getRequiredInjectionSize() noexcept {
using MI_BATCH_BUFFER_START = typename GfxFamily::MI_BATCH_BUFFER_START;
return sizeof(MI_BATCH_BUFFER_START);
}
template <typename GfxFamily>
size_t ExperimentalCommandBuffer::programExperimentalCommandBuffer() {
using MI_BATCH_BUFFER_END = typename GfxFamily::MI_BATCH_BUFFER_END;
getCS(getTotalExperimentalSize<GfxFamily>());
size_t returnOffset = currentStream->getUsed();
// begin timestamp
addTimeStampPipeControl<GfxFamily>();
addExperimentalCommands<GfxFamily>();
// end timestamp
addTimeStampPipeControl<GfxFamily>();
// end
auto pCmd = currentStream->getSpaceForCmd<MI_BATCH_BUFFER_END>();
*pCmd = GfxFamily::cmdInitBatchBufferEnd;
return returnOffset;
}
template <typename GfxFamily>
size_t ExperimentalCommandBuffer::getTotalExperimentalSize() noexcept {
using MI_BATCH_BUFFER_END = typename GfxFamily::MI_BATCH_BUFFER_END;
size_t size = sizeof(MI_BATCH_BUFFER_END) + getTimeStampPipeControlSize<GfxFamily>() + getExperimentalCommandsSize<GfxFamily>();
return size;
}
template <typename GfxFamily>
size_t ExperimentalCommandBuffer::getTimeStampPipeControlSize() noexcept {
// Two P_C for timestamps
return 2 * MemorySynchronizationCommands<GfxFamily>::getSizeForBarrierWithPostSyncOperation(
*commandStreamReceiver->peekExecutionEnvironment().rootDeviceEnvironments[commandStreamReceiver->getRootDeviceIndex()], false);
}
template <typename GfxFamily>
void ExperimentalCommandBuffer::addTimeStampPipeControl() {
uint64_t timeStampAddress = timestamps->getGpuAddress() + timestampsOffset;
PipeControlArgs args;
MemorySynchronizationCommands<GfxFamily>::addBarrierWithPostSyncOperation(
*currentStream,
PostSyncMode::timestamp,
timeStampAddress,
0llu,
*commandStreamReceiver->peekExecutionEnvironment().rootDeviceEnvironments[commandStreamReceiver->getRootDeviceIndex()],
args);
// moving to next chunk
timestampsOffset += sizeof(uint64_t);
DEBUG_BREAK_IF(timestamps->getUnderlyingBufferSize() < timestampsOffset);
}
template <typename GfxFamily>
void ExperimentalCommandBuffer::addExperimentalCommands() {
using MI_SEMAPHORE_WAIT = typename GfxFamily::MI_SEMAPHORE_WAIT;
uint32_t *semaphoreData = reinterpret_cast<uint32_t *>(ptrOffset(experimentalAllocation->getUnderlyingBuffer(), experimentalAllocationOffset));
*semaphoreData = 1;
uint64_t gpuAddr = experimentalAllocation->getGpuAddress() + experimentalAllocationOffset;
EncodeSemaphore<GfxFamily>::programMiSemaphoreWait(currentStream->getSpaceForCmd<MI_SEMAPHORE_WAIT>(),
gpuAddr,
*semaphoreData,
MI_SEMAPHORE_WAIT::COMPARE_OPERATION_SAD_EQUAL_SDD,
false, false, false, false, false);
}
template <typename GfxFamily>
size_t ExperimentalCommandBuffer::getExperimentalCommandsSize() noexcept {
return NEO::EncodeSemaphore<GfxFamily>::getSizeMiSemaphoreWait();
}
} // namespace NEO

1
shared/source/debug_settings/debug_variables_base.inl
View File

@@ -105,7 +105,6 @@ DECLARE_DEBUG_VARIABLE(int64_t, WaitpkgCounterValue, -1, "-1: use default, >=0:
DECLARE_DEBUG_VARIABLE(int32_t, WaitpkgControlValue, -1, "-1: use default, 0: slower wakeup - larger power savings, 1: faster wakeup - smaller power savings")
DECLARE_DEBUG_VARIABLE(int32_t, ForceL1Caching, -1, "Program L1 cache policy for surface state and stateless accesses; values = -1: default, 0: disable, 1: enable")
DECLARE_DEBUG_VARIABLE(int32_t, ForceAuxTranslationEnabled, -1, "Require AUX translation for kernels; values = -1: default, 0: disabled, 1: enabled")
DECLARE_DEBUG_VARIABLE(int32_t, EnableExperimentalCommandBuffer, 0, "Inject experimental command buffer")
DECLARE_DEBUG_VARIABLE(int32_t, OverrideStatelessMocsIndex, -1, "Program provided MOCS index for stateless accesses in state base address for regular buffers; ignore when -1")
DECLARE_DEBUG_VARIABLE(int32_t, OverrideMocsIndexForScratchSpace, -1, "Program provided MOCS index for stateful accesses in surface state for scratch space; ignore when -1")
DECLARE_DEBUG_VARIABLE(int32_t, CFEFusedEUDispatch, -1, "Set Fused EU dispatch in FrontEnd State command; values = -1: default, 0: enabled, 1: disabled")

8
shared/source/device/device.cpp
View File

@@ -8,7 +8,6 @@
#include "shared/source/device/device.h"
#include "shared/source/command_stream/command_stream_receiver.h"
#include "shared/source/command_stream/experimental_command_buffer.h"
#include "shared/source/command_stream/preemption.h"
#include "shared/source/command_stream/submission_status.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
@@ -260,13 +259,6 @@ bool Device::createDeviceImpl() {
executionEnvironment->memoryManager->setForce32BitAllocations(getDeviceInfo().force32BitAddressess);
if (debugManager.flags.EnableExperimentalCommandBuffer.get() > 0) {
for (auto &engine : allEngines) {
auto csr = engine.commandStreamReceiver;
csr->setExperimentalCmdBuffer(std::make_unique<ExperimentalCommandBuffer>(csr, getDeviceInfo().profilingTimerResolution));
}
}
if (debugManager.flags.EnableSWTags.get() && !getRootDeviceEnvironment().tagsManager->isInitialized()) {
getRootDeviceEnvironment().tagsManager->initialize(*this);
}

27
shared/source/gen11/experimental_command_buffer_gen11.cpp
View File

@@ -1,27 +0,0 @@
/*
* Copyright (C) 2019-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_stream/experimental_command_buffer.h"
#include "shared/source/command_stream/experimental_command_buffer.inl"
#include "shared/source/gen11/hw_cmds.h"
#include "shared/source/helpers/gfx_core_helper.h"
namespace NEO {
typedef Gen11Family GfxFamily;
template void ExperimentalCommandBuffer::injectBufferStart<GfxFamily>(LinearStream &parentStream, size_t cmdBufferOffset);
template size_t ExperimentalCommandBuffer::getRequiredInjectionSize<GfxFamily>() noexcept;
template size_t ExperimentalCommandBuffer::programExperimentalCommandBuffer<GfxFamily>();
template size_t ExperimentalCommandBuffer::getTotalExperimentalSize<GfxFamily>() noexcept;
template void ExperimentalCommandBuffer::addTimeStampPipeControl<GfxFamily>();
template size_t ExperimentalCommandBuffer::getTimeStampPipeControlSize<GfxFamily>() noexcept;
template void ExperimentalCommandBuffer::addExperimentalCommands<GfxFamily>();
template size_t ExperimentalCommandBuffer::getExperimentalCommandsSize<GfxFamily>() noexcept;
} // namespace NEO

27
shared/source/gen12lp/experimental_command_buffer_gen12lp.cpp
View File

@@ -1,27 +0,0 @@
/*
* Copyright (C) 2019-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_stream/experimental_command_buffer.h"
#include "shared/source/command_stream/experimental_command_buffer.inl"
#include "shared/source/gen12lp/hw_cmds.h"
#include "shared/source/helpers/gfx_core_helper.h"
namespace NEO {
typedef Gen12LpFamily GfxFamily;
template void ExperimentalCommandBuffer::injectBufferStart<GfxFamily>(LinearStream &parentStream, size_t cmdBufferOffset);
template size_t ExperimentalCommandBuffer::getRequiredInjectionSize<GfxFamily>() noexcept;
template size_t ExperimentalCommandBuffer::programExperimentalCommandBuffer<GfxFamily>();
template size_t ExperimentalCommandBuffer::getTotalExperimentalSize<GfxFamily>() noexcept;
template void ExperimentalCommandBuffer::addTimeStampPipeControl<GfxFamily>();
template size_t ExperimentalCommandBuffer::getTimeStampPipeControlSize<GfxFamily>() noexcept;
template void ExperimentalCommandBuffer::addExperimentalCommands<GfxFamily>();
template size_t ExperimentalCommandBuffer::getExperimentalCommandsSize<GfxFamily>() noexcept;
} // namespace NEO

27
shared/source/gen8/experimental_command_buffer_gen8.cpp
View File

@@ -1,27 +0,0 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_stream/experimental_command_buffer.h"
#include "shared/source/command_stream/experimental_command_buffer.inl"
#include "shared/source/gen8/hw_cmds.h"
#include "shared/source/helpers/gfx_core_helper.h"
namespace NEO {
typedef Gen8Family GfxFamily;
template void ExperimentalCommandBuffer::injectBufferStart<GfxFamily>(LinearStream &parentStream, size_t cmdBufferOffset);
template size_t ExperimentalCommandBuffer::getRequiredInjectionSize<GfxFamily>() noexcept;
template size_t ExperimentalCommandBuffer::programExperimentalCommandBuffer<GfxFamily>();
template size_t ExperimentalCommandBuffer::getTotalExperimentalSize<GfxFamily>() noexcept;
template void ExperimentalCommandBuffer::addTimeStampPipeControl<GfxFamily>();
template size_t ExperimentalCommandBuffer::getTimeStampPipeControlSize<GfxFamily>() noexcept;
template void ExperimentalCommandBuffer::addExperimentalCommands<GfxFamily>();
template size_t ExperimentalCommandBuffer::getExperimentalCommandsSize<GfxFamily>() noexcept;
} // namespace NEO

27
shared/source/gen9/experimental_command_buffer_gen9.cpp
View File

@@ -1,27 +0,0 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_stream/experimental_command_buffer.h"
#include "shared/source/command_stream/experimental_command_buffer.inl"
#include "shared/source/gen9/hw_cmds.h"
#include "shared/source/helpers/gfx_core_helper.h"
namespace NEO {
typedef Gen9Family GfxFamily;
template void ExperimentalCommandBuffer::injectBufferStart<GfxFamily>(LinearStream &parentStream, size_t cmdBufferOffset);
template size_t ExperimentalCommandBuffer::getRequiredInjectionSize<GfxFamily>() noexcept;
template size_t ExperimentalCommandBuffer::programExperimentalCommandBuffer<GfxFamily>();
template size_t ExperimentalCommandBuffer::getTotalExperimentalSize<GfxFamily>() noexcept;
template void ExperimentalCommandBuffer::addTimeStampPipeControl<GfxFamily>();
template size_t ExperimentalCommandBuffer::getTimeStampPipeControlSize<GfxFamily>() noexcept;
template void ExperimentalCommandBuffer::addExperimentalCommands<GfxFamily>();
template size_t ExperimentalCommandBuffer::getExperimentalCommandsSize<GfxFamily>() noexcept;
} // namespace NEO

25
shared/source/xe_hpc_core/experimental_command_buffer_xe_hpc_core.cpp
View File

@@ -1,25 +0,0 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_stream/experimental_command_buffer.inl"
#include "shared/source/xe_hpc_core/hw_cmds_xe_hpc_core_base.h"
namespace NEO {
using GfxFamily = XeHpcCoreFamily;
template void ExperimentalCommandBuffer::injectBufferStart<GfxFamily>(LinearStream &parentStream, size_t cmdBufferOffset);
template size_t ExperimentalCommandBuffer::getRequiredInjectionSize<GfxFamily>() noexcept;
template size_t ExperimentalCommandBuffer::programExperimentalCommandBuffer<GfxFamily>();
template size_t ExperimentalCommandBuffer::getTotalExperimentalSize<GfxFamily>() noexcept;
template void ExperimentalCommandBuffer::addTimeStampPipeControl<GfxFamily>();
template size_t ExperimentalCommandBuffer::getTimeStampPipeControlSize<GfxFamily>() noexcept;
template void ExperimentalCommandBuffer::addExperimentalCommands<GfxFamily>();
template size_t ExperimentalCommandBuffer::getExperimentalCommandsSize<GfxFamily>() noexcept;
} // namespace NEO

25
shared/source/xe_hpg_core/experimental_command_buffer_xe_hpg_core.cpp
View File

@@ -1,25 +0,0 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_stream/experimental_command_buffer.inl"
#include "shared/source/xe_hpg_core/hw_cmds_xe_hpg_core_base.h"
namespace NEO {
typedef XeHpgCoreFamily GfxFamily;
template void ExperimentalCommandBuffer::injectBufferStart<GfxFamily>(LinearStream &parentStream, size_t cmdBufferOffset);
template size_t ExperimentalCommandBuffer::getRequiredInjectionSize<GfxFamily>() noexcept;
template size_t ExperimentalCommandBuffer::programExperimentalCommandBuffer<GfxFamily>();
template size_t ExperimentalCommandBuffer::getTotalExperimentalSize<GfxFamily>() noexcept;
template void ExperimentalCommandBuffer::addTimeStampPipeControl<GfxFamily>();
template size_t ExperimentalCommandBuffer::getTimeStampPipeControlSize<GfxFamily>() noexcept;
template void ExperimentalCommandBuffer::addExperimentalCommands<GfxFamily>();
template size_t ExperimentalCommandBuffer::getExperimentalCommandsSize<GfxFamily>() noexcept;
} // namespace NEO

3
shared/test/common/libult/ult_aub_command_stream_receiver.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2023 Intel Corporation
* Copyright (C) 2019-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -9,7 +9,6 @@
#include "shared/source/aub/aub_subcapture.h"
#include "shared/source/command_stream/aub_command_stream_receiver_hw.h"
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/test/common/mocks/mock_experimental_command_buffer.h"
namespace NEO {

1
shared/test/common/libult/ult_command_stream_receiver.h
View File

@@ -110,7 +110,6 @@ class UltCommandStreamReceiver : public CommandStreamReceiverHw<GfxFamily>, publ
using BaseClass::CommandStreamReceiver::doubleSbaWa;
using BaseClass::CommandStreamReceiver::downloadAllocationImpl;
using BaseClass::CommandStreamReceiver::executionEnvironment;
using BaseClass::CommandStreamReceiver::experimentalCmdBuffer;
using BaseClass::CommandStreamReceiver::feSupportFlags;
using BaseClass::CommandStreamReceiver::flushBcsTask;
using BaseClass::CommandStreamReceiver::flushStamp;

1
shared/test/common/mocks/CMakeLists.txt
View File

@@ -53,7 +53,6 @@ set(NEO_CORE_tests_mocks
${CMAKE_CURRENT_SOURCE_DIR}/mock_elf.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_execution_environment.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_execution_environment.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_experimental_command_buffer.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_gfx_partition.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_gfx_partition.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_gmm.h

28
shared/test/common/mocks/mock_experimental_command_buffer.h
View File

@@ -1,28 +0,0 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/command_stream/experimental_command_buffer.h"
namespace NEO {
class MockExperimentalCommandBuffer : public ExperimentalCommandBuffer {
using BaseClass = ExperimentalCommandBuffer;
public:
using BaseClass::currentStream;
using BaseClass::experimentalAllocation;
using BaseClass::experimentalAllocationOffset;
using BaseClass::timestamps;
using BaseClass::timestampsOffset;
MockExperimentalCommandBuffer(CommandStreamReceiver *csr) : ExperimentalCommandBuffer(csr, 80.0) {
defaultPrint = false;
}
};
} // namespace NEO

1
shared/test/common/test_files/igdrcl.config
View File

@@ -48,7 +48,6 @@ ForceL1Caching = -1
UseKmdMigration = -1
CreateKmdMigratedSharedAllocationWithMultipleBOs = -1
UseKmdMigrationForBuffers = -1
EnableExperimentalCommandBuffer = 0
OverrideStatelessMocsIndex = -1
OverrideMocsIndexForScratchSpace = -1
CFEFusedEUDispatch = -1