Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix: add mock for staging buffer size 

No need to allocate 2MB in unit tests.
This commit changes this size to 4KB.

Signed-off-by: Szymon Morek <szymon.morek@intel.com>
This commit is contained in:
Szymon Morek 2025-05-21 15:02:22 +00:00 committed by Compute-Runtime-Automation
parent b9a3f712ed
commit a2c41e4749
14 changed files with 83 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
opencl/test/unit_test/command_queue/enqueue_read_buffer_tests.cpp
View File

@ -865,7 +865,7 @@ struct ReadBufferStagingBufferTest : public EnqueueReadBufferHw {
void TearDown() override {
EnqueueReadBufferHw::TearDown();
}
constexpr static size_t chunkSize = MemoryConstants::megaByte * 2;
constexpr static size_t chunkSize = MemoryConstants::pageSize;
unsigned char ptr[MemoryConstants::cacheLineSize];
MockBuffer buffer;

25
opencl/test/unit_test/command_queue/enqueue_read_image_tests.cpp
View File

@ -1113,7 +1113,8 @@ struct ReadImageStagingBufferTest : public EnqueueReadImageTest {
EnqueueReadImageTest::TearDown();
}
static constexpr size_t stagingBufferSize = MemoryConstants::megaByte * 2;
static constexpr size_t stagingBufferSize = MemoryConstants::pageSize;
static constexpr size_t pitchSize = stagingBufferSize / 2;
static constexpr size_t readSize = stagingBufferSize * 4;
unsigned char *ptr;
size_t origin[3] = {0, 0, 0};
@ -1124,7 +1125,7 @@ struct ReadImageStagingBufferTest : public EnqueueReadImageTest {
HWTEST_F(ReadImageStagingBufferTest, whenEnqueueStagingReadImageCalledThenReturnSuccess) {
MockCommandQueueHw<FamilyType> mockCommandQueueHw(context, device.get(), &props);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, false, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, nullptr);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, false, origin, region, pitchSize, pitchSize, ptr, nullptr);
EXPECT_TRUE(mockCommandQueueHw.flushCalled);
EXPECT_EQ(res, CL_SUCCESS);
EXPECT_EQ(4ul, mockCommandQueueHw.enqueueReadImageCounter);
@ -1134,8 +1135,8 @@ HWTEST_F(ReadImageStagingBufferTest, whenEnqueueStagingReadImageCalledThenReturn
HWTEST_F(ReadImageStagingBufferTest, whenEnqueueStagingReadImageCalledWithoutRowPitchNorSlicePitchThenReturnSuccess) {
MockCommandQueueHw<FamilyType> mockCommandQueueHw(context, device.get(), &props);
region[0] = MemoryConstants::megaByte / srcImage->getSurfaceFormatInfo().surfaceFormat.imageElementSizeInBytes;
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, false, origin, region, 0u, 0u, ptr, nullptr);
region[0] = pitchSize / srcImage->getSurfaceFormatInfo().surfaceFormat.imageElementSizeInBytes;
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, false, origin, region, pitchSize, pitchSize, ptr, nullptr);
EXPECT_EQ(res, CL_SUCCESS);
EXPECT_EQ(4ul, mockCommandQueueHw.enqueueReadImageCounter);
@ -1145,7 +1146,7 @@ HWTEST_F(ReadImageStagingBufferTest, whenEnqueueStagingReadImageCalledWithoutRow
HWTEST_F(ReadImageStagingBufferTest, whenBlockingEnqueueStagingReadImageCalledThenFinishCalled) {
MockCommandQueueHw<FamilyType> mockCommandQueueHw(context, device.get(), &props);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, true, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, nullptr);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, true, origin, region, pitchSize, pitchSize, ptr, nullptr);
EXPECT_EQ(res, CL_SUCCESS);
EXPECT_EQ(1u, mockCommandQueueHw.finishCalledCount);
@ -1155,7 +1156,7 @@ HWTEST_F(ReadImageStagingBufferTest, whenEnqueueStagingReadImageCalledWithEventT
constexpr cl_command_type expectedCmd = CL_COMMAND_READ_IMAGE;
MockCommandQueueHw<FamilyType> mockCommandQueueHw(context, device.get(), &props);
cl_event event;
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(expectedCmd, srcImage, false, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, &event);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(expectedCmd, srcImage, false, origin, region, pitchSize, pitchSize, ptr, &event);
EXPECT_EQ(res, CL_SUCCESS);
auto pEvent = (Event *)event;
@ -1169,7 +1170,7 @@ HWTEST_F(ReadImageStagingBufferTest, givenOutOfOrderQueueWhenEnqueueStagingReadI
MockCommandQueueHw<FamilyType> mockCommandQueueHw(context, device.get(), &props);
mockCommandQueueHw.setOoqEnabled();
cl_event event;
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, false, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, &event);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, false, origin, region, pitchSize, pitchSize, ptr, &event);
EXPECT_EQ(res, CL_SUCCESS);
auto pEvent = (Event *)event;
@ -1185,7 +1186,7 @@ HWTEST_F(ReadImageStagingBufferTest, givenOutOfOrderQueueWhenEnqueueStagingReadI
mockCommandQueueHw.setOoqEnabled();
cl_event event;
region[1] = 1;
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, false, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, &event);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, false, origin, region, pitchSize, pitchSize, ptr, &event);
EXPECT_EQ(res, CL_SUCCESS);
auto pEvent = (Event *)event;
@ -1199,7 +1200,7 @@ HWTEST_F(ReadImageStagingBufferTest, givenCmdQueueWithProfilingWhenEnqueueStagin
cl_event event;
MockCommandQueueHw<FamilyType> mockCommandQueueHw(context, device.get(), &props);
mockCommandQueueHw.setProfilingEnabled();
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, false, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, &event);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, false, origin, region, pitchSize, pitchSize, ptr, &event);
EXPECT_EQ(res, CL_SUCCESS);
auto pEvent = (Event *)event;
@ -1212,7 +1213,7 @@ HWTEST_F(ReadImageStagingBufferTest, givenCmdQueueWithProfilingWhenEnqueueStagin
HWTEST_F(ReadImageStagingBufferTest, whenEnqueueStagingReadImageFailedThenPropagateErrorCode) {
MockCommandQueueHw<FamilyType> mockCommandQueueHw(context, device.get(), &props);
mockCommandQueueHw.enqueueReadImageCallBase = false;
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, false, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, nullptr);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, false, origin, region, pitchSize, pitchSize, ptr, nullptr);
EXPECT_EQ(res, CL_INVALID_OPERATION);
EXPECT_EQ(1ul, mockCommandQueueHw.enqueueReadImageCounter);
@ -1223,7 +1224,7 @@ HWTEST_F(ReadImageStagingBufferTest, whenEnqueueStagingReadImageCalledWithGpuHan
CsrSelectionArgs csrSelectionArgs{CL_COMMAND_READ_IMAGE, srcImage, nullptr, pDevice->getRootDeviceIndex(), region, nullptr, origin};
auto ultCsr = reinterpret_cast<UltCommandStreamReceiver<FamilyType> *>(&mockCommandQueueHw.selectCsrForBuiltinOperation(csrSelectionArgs));
ultCsr->waitForTaskCountReturnValue = WaitStatus::gpuHang;
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, false, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, nullptr);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, srcImage, false, origin, region, pitchSize, pitchSize, ptr, nullptr);
EXPECT_EQ(res, CL_OUT_OF_RESOURCES);
EXPECT_EQ(2ul, mockCommandQueueHw.enqueueReadImageCounter);
@ -1241,7 +1242,7 @@ HWTEST_F(ReadImageStagingBufferTest, whenEnqueueStagingReadImageCalledFor3DImage
size_t region[3] = {2, 2, 4};
auto image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, image.get(), false, origin, region, 4u, MemoryConstants::megaByte, ptr, nullptr);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, image.get(), false, origin, region, 4u, pitchSize, ptr, nullptr);
EXPECT_EQ(res, CL_SUCCESS);
// (2, 2, 4) splitted into (2, 2, 2) * 2

