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

Revert "performance: Use lock pointer copy with sfence for dc flush mitigation"

Browse Source 
This reverts commit 8c3c703ec0.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation
2024-10-26 14:04:44 +02:00
committed by Compute-Runtime-Automation
parent ebdded1bb9
commit f5c433c8f8
5 changed files with 20 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
opencl/source/mem_obj/buffer.cpp
View File

@@ -24,7 +24,6 @@
#include "shared/source/memory_manager/memory_operations_handler.h"
#include "shared/source/memory_manager/migration_sync_data.h"
#include "shared/source/os_interface/os_interface.h"
#include "shared/source/utilities/cpuintrinsics.h"
#include "opencl/source/cl_device/cl_device.h"
#include "opencl/source/command_queue/command_queue.h"
@@ -213,7 +212,8 @@ bool inline copyHostPointer(Buffer *buffer,
size <= Buffer::maxBufferSizeForCopyOnCpu &&
isCompressionEnabled == false &&
productHelper.getLocalMemoryAccessMode(hwInfo) != LocalMemoryAccessMode::cpuAccessDisallowed &&
isLockable;
isLockable &&
!isGpuCopyRequiredForDcFlushMitigation;
if (debugManager.flags.CopyHostPtrOnCpu.get() != -1) {
copyOnCpuAllowed = debugManager.flags.CopyHostPtrOnCpu.get() == 1;
@@ -222,11 +222,6 @@ bool inline copyHostPointer(Buffer *buffer,
memory->setAubWritable(true, GraphicsAllocation::defaultBank);
memory->setTbxWritable(true, GraphicsAllocation::defaultBank);
memcpy_s(ptrOffset(lockedPointer, buffer->getOffset()), size, hostPtr, size);
if (isGpuCopyRequiredForDcFlushMitigation) {
CpuIntrinsics::sfence();
}
return true;
} else {
auto blitMemoryToAllocationResult = BlitOperationResult::unsupported;

2
opencl/test/unit_test/libult/command_queue_ult.cpp
View File

@@ -20,7 +20,7 @@ bool CommandQueue::isTimestampWaitEnabled() {
}
bool checkIsGpuCopyRequiredForDcFlushMitigation(AllocationType type) {
return ultHwConfig.useGpuCopyForDcFlushMitigation;
return false;
}
} // namespace NEO

30
opencl/test/unit_test/mem_obj/buffer_tests.cpp
View File

@@ -599,22 +599,26 @@ TEST(Buffer, givenClMemCopyHostPointerPassedToBufferCreateWhenAllocationIsNotInS
}
}
namespace CpuIntrinsicsTests {
extern std::atomic<uint32_t> sfenceCounter;
} // namespace CpuIntrinsicsTests
TEST(Buffer, givenDcFlushMitigationWhenCreateBufferCopyHostptrThenUseLockPointerCopyWithSfence) {
TEST(Buffer, givenDcFlushMitigationWhenCreateBufferCopyHostptrThenUseBlitterCopy) {
DebugManagerStateRestore restorer;
debugManager.flags.AllowDcFlush.set(0);
ExecutionEnvironment *executionEnvironment = MockClDevice::prepareExecutionEnvironment(defaultHwInfo.get(), 0u);
executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo()->capabilityTable.blitterOperationsSupported = true;
auto productHelper = executionEnvironment->rootDeviceEnvironments[0]->productHelper.get();
if (!productHelper->isDcFlushMitigated()) {
if (!(productHelper->isBlitterFullySupported(*defaultHwInfo) && productHelper->isDcFlushMitigated())) {
GTEST_SKIP();
}
VariableBackup<UltHwConfig> backup(&ultHwConfig);
ultHwConfig.useGpuCopyForDcFlushMitigation = true;
DebugManagerStateRestore restorer;
debugManager.flags.AllowDcFlush.set(0);
auto blitterCalled = 0u;
auto mockBlitMemoryToAllocation = [&](const NEO::Device &device, NEO::GraphicsAllocation *memory, size_t offset, const void *hostPtr,
Vec3<size_t> size) -> NEO::BlitOperationResult {
memcpy(memory->getUnderlyingBuffer(), hostPtr, size.x);
blitterCalled++;
return BlitOperationResult::success;
};
VariableBackup<NEO::BlitHelperFunctions::BlitMemoryToAllocationFunc> blitMemoryToAllocationFuncBackup(
&NEO::BlitHelperFunctions::blitMemoryToAllocation, mockBlitMemoryToAllocation);
auto *memoryManager = new MockMemoryManagerFailFirstAllocation(*executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager);
@@ -622,7 +626,6 @@ TEST(Buffer, givenDcFlushMitigationWhenCreateBufferCopyHostptrThenUseLockPointer
auto device = std::make_unique<MockClDevice>(MockDevice::create<MockDevice>(executionEnvironment, 0));
MockContext ctx(device.get());
CpuIntrinsicsTests::sfenceCounter.store(0u);
cl_int retVal = 0;
cl_mem_flags flags = CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR;
@@ -631,8 +634,7 @@ TEST(Buffer, givenDcFlushMitigationWhenCreateBufferCopyHostptrThenUseLockPointer
std::unique_ptr<Buffer> buffer(Buffer::create(&ctx, flags, sizeof(memory), memory, retVal));
ASSERT_NE(nullptr, buffer.get());
EXPECT_EQ(1u, CpuIntrinsicsTests::sfenceCounter.load());
CpuIntrinsicsTests::sfenceCounter.store(0u);
EXPECT_EQ(blitterCalled, 1u);
}
TEST(Buffer, givenPropertiesWithClDeviceHandleListKHRWhenCreateBufferThenCorrectBufferIsSet) {

2
shared/test/common/base_ult_config_listener.cpp
View File

@@ -50,7 +50,7 @@ void BaseUltConfigListener::OnTestEnd(const ::testing::TestInfo &) {
// Ensure that global state is restored
UltHwConfig expectedState{};
static_assert(sizeof(UltHwConfig) == (17 * sizeof(bool) + sizeof(const char *)) + sizeof(UltHwConfig::padding), ""); // Ensure that there is no internal padding
static_assert(sizeof(UltHwConfig) == (16 * sizeof(bool) + sizeof(const char *)), ""); // Ensure that there is no internal padding
EXPECT_EQ(0, memcmp(&expectedState, &ultHwConfig, sizeof(UltHwConfig)));
EXPECT_EQ(0, memcmp(&referencedHwInfo.platform, &defaultHwInfo->platform, sizeof(PLATFORM)));

3
shared/test/common/helpers/ult_hw_config.h
View File

@@ -16,7 +16,6 @@ struct UltHwConfig {
bool useWaitForTimestamps = false;
bool useBlitSplit = false;
bool useFirstSubmissionInitDevice = false;
bool useGpuCopyForDcFlushMitigation = false;
bool csrFailInitDirectSubmission = false;
bool csrBaseCallDirectSubmissionAvailable = false;
@@ -29,8 +28,6 @@ struct UltHwConfig {
bool csrCreatePreemptionReturnValue = true;
bool reserved = false;
char padding[7];
const char *aubTestName = nullptr;
};