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

refactor: remove not needed code related to vme

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2025-07-28 12:52:50 +00:00
committed by Compute-Runtime-Automation
parent b7f9d55118
commit dd568b35b9
20 changed files with 10 additions and 351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
opencl/source/kernel/kernel.cpp
View File

@@ -1590,12 +1590,7 @@ cl_int Kernel::setArgImageWithMipLevel(uint32_t argIndex,
// Sets SS structure
UNRECOVERABLE_IF(surfaceState == nullptr);
if (arg.getExtendedTypeInfo().isMediaImage) {
DEBUG_BREAK_IF(!kernelInfo.kernelDescriptor.kernelAttributes.flags.usesVme);
pImage->setMediaImageArg(surfaceState, rootDeviceIndex);
} else {
pImage->setImageArg(surfaceState, arg.getExtendedTypeInfo().isMediaBlockImage, mipLevel, rootDeviceIndex);
}
pImage->setImageArg(surfaceState, arg.getExtendedTypeInfo().isMediaBlockImage, mipLevel, rootDeviceIndex);
auto &imageDesc = pImage->getImageDesc();
auto &imageFormat = pImage->getImageFormat();

6
opencl/source/mem_obj/image.h
View File

@@ -142,9 +142,6 @@ class Image : public MemObj {
size_t *paramValueSizeRet);
virtual void setImageArg(void *memory, bool isMediaBlockImage, uint32_t mipLevel, uint32_t rootDeviceIndex) = 0;
virtual void setMediaImageArg(void *memory, uint32_t rootDeviceIndex) = 0;
virtual void setMediaSurfaceRotation(void *memory) = 0;
virtual void setSurfaceMemoryObjectControlState(void *memory, uint32_t value) = 0;
const cl_image_desc &getImageDesc() const;
const cl_image_format &getImageFormat() const;
@@ -343,9 +340,6 @@ class ImageHw : public Image {
void setImageArg(void *memory, bool setAsMediaBlockImage, uint32_t mipLevel, uint32_t rootDeviceIndex) override;
void setAuxParamsForMultisamples(RENDER_SURFACE_STATE *surfaceState, uint32_t rootDeviceIndex);
void setMediaImageArg(void *memory, uint32_t rootDeviceIndex) override;
void setMediaSurfaceRotation(void *memory) override;
void setSurfaceMemoryObjectControlState(void *memory, uint32_t value) override;
void appendSurfaceStateParams(RENDER_SURFACE_STATE *surfaceState, uint32_t rootDeviceIndex);
void appendSurfaceStateDepthParams(RENDER_SURFACE_STATE *surfaceState, Gmm *gmm);
void appendSurfaceStateExt(void *memory);

71
opencl/source/mem_obj/image.inl
View File

@@ -147,57 +147,6 @@ template <typename GfxFamily>
inline void ImageHw<GfxFamily>::appendSurfaceStateDepthParams(RENDER_SURFACE_STATE *surfaceState, Gmm *gmm) {
}
template <typename GfxFamily>
void ImageHw<GfxFamily>::setMediaImageArg(void *memory, uint32_t rootDeviceIndex) {
using MEDIA_SURFACE_STATE = typename GfxFamily::MEDIA_SURFACE_STATE;
using SURFACE_FORMAT = typename MEDIA_SURFACE_STATE::SURFACE_FORMAT;
SURFACE_FORMAT surfaceFormat = MEDIA_SURFACE_STATE::SURFACE_FORMAT_Y8_UNORM_VA;
auto graphicsAllocation = multiGraphicsAllocation.getGraphicsAllocation(rootDeviceIndex);
auto gmmHelper = executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->getGmmHelper();
auto surfaceState = reinterpret_cast<MEDIA_SURFACE_STATE *>(memory);
MEDIA_SURFACE_STATE state = GfxFamily::cmdInitMediaSurfaceState;
setMediaSurfaceRotation(reinterpret_cast<void *>(&state));
DEBUG_BREAK_IF(surfaceFormat == MEDIA_SURFACE_STATE::SURFACE_FORMAT_Y1_UNORM);
state.setWidth(static_cast<uint32_t>(getImageDesc().image_width));
state.setHeight(static_cast<uint32_t>(getImageDesc().image_height));
state.setPictureStructure(MEDIA_SURFACE_STATE::PICTURE_STRUCTURE_FRAME_PICTURE);
auto gmm = graphicsAllocation->getDefaultGmm();
auto tileMode = static_cast<typename MEDIA_SURFACE_STATE::TILE_MODE>(gmm->gmmResourceInfo->getTileModeSurfaceState());
state.setTileMode(tileMode);
state.setSurfacePitch(static_cast<uint32_t>(getImageDesc().image_row_pitch));
state.setSurfaceFormat(surfaceFormat);
state.setHalfPitchForChroma(false);
state.setInterleaveChroma(false);
state.setXOffsetForUCb(0);
state.setYOffsetForUCb(0);
state.setXOffsetForVCr(0);
state.setYOffsetForVCr(0);
setSurfaceMemoryObjectControlState(
reinterpret_cast<void *>(&state),
gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_IMAGE));
if (isNV12Image(&this->getImageFormat())) {
state.setInterleaveChroma(true);
state.setYOffsetForUCb(this->surfaceOffsets.yOffsetForUVplane);
}
state.setVerticalLineStride(0);
state.setVerticalLineStrideOffset(0);
state.setSurfaceBaseAddress(graphicsAllocation->getGpuAddress() + this->surfaceOffsets.offset);
*surfaceState = state;
}
template <typename GfxFamily>
void ImageHw<GfxFamily>::transformImage2dArrayTo3d(void *memory) {
DEBUG_BREAK_IF(imageDesc.image_type != CL_MEM_OBJECT_IMAGE3D);
@@ -219,24 +168,4 @@ template <typename GfxFamily>
void ImageHw<GfxFamily>::adjustDepthLimitations(RENDER_SURFACE_STATE *surfaceState, uint32_t minArrayElement, uint32_t renderTargetViewExtent, uint32_t depth, uint32_t mipCount, bool is3DUavOrRtv) {
}
template <typename GfxFamily>
inline void ImageHw<GfxFamily>::setMediaSurfaceRotation(void *memory) {
using MEDIA_SURFACE_STATE = typename GfxFamily::MEDIA_SURFACE_STATE;
auto surfaceState = reinterpret_cast<MEDIA_SURFACE_STATE *>(memory);
surfaceState->setRotation(MEDIA_SURFACE_STATE::ROTATION_NO_ROTATION_OR_0_DEGREE);
surfaceState->setXOffset(0);
surfaceState->setYOffset(0);
}
template <typename GfxFamily>
inline void ImageHw<GfxFamily>::setSurfaceMemoryObjectControlState(void *memory, uint32_t value) {
using MEDIA_SURFACE_STATE = typename GfxFamily::MEDIA_SURFACE_STATE;
auto surfaceState = reinterpret_cast<MEDIA_SURFACE_STATE *>(memory);
surfaceState->setSurfaceMemoryObjectControlState(value);
}
} // namespace NEO

11
opencl/test/unit_test/accelerators/CMakeLists.txt
View File

@@ -1,11 +0,0 @@
#
# Copyright (C) 2018-2021 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(IGDRCL_SRCS_tests_accelerators
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/media_image_arg_tests.cpp
)
target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_accelerators})