2
opencl/test/unit_test/command_queue/enqueue_svm_tests.cpp
View File

@ -2413,7 +2413,7 @@ struct StagingBufferTest : public EnqueueSvmTest {
EnqueueSvmTest::TearDown();
}
static constexpr size_t stagingBufferSize = MemoryConstants::megaByte * 2;
static constexpr size_t stagingBufferSize = MemoryConstants::pageSize;
static constexpr size_t copySize = stagingBufferSize * 4;
static constexpr size_t expectedNumOfCopies = copySize / stagingBufferSize;

2
opencl/test/unit_test/command_queue/enqueue_write_buffer_tests.cpp
View File

@ -645,7 +645,7 @@ struct WriteBufferStagingBufferTest : public EnqueueWriteBufferHw {
void TearDown() override {
EnqueueWriteBufferHw::TearDown();
}
constexpr static size_t chunkSize = MemoryConstants::megaByte * 2;
constexpr static size_t chunkSize = MemoryConstants::pageSize;
unsigned char ptr[MemoryConstants::cacheLineSize];
MockBuffer buffer;

23
opencl/test/unit_test/command_queue/enqueue_write_image_tests.cpp
View File

@ -833,7 +833,8 @@ struct WriteImageStagingBufferTest : public EnqueueWriteImageTest {
EnqueueWriteImageTest::TearDown();
}
static constexpr size_t stagingBufferSize = MemoryConstants::megaByte * 2;
static constexpr size_t stagingBufferSize = MemoryConstants::pageSize;
static constexpr size_t pitchSize = stagingBufferSize / 2;
static constexpr size_t writeSize = stagingBufferSize * 4;
unsigned char *ptr;
size_t origin[3] = {0, 0, 0};
@ -844,7 +845,7 @@ struct WriteImageStagingBufferTest : public EnqueueWriteImageTest {
HWTEST_F(WriteImageStagingBufferTest, whenEnqueueStagingWriteImageCalledThenReturnSuccess) {
MockCommandQueueHw<FamilyType> mockCommandQueueHw(context, device.get(), &props);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, false, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, nullptr);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, false, origin, region, pitchSize, pitchSize, ptr, nullptr);
EXPECT_TRUE(mockCommandQueueHw.flushCalled);
EXPECT_EQ(res, CL_SUCCESS);
EXPECT_EQ(4ul, mockCommandQueueHw.enqueueWriteImageCounter);
@ -854,7 +855,7 @@ HWTEST_F(WriteImageStagingBufferTest, whenEnqueueStagingWriteImageCalledThenRetu
HWTEST_F(WriteImageStagingBufferTest, whenEnqueueStagingWriteImageCalledWithoutRowPitchNorSlicePitchThenReturnSuccess) {
MockCommandQueueHw<FamilyType> mockCommandQueueHw(context, device.get(), &props);
region[0] = MemoryConstants::megaByte / dstImage->getSurfaceFormatInfo().surfaceFormat.imageElementSizeInBytes;
region[0] = pitchSize / dstImage->getSurfaceFormatInfo().surfaceFormat.imageElementSizeInBytes;
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, false, origin, region, 0u, 0u, ptr, nullptr);
EXPECT_EQ(res, CL_SUCCESS);
@ -865,7 +866,7 @@ HWTEST_F(WriteImageStagingBufferTest, whenEnqueueStagingWriteImageCalledWithoutR
HWTEST_F(WriteImageStagingBufferTest, whenBlockingEnqueueStagingWriteImageCalledThenFinishCalled) {
MockCommandQueueHw<FamilyType> mockCommandQueueHw(context, device.get(), &props);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, true, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, nullptr);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, true, origin, region, pitchSize, pitchSize, ptr, nullptr);
EXPECT_EQ(res, CL_SUCCESS);
EXPECT_EQ(1u, mockCommandQueueHw.finishCalledCount);
@ -875,7 +876,7 @@ HWTEST_F(WriteImageStagingBufferTest, whenEnqueueStagingWriteImageCalledWithEven
constexpr cl_command_type expectedLastCmd = CL_COMMAND_WRITE_IMAGE;
MockCommandQueueHw<FamilyType> mockCommandQueueHw(context, device.get(), &props);
cl_event event;
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, false, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, &event);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, false, origin, region, pitchSize, pitchSize, ptr, &event);
EXPECT_EQ(res, CL_SUCCESS);
auto pEvent = (Event *)event;
@ -889,7 +890,7 @@ HWTEST_F(WriteImageStagingBufferTest, givenOutOfOrderQueueWhenEnqueueStagingWrit
MockCommandQueueHw<FamilyType> mockCommandQueueHw(context, device.get(), &props);
mockCommandQueueHw.setOoqEnabled();
cl_event event;
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, false, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, &event);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, false, origin, region, pitchSize, pitchSize, ptr, &event);
EXPECT_EQ(res, CL_SUCCESS);
auto pEvent = (Event *)event;
@ -905,7 +906,7 @@ HWTEST_F(WriteImageStagingBufferTest, givenOutOfOrderQueueWhenEnqueueStagingWrit
mockCommandQueueHw.setOoqEnabled();
cl_event event;
region[1] = 1;
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, false, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, &event);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, false, origin, region, pitchSize, pitchSize, ptr, &event);
EXPECT_EQ(res, CL_SUCCESS);
auto pEvent = (Event *)event;
@ -919,7 +920,7 @@ HWTEST_F(WriteImageStagingBufferTest, givenCmdQueueWithProfilingWhenEnqueueStagi
cl_event event;
MockCommandQueueHw<FamilyType> mockCommandQueueHw(context, device.get(), &props);
mockCommandQueueHw.setProfilingEnabled();
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, false, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, &event);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, false, origin, region, pitchSize, pitchSize, ptr, &event);
EXPECT_EQ(res, CL_SUCCESS);
auto pEvent = (Event *)event;
@ -932,7 +933,7 @@ HWTEST_F(WriteImageStagingBufferTest, givenCmdQueueWithProfilingWhenEnqueueStagi
HWTEST_F(WriteImageStagingBufferTest, whenEnqueueStagingWriteImageFailedThenPropagateErrorCode) {
MockCommandQueueHw<FamilyType> mockCommandQueueHw(context, device.get(), &props);
mockCommandQueueHw.enqueueWriteImageCallBase = false;
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, false, origin, region, MemoryConstants::megaByte, MemoryConstants::megaByte, ptr, nullptr);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, dstImage, false, origin, region, pitchSize, pitchSize, ptr, nullptr);
EXPECT_EQ(res, CL_INVALID_OPERATION);
EXPECT_EQ(1ul, mockCommandQueueHw.enqueueWriteImageCounter);
@ -962,7 +963,7 @@ HWTEST_F(WriteImageStagingBufferTest, whenEnqueueStagingWriteImageCalledFor3DIma
size_t region[3] = {2, 2, 4};
auto image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, image.get(), false, origin, region, 4u, MemoryConstants::megaByte, ptr, nullptr);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, image.get(), false, origin, region, 4u, pitchSize, ptr, nullptr);
EXPECT_EQ(res, CL_SUCCESS);
// (2, 2, 4) splitted into (2, 2, 2) * 2
@ -984,6 +985,6 @@ HWTEST_F(WriteImageStagingBufferTest, whenEnqueueStagingWriteImageCalledForMipMa
size_t region[3] = {2, 2, 4};
auto image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, image.get(), false, origin, region, 4u, MemoryConstants::megaByte, ptr, nullptr);
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, image.get(), false, origin, region, 4u, pitchSize, ptr, nullptr);
EXPECT_EQ(res, CL_SUCCESS);
}

