intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-21 09:14:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

performance: change buffer type for new coherency model

Browse Source 
Related-To: NEO-11882

Signed-off-by: Szymon Morek <szymon.morek@intel.com>
This commit is contained in:
Szymon Morek
2024-07-02 07:50:14 +00:00
committed by Compute-Runtime-Automation
parent b4903a9a0f
commit c979495265
10 changed files with 143 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -339,12 +339,14 @@ Buffer *Buffer::create(Context *context,
auto &rootDeviceEnvironment = *executionEnvironment.rootDeviceEnvironments[rootDeviceIndex];
auto hwInfo = rootDeviceEnvironment.getHardwareInfo();
auto &gfxCoreHelper = rootDeviceEnvironment.getHelper<GfxCoreHelper>();
auto &productHelper = rootDeviceEnvironment.getHelper<ProductHelper>();
bool compressionEnabled = MemObjHelper::isSuitableForCompression(GfxCoreHelper::compressedBuffersSupported(*hwInfo), memoryProperties, *context,
gfxCoreHelper.isBufferSizeSuitableForCompression(size));
auto isNewCoherencyModelSupported = productHelper.isNewCoherencyModelSupported();
allocationInfo.allocationType = getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled,
memoryManager->isLocalMemorySupported(rootDeviceIndex));
memoryManager->isLocalMemorySupported(rootDeviceIndex),
isNewCoherencyModelSupported);
if (allocationCpuPtr) {
forceCopyHostPtr = !useHostPtr && !copyHostPtr;
@@ -372,6 +374,9 @@ Buffer *Buffer::create(Context *context,
allocationInfo.zeroCopyAllowed = false;
allocationInfo.allocateMemory = true;
}
} else if (isNewCoherencyModelSupported) {
allocationInfo.zeroCopyAllowed = false;
allocationInfo.allocateMemory = true;
}
if (debugManager.flags.DisableZeroCopyForUseHostPtr.get()) {
@@ -638,13 +643,14 @@ void Buffer::checkMemory(const MemoryProperties &memoryProperties,
}
AllocationType Buffer::getGraphicsAllocationTypeAndCompressionPreference(const MemoryProperties &properties,
bool &compressionEnabled, bool isLocalMemoryEnabled) {
bool &compressionEnabled, bool isLocalMemoryEnabled,
bool isNewCoherencyModelSupported) {
if (properties.flags.forceHostMemory) {
compressionEnabled = false;
return AllocationType::bufferHostMemory;
}
if (properties.flags.useHostPtr && !isLocalMemoryEnabled) {
if (properties.flags.useHostPtr && (!isLocalMemoryEnabled && !isNewCoherencyModelSupported)) {
compressionEnabled = false;
return AllocationType::bufferHostMemory;
}

3
opencl/source/mem_obj/buffer.h
View File

@@ -208,7 +208,8 @@ class Buffer : public MemObj {
uint32_t rootDeviceIndex,
bool forceCopyHostPtr);
static AllocationType getGraphicsAllocationTypeAndCompressionPreference(const MemoryProperties &properties,
bool &compressionEnabled, bool localMemoryEnabled);
bool &compressionEnabled, bool localMemoryEnabled,
bool isNewCoherencyModelSupported);
static bool isReadOnlyMemoryPermittedByFlags(const MemoryProperties &properties);
void transferData(void *dst, void *src, size_t copySize, size_t copyOffset);

8
opencl/test/unit_test/api/cl_create_buffer_tests.cpp
View File

@@ -470,7 +470,7 @@ TEST_F(ClCreateBufferTests, WhenCreatingBufferWithPropertiesThenPropertiesAreCor
using clCreateBufferTestsWithRestrictions = api_test_using_aligned_memory_manager;
TEST_F(clCreateBufferTestsWithRestrictions, GivenMemoryManagerRestrictionsWhenMinIsLessThanHostPtrThenUseZeroCopy) {
TEST_F(clCreateBufferTestsWithRestrictions, GivenMemoryManagerRestrictionsAndOldCoherencyModelWhenMinIsLessThanHostPtrThenUseZeroCopy) {
std::unique_ptr<unsigned char[]> hostMem(nullptr);
unsigned char *destMem = nullptr;
cl_mem_flags flags = CL_MEM_USE_HOST_PTR;
@@ -495,7 +495,13 @@ TEST_F(clCreateBufferTestsWithRestrictions, GivenMemoryManagerRestrictionsWhenMi
EXPECT_NE(nullptr, buffer);
Buffer *bufferObj = NEO::castToObject<Buffer>(buffer);
auto &productHelper = device->getProductHelper();
if (productHelper.isNewCoherencyModelSupported()) {
EXPECT_FALSE(bufferObj->isMemObjZeroCopy());
} else {
EXPECT_TRUE(bufferObj->isMemObjZeroCopy());
}
retVal = clReleaseMemObject(buffer);
EXPECT_EQ(CL_SUCCESS, retVal);

20
opencl/test/unit_test/command_queue/read_write_buffer_cpu_copy.cpp
View File

@@ -136,7 +136,7 @@ HWTEST_F(ReadWriteBufferCpuCopyTest, GivenUnalignedSrcPtrWhenWritingBufferThenMe
delete[] bufferPtrBase;
}
HWTEST_F(ReadWriteBufferCpuCopyTest, GivenSpecificMemoryStructuresWhenReadingWritingMemoryThenCpuReadWriteIsAllowed) {
HWTEST_F(ReadWriteBufferCpuCopyTest, GivenSpecificMemoryStructuresAndOldCoherencyModelWhenReadingWritingMemoryThenCpuReadWriteIsAllowed) {
DebugManagerStateRestore restorer;
debugManager.flags.ForceLocalMemoryAccessMode.set(static_cast<int32_t>(LocalMemoryAccessMode::defaultMode));
cl_int retVal;
@@ -152,13 +152,14 @@ HWTEST_F(ReadWriteBufferCpuCopyTest, GivenSpecificMemoryStructuresWhenReadingWri
auto mockContext = std::unique_ptr<MockContext>(new MockContext(mockDevice.get()));
auto memoryManager = static_cast<OsAgnosticMemoryManager *>(mockDevice->getMemoryManager());
memoryManager->turnOnFakingBigAllocations();
auto &productHelper = mockDevice->getProductHelper();
auto isZeroCopyAllowed = !productHelper.isNewCoherencyModelSupported();
std::unique_ptr<Buffer> buffer(Buffer::create(context, CL_MEM_USE_HOST_PTR, size, alignedBufferPtr, retVal));
EXPECT_EQ(retVal, CL_SUCCESS);
EXPECT_TRUE(buffer->isMemObjZeroCopy());
EXPECT_EQ(isZeroCopyAllowed, buffer->isMemObjZeroCopy());
// zeroCopy == true && aligned/unaligned hostPtr
EXPECT_TRUE(buffer->isReadWriteOnCpuPreferred(alignedHostPtr, MemoryConstants::cacheLineSize + 1, mockDevice->getDevice()));
EXPECT_EQ(isZeroCopyAllowed, buffer->isReadWriteOnCpuPreferred(alignedHostPtr, MemoryConstants::cacheLineSize + 1, mockDevice->getDevice()));
EXPECT_TRUE(buffer->isReadWriteOnCpuPreferred(unalignedHostPtr, MemoryConstants::cacheLineSize, mockDevice->getDevice()));
buffer.reset(Buffer::create(context, CL_MEM_USE_HOST_PTR, size, unalignedBufferPtr, retVal));
@@ -172,11 +173,11 @@ HWTEST_F(ReadWriteBufferCpuCopyTest, GivenSpecificMemoryStructuresWhenReadingWri
// platform LP == true && size <= 10 MB
mockDevice->deviceInfo.platformLP = true;
EXPECT_TRUE(buffer->isReadWriteOnCpuPreferred(smallBufferPtr, 1 * MemoryConstants::megaByte, mockDevice->getDevice()));
EXPECT_EQ(isZeroCopyAllowed, buffer->isReadWriteOnCpuPreferred(smallBufferPtr, 1 * MemoryConstants::megaByte, mockDevice->getDevice()));
// platform LP == false && size <= 10 MB
mockDevice->deviceInfo.platformLP = false;
EXPECT_TRUE(buffer->isReadWriteOnCpuPreferred(smallBufferPtr, 1 * MemoryConstants::megaByte, mockDevice->getDevice()));
EXPECT_EQ(isZeroCopyAllowed, buffer->isReadWriteOnCpuPreferred(smallBufferPtr, 1 * MemoryConstants::megaByte, mockDevice->getDevice()));
buffer.reset(Buffer::create(mockContext.get(), CL_MEM_ALLOC_HOST_PTR, largeBufferSize, nullptr, retVal));
@@ -189,7 +190,7 @@ HWTEST_F(ReadWriteBufferCpuCopyTest, GivenSpecificMemoryStructuresWhenReadingWri
alignedFree(alignedBufferPtr);
}
HWTEST_F(ReadWriteBufferCpuCopyTest, GivenSpecificMemoryStructuresWhenReadingWritingMemoryThenCpuReadWriteIsNotAllowed) {
HWTEST_F(ReadWriteBufferCpuCopyTest, GivenSpecificMemoryStructuresAndOldCoherencyModelWhenReadingWritingMemoryThenCpuReadWriteIsNotAllowed) {
cl_int retVal;
size_t size = MemoryConstants::cacheLineSize;
auto alignedBufferPtr = alignedMalloc(MemoryConstants::cacheLineSize + 1, MemoryConstants::cacheLineSize);
@@ -204,10 +205,11 @@ HWTEST_F(ReadWriteBufferCpuCopyTest, GivenSpecificMemoryStructuresWhenReadingWri
auto memoryManager = static_cast<OsAgnosticMemoryManager *>(mockDevice->getMemoryManager());
memoryManager->turnOnFakingBigAllocations();
auto &productHelper = mockDevice->getProductHelper();
auto isZeroCopyAllowed = !productHelper.isNewCoherencyModelSupported();
std::unique_ptr<Buffer> buffer(Buffer::create(context, CL_MEM_USE_HOST_PTR, size, alignedBufferPtr, retVal));
EXPECT_EQ(retVal, CL_SUCCESS);
EXPECT_TRUE(buffer->isMemObjZeroCopy());
EXPECT_EQ(isZeroCopyAllowed, buffer->isMemObjZeroCopy());
// non blocking
EXPECT_FALSE(mockCommandQueue->bufferCpuCopyAllowed(buffer.get(), CL_COMMAND_NDRANGE_KERNEL, false, size, unalignedHostPtr, 0u, nullptr));

25
opencl/test/unit_test/context/driver_diagnostics_enqueue_tests.cpp
View File

@@ -148,7 +148,11 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenNonBlockingReadAndSharedMemWhenEnq
nullptr,
nullptr);
if (isZeroCopyAllowed) {
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_READ_BUFFER_RECT_DOESNT_REQUIRES_COPY_DATA], static_cast<cl_mem>(buffer), address);
} else {
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_BUFFER_DOESNT_MEET_ALIGNMENT_RESTRICTIONS], address, MemoryConstants::cacheLineSize, MemoryConstants::pageSize, MemoryConstants::pageSize);
}
EXPECT_TRUE(containsHint(expectedHint, userData));
}
@@ -184,7 +188,11 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenNonBlockingWriteAndBufferSharesMem
0,
nullptr,
nullptr);
if (isZeroCopyAllowed) {
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_WRITE_BUFFER_DOESNT_REQUIRE_COPY_DATA], static_cast<cl_mem>(buffer), address);
} else {
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_WRITE_BUFFER_REQUIRES_COPY_DATA], static_cast<cl_mem>(buffer), address);
}
EXPECT_TRUE(containsHint(expectedHint, userData));
}
@@ -220,7 +228,11 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenBlockingWriteAndBufferSharesMemWit
0,
nullptr,
nullptr);
if (isZeroCopyAllowed) {
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_WRITE_BUFFER_DOESNT_REQUIRE_COPY_DATA], static_cast<cl_mem>(buffer), address);
} else {
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_WRITE_BUFFER_REQUIRES_COPY_DATA], static_cast<cl_mem>(buffer), address);
}
EXPECT_TRUE(containsHint(expectedHint, userData));
}
@@ -256,7 +268,11 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenNonBlockingReadAndBufferSharesMemW
0,
nullptr,
nullptr);
if (isZeroCopyAllowed) {
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_READ_BUFFER_DOESNT_REQUIRE_COPY_DATA], static_cast<cl_mem>(buffer), address);
} else {
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_READ_BUFFER_REQUIRES_COPY_DATA], static_cast<cl_mem>(buffer), address);
}
EXPECT_TRUE(containsHint(expectedHint, userData));
}
@@ -292,7 +308,11 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenBlockingReadAndBufferSharesMemWith
0,
nullptr,
nullptr);
if (isZeroCopyAllowed) {
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_READ_BUFFER_DOESNT_REQUIRE_COPY_DATA], static_cast<cl_mem>(buffer), address);
} else {
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_READ_BUFFER_REQUIRES_COPY_DATA], static_cast<cl_mem>(buffer), address);
}
EXPECT_TRUE(containsHint(expectedHint, userData));
}
@@ -343,8 +363,11 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenNonBlockingWriteAndSharedMemWhenEn
0,
nullptr,
nullptr);
if (isZeroCopyAllowed) {
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_WRITE_BUFFER_RECT_DOESNT_REQUIRE_COPY_DATA], static_cast<cl_mem>(buffer));
} else {
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_WRITE_BUFFER_RECT_REQUIRES_COPY_DATA], static_cast<cl_mem>(buffer));
}
EXPECT_TRUE(containsHint(expectedHint, userData));
}

