mirror of https://github.com/intel/gmmlib.git
226 lines
11 KiB
C++
226 lines
11 KiB
C++
/*==============================================================================
|
|
Copyright(c) 2017 Intel Corporation
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a
|
|
copy of this software and associated documentation files(the "Software"),
|
|
to deal in the Software without restriction, including without limitation
|
|
the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
and / or sell copies of the Software, and to permit persons to whom the
|
|
Software is furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included
|
|
in all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
OTHER DEALINGS IN THE SOFTWARE.
|
|
============================================================================*/
|
|
|
|
#include "GmmGen10ResourceULT.h"
|
|
|
|
using namespace std;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////
|
|
/// Sets up common environment for Resource fixture tests. this is called once per
|
|
/// test case before executing all tests under resource fixture test case.
|
|
// It also calls SetupTestCase from CommonULT to initialize global context and others.
|
|
///
|
|
/// @see CTestGen9Resource::SetUpTestCase()
|
|
///
|
|
/////////////////////////////////////////////////////////////////////////////////////
|
|
void CTestGen10Resource::SetUpTestCase()
|
|
{
|
|
printf("%s\n", __FUNCTION__);
|
|
GfxPlatform.eProductFamily = IGFX_CANNONLAKE;
|
|
GfxPlatform.eRenderCoreFamily = IGFX_GEN10_CORE;
|
|
|
|
CommonULT::SetUpTestCase();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////
|
|
/// cleans up once all the tests finish execution. It also calls TearDownTestCase
|
|
/// from CommonULT to destroy global context and others.
|
|
///
|
|
/// @see CTestGen10Resource::TearDownTestCase()
|
|
/////////////////////////////////////////////////////////////////////////////////////
|
|
void CTestGen10Resource::TearDownTestCase()
|
|
{
|
|
printf("%s\n", __FUNCTION__);
|
|
|
|
CommonULT::TearDownTestCase();
|
|
}
|
|
|
|
/// @brief ULT for 2D TileYs Resource
|
|
TEST_F(CTestGen10Resource, Test2DTileYsResource)
|
|
{
|
|
printf("%s\n", __FUNCTION__);
|
|
}
|
|
|
|
/// @brief ULT for 2D TileYf Resource
|
|
TEST_F(CTestGen10Resource, Test2DTileYfResource)
|
|
{
|
|
printf("%s\n", __FUNCTION__);
|
|
}
|
|
|
|
TEST_F(CTestGen10Resource, TestMSAA)
|
|
{
|
|
//Tile dimensions in Bytes
|
|
const uint32_t MCSTileSize[1][2] = {128, 32}; //MCS is TileY
|
|
|
|
//Gen9: MSAA 16x no MCS for width > 8K
|
|
//No MSAA for YUV/compressed formats
|
|
//Interleaved MSS (IMS) for Depth/Stencil. Arrayed MSS (CMS) for Color RT
|
|
//MSS (Arrayed): px_wL, px_hL = pixel width/height of single sample at Lod L
|
|
// MSS width = px_wL, MSS height = NumSamples*px_hL
|
|
//MSS (Interleaved): px_wL, px_hL = pixel width/height of single sample at Lod L
|
|
// Samples MSS width MSS Height
|
|
// 2x 4*ceil(px_wL/2) px_hL
|
|
// 4x 4*ceil(px_wL/2) 4*ceil(px_hL/2)
|
|
// 8x 8*ceil(px_wL/2) 4*ceil(px_hL/2)
|
|
// 16x 8*ceil(px_wL/2) 8*ceil(px_hL/2)
|
|
//MCS (bpp): 2x/4x - bpp_8, 8x - bpp_32, 16x - bpp_64
|
|
|
|
const uint32_t TestDimensions[4][2] = {
|
|
//Input dimensions in #Tiles
|
|
{15, 20}, //16 Tiles x 20 <Max Width: Depth MSS crosses Pitch limit beyond this>
|
|
{0, 0}, //1x1x1
|
|
{1, 0}, //2 Tilesx1
|
|
{1, 1}, //2 Tiles x 2
|
|
};
|
|
|
|
uint32_t TestArraySize[2] = {1, 5};
|
|
uint32_t MinPitch = 32;
|
|
|
|
uint32_t HAlign = 0, VAlign = 0;
|
|
uint32_t TileDimX = 0, TileDimY = 0;
|
|
uint32_t MCSHAlign = 0, MCSVAlign = 0, TileSize = 0;
|
|
uint32_t ExpectedMCSBpp = 0;
|
|
std::vector<tuple<int, int, int, bool, int, int>> List; //TEST_TILE_TYPE, TEST_BPP, TEST_RESOURCE_TYPE, Depth or RT, TestDimension index, ArraySize
|
|
auto Size = BuildInputIterator(List, 4, 2); // Size of arrays TestDimensions, TestArraySize
|
|
|
|
for(auto element : List)
|
|
{
|
|
GMM_RESCREATE_PARAMS gmmParams = {};
|
|
gmmParams.Flags.Info = {0};
|
|
|
|
TEST_TILE_TYPE Tiling = (TEST_TILE_TYPE)std::get<0>(element);
|
|
TEST_BPP Bpp = (TEST_BPP)std::get<1>(element);
|
|
TEST_RESOURCE_TYPE ResType = (TEST_RESOURCE_TYPE)std::get<2>(element);
|
|
bool IsRT = std::get<3>(element); // True for RT, False for Depth
|
|
int TestDimIdx = std::get<4>(element); //index into TestDimensions array
|
|
int ArrayIdx = std::get<5>(element); //index into TestArraySize
|
|
TileSize = (Tiling == TEST_TILEYS) ? GMM_KBYTE(64) : GMM_KBYTE(4);
|
|
|
|
//Discard un-supported Tiling/Res_type/bpp for this test
|
|
if(ResType != TEST_RESOURCE_2D || //No 1D/3D/Cube. Supported 2D mip-maps/array
|
|
(!IsRT && (Tiling == TEST_TILEX ||
|
|
!(Bpp == TEST_BPP_16 || Bpp == TEST_BPP_32)))) //depth supported on 16bit, 32bit formats only
|
|
continue;
|
|
|
|
SetTileFlag(gmmParams, Tiling);
|
|
SetResType(gmmParams, ResType);
|
|
SetResGpuFlags(gmmParams, IsRT);
|
|
SetResArraySize(gmmParams, TestArraySize[ArrayIdx]);
|
|
|
|
gmmParams.NoGfxMemory = 1;
|
|
gmmParams.Format = SetResourceFormat(Bpp);
|
|
for(uint32_t k = MSAA_2x; k <= MSAA_16x; k++)
|
|
{
|
|
GetAlignmentAndTileDimensionsForMSAA(Bpp, IsRT, Tiling, (TEST_MSAA)k,
|
|
TileDimX, TileDimY, HAlign, VAlign,
|
|
ExpectedMCSBpp, MCSHAlign, MCSVAlign);
|
|
|
|
gmmParams.BaseWidth64 = TestDimensions[TestDimIdx][0] * TileDimX + 0x1;
|
|
gmmParams.BaseHeight = TestDimensions[TestDimIdx][1] * TileDimY + 0x1;
|
|
gmmParams.Depth = 0x1;
|
|
gmmParams.MSAA.NumSamples = static_cast<uint32_t>(pow((double)2, k));
|
|
gmmParams.Flags.Gpu.MCS = 0;
|
|
|
|
//MSS surface
|
|
GMM_RESOURCE_INFO *MSSResourceInfo;
|
|
MSSResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
|
|
|
|
if(MSSResourceInfo)
|
|
{
|
|
VerifyResourceHAlign<true>(MSSResourceInfo, HAlign);
|
|
VerifyResourceVAlign<true>(MSSResourceInfo, VAlign);
|
|
if(IsRT) //Arrayed MSS
|
|
{
|
|
uint32_t ExpectedPitch = 0, ExpectedQPitch = 0;
|
|
ExpectedPitch = GMM_ULT_ALIGN(GMM_ULT_ALIGN(gmmParams.BaseWidth64, HAlign) * (uint32_t)pow(2.0, Bpp), TileDimX); // Aligned width * bpp, aligned to TileWidth
|
|
ExpectedPitch = GFX_MAX(ExpectedPitch, MinPitch);
|
|
VerifyResourcePitch<true>(MSSResourceInfo, ExpectedPitch);
|
|
if(Tiling != TEST_LINEAR)
|
|
VerifyResourcePitchInTiles<true>(MSSResourceInfo, ExpectedPitch / TileDimX);
|
|
|
|
ExpectedQPitch = GMM_ULT_ALIGN(gmmParams.BaseHeight, VAlign);
|
|
if(gmmParams.ArraySize > 1) //Gen9: Qpitch is distance between array slices (not sample slices)
|
|
{
|
|
VerifyResourceQPitch<true>(MSSResourceInfo, ExpectedQPitch);
|
|
}
|
|
|
|
uint32_t ExpectedHeight = GMM_ULT_ALIGN(ExpectedQPitch * gmmParams.MSAA.NumSamples * gmmParams.ArraySize, TileDimY); //Align Height =ExpectedPitch * NumSamples * ExpectedQPitch, to Tile-Height
|
|
VerifyResourceSize<true>(MSSResourceInfo, GMM_ULT_ALIGN(ExpectedPitch * ExpectedHeight, TileSize));
|
|
}
|
|
else // Interleaved MSS
|
|
{
|
|
uint32_t WidthMultiplier, HeightMultiplier;
|
|
GetInterleaveMSSPattern((TEST_MSAA)k, WidthMultiplier, HeightMultiplier);
|
|
gmmParams.BaseWidth64 = WidthMultiplier > 1 ? GMM_ULT_ALIGN(gmmParams.BaseWidth64, 2) : gmmParams.BaseWidth64;
|
|
gmmParams.BaseHeight = HeightMultiplier > 1 ? GMM_ULT_ALIGN(gmmParams.BaseHeight, 2) : gmmParams.BaseHeight;
|
|
|
|
uint32_t ExpectedPitch = GMM_ULT_ALIGN(GMM_ULT_ALIGN(gmmParams.BaseWidth64 * WidthMultiplier, HAlign) * (uint32_t)pow(2.0, Bpp), TileDimX);
|
|
VerifyResourcePitch<true>(MSSResourceInfo, ExpectedPitch);
|
|
if(Tiling != TEST_LINEAR)
|
|
{
|
|
VerifyResourcePitchInTiles<true>(MSSResourceInfo, ExpectedPitch / TileDimX);
|
|
}
|
|
|
|
uint64_t ExpectedQPitch = GMM_ULT_ALIGN(gmmParams.BaseHeight * HeightMultiplier, VAlign);
|
|
if(gmmParams.ArraySize > 1)
|
|
{
|
|
VerifyResourceQPitch<true>(MSSResourceInfo, ExpectedQPitch);
|
|
}
|
|
uint64_t ExpectedHeight = GMM_ULT_ALIGN(ExpectedQPitch * gmmParams.ArraySize, TileDimY); //Align Height = ExpectedQPitch*ArraySize, to Tile-Height
|
|
VerifyResourceSize<true>(MSSResourceInfo, GMM_ULT_ALIGN(ExpectedPitch * ExpectedHeight, TileSize)); //ExpectedPitch *ExpectedHeight
|
|
}
|
|
}
|
|
|
|
//No MCS surface if MSS creation failed
|
|
if(MSSResourceInfo)
|
|
{
|
|
gmmParams.Flags.Gpu.MCS = 1;
|
|
GMM_RESOURCE_INFO *MCSResourceInfo;
|
|
MCSResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
|
|
|
|
VerifyResourceHAlign<true>(MCSResourceInfo, MCSHAlign);
|
|
VerifyResourceVAlign<true>(MCSResourceInfo, MCSVAlign);
|
|
|
|
uint32_t ExpectedPitch = GMM_ULT_ALIGN(GMM_ULT_ALIGN(gmmParams.BaseWidth64, MCSHAlign) * ExpectedMCSBpp, MCSTileSize[0][0]); // Align in texels, tehn multiply w/ Bpt
|
|
VerifyResourcePitch<true>(MCSResourceInfo, ExpectedPitch);
|
|
VerifyResourcePitchInTiles<true>(MCSResourceInfo, ExpectedPitch / MCSTileSize[0][0]);
|
|
|
|
uint32_t ExpectedQPitch = GMM_ULT_ALIGN(gmmParams.BaseHeight, MCSVAlign);
|
|
if(gmmParams.ArraySize > 1)
|
|
{
|
|
ExpectedQPitch = GMM_ULT_ALIGN(gmmParams.BaseHeight, MCSVAlign); //QPitch only for array
|
|
VerifyResourceQPitch<true>(MCSResourceInfo, ExpectedQPitch);
|
|
}
|
|
|
|
uint32_t ExpectedHeight = GMM_ULT_ALIGN(ExpectedQPitch * gmmParams.ArraySize, MCSTileSize[0][1]);
|
|
VerifyResourceSize<true>(MCSResourceInfo, GMM_ULT_ALIGN(ExpectedPitch * ExpectedHeight, GMM_KBYTE(4))); //MCS Tile is TileY
|
|
|
|
pGmmULTClientContext->DestroyResInfoObject(MCSResourceInfo);
|
|
} //MCS
|
|
|
|
pGmmULTClientContext->DestroyResInfoObject(MSSResourceInfo);
|
|
} //NumSamples = k
|
|
} //Iterate through all Input types
|
|
|
|
//Mip-mapped, MSAA case:
|
|
}
|