1
opencl/test/unit_test/linux/CMakeLists.txt
View File

@ -22,6 +22,7 @@ add_executable(igdrcl_${target_name}
${CMAKE_CURRENT_SOURCE_DIR}/mock_os_layer.h
${CMAKE_CURRENT_SOURCE_DIR}/os_interface_linux_tests.cpp
${NEO_SHARED_TEST_DIRECTORY}/common/helpers/virtual_file_system_listener.cpp
${NEO_SHARED_TEST_DIRECTORY}/common/mocks/mock_get_staging_buffer_size.cpp
${NEO_SHARED_DIRECTORY}/os_interface/linux/sys_calls_linux.cpp
${NEO_SHARED_DIRECTORY}/dll/create_memory_manager_drm.cpp
${NEO_SHARED_DIRECTORY}/dll/device_dll.cpp

1
opencl/test/unit_test/windows/CMakeLists.txt
View File

@ -36,6 +36,7 @@ if(WIN32)
${NEO_SHARED_TEST_DIRECTORY}/common/os_interface/windows/sys_calls.cpp
${NEO_SHARED_TEST_DIRECTORY}/common/os_interface/windows/sys_calls_winmm.cpp
${NEO_SHARED_TEST_DIRECTORY}/common/os_interface/windows/wddm_calls.cpp
${NEO_SHARED_TEST_DIRECTORY}/common/mocks/mock_get_staging_buffer_size.cpp
${NEO_SOURCE_DIR}/opencl/test/unit_test/test_macros/test_checks_ocl.cpp
)

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

