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

Add support for ZE_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER 

Change-Id: I52267d3179ded147a91bcfa0d0023fd4cacb4129
Signed-off: Jaime Arteaga <jaime.a.arteaga.molina@intel.com>
This commit is contained in:
Jaime Arteaga 2020-03-21 17:18:03 -07:00
parent 2c25777f3c
commit 8f4ca00b8c
5 changed files with 205 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
level_zero/core/source/sampler/sampler_hw.inl
View File

@ -17,11 +17,10 @@ template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t SamplerCoreFamily<gfxCoreFamily>::initialize(Device *device, const ze_sampler_desc_t *desc) {
using SAMPLER_STATE = typename GfxFamily::SAMPLER_STATE;
ze_result_t ret;
ret = BaseClass::initialize(device, desc);
if (ret != ZE_RESULT_SUCCESS)
ze_result_t ret = BaseClass::initialize(device, desc);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
auto addressControlModeX = SAMPLER_STATE::TEXTURE_COORDINATE_MODE_CLAMP_BORDER;
auto addressControlModeY = SAMPLER_STATE::TEXTURE_COORDINATE_MODE_CLAMP_BORDER;
@ -31,6 +30,11 @@ ze_result_t SamplerCoreFamily<gfxCoreFamily>::initialize(Device *device, const z
case ZE_SAMPLER_ADDRESS_MODE_NONE:
case ZE_SAMPLER_ADDRESS_MODE_CLAMP:
break;
case ZE_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER:
addressControlModeX = SAMPLER_STATE::TEXTURE_COORDINATE_MODE_CLAMP;
addressControlModeY = SAMPLER_STATE::TEXTURE_COORDINATE_MODE_CLAMP;
addressControlModeZ = SAMPLER_STATE::TEXTURE_COORDINATE_MODE_CLAMP;
break;
case ZE_SAMPLER_ADDRESS_MODE_MIRROR:
addressControlModeX = SAMPLER_STATE::TEXTURE_COORDINATE_MODE_MIRROR;
addressControlModeY = SAMPLER_STATE::TEXTURE_COORDINATE_MODE_MIRROR;

1
level_zero/core/test/unit_tests/mocks/CMakeLists.txt
View File

@ -23,6 +23,7 @@ set(L0_MOCKS_SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/mock_kernel.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_memory_manager.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_memory_manager.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sampler.h
)
add_library(${TARGET_NAME} OBJECT ${L0_MOCKS_SOURCES})

45
level_zero/core/test/unit_tests/mocks/mock_sampler.h Normal file
View File

@ -0,0 +1,45 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/core/source/sampler/sampler.h"
#include "level_zero/core/source/sampler/sampler_hw.h"
#include "level_zero/core/test/unit_tests/mock.h"
#include "level_zero/core/test/unit_tests/white_box.h"
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winconsistent-missing-override"
#endif
namespace L0 {
namespace ult {
using Sampler = WhiteBox<::L0::Sampler>;
template <>
struct Mock<Sampler> : public Sampler {
Mock() = default;
MOCK_METHOD0(destroy, ze_result_t());
MOCK_METHOD2(create, ze_result_t(Device *, const ze_sampler_desc_t *));
};
template <GFXCORE_FAMILY gfxCoreFamily>
struct MockSamplerHw : public L0::SamplerCoreFamily<gfxCoreFamily> {
using BaseClass = ::L0::SamplerCoreFamily<gfxCoreFamily>;
using BaseClass::lodMax;
using BaseClass::lodMin;
using BaseClass::samplerState;
};
} // namespace ult
} // namespace L0
#if defined(__clang__)
#pragma clang diagnostic pop
#endif

10
level_zero/core/test/unit_tests/sources/sampler/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
#
# Copyright (C) 2020 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_sampler.cpp
)

141
level_zero/core/test/unit_tests/sources/sampler/test_sampler.cpp Normal file
View File

@ -0,0 +1,141 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/utilities/numeric.h"
#include "test.h"
#include "level_zero/core/source/sampler/sampler_hw.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/core/test/unit_tests/mocks/mock_sampler.h"
namespace L0 {
namespace ult {
const auto samplerAddressMode = ::testing::Values(
ZE_SAMPLER_ADDRESS_MODE_NONE,
ZE_SAMPLER_ADDRESS_MODE_REPEAT,
ZE_SAMPLER_ADDRESS_MODE_CLAMP,
ZE_SAMPLER_ADDRESS_MODE_MIRROR,
ZE_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER);
const auto samplerFilterMode = ::testing::Values(
ZE_SAMPLER_FILTER_MODE_NEAREST,
ZE_SAMPLER_FILTER_MODE_LINEAR);
const auto samplerIsNormalized = ::testing::Values(
true,
false);
using SamplerCreateSupport = IsWithinProducts<IGFX_SKYLAKE, IGFX_TIGERLAKE_LP>;
class SamplerCreateTest
: public Test<DeviceFixture>,
public ::testing::WithParamInterface<std::tuple<ze_sampler_address_mode_t,
ze_sampler_filter_mode_t,
ze_bool_t>> {};
HWTEST2_P(SamplerCreateTest, givenDifferentDescriptorValuesThenSamplerIsCorrectlyCreated, SamplerCreateSupport) {
using SAMPLER_STATE = typename FamilyType::SAMPLER_STATE;
ze_sampler_address_mode_t addressMode = std::get<0>(GetParam());
ze_sampler_filter_mode_t filterMode = std::get<1>(GetParam());
ze_bool_t isNormalized = std::get<2>(GetParam());
ze_sampler_desc_t desc = {};
desc.version = ZE_SAMPLER_DESC_VERSION_CURRENT;
desc.addressMode = addressMode;
desc.filterMode = filterMode;
desc.isNormalized = isNormalized;
auto sampler = new MockSamplerHw<gfxCoreFamily>();
EXPECT_NE(nullptr, sampler);
sampler->initialize(device, &desc);
if (addressMode == ZE_SAMPLER_ADDRESS_MODE_NONE) {
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_CLAMP_BORDER,
sampler->samplerState.getTcxAddressControlMode());
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_CLAMP_BORDER,
sampler->samplerState.getTcyAddressControlMode());
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_CLAMP_BORDER,
sampler->samplerState.getTczAddressControlMode());
} else if (addressMode == ZE_SAMPLER_ADDRESS_MODE_REPEAT) {
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_WRAP,
sampler->samplerState.getTcxAddressControlMode());
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_WRAP,
sampler->samplerState.getTcyAddressControlMode());
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_WRAP,
sampler->samplerState.getTczAddressControlMode());
} else if (addressMode == ZE_SAMPLER_ADDRESS_MODE_CLAMP) {
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_CLAMP_BORDER,
sampler->samplerState.getTcxAddressControlMode());
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_CLAMP_BORDER,
sampler->samplerState.getTcyAddressControlMode());
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_CLAMP_BORDER,
sampler->samplerState.getTczAddressControlMode());
} else if (addressMode == ZE_SAMPLER_ADDRESS_MODE_MIRROR) {
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_MIRROR,
sampler->samplerState.getTcxAddressControlMode());
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_MIRROR,
sampler->samplerState.getTcyAddressControlMode());
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_MIRROR,
sampler->samplerState.getTczAddressControlMode());
} else if (addressMode == ZE_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER) {
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_CLAMP,
sampler->samplerState.getTcxAddressControlMode());
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_CLAMP,
sampler->samplerState.getTcyAddressControlMode());
EXPECT_EQ(SAMPLER_STATE::TEXTURE_COORDINATE_MODE_CLAMP,
sampler->samplerState.getTczAddressControlMode());
}
if (filterMode == ZE_SAMPLER_FILTER_MODE_NEAREST) {
EXPECT_EQ(SAMPLER_STATE::MIN_MODE_FILTER_NEAREST,
sampler->samplerState.getMinModeFilter());
EXPECT_EQ(SAMPLER_STATE::MAG_MODE_FILTER_NEAREST,
sampler->samplerState.getMagModeFilter());
EXPECT_EQ(SAMPLER_STATE::MIP_MODE_FILTER_NEAREST,
sampler->samplerState.getMipModeFilter());
EXPECT_FALSE(sampler->samplerState.getRAddressMinFilterRoundingEnable());
EXPECT_FALSE(sampler->samplerState.getRAddressMagFilterRoundingEnable());
EXPECT_FALSE(sampler->samplerState.getVAddressMinFilterRoundingEnable());
EXPECT_FALSE(sampler->samplerState.getVAddressMagFilterRoundingEnable());
EXPECT_FALSE(sampler->samplerState.getUAddressMinFilterRoundingEnable());
EXPECT_FALSE(sampler->samplerState.getUAddressMagFilterRoundingEnable());
} else if (filterMode == ZE_SAMPLER_FILTER_MODE_LINEAR) {
EXPECT_EQ(SAMPLER_STATE::MIN_MODE_FILTER_LINEAR,
sampler->samplerState.getMinModeFilter());
EXPECT_EQ(SAMPLER_STATE::MAG_MODE_FILTER_LINEAR,
sampler->samplerState.getMagModeFilter());
EXPECT_EQ(SAMPLER_STATE::MIP_MODE_FILTER_NEAREST,
sampler->samplerState.getMipModeFilter());
EXPECT_TRUE(sampler->samplerState.getRAddressMinFilterRoundingEnable());
EXPECT_TRUE(sampler->samplerState.getRAddressMagFilterRoundingEnable());
EXPECT_TRUE(sampler->samplerState.getVAddressMinFilterRoundingEnable());
EXPECT_TRUE(sampler->samplerState.getVAddressMagFilterRoundingEnable());
EXPECT_TRUE(sampler->samplerState.getUAddressMinFilterRoundingEnable());
EXPECT_TRUE(sampler->samplerState.getUAddressMagFilterRoundingEnable());
}
NEO::FixedU4D8 minLodValue =
NEO::FixedU4D8(std::min(sampler->getGenSamplerMaxLod(), sampler->lodMin));
NEO::FixedU4D8 maxLodValue =
NEO::FixedU4D8(std::min(sampler->getGenSamplerMaxLod(), sampler->lodMax));
EXPECT_EQ(minLodValue.getRawAccess(), sampler->samplerState.getMinLod());
EXPECT_EQ(maxLodValue.getRawAccess(), sampler->samplerState.getMaxLod());
sampler->destroy();
}
INSTANTIATE_TEST_CASE_P(SamplerDescCombinations, SamplerCreateTest,
::testing::Combine(samplerAddressMode,
samplerFilterMode,
samplerIsNormalized));
} // namespace ult
} // namespace L0