139
opencl/test/unit_test/accelerators/media_image_arg_tests.cpp
View File

@@ -1,139 +0,0 @@
/*
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/ptr_math.h"
#include "shared/source/memory_manager/surface.h"
#include "opencl/source/kernel/kernel.h"
#include "opencl/source/mem_obj/image.h"
#include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
#include "opencl/test/unit_test/fixtures/image_fixture.h"
#include "opencl/test/unit_test/mocks/mock_cl_device.h"
#include "opencl/test/unit_test/mocks/mock_kernel.h"
#include "opencl/test/unit_test/mocks/mock_program.h"
namespace NEO {
struct KernelInfo;
} // namespace NEO
using namespace NEO;
class MediaImageSetArgTest : public ClDeviceFixture,
public testing::Test {
public:
MediaImageSetArgTest() = default;
protected:
void SetUp() override {
ClDeviceFixture::setUp();
context = new MockContext(pClDevice);
pKernelInfo = std::make_unique<MockKernelInfo>();
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
program->setContext(context);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->addArgImage(0, 0x00, iOpenCL::IMAGE_MEMORY_OBJECT_2D_MEDIA);
pKernelInfo->addArgImage(0, 0x40, iOpenCL::IMAGE_MEMORY_OBJECT_2D_MEDIA);
int32_t retVal = CL_INVALID_PLATFORM;
pMultiDeviceKernel = MultiDeviceKernel::create<MockKernel>(program.get(), MockKernel::toKernelInfoContainer(*static_cast<KernelInfo *>(pKernelInfo.get()), rootDeviceIndex), retVal);
pKernel = static_cast<MockKernel *>(pMultiDeviceKernel->getKernel(rootDeviceIndex));
ASSERT_NE(nullptr, pKernel);
ASSERT_EQ(CL_SUCCESS, retVal);
pKernel->setKernelArgHandler(0, &Kernel::setArgImage);
pKernel->setKernelArgHandler(1, &Kernel::setArgImage);
srcImage = Image2dHelperUlt<>::create(context);
ASSERT_NE(nullptr, srcImage);
}
void TearDown() override {
delete srcImage;
delete pMultiDeviceKernel;
program.reset();
delete context;
ClDeviceFixture::tearDown();
}
cl_int retVal = CL_SUCCESS;
MockContext *context;
std::unique_ptr<MockProgram> program;
MockKernel *pKernel = nullptr;
MultiDeviceKernel *pMultiDeviceKernel = nullptr;
std::unique_ptr<MockKernelInfo> pKernelInfo;
char surfaceStateHeap[0x80];
Image *srcImage = nullptr;
};
HWTEST_F(MediaImageSetArgTest, WhenSettingMediaImageArgThenArgsSetCorrectly) {
typedef typename FamilyType::MEDIA_SURFACE_STATE MEDIA_SURFACE_STATE;
auto pSurfaceState = reinterpret_cast<const MEDIA_SURFACE_STATE *>(
ptrOffset(pKernel->getSurfaceStateHeap(),
pKernelInfo->argAsImg(0).bindful));
srcImage->setMediaImageArg(const_cast<MEDIA_SURFACE_STATE *>(pSurfaceState), pClDevice->getRootDeviceIndex());
SurfaceOffsets surfaceOffsets;
srcImage->getSurfaceOffsets(surfaceOffsets);
EXPECT_EQ(srcImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex())->getGpuAddress() + surfaceOffsets.offset,
pSurfaceState->getSurfaceBaseAddress());
std::vector<Surface *> surfaces;
pKernel->getResidency(surfaces);
EXPECT_EQ(0u, surfaces.size());
}
HWTEST_F(MediaImageSetArgTest, WhenSettingKernelArgImageThenArgsSetCorrectly) {
typedef typename FamilyType::MEDIA_SURFACE_STATE MEDIA_SURFACE_STATE;
cl_mem memObj = srcImage;
retVal = clSetKernelArg(
pMultiDeviceKernel,
0,
sizeof(memObj),
&memObj);
ASSERT_EQ(CL_SUCCESS, retVal);
auto pSurfaceState = reinterpret_cast<const MEDIA_SURFACE_STATE *>(
ptrOffset(pKernel->getSurfaceStateHeap(),
pKernelInfo->argAsImg(0).bindful));
uint64_t surfaceAddress = pSurfaceState->getSurfaceBaseAddress();
ASSERT_EQ(srcImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex())->getGpuAddress(), surfaceAddress);
EXPECT_EQ(srcImage->getImageDesc().image_width, pSurfaceState->getWidth());
EXPECT_EQ(srcImage->getImageDesc().image_height, pSurfaceState->getHeight());
typename FamilyType::MEDIA_SURFACE_STATE::TILE_MODE tileMode;
if (srcImage->isTiledAllocation()) {
tileMode = FamilyType::MEDIA_SURFACE_STATE::TILE_MODE_TILEMODE_YMAJOR;
} else {
tileMode = FamilyType::MEDIA_SURFACE_STATE::TILE_MODE_TILEMODE_LINEAR;
}
EXPECT_EQ(tileMode, pSurfaceState->getTileMode());
EXPECT_EQ(MEDIA_SURFACE_STATE::SURFACE_FORMAT_Y8_UNORM_VA, pSurfaceState->getSurfaceFormat());
EXPECT_EQ(MEDIA_SURFACE_STATE::PICTURE_STRUCTURE_FRAME_PICTURE, pSurfaceState->getPictureStructure());
std::vector<Surface *> surfaces;
pKernel->getResidency(surfaces);
for (auto &surface : surfaces) {
delete surface;
}
EXPECT_EQ(1u, surfaces.size());
}

3
opencl/test/unit_test/command_queue/enqueue_map_image_tests.cpp
View File

@@ -938,9 +938,6 @@ TEST_F(EnqueueMapImageTest, givenImage1DArrayWhenEnqueueMapImageIsCalledThenRetu
}
void setImageArg(void *memory, bool isMediaBlockImage, uint32_t mipLevel, uint32_t rootDeviceIndex) override {}
void setMediaImageArg(void *memory, uint32_t rootDeviceIndex) override {}
void setMediaSurfaceRotation(void *memory) override {}
void setSurfaceMemoryObjectControlState(void *memory, uint32_t value) override {}
void transformImage2dArrayTo3d(void *memory) override {}
void transformImage3dTo2dArray(void *memory) override {}
};

2
opencl/test/unit_test/kernel/kernel_tests.cpp
View File

@@ -2441,7 +2441,6 @@ TEST(KernelImageDetectionTests, givenKernelWithImagesOnlyWhenItIsAskedIfItHasIma
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
pKernelInfo->addArgImage(0);
pKernelInfo->argAt(0).getExtendedTypeInfo().isMediaImage = true;
pKernelInfo->addArgImage(1);
pKernelInfo->addArgImage(2);
@@ -2461,7 +2460,6 @@ TEST(KernelImageDetectionTests, givenKernelWithImagesAndBuffersWhenItIsAskedIfIt
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
pKernelInfo->addArgImage(0);
pKernelInfo->argAt(0).getExtendedTypeInfo().isMediaImage = true;
pKernelInfo->addArgBuffer(1);
pKernelInfo->addArgImage(2);

5
opencl/test/unit_test/mem_obj/image_validate_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -773,9 +773,6 @@ struct NullImage : public Image {
delete this->multiGraphicsAllocation.getGraphicsAllocation(0);
}
void setImageArg(void *memory, bool isMediaBlockImage, uint32_t mipLevel, uint32_t rootDeviceIndex) override {}
void setMediaImageArg(void *memory, uint32_t rootDeviceIndex) override {}
void setMediaSurfaceRotation(void *memory) override {}
void setSurfaceMemoryObjectControlState(void *memory, uint32_t value) override {}
void transformImage2dArrayTo3d(void *memory) override {}
void transformImage3dTo2dArray(void *memory) override {}
};

18
opencl/test/unit_test/mem_obj/nv12_image_tests.cpp
View File

@@ -437,24 +437,6 @@ HWTEST_F(Nv12ImageTest, WhenSettingImageArgUvPlaneImageThenOffsetSurfaceBaseAddr
EXPECT_EQ(tileMode, surfaceState.getTileMode());
}
HWTEST_F(Nv12ImageTest, WhenSettingMediaImageArgThenSurfaceStateIsCorrect) {
using MEDIA_SURFACE_STATE = typename FamilyType::MEDIA_SURFACE_STATE;
MEDIA_SURFACE_STATE surfaceState;
std::unique_ptr<Image> image{createImageWithFlags(CL_MEM_READ_ONLY | CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL)};
ASSERT_NE(nullptr, image);
SurfaceOffsets surfaceOffsets;
image->getSurfaceOffsets(surfaceOffsets);
image->setMediaImageArg(&surfaceState, context.getDevice(0)->getRootDeviceIndex());
EXPECT_EQ(surfaceOffsets.xOffset, surfaceState.getXOffsetForUCb());
EXPECT_EQ(surfaceOffsets.yOffset, surfaceState.getXOffsetForUCb());
EXPECT_EQ(surfaceOffsets.yOffsetForUVplane, surfaceState.getYOffsetForUCb());
EXPECT_EQ(image->getGraphicsAllocation(context.getDevice(0)->getRootDeviceIndex())->getGpuAddress() + surfaceOffsets.offset,
surfaceState.getSurfaceBaseAddress());
}
TEST_F(Nv12ImageTest, WhenRedescribingThenNV12ImageAndUVPlaneImageHaveCorrectOffsets) {
std::unique_ptr<Image> image{createImageWithFlags(CL_MEM_READ_ONLY | CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL)};
ASSERT_NE(nullptr, image);

5
opencl/test/unit_test/mocks/mock_image.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -40,9 +40,6 @@ struct MockImageBase : public Image {
}
void setImageArg(void *memory, bool isMediaBlockImage, uint32_t mipLevel, uint32_t rootDeviceIndex) override {}
void setMediaImageArg(void *memory, uint32_t rootDeviceIndex) override {}
void setMediaSurfaceRotation(void *memory) override {}
void setSurfaceMemoryObjectControlState(void *memory, uint32_t value) override {}
void transformImage2dArrayTo3d(void *memory) override {}
void transformImage3dTo2dArray(void *memory) override {}
};

7
shared/source/command_stream/preemption.cpp
View File

@@ -28,16 +28,12 @@ bool PreemptionHelper::allowThreadGroupPreemption(const PreemptionFlags &flags)
flags.flags.disableLSQCROPERFforOCL) {
return false;
}
if (flags.flags.vmeKernel) {
return false;
}
return true;
}
bool PreemptionHelper::allowMidThreadPreemption(const PreemptionFlags &flags) {
return (flags.flags.disabledMidThreadPreemptionKernel == 0) &&
!(flags.flags.vmeKernel);
return flags.flags.disabledMidThreadPreemptionKernel == 0;
}
PreemptionMode PreemptionHelper::taskPreemptionMode(PreemptionMode devicePreemptionMode, const PreemptionFlags &flags) {
@@ -86,7 +82,6 @@ PreemptionFlags PreemptionHelper::createPreemptionLevelFlags(Device &device, con
PreemptionFlags flags = {};
if (kernelDescriptor) {
flags.flags.disabledMidThreadPreemptionKernel = kernelDescriptor->kernelAttributes.flags.requiresDisabledMidThreadPreemption;
flags.flags.vmeKernel = kernelDescriptor->kernelAttributes.flags.usesVme;
flags.flags.usesFencesForReadWriteImages = kernelDescriptor->kernelAttributes.flags.usesFencesForReadWriteImages;
}
flags.flags.disablePerCtxtPreemptionGranularityControl = device.getHardwareInfo().workaroundTable.flags.waDisablePerCtxtPreemptionGranularityControl;

3
shared/source/command_stream/preemption.h
View File

@@ -29,11 +29,10 @@ struct PreemptionFlags {
union {
struct {
uint32_t disabledMidThreadPreemptionKernel : 1;
uint32_t vmeKernel : 1;
uint32_t disablePerCtxtPreemptionGranularityControl : 1;
uint32_t usesFencesForReadWriteImages : 1;
uint32_t disableLSQCROPERFforOCL : 1;
uint32_t reserved : 27;
uint32_t reserved : 28;
} flags;
uint32_t data;
};

4
shared/source/device_binary_format/zebin/zeinfo_decoder.cpp
View File

@@ -1242,16 +1242,12 @@ DecodeError populateKernelPayloadArgument(NEO::KernelDescriptor &dst, const Kern
}
auto &extendedInfo = dst.payloadMappings.explicitArgs[src.argIndex].getExtendedTypeInfo();
extendedInfo.isMediaImage = (src.imageType == Types::Kernel::PayloadArgument::ImageType::imageType2DMedia);
extendedInfo.isMediaBlockImage = (src.imageType == Types::Kernel::PayloadArgument::ImageType::imageType2DMediaBlock);
extendedInfo.isTransformable = src.imageTransformable;
dst.kernelAttributes.flags.usesImages = true;
} break;
case Types::Kernel::PayloadArgument::addressSpaceSampler: {
using SamplerType = Types::Kernel::PayloadArgument::SamplerType;
dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescSampler>(true);
const bool usesVme = src.samplerType == SamplerType::samplerTypeVME;
dst.kernelAttributes.flags.usesVme = usesVme;
dst.kernelAttributes.flags.usesSamplers = true;
} break;
}

1
shared/source/kernel/kernel_arg_descriptor.h
View File

@@ -146,7 +146,6 @@ struct ArgDescriptor final {
}
union {
struct {
bool isMediaImage : 1;
bool isMediaBlockImage : 1;
bool isTransformable : 1;
bool needsPatch : 1;

9
shared/source/kernel/kernel_descriptor.h
View File

@@ -122,10 +122,9 @@ struct KernelDescriptor : NEO::NonCopyableAndNonMovableClass {
bool usesFencesForReadWriteImages : 1;
bool usesFlattenedLocalIds : 1;
bool usesPrivateMemory : 1;
bool usesVme : 1;
bool usesImages : 1;
// 1
bool usesSamplers : 1;
// 1
bool usesSyncBuffer : 1;
bool deprecatedDoNotUse : 1;
bool usesStatelessWrites : 1;
@@ -133,8 +132,8 @@ struct KernelDescriptor : NEO::NonCopyableAndNonMovableClass {
bool perThreadDataHeaderIsPresent : 1;
bool perThreadDataUnusedGrfIsPresent : 1;
bool requiresDisabledEUFusion : 1;
// 2
bool requiresDisabledMidThreadPreemption : 1;
// 2
bool requiresSubgroupIndependentForwardProgress : 1;
bool requiresWorkgroupWalkOrder : 1;
bool requiresImplicitArgs : 1;
@@ -142,10 +141,10 @@ struct KernelDescriptor : NEO::NonCopyableAndNonMovableClass {
bool hasRTCalls : 1;
bool isInvalid : 1;
bool hasSample : 1;
// 3
bool usesAssert : 1;
// 3
bool usesRegionGroupBarrier : 1;
bool reserved : 6;
bool reserved : 7;
};
std::array<bool, 4> packed;
} flags = {};

12
shared/source/kernel/kernel_descriptor_from_patchtokens.cpp
View File

@@ -243,10 +243,6 @@ void populateKernelArgDescriptor(KernelDescriptor &dst, size_t argNum, const SPa
dst.kernelAttributes.numArgsStateful++;
}
if (token.Type == iOpenCL::IMAGE_MEMORY_OBJECT_2D_MEDIA) {
dst.payloadMappings.explicitArgs[argNum].getExtendedTypeInfo().isMediaImage = true;
}
if (token.Type == iOpenCL::IMAGE_MEMORY_OBJECT_2D_MEDIA_BLOCK) {
dst.payloadMappings.explicitArgs[argNum].getExtendedTypeInfo().isMediaBlockImage = true;
}
@@ -266,13 +262,6 @@ void populateKernelArgDescriptor(KernelDescriptor &dst, size_t argNum, const SPa
argSampler.bindful = token.Offset;
argSampler.samplerType = token.Type;
if (token.Type != iOpenCL::SAMPLER_OBJECT_TEXTURE) {
DEBUG_BREAK_IF(token.Type != iOpenCL::SAMPLER_OBJECT_VME &&
token.Type != iOpenCL::SAMPLER_OBJECT_VE &&
token.Type != iOpenCL::SAMPLER_OBJECT_VD);
dst.kernelAttributes.flags.usesVme |= (token.Type == iOpenCL::SAMPLER_OBJECT_VME);
}
}
void populateKernelArgDescriptor(KernelDescriptor &dst, size_t argNum, const SPatchGlobalMemoryObjectKernelArgument &token) {
@@ -464,7 +453,6 @@ void populateKernelDescriptor(KernelDescriptor &dst, const PatchTokenBinary::Ker
populateKernelDescriptorIfNotNull(dst, str);
}
dst.kernelAttributes.flags.usesVme |= (src.tokens.inlineVmeSamplerInfo != nullptr);
dst.entryPoints.systemKernel = src.tokens.stateSip ? src.tokens.stateSip->SystemKernelOffset : 0U;
populateKernelDescriptorIfNotNull(dst, src.tokens.allocateSystemThreadSurface);

4
shared/test/common/mocks/mock_kernel_info.cpp
View File

@@ -32,9 +32,7 @@ void MockKernelInfo::addArgImage(uint32_t index, SurfaceStateHeapOffset offset,
arg.bindless = offset;
}
if (type == iOpenCL::IMAGE_MEMORY_OBJECT_2D_MEDIA) {
argAt(index).getExtendedTypeInfo().isMediaImage = true;
} else if (type == iOpenCL::IMAGE_MEMORY_OBJECT_2D_MEDIA_BLOCK) {
if (type == iOpenCL::IMAGE_MEMORY_OBJECT_2D_MEDIA_BLOCK) {
argAt(index).getExtendedTypeInfo().isMediaBlockImage = true;
}

2
shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp
View File

@@ -5772,7 +5772,6 @@ TEST_F(decodeZeInfoKernelEntryTest, GivenValidImageArgumentWithImageMetadataThen
auto &args = kernelDescriptor->payloadMappings.explicitArgs;
EXPECT_EQ(64U, args[0].as<ArgDescImage>().bindful);
EXPECT_TRUE(args[0].getExtendedTypeInfo().isMediaImage);
EXPECT_TRUE(args[0].getExtendedTypeInfo().isTransformable);
EXPECT_EQ(NEOImageType::imageType2DMedia, args[0].as<ArgDescImage>().imageType);
@@ -5868,7 +5867,6 @@ TEST_F(decodeZeInfoKernelEntryTest, GivenValidSamplerArgumentWithMetadataThenPop
EXPECT_EQ(undefined<uint8_t>, sampler2.size);
EXPECT_TRUE(kd.kernelAttributes.flags.usesSamplers);
EXPECT_FALSE(kd.kernelAttributes.flags.usesVme);
}
TEST_F(decodeZeInfoKernelEntryTest, GivenBindlessSamplerArgumentWithMetadataThenKernelDescriptorIsPopulated) {

29
shared/test/unit_test/kernel/kernel_descriptor_from_patchtokens_tests.cpp
View File

@@ -558,27 +558,16 @@ TEST(KernelDescriptorFromPatchtokens, GivenKernelWithImageMemoryObjectKernelArgu
EXPECT_TRUE(dst.payloadMappings.explicitArgs[1].is<NEO::ArgDescriptor::argTImage>());
EXPECT_EQ(imageArg.Offset, dst.payloadMappings.explicitArgs[1].as<NEO::ArgDescImage>().bindful);
EXPECT_TRUE(NEO::isUndefinedOffset(dst.payloadMappings.explicitArgs[1].as<NEO::ArgDescImage>().bindless));
EXPECT_FALSE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().isMediaImage);
EXPECT_FALSE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().isMediaBlockImage);
EXPECT_FALSE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().isTransformable);
;
EXPECT_TRUE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().needsPatch);
}
{
imageArg.Type = iOpenCL::IMAGE_MEMORY_OBJECT_2D_MEDIA;
NEO::KernelDescriptor dst = {};
NEO::populateKernelDescriptor(dst, kernelTokens, sizeof(void *));
EXPECT_TRUE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().isMediaImage);
EXPECT_FALSE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().isMediaBlockImage);
EXPECT_FALSE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().isTransformable);
}
{
imageArg.Type = iOpenCL::IMAGE_MEMORY_OBJECT_2D_MEDIA_BLOCK;
NEO::KernelDescriptor dst = {};
NEO::populateKernelDescriptor(dst, kernelTokens, sizeof(void *));
EXPECT_FALSE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().isMediaImage);
EXPECT_TRUE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().isMediaBlockImage);
EXPECT_FALSE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().isTransformable);
}
@@ -587,7 +576,6 @@ TEST(KernelDescriptorFromPatchtokens, GivenKernelWithImageMemoryObjectKernelArgu
imageArg.Transformable = 1;
NEO::KernelDescriptor dst = {};
NEO::populateKernelDescriptor(dst, kernelTokens, sizeof(void *));
EXPECT_FALSE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().isMediaImage);
EXPECT_TRUE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().isMediaBlockImage);
EXPECT_TRUE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().isTransformable);
}
@@ -630,7 +618,6 @@ TEST(KernelDescriptorFromPatchtokens, GivenKernelWithSamplerKernelArgumentThenKe
EXPECT_TRUE(NEO::isUndefinedOffset(dst.payloadMappings.explicitArgs[1].as<NEO::ArgDescSampler>().bindless));
EXPECT_EQ(samplerArg.Type, dst.payloadMappings.explicitArgs[1].as<NEO::ArgDescSampler>().samplerType);
EXPECT_TRUE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().needsPatch);
EXPECT_FALSE(dst.kernelAttributes.flags.usesVme);
}
TEST(KernelDescriptorFromPatchtokens, GivenKernelWithSamplerKernelArgumentWhenSamplerIsVmeThenKernelDescriptorIsProperlyPopulated) {
@@ -650,7 +637,6 @@ TEST(KernelDescriptorFromPatchtokens, GivenKernelWithSamplerKernelArgumentWhenSa
NEO::populateKernelDescriptor(dst, kernelTokens, sizeof(void *));
EXPECT_TRUE(dst.payloadMappings.explicitArgs[1].is<NEO::ArgDescriptor::argTSampler>());
EXPECT_EQ(samplerArg.Type, dst.payloadMappings.explicitArgs[1].as<NEO::ArgDescSampler>().samplerType);
EXPECT_TRUE(dst.kernelAttributes.flags.usesVme);
}
{
@@ -659,7 +645,6 @@ TEST(KernelDescriptorFromPatchtokens, GivenKernelWithSamplerKernelArgumentWhenSa
NEO::populateKernelDescriptor(dst, kernelTokens, sizeof(void *));
EXPECT_TRUE(dst.payloadMappings.explicitArgs[1].is<NEO::ArgDescriptor::argTSampler>());
EXPECT_EQ(samplerArg.Type, dst.payloadMappings.explicitArgs[1].as<NEO::ArgDescSampler>().samplerType);
EXPECT_FALSE(dst.kernelAttributes.flags.usesVme);
}
{
@@ -668,7 +653,6 @@ TEST(KernelDescriptorFromPatchtokens, GivenKernelWithSamplerKernelArgumentWhenSa
NEO::populateKernelDescriptor(dst, kernelTokens, sizeof(void *));
EXPECT_TRUE(dst.payloadMappings.explicitArgs[1].is<NEO::ArgDescriptor::argTSampler>());
EXPECT_EQ(samplerArg.Type, dst.payloadMappings.explicitArgs[1].as<NEO::ArgDescSampler>().samplerType);
EXPECT_FALSE(dst.kernelAttributes.flags.usesVme);
}
}
@@ -1013,19 +997,6 @@ TEST(KernelDescriptorFromPatchtokens, GivenKernelWithSlmArgumentAndMetadataThenK
}
}
TEST(KernelDescriptorFromPatchtokens, GivenKernelWithInlineVmeThenKernelDescriptorIsProperlyPopulated) {
std::vector<uint8_t> storage;
NEO::PatchTokenBinary::KernelFromPatchtokens kernelTokens = PatchTokensTestData::ValidEmptyKernel::create(storage);
NEO::KernelDescriptor dst;
NEO::populateKernelDescriptor(dst, kernelTokens, 4);
EXPECT_FALSE(dst.kernelAttributes.flags.usesVme);
iOpenCL::SPatchItemHeader inlineVme = {};
kernelTokens.tokens.inlineVmeSamplerInfo = &inlineVme;
NEO::populateKernelDescriptor(dst, kernelTokens, 4);
EXPECT_TRUE(dst.kernelAttributes.flags.usesVme);
}
TEST(KernelDescriptorFromPatchtokens, GivenKernelWithSipDataThenKernelDescriptorIsProperlyPopulated) {
std::vector<uint8_t> storage;
NEO::PatchTokenBinary::KernelFromPatchtokens kernelTokens = PatchTokensTestData::ValidEmptyKernel::create(storage);

23
shared/test/unit_test/preemption/preemption_tests.cpp
View File

@@ -72,13 +72,6 @@ TEST_F(ThreadGroupPreemptionTests, GivenDisallowByReadWriteFencesWaThenThreadGro
EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(ThreadGroupPreemptionTests, GivenDisallowByVmeKernelThenThreadGroupPreemptionIsDisabled) {
kernelDescriptor.kernelAttributes.flags.usesVme = true;
PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(*device, &kernelDescriptor);
EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(ThreadGroupPreemptionTests, GivenDefaultThenThreadGroupPreemptionIsEnabled) {
PreemptionFlags flags = {};
EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags));
@@ -146,13 +139,6 @@ TEST_F(MidThreadPreemptionTests, GivenDisallowMidThreadPreemptionByKernelThenMid
EXPECT_FALSE(PreemptionHelper::allowMidThreadPreemption(flags));
}
TEST_F(MidThreadPreemptionTests, GivenDisallowMidThreadPreemptionByVmeKernelThenMidThreadPreemptionIsEnabled) {
device->setPreemptionMode(PreemptionMode::MidThread);
kernelDescriptor.kernelAttributes.flags.usesVme = true;
PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(*device, &kernelDescriptor);
EXPECT_FALSE(PreemptionHelper::allowMidThreadPreemption(flags));
}
TEST_F(MidThreadPreemptionTests, GivenTaskPreemptionDisallowMidThreadByDeviceThenThreadGroupPreemptionIsEnabled) {
kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = false;
device->setPreemptionMode(PreemptionMode::ThreadGroup);
@@ -169,15 +155,6 @@ TEST_F(MidThreadPreemptionTests, GivenTaskPreemptionDisallowMidThreadByKernelThe
EXPECT_EQ(PreemptionMode::ThreadGroup, outMode);
}
TEST_F(MidThreadPreemptionTests, GivenTaskPreemptionDisallowMidThreadByVmeKernelThenThreadGroupPreemptionIsEnabled) {
kernelDescriptor.kernelAttributes.flags.usesVme = true;
device->setPreemptionMode(PreemptionMode::MidThread);
PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(*device, &kernelDescriptor);
PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
// VME disables mid thread and thread group when device does not support it
EXPECT_EQ(PreemptionMode::MidBatch, outMode);
}
TEST_F(MidThreadPreemptionTests, GivenDeviceSupportsMidThreadPreemptionThenMidThreadPreemptionIsEnabled) {
kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = false;
device->setPreemptionMode(PreemptionMode::MidThread);