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

feature: additional fixes to enable feature and adjusting builtins types

Browse Source 
Resolves: NEO-13973

Signed-off-by: Damian Tomczak <damian.tomczak@intel.com>
This commit is contained in:
Damian Tomczak
2025-03-18 15:55:03 +00:00
committed by Compute-Runtime-Automation
parent 75461d190d
commit 1995a7fbcf
22 changed files with 94 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
opencl/source/command_queue/enqueue_read_image.h
View File

@@ -145,7 +145,9 @@ cl_int CommandQueueHw<GfxFamily>::enqueueReadImageImpl(
dc.bcsSplit = bcsSplit;
dc.direction = csrSelectionArgs.direction;
auto eBuiltInOps = EBuiltInOps::copyImage3dToBuffer;
const bool useStateless = forceStateless(srcImage->getSize());
const bool useHeapless = this->getHeaplessModeEnabled();
auto eBuiltInOps = EBuiltInOps::adjustBuiltinType<EBuiltInOps::copyImage3dToBuffer>(useStateless, useHeapless);
MultiDispatchInfo dispatchInfo(dc);
const auto dispatchResult = dispatchBcsOrGpgpuEnqueue<CL_COMMAND_READ_IMAGE>(dispatchInfo, surfaces, eBuiltInOps, numEventsInWaitList, eventWaitList, event, blockingRead == CL_TRUE, csr);

4
opencl/source/command_queue/enqueue_write_image.h
View File

@@ -134,7 +134,9 @@ cl_int CommandQueueHw<GfxFamily>::enqueueWriteImageImpl(
dc.bcsSplit = bcsSplit;
dc.direction = csrSelectionArgs.direction;
auto eBuiltInOps = EBuiltInOps::adjustImageBuiltinType<EBuiltInOps::copyBufferToImage3d>(this->heaplessModeEnabled);
const bool useStateless = forceStateless(dstImage->getSize());
const bool useHeapless = getHeaplessModeEnabled();
auto eBuiltInOps = EBuiltInOps::adjustBuiltinType<EBuiltInOps::copyBufferToImage3d>(useStateless, useHeapless);
MultiDispatchInfo dispatchInfo(dc);
const auto dispatchResult = dispatchBcsOrGpgpuEnqueue<CL_COMMAND_WRITE_IMAGE>(dispatchInfo, surfaces, eBuiltInOps, numEventsInWaitList, eventWaitList, event, blockingWrite == CL_TRUE, csr);

27
opencl/test/unit_test/command_queue/command_enqueue_fixture.h
View File

@@ -6,6 +6,7 @@
*/
#pragma once
#include "shared/source/helpers/compiler_product_helper.h"
#include "shared/source/helpers/gfx_core_helper.h"
#include "shared/test/common/mocks/mock_memory_manager.h"
@@ -18,6 +19,7 @@
#include "opencl/test/unit_test/helpers/cl_hw_parse.h"
#include "opencl/test/unit_test/indirect_heap/indirect_heap_fixture.h"
#include "opencl/test/unit_test/mocks/mock_cl_device.h"
#include "opencl/test/unit_test/mocks/mock_command_queue.h"
#include "test_traits_common.h"
@@ -39,7 +41,7 @@ struct CommandDeviceFixture : public ClDeviceFixture,
struct CommandEnqueueBaseFixture : CommandDeviceFixture,
public IndirectHeapFixture,
public ClHardwareParse {
virtual public ClHardwareParse {
using IndirectHeapFixture::setUp;
void setUp(cl_command_queue_properties cmdQueueProperties = 0) {
CommandDeviceFixture::setUp(cmdQueueProperties);
@@ -67,6 +69,29 @@ struct CommandEnqueueFixture : public CommandEnqueueBaseFixture,
}
};
struct SurfaceStateAccessor : virtual public ClHardwareParse {
template <typename FamilyType>
const FamilyType::RENDER_SURFACE_STATE *getSurfaceState(std::unique_ptr<MockCommandQueueHw<FamilyType>> &mockCmdQ, uint32_t index) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
const RENDER_SURFACE_STATE *surfaceState = nullptr;
auto kernel = mockCmdQ->storedMultiDispatchInfo.begin()->getKernel();
const auto &kernelInfo = kernel->getKernelInfo();
if (kernelInfo.kernelDescriptor.kernelAttributes.imageAddressingMode == KernelDescriptor::AddressingMode::Bindless) {
auto bindlessOffset = static_cast<uint32_t>(kernelInfo.getArgDescriptorAt(index).template as<ArgDescImage>().bindless);
auto bindlessSurfaceStateIndex = kernel->getSurfaceStateIndexForBindlessOffset(bindlessOffset);
void *surfaceStateAddress = ptrOffset(kernel->getSurfaceStateHeap(), bindlessSurfaceStateIndex * sizeof(RENDER_SURFACE_STATE));
surfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(surfaceStateAddress);
} else {
uint32_t bindfulIndex = static_cast<uint32_t>(kernelInfo.getArgDescriptorAt(index).template as<ArgDescImage>().bindful) / sizeof(RENDER_SURFACE_STATE);
surfaceState = HardwareParse::getSurfaceState<FamilyType>(&mockCmdQ->getIndirectHeap(IndirectHeap::Type::surfaceState, 0), bindfulIndex);
}
return surfaceState;
}
};
struct NegativeFailAllocationCommandEnqueueBaseFixture : public CommandEnqueueBaseFixture {
void setUp() {
CommandEnqueueBaseFixture::setUp();

13
opencl/test/unit_test/command_queue/command_queue_hw_2_tests.cpp
View File

@@ -216,20 +216,20 @@ HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueReadWriteBufferCallWhenBu
}
HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueWriteImageCallWhenBuiltinParamsArePassedThenCheckValuesCorectness) {
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
DebugManagerStateRestore restorer;
debugManager.flags.EnableCopyWithStagingBuffers.set(0);
bool heaplessAllowed = UnitTestHelper<FamilyType>::isHeaplessAllowed();
for (auto useHeapless : {false, true}) {
for (auto useHeapless : {false, heaplessAllowed}) {
if (useHeapless && !heaplessAllowed) {
continue;
}
reinterpret_cast<MockCommandQueueHw<FamilyType> *>(pCmdQ)->heaplessModeEnabled = useHeapless;
auto builtInType = EBuiltInOps::adjustImageBuiltinType<EBuiltInOps::copyBufferToImage3d>(useHeapless);
setUpImpl(builtInType);
reinterpret_cast<MockCommandQueueHw<FamilyType> *>(pCmdQ)->heaplessModeEnabled = useHeapless;
setUpImpl(EBuiltInOps::adjustBuiltinType<EBuiltInOps::copyBufferToImage3d>(false, useHeapless));
std::unique_ptr<Image> dstImage(ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(context));
@@ -271,7 +271,8 @@ HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueWriteImageCallWhenBuiltin
HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueReadImageCallWhenBuiltinParamsArePassedThenCheckValuesCorectness) {
setUpImpl(EBuiltInOps::copyImage3dToBuffer);
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
setUpImpl(EBuiltInOps::adjustBuiltinType<EBuiltInOps::copyImage3dToBuffer>(false, pCmdQ->getHeaplessModeEnabled()));
std::unique_ptr<Image> dstImage(ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(context));

1
opencl/test/unit_test/command_queue/enqueue_copy_buffer_to_image_fixture.h
View File

@@ -17,6 +17,7 @@
namespace NEO {
struct EnqueueCopyBufferToImageTest : public CommandEnqueueFixture,
public SurfaceStateAccessor,
public ::testing::Test {
void SetUp() override {

5
opencl/test/unit_test/command_queue/enqueue_copy_buffer_to_image_tests.cpp
View File

@@ -171,12 +171,11 @@ HWTEST_F(EnqueueCopyBufferToImageTest, WhenCopyingBufferToImageThenSurfaceStateI
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
VariableBackup<CommandQueue *> cmdQBackup(&pCmdQ, mockCmdQ.get());
mockCmdQ->storeMultiDispatchInfo = true;
enqueueCopyBufferToImage<FamilyType>();
const auto &kernelInfo = mockCmdQ->storedMultiDispatchInfo.begin()->getKernel()->getKernelInfo();
uint32_t index = static_cast<uint32_t>(kernelInfo.getArgDescriptorAt(1).template as<ArgDescImage>().bindful) / sizeof(RENDER_SURFACE_STATE);
const auto surfaceState = SurfaceStateAccessor::getSurfaceState<FamilyType>(mockCmdQ, 1);
const auto surfaceState = getSurfaceState<FamilyType>(&pCmdQ->getIndirectHeap(IndirectHeap::Type::surfaceState, 0), index);
const auto &imageDesc = dstImage->getImageDesc();
// EnqueueReadImage uses multi-byte copies depending on per-pixel-size-in-bytes
EXPECT_EQ(imageDesc.image_width, surfaceState->getWidth());

1
opencl/test/unit_test/command_queue/enqueue_copy_image_fixture.h
View File

@@ -17,6 +17,7 @@
namespace NEO {
struct EnqueueCopyImageTest : public CommandEnqueueFixture,
public SurfaceStateAccessor,
public ::testing::Test {
void SetUp(void) override {

11
opencl/test/unit_test/command_queue/enqueue_copy_image_tests.cpp
View File

@@ -180,10 +180,9 @@ HWTEST_F(EnqueueCopyImageTest, WhenCopyingImageThenSurfaceStateIsCorrect) {
enqueueCopyImage<FamilyType>();
const auto &kernelInfo = mockCmdQ->storedMultiDispatchInfo.begin()->getKernel()->getKernelInfo();
for (uint32_t i = 0; i < 2; ++i) {
uint32_t index = static_cast<uint32_t>(kernelInfo.getArgDescriptorAt(i).template as<ArgDescImage>().bindful) / sizeof(RENDER_SURFACE_STATE);
const auto surfaceState = getSurfaceState<FamilyType>(&pCmdQ->getIndirectHeap(IndirectHeap::Type::surfaceState, 0), index);
const auto surfaceState = SurfaceStateAccessor::getSurfaceState<FamilyType>(mockCmdQ, i);
const auto &imageDesc = dstImage->getImageDesc();
EXPECT_EQ(imageDesc.image_width, surfaceState->getWidth());
EXPECT_EQ(imageDesc.image_height, surfaceState->getHeight());
@@ -201,12 +200,10 @@ HWTEST_F(EnqueueCopyImageTest, WhenCopyingImageThenSurfaceStateIsCorrect) {
EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_VERTICAL_ALIGNMENT_VALIGN_4, surfaceState->getSurfaceVerticalAlignment());
}
uint32_t srcIndex = static_cast<uint32_t>(kernelInfo.getArgDescriptorAt(0).template as<ArgDescImage>().bindful) / sizeof(RENDER_SURFACE_STATE);
const auto srcSurfaceState = getSurfaceState<FamilyType>(&pCmdQ->getIndirectHeap(IndirectHeap::Type::surfaceState, 0), srcIndex);
const auto srcSurfaceState = SurfaceStateAccessor::getSurfaceState<FamilyType>(mockCmdQ, 0);
EXPECT_EQ(srcImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex())->getGpuAddress(), srcSurfaceState->getSurfaceBaseAddress());
uint32_t dstIndex = static_cast<uint32_t>(kernelInfo.getArgDescriptorAt(1).template as<ArgDescImage>().bindful) / sizeof(RENDER_SURFACE_STATE);
const auto dstSurfaceState = getSurfaceState<FamilyType>(&pCmdQ->getIndirectHeap(IndirectHeap::Type::surfaceState, 0), dstIndex);
const auto dstSurfaceState = SurfaceStateAccessor::getSurfaceState<FamilyType>(mockCmdQ, 1);
EXPECT_EQ(dstImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex())->getGpuAddress(), dstSurfaceState->getSurfaceBaseAddress());
}

1
opencl/test/unit_test/command_queue/enqueue_copy_image_to_buffer_fixture.h
View File

@@ -17,6 +17,7 @@
namespace NEO {
struct EnqueueCopyImageToBufferTest : public CommandEnqueueFixture,
public SurfaceStateAccessor,
public ::testing::Test {
void SetUp(void) override {

6
opencl/test/unit_test/command_queue/enqueue_copy_image_to_buffer_tests.cpp
View File

@@ -169,9 +169,13 @@ HWCMDTEST_F(IGFX_GEN12LP_CORE, EnqueueCopyImageToBufferTest, WhenCopyingImageToB
HWTEST_F(EnqueueCopyImageToBufferTest, WhenCopyingImageToBufferThenSurfaceStateIsCorrect) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
VariableBackup<CommandQueue *> cmdQBackup(&pCmdQ, mockCmdQ.get());
mockCmdQ->storeMultiDispatchInfo = true;
enqueueCopyImageToBuffer<FamilyType>();
const auto surfaceState = getSurfaceState<FamilyType>(&pCmdQ->getIndirectHeap(IndirectHeap::Type::surfaceState, 0), 0);
const auto surfaceState = SurfaceStateAccessor::getSurfaceState<FamilyType>(mockCmdQ, 0);
const auto &imageDesc = srcImage->getImageDesc();
// EnqueueReadImage uses multi-byte copies depending on per-pixel-size-in-bytes
EXPECT_EQ(imageDesc.image_width, surfaceState->getWidth());

6
opencl/test/unit_test/command_queue/enqueue_fill_image_tests.cpp
View File

@@ -22,6 +22,7 @@
using namespace NEO;
class EnqueueFillImageTest : public EnqueueFillImageTestFixture,
public SurfaceStateAccessor,
public ::testing::Test {
public:
void SetUp(void) override {
@@ -194,12 +195,11 @@ HWTEST_F(EnqueueFillImageTest, WhenFillingImageThenSurfaceStateIsCorrect) {
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
VariableBackup<CommandQueue *> cmdQBackup(&pCmdQ, mockCmdQ.get());
mockCmdQ->storeMultiDispatchInfo = true;
enqueueFillImage<FamilyType>();
const auto &kernelInfo = mockCmdQ->storedMultiDispatchInfo.begin()->getKernel()->getKernelInfo();
uint32_t index = static_cast<uint32_t>(kernelInfo.getArgDescriptorAt(0).template as<ArgDescImage>().bindful) / sizeof(RENDER_SURFACE_STATE);
const auto surfaceState = SurfaceStateAccessor::getSurfaceState<FamilyType>(mockCmdQ, 0);
const auto surfaceState = getSurfaceState<FamilyType>(&pCmdQ->getIndirectHeap(IndirectHeap::Type::surfaceState, 0), index);
const auto &imageDesc = image->getImageDesc();
EXPECT_EQ(imageDesc.image_width, surfaceState->getWidth());
EXPECT_EQ(imageDesc.image_height, surfaceState->getHeight());

1
opencl/test/unit_test/command_queue/enqueue_read_image_fixture.h
View File

@@ -17,6 +17,7 @@
namespace NEO {
struct EnqueueReadImageTest : public CommandEnqueueFixture,
public SurfaceStateAccessor,
public ::testing::Test {
typedef CommandQueueHwFixture CommandQueueFixture;
using CommandQueueHwFixture::pCmdQ;

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

@@ -650,11 +650,15 @@ HWCMDTEST_F(IGFX_GEN12LP_CORE, EnqueueReadImageTest, WhenReadingImageThenInterfa
HWTEST_F(EnqueueReadImageTest, WhenReadingImageThenSurfaceStateIsCorrect) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
VariableBackup<CommandQueue *> cmdQBackup(&pCmdQ, mockCmdQ.get());
mockCmdQ->storeMultiDispatchInfo = true;
enqueueReadImage<FamilyType>();
// BufferToImage kernel uses BTI=1 for destSurface
uint32_t bindingTableIndex = 0;
const auto surfaceState = getSurfaceState<FamilyType>(&pCmdQ->getIndirectHeap(IndirectHeap::Type::surfaceState, 0), bindingTableIndex);
const auto surfaceState = SurfaceStateAccessor::getSurfaceState<FamilyType>(mockCmdQ, bindingTableIndex);
// EnqueueReadImage uses multi-byte copies depending on per-pixel-size-in-bytes
const auto &imageDesc = srcImage->getImageDesc();
@@ -726,7 +730,7 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DarrayWhenReadImageIsCalledThenHostPtr
HWTEST_F(EnqueueReadImageTest, GivenImage1DarrayWhenReadImageIsCalledThenRowPitchIsSetToSlicePitch) {
auto builtIns = new MockBuiltins();
MockRootDeviceEnvironment::resetBuiltins(pCmdQ->getDevice().getExecutionEnvironment()->rootDeviceEnvironments[pCmdQ->getDevice().getRootDeviceIndex()].get(), builtIns);
EBuiltInOps::Type copyBuiltIn = EBuiltInOps::copyImage3dToBuffer;
EBuiltInOps::Type copyBuiltIn = EBuiltInOps::adjustBuiltinType<EBuiltInOps::copyImage3dToBuffer>(false, pCmdQ->getHeaplessModeEnabled());
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
copyBuiltIn,
pCmdQ->getClDevice());
@@ -941,15 +945,16 @@ typedef EnqueueReadImageMipMapTest MipMapReadImageTest;
HWTEST_P(MipMapReadImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalledThenProperMipLevelIsSet) {
auto builtIns = new MockBuiltins();
MockRootDeviceEnvironment::resetBuiltins(pCmdQ->getDevice().getExecutionEnvironment()->rootDeviceEnvironments[pCmdQ->getDevice().getRootDeviceIndex()].get(), builtIns);
EBuiltInOps::Type eBuiltInOp = EBuiltInOps::adjustBuiltinType<EBuiltInOps::copyImage3dToBuffer>(false, pCmdQ->getHeaplessModeEnabled());
auto imageType = (cl_mem_object_type)GetParam();
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::copyImage3dToBuffer,
eBuiltInOp,
pCmdQ->getClDevice());
// substitute original builder with mock builder
auto oldBuilder = pClExecutionEnvironment->setBuiltinDispatchInfoBuilder(
rootDeviceIndex,
EBuiltInOps::copyImage3dToBuffer,
eBuiltInOp,
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, pCmdQ->getClDevice(), &origBuilder)));
cl_int retVal = CL_SUCCESS;
@@ -1004,7 +1009,7 @@ HWTEST_P(MipMapReadImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalled
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::copyImage3dToBuffer,
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(eBuiltInOp,
pCmdQ->getClDevice()));
auto params = mockBuilder.getBuiltinOpParams();
@@ -1013,7 +1018,7 @@ HWTEST_P(MipMapReadImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalled
// restore original builder and retrieve mock builder
auto newBuilder = pClExecutionEnvironment->setBuiltinDispatchInfoBuilder(
rootDeviceIndex,
EBuiltInOps::copyImage3dToBuffer,
eBuiltInOp,
std::move(oldBuilder));
EXPECT_NE(nullptr, newBuilder);
}

1
opencl/test/unit_test/command_queue/enqueue_write_image_fixture.h
View File

@@ -17,6 +17,7 @@
namespace NEO {
struct EnqueueWriteImageTest : public CommandEnqueueFixture,
public SurfaceStateAccessor,
public ::testing::Test {
void SetUp(void) override {

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

@@ -189,17 +189,16 @@ HWCMDTEST_F(IGFX_GEN12LP_CORE, EnqueueWriteImageTest, WhenWritingImageThenInterf
EXPECT_NE(kernelStartPointer, interfaceDescriptorData.getBindingTablePointer());
}
HWTEST_F(EnqueueWriteImageTest, WhenWritingImageThenSurfaceStateIsProgrammedCorrectly) {
HWTEST_F(EnqueueWriteImageTest, WhenWritingImageThenSurfaceStateIsCorrect) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
VariableBackup<CommandQueue *> cmdQBackup(&pCmdQ, mockCmdQ.get());
mockCmdQ->storeMultiDispatchInfo = true;
enqueueWriteImage<FamilyType>();
auto index = mockCmdQ->storedMultiDispatchInfo.begin()->getKernel()->getKernelInfo().getArgDescriptorAt(1).template as<ArgDescImage>().bindful / sizeof(RENDER_SURFACE_STATE);
const auto surfaceState = getSurfaceState<FamilyType>(&pCmdQ->getIndirectHeap(IndirectHeap::Type::surfaceState, 0), static_cast<uint32_t>(index));
const auto surfaceState = SurfaceStateAccessor::getSurfaceState<FamilyType>(mockCmdQ, 1);
// EnqueueWriteImage uses multi-byte copies depending on per-pixel-size-in-bytes
const auto &imageDesc = dstImage->getImageDesc();
@@ -250,7 +249,9 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage1DarrayWhenWriteImageIsCalledThenRowPi
auto builtIns = new MockBuiltins();
MockRootDeviceEnvironment::resetBuiltins(pCmdQ->getDevice().getExecutionEnvironment()->rootDeviceEnvironments[pCmdQ->getDevice().getRootDeviceIndex()].get(), builtIns);
EBuiltInOps::Type copyBuiltIn = EBuiltInOps::copyBufferToImage3d;
const bool useStateless = false;
auto copyBuiltIn = EBuiltInOps::adjustBuiltinType<EBuiltInOps::copyBufferToImage3d>(useStateless, pCmdQ->getHeaplessModeEnabled());
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
copyBuiltIn,
pCmdQ->getClDevice());
@@ -401,14 +402,16 @@ HWTEST_P(MipMapWriteImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalle
auto builtIns = new MockBuiltins();
MockRootDeviceEnvironment::resetBuiltins(pCmdQ->getDevice().getExecutionEnvironment()->rootDeviceEnvironments[pCmdQ->getDevice().getRootDeviceIndex()].get(), builtIns);
EBuiltInOps::Type eBuiltInOp = EBuiltInOps::adjustBuiltinType<EBuiltInOps::copyBufferToImage3d>(false, pCmdQ->getHeaplessModeEnabled());
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::copyBufferToImage3d,
eBuiltInOp,
pCmdQ->getClDevice());
// substitute original builder with mock builder
auto oldBuilder = pClExecutionEnvironment->setBuiltinDispatchInfoBuilder(
rootDeviceIndex,
EBuiltInOps::copyBufferToImage3d,
eBuiltInOp,
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, pCmdQ->getClDevice(), &origBuilder)));
cl_int retVal = CL_SUCCESS;
@@ -466,7 +469,7 @@ HWTEST_P(MipMapWriteImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalle
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::copyBufferToImage3d,
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(eBuiltInOp,
pCmdQ->getClDevice()));
auto params = mockBuilder.getBuiltinOpParams();
@@ -475,7 +478,7 @@ HWTEST_P(MipMapWriteImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalle
// restore original builder and retrieve mock builder
auto newBuilder = pClExecutionEnvironment->setBuiltinDispatchInfoBuilder(
rootDeviceIndex,
EBuiltInOps::copyBufferToImage3d,
eBuiltInOp,
std::move(oldBuilder));
EXPECT_NE(nullptr, newBuilder);
}

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

@@ -440,7 +440,7 @@ TEST_F(ClDrmMemoryManagerTest, givenDrmMemoryManagerWhenTiledImageIsBeingCreated
mock->reset();
}
HWTEST_F(ClDrmMemoryManagerTest, givenDrmMemoryManagerWhenTiledImageIsBeingCreatedFromHostPtrThenAllocateGraphicsMemoryForImageIsUsed) {
HWTEST2_F(ClDrmMemoryManagerTest, givenDrmMemoryManagerWhenTiledImageIsBeingCreatedFromHostPtrThenAllocateGraphicsMemoryForImageIsUsed, IsAtMostXe3Core) {
if (!defaultHwInfo->capabilityTable.supportsImages) {
GTEST_SKIP();
}