6
opencl/test/unit_test/context/driver_diagnostics_tests.h
View File

@@ -141,6 +141,8 @@ struct PerformanceHintEnqueueBufferTest : public PerformanceHintEnqueueTest {
MemoryConstants::cacheLineSize,
address,
retVal);
auto &productHelper = context->getDevice(0)->getProductHelper();
isZeroCopyAllowed = !productHelper.isNewCoherencyModelSupported();
}
void TearDown() override {
@@ -150,6 +152,7 @@ struct PerformanceHintEnqueueBufferTest : public PerformanceHintEnqueueTest {
}
void *address = nullptr;
Buffer *buffer = nullptr;
bool isZeroCopyAllowed = true;
};
struct PerformanceHintEnqueueReadBufferTest : public PerformanceHintEnqueueBufferTest,
@@ -215,6 +218,9 @@ struct PerformanceHintEnqueueMapTest : public PerformanceHintEnqueueTest,
if (context->getDevice(0)->getRootDeviceEnvironment().getProductHelper().isDcFlushMitigated()) {
GTEST_SKIP();
}
if (context->getDevice(0)->getRootDeviceEnvironment().getProductHelper().isNewCoherencyModelSupported()) {
GTEST_SKIP();
}
}
void TearDown() override {

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

@@ -440,7 +440,7 @@ TEST(Buffer, givenCompressedBuffersEnabledWhenAllocationTypeIsQueriedThenBufferC
bool compressionEnabled = MemObjHelper::isSuitableForCompression(true, memoryProperties, context, true);
EXPECT_TRUE(compressionEnabled);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, false);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, false, false);
EXPECT_TRUE(compressionEnabled);
EXPECT_EQ(AllocationType::buffer, type);
}
@@ -453,7 +453,7 @@ TEST(Buffer, givenCompressedBuffersDisabledLocalMemoryEnabledWhenAllocationTypeI
bool compressionEnabled = MemObjHelper::isSuitableForCompression(false, memoryProperties, context, true);
EXPECT_FALSE(compressionEnabled);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, true);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, true, false);
EXPECT_FALSE(compressionEnabled);
EXPECT_EQ(AllocationType::buffer, type);
}
@@ -467,7 +467,7 @@ TEST(Buffer, givenUseHostPtrFlagAndLocalMemoryDisabledWhenAllocationTypeIsQuerie
bool compressionEnabled = MemObjHelper::isSuitableForCompression(false, memoryProperties, context, true);
EXPECT_FALSE(compressionEnabled);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, false);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, false, false);
EXPECT_FALSE(compressionEnabled);
EXPECT_EQ(AllocationType::bufferHostMemory, type);
}
@@ -481,7 +481,7 @@ TEST(Buffer, givenUseHostPtrFlagAndLocalMemoryEnabledWhenAllocationTypeIsQueried
bool compressionEnabled = MemObjHelper::isSuitableForCompression(false, memoryProperties, context, true);
EXPECT_FALSE(compressionEnabled);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, true);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, true, false);
EXPECT_FALSE(compressionEnabled);
EXPECT_EQ(AllocationType::buffer, type);
}
@@ -495,7 +495,7 @@ TEST(Buffer, givenAllocHostPtrFlagWhenAllocationTypeIsQueriedThenBufferTypeIsRet
bool compressionEnabled = MemObjHelper::isSuitableForCompression(false, memoryProperties, context, true);
EXPECT_FALSE(compressionEnabled);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, false);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, false, false);
EXPECT_FALSE(compressionEnabled);
EXPECT_EQ(AllocationType::buffer, type);
}
@@ -509,7 +509,7 @@ TEST(Buffer, givenUseHostPtrFlagAndLocalMemoryDisabledAndCompressedBuffersEnable
bool compressionEnabled = MemObjHelper::isSuitableForCompression(true, memoryProperties, context, true);
EXPECT_TRUE(compressionEnabled);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, false);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, false, false);
EXPECT_FALSE(compressionEnabled);
EXPECT_EQ(AllocationType::bufferHostMemory, type);
}
@@ -523,7 +523,7 @@ TEST(Buffer, givenUseHostPtrFlagAndLocalMemoryEnabledAndCompressedBuffersEnabled
bool compressionEnabled = MemObjHelper::isSuitableForCompression(true, memoryProperties, context, true);
EXPECT_TRUE(compressionEnabled);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, true);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, true, false);
EXPECT_TRUE(compressionEnabled);
EXPECT_EQ(AllocationType::buffer, type);
}
@@ -537,7 +537,7 @@ TEST(Buffer, givenUseHostPointerFlagAndForceSharedPhysicalStorageWhenLocalMemory
bool compressionEnabled = MemObjHelper::isSuitableForCompression(true, memoryProperties, context, true);
EXPECT_TRUE(compressionEnabled);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, true);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, true, false);
EXPECT_FALSE(compressionEnabled);
EXPECT_EQ(AllocationType::bufferHostMemory, type);
}
@@ -551,7 +551,7 @@ TEST(Buffer, givenAllocHostPtrFlagAndCompressedBuffersEnabledWhenAllocationTypeI
bool compressionEnabled = MemObjHelper::isSuitableForCompression(true, memoryProperties, context, true);
EXPECT_TRUE(compressionEnabled);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, false);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, false, false);
EXPECT_TRUE(compressionEnabled);
EXPECT_EQ(AllocationType::buffer, type);
}
@@ -564,11 +564,24 @@ TEST(Buffer, givenZeroFlagsNoSharedContextAndCompressedBuffersDisabledWhenAlloca
bool compressionEnabled = MemObjHelper::isSuitableForCompression(false, memoryProperties, context, true);
EXPECT_FALSE(compressionEnabled);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, false);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, false, false);
EXPECT_FALSE(compressionEnabled);
EXPECT_EQ(AllocationType::buffer, type);
}
TEST(Buffer, givenUseHostPtrFlagAndLocalMemoryDisabledAndCompressedBuffersEnabledAndNewCoherencyModelEnabledWhenAllocationTypeIsQueriedThenBufferMemoryTypeIsReturned) {
cl_mem_flags flags = CL_MEM_USE_HOST_PTR;
MockContext context;
MemoryProperties memoryProperties = ClMemoryPropertiesHelper::createMemoryProperties(flags, 0, 0, &context.getDevice(0)->getDevice());
bool compressionEnabled = MemObjHelper::isSuitableForCompression(true, memoryProperties, context, true);
EXPECT_TRUE(compressionEnabled);
auto type = MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(memoryProperties, compressionEnabled, false, true);
EXPECT_TRUE(compressionEnabled);
EXPECT_EQ(AllocationType::buffer, type);
}
TEST(Buffer, givenClMemCopyHostPointerPassedToBufferCreateWhenAllocationIsNotInSystemMemoryPoolAndCopyOnCpuDisabledThenAllocationIsWrittenByEnqueueWriteBuffer) {
DebugManagerStateRestore restorer;
debugManager.flags.CopyHostPtrOnCpu.set(0);
@@ -1359,10 +1372,15 @@ TEST(Buffers64on32Tests, given32BitBufferCreatedWithUseHostPtrFlagThatIsZeroCopy
(void *)offsetedPtr,
retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_TRUE(buffer->isMemObjZeroCopy());
EXPECT_EQ((void *)offsetedPtr, buffer->getCpuAddressForMapping());
auto &productHelper = context.getDevice(0)->getProductHelper();
if (productHelper.isNewCoherencyModelSupported()) {
EXPECT_FALSE(buffer->isMemObjZeroCopy());
} else {
EXPECT_TRUE(buffer->isMemObjZeroCopy());
EXPECT_EQ((void *)offsetedPtr, buffer->getCpuAddressForMemoryTransfer());
}
delete buffer;
debugManager.flags.Force32bitAddressing.set(false);

4
opencl/test/unit_test/mem_obj/mem_obj_helper_tests.cpp
View File

@@ -431,7 +431,7 @@ TEST(MemObjHelper, givenDifferentCapabilityAndDebugFlagValuesWhenCheckingBufferC
bool compressionEnabled = MemObjHelper::isSuitableForCompression(GfxCoreHelper::compressedBuffersSupported(*defaultHwInfo), memoryProperties, context, true);
MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(
memoryProperties, compressionEnabled, false);
memoryProperties, compressionEnabled, false, false);
bool expectBufferCompressed = ftrRenderCompressedBuffers && (enableMultiTileCompressionValue == 1);
if (expectBufferCompressed) {
@@ -483,7 +483,7 @@ TEST(MemObjHelper, givenDifferentValuesWhenCheckingBufferCompressionSupportThenC
bool compressionEnabled = MemObjHelper::isSuitableForCompression(GfxCoreHelper::compressedBuffersSupported(*defaultHwInfo), memoryProperties, context, true);
MockPublicAccessBuffer::getGraphicsAllocationTypeAndCompressionPreference(
memoryProperties, compressionEnabled, false);
memoryProperties, compressionEnabled, false, false);
bool isCompressionDisabled = isValueSet(flags, CL_MEM_UNCOMPRESSED_HINT_INTEL) ||
isValueSet(flagsIntel, CL_MEM_UNCOMPRESSED_HINT_INTEL);

14
opencl/test/unit_test/mem_obj/zero_copy_tests.cpp
View File

@@ -13,6 +13,7 @@
#include "opencl/source/cl_device/cl_device.h"
#include "opencl/source/mem_obj/buffer.h"
#include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
#include "opencl/test/unit_test/mocks/mock_cl_device.h"
#include "opencl/test/unit_test/mocks/mock_context.h"
#include "gtest/gtest.h"
@@ -83,6 +84,10 @@ TEST_P(ZeroCopyBufferTest, GivenCacheAlignedPointerWhenCreatingBufferThenZeroCop
passedPtr,
retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
auto &productHelper = pClDevice->getProductHelper();
if (flags & CL_MEM_USE_HOST_PTR) {
shouldBeZeroCopy = shouldBeZeroCopy && !productHelper.isNewCoherencyModelSupported();
}
EXPECT_EQ(shouldBeZeroCopy, buffer->isMemObjZeroCopy()) << "Zero Copy not handled properly";
if (!shouldBeZeroCopy && flags & CL_MEM_USE_HOST_PTR) {
EXPECT_NE(buffer->getCpuAddress(), hostPtr);
@@ -148,7 +153,7 @@ TEST(ZeroCopyWithDebugFlag, GivenBufferInputsThatWouldResultInZeroCopyAndDisable
EXPECT_NE(mapAllocation, bufferAllocation);
}
TEST(ZeroCopyBufferWith32BitAddressing, GivenDeviceSupporting32BitAddressingWhenAskedForBufferCreationFromHostPtrThenNonZeroCopyBufferIsReturned) {
TEST(ZeroCopyBufferWith32BitAddressing, GivenDeviceSupporting32BitAddressingAndOldCoherencyModelWhenAskedForBufferCreationFromHostPtrThenNonZeroCopyBufferIsReturned) {
DebugManagerStateRestore dbgRestorer;
debugManager.flags.Force32bitAddressing.set(true);
MockContext context;
@@ -158,8 +163,13 @@ TEST(ZeroCopyBufferWith32BitAddressing, GivenDeviceSupporting32BitAddressingWhen
std::unique_ptr<Buffer> buffer(Buffer::create(&context, CL_MEM_USE_HOST_PTR, size, hostPtr, retVal));
EXPECT_EQ(CL_SUCCESS, retVal);
auto &productHelper = context.getDevice(0)->getProductHelper();
if (productHelper.isNewCoherencyModelSupported()) {
EXPECT_FALSE(buffer->isMemObjZeroCopy());
} else {
EXPECT_TRUE(buffer->isMemObjZeroCopy());
}
if constexpr (is64bit) {
EXPECT_TRUE(buffer->getGraphicsAllocation(context.getDevice(0)->getRootDeviceIndex())->is32BitAllocation());
}

37
opencl/test/unit_test/os_interface/linux/cl_drm_memory_manager_tests.cpp
View File

@@ -96,10 +96,16 @@ TEST_F(ClDrmMemoryManagerTest, Given32bitAllocatorWhenAskedForBufferAllocationTh
TEST_F(ClDrmMemoryManagerTest, Given32bitAllocatorWhenAskedForBufferCreatedFromHostPtrThen32BitBufferIsReturned) {
DebugManagerStateRestore dbgRestorer;
auto isNewCoherencyModelSupported = pClDevice->getProductHelper().isNewCoherencyModelSupported();
mock->ioctlExpected.gemUserptr = 1;
mock->ioctlExpected.gemWait = 1;
mock->ioctlExpected.gemClose = 1;
if (isNewCoherencyModelSupported) {
mock->ioctlExpected.gemUserptr = 2;
mock->ioctlExpected.gemWait = 2;
mock->ioctlExpected.gemClose = 2;
}
debugManager.flags.Force32bitAddressing.set(true);
MockContext context(pClDevice);
memoryManager->setForce32BitAllocations(true);
@@ -118,7 +124,6 @@ TEST_F(ClDrmMemoryManagerTest, Given32bitAllocatorWhenAskedForBufferCreatedFromH
retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_TRUE(buffer->isMemObjZeroCopy());
auto bufferAddress = buffer->getGraphicsAllocation(rootDeviceIndex)->getGpuAddress();
auto drmAllocation = static_cast<DrmAllocation *>(buffer->getGraphicsAllocation(rootDeviceIndex));
@@ -135,15 +140,20 @@ TEST_F(ClDrmMemoryManagerTest, Given32bitAllocatorWhenAskedForBufferCreatedFromH
auto bufferObject = drmAllocation->getBO();
EXPECT_EQ(drmAllocation->getUnderlyingBuffer(), reinterpret_cast<void *>(offsetedPtr));
// Gpu address should be different
EXPECT_NE(offsetedPtr, drmAllocation->getGpuAddress());
if (isNewCoherencyModelSupported) {
EXPECT_FALSE(buffer->isMemObjZeroCopy());
EXPECT_EQ(allocationGpuOffset, 0ull);
EXPECT_EQ(allocationPageOffset, 0ull);
} else {
EXPECT_TRUE(buffer->isMemObjZeroCopy());
EXPECT_EQ(drmAllocation->getUnderlyingBuffer(), reinterpret_cast<void *>(offsetedPtr));
// Gpu address offset iqual to cpu offset
EXPECT_EQ(allocationGpuOffset, ptrOffset);
EXPECT_EQ(allocationPageOffset, ptrOffset);
}
auto boAddress = bufferObject->peekAddress();
EXPECT_EQ(alignDown(boAddress, MemoryConstants::pageSize), boAddress);
@@ -152,6 +162,7 @@ TEST_F(ClDrmMemoryManagerTest, Given32bitAllocatorWhenAskedForBufferCreatedFromH
TEST_F(ClDrmMemoryManagerTest, Given32bitAllocatorWhenAskedForBufferCreatedFrom64BitHostPtrThen32BitBufferIsReturned) {
DebugManagerStateRestore dbgRestorer;
auto isNewCoherencyModelSupported = pClDevice->getProductHelper().isNewCoherencyModelSupported();
{
if (is32bit) {
mock->ioctlExpected.total = -1;
@@ -159,7 +170,11 @@ TEST_F(ClDrmMemoryManagerTest, Given32bitAllocatorWhenAskedForBufferCreatedFrom6
mock->ioctlExpected.gemUserptr = 1;
mock->ioctlExpected.gemWait = 1;
mock->ioctlExpected.gemClose = 1;
if (isNewCoherencyModelSupported) {
mock->ioctlExpected.gemUserptr = 2;
mock->ioctlExpected.gemWait = 2;
mock->ioctlExpected.gemClose = 2;
}
debugManager.flags.Force32bitAddressing.set(true);
MockContext context(pClDevice);
memoryManager->setForce32BitAllocations(true);
@@ -178,7 +193,6 @@ TEST_F(ClDrmMemoryManagerTest, Given32bitAllocatorWhenAskedForBufferCreatedFrom6
retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_TRUE(buffer->isMemObjZeroCopy());
auto bufferAddress = buffer->getGraphicsAllocation(rootDeviceIndex)->getGpuAddress();
auto baseAddress = buffer->getGraphicsAllocation(rootDeviceIndex)->getGpuBaseAddress();
@@ -191,8 +205,13 @@ TEST_F(ClDrmMemoryManagerTest, Given32bitAllocatorWhenAskedForBufferCreatedFrom6
auto allocationCpuPtr = drmAllocation->getUnderlyingBuffer();
auto allocationPageOffset = ptrDiff(allocationCpuPtr, alignDown(allocationCpuPtr, MemoryConstants::pageSize));
auto bufferObject = drmAllocation->getBO();
if (isNewCoherencyModelSupported) {
EXPECT_FALSE(buffer->isMemObjZeroCopy());
EXPECT_EQ(allocationPageOffset, 0ull);
} else {
EXPECT_TRUE(buffer->isMemObjZeroCopy());
EXPECT_EQ(allocationPageOffset, ptrOffset);
}
auto boAddress = bufferObject->peekAddress();
EXPECT_EQ(alignDown(boAddress, MemoryConstants::pageSize), boAddress);