@ -18,6 +18,7 @@ set(NEO_SHARED_DLLS
${CMAKE_CURRENT_SOURCE_DIR}/unified_memory_reuse_cleaner_enabled.cpp
${CMAKE_CURRENT_SOURCE_DIR}/create_command_stream.cpp
${CMAKE_CURRENT_SOURCE_DIR}/options_dll.cpp
${CMAKE_CURRENT_SOURCE_DIR}/get_staging_buffer_size.cpp
)
add_library(neo_shared_dlls_precompiled_objects OBJECT ${NEO_SHARED_DLLS})

15
shared/source/dll/get_staging_buffer_size.cpp Normal file
View File

@ -0,0 +1,15 @@
/*
* Copyright (C) 2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/utilities/staging_buffer_manager.h"
namespace NEO {
size_t getDefaultStagingBufferSize() {
return MemoryConstants::pageSize2M;
}
} // namespace NEO

3
shared/source/utilities/staging_buffer_manager.cpp
View File

@ -38,6 +38,7 @@ void StagingBufferTracker::freeChunk() const {
StagingBufferManager::StagingBufferManager(SVMAllocsManager *svmAllocsManager, const RootDeviceIndicesContainer &rootDeviceIndices, const std::map<uint32_t, DeviceBitfield> &deviceBitfields, bool requiresWritable)
: svmAllocsManager(svmAllocsManager), rootDeviceIndices(rootDeviceIndices), deviceBitfields(deviceBitfields), requiresWritable(requiresWritable) {
chunkSize = getDefaultStagingBufferSize();
if (debugManager.flags.StagingBufferSize.get() != -1) {
chunkSize = debugManager.flags.StagingBufferSize.get() * MemoryConstants::kiloByte;
}
@ -346,7 +347,7 @@ std::pair<HeapAllocator *, uint64_t> StagingBufferManager::requestStagingBuffer(
return {retriedAllocator, retriedChunkBuffer};
}
auto stagingBufferSize = alignUp(std::max(chunkSize, size), MemoryConstants::pageSize2M);
auto stagingBufferSize = alignUp(std::max(chunkSize, size), getDefaultStagingBufferSize());
auto usmHost = allocateStagingBuffer(stagingBufferSize);
if (usmHost != nullptr) {
StagingBuffer stagingBuffer{usmHost, stagingBufferSize};

4
shared/source/utilities/staging_buffer_manager.h
View File

@ -119,7 +119,7 @@ class StagingBufferManager : NEO::NonCopyableAndNonMovableClass {
bool isValidForStaging(const Device &device, const void *ptr, size_t size, bool hasDependencies);
size_t chunkSize = MemoryConstants::pageSize2M;
size_t chunkSize = 0;
std::mutex mtx;
std::vector<StagingBuffer> stagingBuffers;
std::vector<StagingBufferTracker> trackers;
@ -134,4 +134,6 @@ class StagingBufferManager : NEO::NonCopyableAndNonMovableClass {
static_assert(NEO::NonCopyableAndNonMovable<StagingBufferManager>);
size_t getDefaultStagingBufferSize();
} // namespace NEO

2
shared/test/common/libult/CMakeLists.txt
View File

@ -209,6 +209,7 @@ set(neo_libult_SRCS_LINUX
${NEO_SHARED_TEST_DIRECTORY}/common/os_interface/linux/options.inl
${NEO_SHARED_TEST_DIRECTORY}/common/os_interface/setup_external_dependencies_${DRIVER_MODEL}.cpp
${NEO_SHARED_TEST_DIRECTORY}/common/os_interface/linux/sys_calls_linux_ult.cpp
${NEO_SHARED_TEST_DIRECTORY}/common/mocks/mock_get_staging_buffer_size.cpp
)
set_property(GLOBAL APPEND PROPERTY neo_libult_SRCS_LINUX ${neo_libult_SRCS_LINUX})
@ -224,6 +225,7 @@ set(neo_libult_SRCS_WINDOWS
${NEO_SHARED_TEST_DIRECTORY}/common/os_interface/windows/sys_calls.cpp
${NEO_SHARED_TEST_DIRECTORY}/common/os_interface/windows/sys_calls_winmm.cpp
${NEO_SHARED_TEST_DIRECTORY}/common/os_interface/windows/wddm_calls.cpp
${NEO_SHARED_TEST_DIRECTORY}/common/mocks/mock_get_staging_buffer_size.cpp
)
set_property(GLOBAL APPEND PROPERTY neo_libult_SRCS_WINDOWS ${neo_libult_SRCS_WINDOWS})

15
shared/test/common/mocks/mock_get_staging_buffer_size.cpp Normal file
View File

@ -0,0 +1,15 @@
/*
* Copyright (C) 2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/utilities/staging_buffer_manager.h"
namespace NEO {
size_t getDefaultStagingBufferSize() {
return MemoryConstants::pageSize;
}
} // namespace NEO

29
shared/test/unit_test/utilities/staging_buffer_manager_tests.cpp
View File

@ -147,7 +147,7 @@ class StagingBufferManagerFixture : public DeviceFixture {
EXPECT_EQ(expectedChunks, chunkCounter);
auto expectedNewUsmAllocations = 1u;
if (isRead && pixelElemSize * globalRegion[0] * globalRegion[1] > stagingBufferSize) {
if (isRead && rowPitch * globalRegion[1] > stagingBufferSize) {
expectedNewUsmAllocations = 2u;
}
EXPECT_EQ(expectedNewUsmAllocations, newUsmAllocations);
@ -189,7 +189,8 @@ class StagingBufferManagerFixture : public DeviceFixture {
}
}
constexpr static size_t stagingBufferSize = MemoryConstants::megaByte * 2;
constexpr static size_t stagingBufferSize = MemoryConstants::pageSize;
constexpr static size_t pitchSize = stagingBufferSize / 2;
constexpr static size_t pixelElemSize = 1u;
DebugManagerStateRestore restorer;
std::unique_ptr<MockSVMAllocsManager> svmAllocsManager;
@ -510,14 +511,14 @@ TEST_F(StagingBufferManagerTest, givenStagingBufferWhenPerformImageWriteWithMult
size_t expectedChunks = 4;
const size_t globalOrigin[3] = {0, 0, 0};
const size_t globalRegion[3] = {4, 8, 1};
imageTransferThroughStagingBuffers(false, MemoryConstants::megaByte, globalOrigin, globalRegion, expectedChunks);
imageTransferThroughStagingBuffers(false, pitchSize, globalOrigin, globalRegion, expectedChunks);
}
TEST_F(StagingBufferManagerTest, givenStagingBufferWhenPerformImageWriteWithRemainderThenWholeRegionCovered) {
size_t expectedChunks = 4;
const size_t globalOrigin[3] = {0, 0, 0};
const size_t globalRegion[3] = {4, 7, 1};
imageTransferThroughStagingBuffers(false, MemoryConstants::megaByte, globalOrigin, globalRegion, expectedChunks);
imageTransferThroughStagingBuffers(false, pitchSize, globalOrigin, globalRegion, expectedChunks);
}
TEST_F(StagingBufferManagerTest, givenStagingBufferWhenPerformImageReadThenRegionCovered) {
@ -553,21 +554,21 @@ TEST_F(StagingBufferManagerTest, givenStagingBufferWhenPerformImageReadWithOrigi
TEST_F(StagingBufferManagerTest, givenStagingBufferWhenPerformImageReadWithMultipleRowsPerChunkThenWholeRegionCovered) {
size_t expectedChunks = 4;
const size_t globalOrigin[3] = {0, 0, 0};
const size_t globalRegion[3] = {1 * MemoryConstants::megaByte, 8, 1};
const size_t globalRegion[3] = {pitchSize, 8, 1};
imageTransferThroughStagingBuffers(true, pixelElemSize * globalRegion[0], globalOrigin, globalRegion, expectedChunks);
}
TEST_F(StagingBufferManagerTest, givenStagingBufferWhenPerformImageReadWithRemainderThenWholeRegionCovered) {
size_t expectedChunks = 4;
const size_t globalOrigin[3] = {0, 0, 0};
const size_t globalRegion[3] = {1 * MemoryConstants::megaByte, 7, 1};
const size_t globalRegion[3] = {pitchSize, 7, 1};
imageTransferThroughStagingBuffers(true, pixelElemSize * globalRegion[0], globalOrigin, globalRegion, expectedChunks);
}
TEST_F(StagingBufferManagerTest, givenStagingBufferWhenPerformImageReadWithRemainderAndTransfersWithinLimitThenWholeRegionCovered) {
size_t expectedChunks = 2;
const size_t globalOrigin[3] = {0, 0, 0};
const size_t globalRegion[3] = {1 * MemoryConstants::megaByte, 3, 1};
const size_t globalRegion[3] = {pitchSize, 3, 1};
imageTransferThroughStagingBuffers(true, pixelElemSize * globalRegion[0], globalOrigin, globalRegion, expectedChunks);
}
@ -584,7 +585,7 @@ HWTEST_F(StagingBufferManagerTest, givenStagingBufferWhenGpuHangDuringChunkReadF
};
auto ultCsr = reinterpret_cast<UltCommandStreamReceiver<FamilyType> *>(csr);
ultCsr->waitForTaskCountReturnValue = WaitStatus::gpuHang;
auto ret = stagingBufferManager->performImageTransfer(ptr, globalOrigin, globalRegion, MemoryConstants::megaByte, MemoryConstants::megaByte, pixelElemSize, false, chunkWrite, csr, true);
auto ret = stagingBufferManager->performImageTransfer(ptr, globalOrigin, globalRegion, pitchSize, pitchSize, pixelElemSize, false, chunkWrite, csr, true);
EXPECT_EQ(0, ret.chunkCopyStatus);
EXPECT_EQ(WaitStatus::gpuHang, ret.waitStatus);
EXPECT_EQ(2u, chunkCounter);
@ -606,7 +607,7 @@ HWTEST_F(StagingBufferManagerTest, givenStagingBufferWhenGpuHangAfterChunkReadFr
}
return 0;
};
auto ret = stagingBufferManager->performImageTransfer(ptr, globalOrigin, globalRegion, MemoryConstants::megaByte, MemoryConstants::megaByte, pixelElemSize, false, chunkWrite, csr, true);
auto ret = stagingBufferManager->performImageTransfer(ptr, globalOrigin, globalRegion, pitchSize, pitchSize, pixelElemSize, false, chunkWrite, csr, true);
EXPECT_EQ(0, ret.chunkCopyStatus);
EXPECT_EQ(WaitStatus::gpuHang, ret.waitStatus);
EXPECT_EQ(4u, chunkCounter);
@ -629,7 +630,7 @@ HWTEST_F(StagingBufferManagerTest, givenStagingBufferWhenGpuHangDuringRemainderC
}
return 0;
};
auto ret = stagingBufferManager->performImageTransfer(ptr, globalOrigin, globalRegion, MemoryConstants::megaByte, MemoryConstants::megaByte, pixelElemSize, false, chunkWrite, csr, true);
auto ret = stagingBufferManager->performImageTransfer(ptr, globalOrigin, globalRegion, pitchSize, pitchSize, pixelElemSize, false, chunkWrite, csr, true);
EXPECT_EQ(0, ret.chunkCopyStatus);
EXPECT_EQ(WaitStatus::gpuHang, ret.waitStatus);
EXPECT_EQ(remainderCounter - 1, chunkCounter);
@ -648,7 +649,7 @@ TEST_F(StagingBufferManagerTest, givenStagingBufferWhenFailedChunkImageWriteThen
++chunkCounter;
return expectedErrorCode;
};
auto ret = stagingBufferManager->performImageTransfer(ptr, globalOrigin, globalRegion, MemoryConstants::megaByte, MemoryConstants::megaByte, pixelElemSize, false, chunkWrite, csr, false);
auto ret = stagingBufferManager->performImageTransfer(ptr, globalOrigin, globalRegion, pitchSize, pitchSize, pixelElemSize, false, chunkWrite, csr, false);
EXPECT_EQ(expectedErrorCode, ret.chunkCopyStatus);
EXPECT_EQ(WaitStatus::ready, ret.waitStatus);
EXPECT_EQ(1u, chunkCounter);
@ -671,7 +672,7 @@ TEST_F(StagingBufferManagerTest, givenStagingBufferWhenFailedChunkImageWriteWith
}
return 0;
};
auto ret = stagingBufferManager->performImageTransfer(ptr, globalOrigin, globalRegion, MemoryConstants::megaByte, MemoryConstants::megaByte, pixelElemSize, false, chunkWrite, csr, false);
auto ret = stagingBufferManager->performImageTransfer(ptr, globalOrigin, globalRegion, pitchSize, pitchSize, pixelElemSize, false, chunkWrite, csr, false);
EXPECT_EQ(expectedErrorCode, ret.chunkCopyStatus);
EXPECT_EQ(WaitStatus::ready, ret.waitStatus);
EXPECT_EQ(remainderCounter, chunkCounter);
@ -761,7 +762,7 @@ HWTEST_F(StagingBufferManagerTest, givenStagingBufferWhenGpuHangDuringSliceRemai
auto expectedChunks = 5u;
size_t rowPitch = 4u;
auto rowsNum = 4u;
size_t slicePitch = MemoryConstants::megaByte;
size_t slicePitch = pitchSize;
const size_t globalOrigin[3] = {0, 0, 0};
const size_t globalRegion[3] = {rowPitch, rowsNum, 9};
auto size = stagingBufferSize * expectedChunks / sizeof(unsigned int);
@ -787,7 +788,7 @@ TEST_F(StagingBufferManagerTest, givenStagingBufferWhenFailedChunkImageWriteWith
auto expectedChunks = 5u;
size_t rowPitch = 4u;
auto rowsNum = 4u;
size_t slicePitch = MemoryConstants::megaByte;
size_t slicePitch = pitchSize;
const size_t globalOrigin[3] = {0, 0, 0};
const size_t globalRegion[3] = {rowPitch, rowsNum, 9};
auto size = stagingBufferSize * expectedChunks / sizeof(unsigned int);