fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-02-19 19:00:33 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

intel/isl: Add unit tests for ISL_AUX_STATE_COMPRESSED_HIER_DEPTH.

Browse source 
v2: Add additional AUX state transition test-cases for HIZ_CCS (Nanley).

v3: Assume partial resolve is equivalent to full resolve on legacy HiZ
    surfaces during isl_aux_state_transition_aux_op() instead of
    asserting (Nanley).

v4: Move some tests into different group, add more MCS tests (Nanley).

Acked-by: Nanley Chery <nanley.g.chery@intel.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/31139>
This commit is contained in:
Francisco Jerez 2024-12-03 19:19:10 -08:00 • committed by Marge Bot
parent 35512cebb1
commit c0cf14f0e2
1 changed files with 71 additions and 5 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

76
src/intel/isl/tests/isl_aux_info_test.cpp
View file

@ -50,6 +50,8 @@ TEST(PrepareAccess, CompressedFalseFastClearFalsePartialResolveFalse) {
E(COMPRESSED_CLEAR, NONE, true, ASSERT);
E(COMPRESSED_NO_CLEAR, NONE, false, FULL_RESOLVE);
E(COMPRESSED_NO_CLEAR, NONE, true, ASSERT);
E(COMPRESSED_HIER_DEPTH, NONE, false, FULL_RESOLVE);
E(COMPRESSED_HIER_DEPTH, NONE, true, ASSERT);
E(RESOLVED, NONE, false, NONE);
E(RESOLVED, NONE, true, ASSERT);
E(PASS_THROUGH, NONE, false, NONE);
@ -101,6 +103,12 @@ TEST(PrepareAccess, CompressedTrueFastClearTruePartialResolveFalse) {
E(COMPRESSED_CLEAR, HIZ, true, NONE);
E(COMPRESSED_NO_CLEAR, HIZ, false, NONE);
E(COMPRESSED_NO_CLEAR, HIZ, true, NONE);
E(COMPRESSED_HIER_DEPTH, HIZ, false, FULL_RESOLVE);
E(COMPRESSED_HIER_DEPTH, HIZ, true, NONE);
E(COMPRESSED_HIER_DEPTH, HIZ_CCS, false, FULL_RESOLVE);
E(COMPRESSED_HIER_DEPTH, HIZ_CCS, true, NONE);
E(COMPRESSED_HIER_DEPTH, HIZ_CCS_WT, false, FULL_RESOLVE);
E(COMPRESSED_HIER_DEPTH, HIZ_CCS_WT, true, PARTIAL_RESOLVE);
E(RESOLVED, HIZ, false, NONE);
E(RESOLVED, HIZ, true, NONE);
E(PASS_THROUGH, HIZ, false, NONE);
@ -118,6 +126,8 @@ TEST(PrepareAccess, CompressedTrueFastClearTruePartialResolveTrue) {
E(COMPRESSED_CLEAR, MCS, true, NONE);
E(COMPRESSED_NO_CLEAR, MCS, false, NONE);
E(COMPRESSED_NO_CLEAR, MCS, true, NONE);
E(COMPRESSED_HIER_DEPTH, MCS, false, ASSERT);
E(COMPRESSED_HIER_DEPTH, MCS, true, ASSERT);
E(RESOLVED, MCS, false, NONE);
E(RESOLVED, MCS, true, NONE);
E(PASS_THROUGH, MCS, false, NONE);
@ -156,6 +166,7 @@ TEST(StateTransitionAuxOp, None) {
E(PARTIAL_CLEAR, NONE, NONE, ASSERT);
E(COMPRESSED_CLEAR, NONE, NONE, ASSERT);
E(COMPRESSED_NO_CLEAR, NONE, NONE, ASSERT);
E(COMPRESSED_HIER_DEPTH, NONE, NONE, ASSERT);
E(RESOLVED, NONE, NONE, RESOLVED);
E(PASS_THROUGH, NONE, NONE, PASS_THROUGH);
E(AUX_INVALID, NONE, NONE, AUX_INVALID);
@ -164,6 +175,7 @@ TEST(StateTransitionAuxOp, None) {
E(PARTIAL_CLEAR, MC, NONE, ASSERT);
E(COMPRESSED_CLEAR, MC, NONE, ASSERT);
E(COMPRESSED_NO_CLEAR, MC, NONE, COMPRESSED_NO_CLEAR);
E(COMPRESSED_HIER_DEPTH, MC, NONE, ASSERT);
E(RESOLVED, MC, NONE, RESOLVED);
E(PASS_THROUGH, MC, NONE, PASS_THROUGH);
E(AUX_INVALID, MC, NONE, AUX_INVALID);
@ -172,6 +184,7 @@ TEST(StateTransitionAuxOp, None) {
E(PARTIAL_CLEAR, HIZ, NONE, PARTIAL_CLEAR);
E(COMPRESSED_CLEAR, HIZ, NONE, COMPRESSED_CLEAR);
E(COMPRESSED_NO_CLEAR, HIZ, NONE, COMPRESSED_NO_CLEAR);
E(COMPRESSED_HIER_DEPTH, HIZ, NONE, COMPRESSED_HIER_DEPTH);
E(RESOLVED, HIZ, NONE, RESOLVED);
E(PASS_THROUGH, HIZ, NONE, PASS_THROUGH);
E(AUX_INVALID, HIZ, NONE, AUX_INVALID);
@ -180,6 +193,7 @@ TEST(StateTransitionAuxOp, None) {
E(PARTIAL_CLEAR, CCS_E, NONE, PARTIAL_CLEAR);
E(COMPRESSED_CLEAR, CCS_E, NONE, COMPRESSED_CLEAR);
E(COMPRESSED_NO_CLEAR, CCS_E, NONE, COMPRESSED_NO_CLEAR);
E(COMPRESSED_HIER_DEPTH, CCS_E, NONE, ASSERT);
E(RESOLVED, CCS_E, NONE, RESOLVED);
E(PASS_THROUGH, CCS_E, NONE, PASS_THROUGH);
E(AUX_INVALID, CCS_E, NONE, AUX_INVALID);
@ -190,6 +204,7 @@ TEST(StateTransitionAuxOp, FastClear) {
E(PARTIAL_CLEAR, NONE, FAST_CLEAR, ASSERT);
E(COMPRESSED_CLEAR, NONE, FAST_CLEAR, ASSERT);
E(COMPRESSED_NO_CLEAR, NONE, FAST_CLEAR, ASSERT);
E(COMPRESSED_HIER_DEPTH, NONE, FAST_CLEAR, ASSERT);
E(RESOLVED, NONE, FAST_CLEAR, ASSERT);
E(PASS_THROUGH, NONE, FAST_CLEAR, ASSERT);
E(AUX_INVALID, NONE, FAST_CLEAR, ASSERT);
@ -198,6 +213,7 @@ TEST(StateTransitionAuxOp, FastClear) {
E(PARTIAL_CLEAR, MC, FAST_CLEAR, ASSERT);
E(COMPRESSED_CLEAR, MC, FAST_CLEAR, ASSERT);
E(COMPRESSED_NO_CLEAR, MC, FAST_CLEAR, ASSERT);
E(COMPRESSED_HIER_DEPTH, MC, FAST_CLEAR, ASSERT);
E(RESOLVED, MC, FAST_CLEAR, ASSERT);
E(PASS_THROUGH, MC, FAST_CLEAR, ASSERT);
E(AUX_INVALID, MC, FAST_CLEAR, ASSERT);
@ -206,6 +222,7 @@ TEST(StateTransitionAuxOp, FastClear) {
E(PARTIAL_CLEAR, HIZ, FAST_CLEAR, CLEAR);
E(COMPRESSED_CLEAR, HIZ, FAST_CLEAR, CLEAR);
E(COMPRESSED_NO_CLEAR, HIZ, FAST_CLEAR, CLEAR);
E(COMPRESSED_HIER_DEPTH, HIZ, FAST_CLEAR, CLEAR);
E(RESOLVED, HIZ, FAST_CLEAR, CLEAR);
E(PASS_THROUGH, HIZ, FAST_CLEAR, CLEAR);
E(AUX_INVALID, HIZ, FAST_CLEAR, CLEAR);
@ -214,6 +231,7 @@ TEST(StateTransitionAuxOp, FastClear) {
E(PARTIAL_CLEAR, CCS_E, FAST_CLEAR, CLEAR);
E(COMPRESSED_CLEAR, CCS_E, FAST_CLEAR, CLEAR);
E(COMPRESSED_NO_CLEAR, CCS_E, FAST_CLEAR, CLEAR);
E(COMPRESSED_HIER_DEPTH, CCS_E, FAST_CLEAR, ASSERT);
E(RESOLVED, CCS_E, FAST_CLEAR, CLEAR);
E(PASS_THROUGH, CCS_E, FAST_CLEAR, CLEAR);
E(AUX_INVALID, CCS_E, FAST_CLEAR, CLEAR);
@ -224,6 +242,7 @@ TEST(StateTransitionAuxOp, PartialResolve) {
E(PARTIAL_CLEAR, NONE, PARTIAL_RESOLVE, ASSERT);
E(COMPRESSED_CLEAR, NONE, PARTIAL_RESOLVE, ASSERT);
E(COMPRESSED_NO_CLEAR, NONE, PARTIAL_RESOLVE, ASSERT);
E(COMPRESSED_HIER_DEPTH, NONE, PARTIAL_RESOLVE, ASSERT);
E(RESOLVED, NONE, PARTIAL_RESOLVE, ASSERT);
E(PASS_THROUGH, NONE, PARTIAL_RESOLVE, ASSERT);
E(AUX_INVALID, NONE, PARTIAL_RESOLVE, ASSERT);
@ -232,22 +251,34 @@ TEST(StateTransitionAuxOp, PartialResolve) {
E(PARTIAL_CLEAR, MC, PARTIAL_RESOLVE, ASSERT);
E(COMPRESSED_CLEAR, MC, PARTIAL_RESOLVE, ASSERT);
E(COMPRESSED_NO_CLEAR, MC, PARTIAL_RESOLVE, ASSERT);
E(COMPRESSED_HIER_DEPTH, MC, PARTIAL_RESOLVE, ASSERT);
E(RESOLVED, MC, PARTIAL_RESOLVE, ASSERT);
E(PASS_THROUGH, MC, PARTIAL_RESOLVE, ASSERT);
E(AUX_INVALID, MC, PARTIAL_RESOLVE, ASSERT);
E(CLEAR, HIZ, PARTIAL_RESOLVE, ASSERT);
E(CLEAR, HIZ, PARTIAL_RESOLVE, RESOLVED);
E(PARTIAL_CLEAR, HIZ, PARTIAL_RESOLVE, ASSERT);
E(COMPRESSED_CLEAR, HIZ, PARTIAL_RESOLVE, ASSERT);
E(COMPRESSED_NO_CLEAR, HIZ, PARTIAL_RESOLVE, ASSERT);
E(RESOLVED, HIZ, PARTIAL_RESOLVE, ASSERT);
E(PASS_THROUGH, HIZ, PARTIAL_RESOLVE, ASSERT);
E(COMPRESSED_CLEAR, HIZ, PARTIAL_RESOLVE, RESOLVED);
E(COMPRESSED_NO_CLEAR, HIZ, PARTIAL_RESOLVE, RESOLVED);
E(COMPRESSED_HIER_DEPTH, HIZ, PARTIAL_RESOLVE, RESOLVED);
E(RESOLVED, HIZ, PARTIAL_RESOLVE, RESOLVED);
E(PASS_THROUGH, HIZ, PARTIAL_RESOLVE, PASS_THROUGH);
E(AUX_INVALID, HIZ, PARTIAL_RESOLVE, ASSERT);
E(CLEAR, HIZ_CCS, PARTIAL_RESOLVE, COMPRESSED_CLEAR);
E(PARTIAL_CLEAR, HIZ_CCS, PARTIAL_RESOLVE, ASSERT);
E(COMPRESSED_CLEAR, HIZ_CCS, PARTIAL_RESOLVE, COMPRESSED_CLEAR);
E(COMPRESSED_NO_CLEAR, HIZ_CCS, PARTIAL_RESOLVE, COMPRESSED_NO_CLEAR);
E(COMPRESSED_HIER_DEPTH, HIZ_CCS, PARTIAL_RESOLVE, COMPRESSED_CLEAR);
E(RESOLVED, HIZ_CCS, PARTIAL_RESOLVE, RESOLVED);
E(PASS_THROUGH, HIZ_CCS, PARTIAL_RESOLVE, PASS_THROUGH);
E(AUX_INVALID, HIZ_CCS, PARTIAL_RESOLVE, ASSERT);
E(CLEAR, CCS_E, PARTIAL_RESOLVE, COMPRESSED_NO_CLEAR);
E(PARTIAL_CLEAR, CCS_E, PARTIAL_RESOLVE, COMPRESSED_NO_CLEAR);
E(COMPRESSED_CLEAR, CCS_E, PARTIAL_RESOLVE, COMPRESSED_NO_CLEAR);
E(COMPRESSED_NO_CLEAR, CCS_E, PARTIAL_RESOLVE, COMPRESSED_NO_CLEAR);
E(COMPRESSED_HIER_DEPTH, CCS_E, PARTIAL_RESOLVE, ASSERT);
E(RESOLVED, CCS_E, PARTIAL_RESOLVE, RESOLVED);
E(PASS_THROUGH, CCS_E, PARTIAL_RESOLVE, PASS_THROUGH);
E(AUX_INVALID, CCS_E, PARTIAL_RESOLVE, ASSERT);
@ -258,6 +289,7 @@ TEST(StateTransitionAuxOp, FullResolve) {
E(PARTIAL_CLEAR, NONE, FULL_RESOLVE, ASSERT);
E(COMPRESSED_CLEAR, NONE, FULL_RESOLVE, ASSERT);
E(COMPRESSED_NO_CLEAR, NONE, FULL_RESOLVE, ASSERT);
E(COMPRESSED_HIER_DEPTH, NONE, FULL_RESOLVE, ASSERT);
E(RESOLVED, NONE, FULL_RESOLVE, ASSERT);
E(PASS_THROUGH, NONE, FULL_RESOLVE, ASSERT);
E(AUX_INVALID, NONE, FULL_RESOLVE, ASSERT);
@ -266,6 +298,7 @@ TEST(StateTransitionAuxOp, FullResolve) {
E(PARTIAL_CLEAR, MC, FULL_RESOLVE, ASSERT);
E(COMPRESSED_CLEAR, MC, FULL_RESOLVE, ASSERT);
E(COMPRESSED_NO_CLEAR, MC, FULL_RESOLVE, PASS_THROUGH);
E(COMPRESSED_HIER_DEPTH, MC, FULL_RESOLVE, ASSERT);
E(RESOLVED, MC, FULL_RESOLVE, PASS_THROUGH);
E(PASS_THROUGH, MC, FULL_RESOLVE, PASS_THROUGH);
E(AUX_INVALID, MC, FULL_RESOLVE, ASSERT);
@ -274,6 +307,7 @@ TEST(StateTransitionAuxOp, FullResolve) {
E(PARTIAL_CLEAR, HIZ, FULL_RESOLVE, RESOLVED);
E(COMPRESSED_CLEAR, HIZ, FULL_RESOLVE, RESOLVED);
E(COMPRESSED_NO_CLEAR, HIZ, FULL_RESOLVE, RESOLVED);
E(COMPRESSED_HIER_DEPTH, HIZ, FULL_RESOLVE, RESOLVED);
E(RESOLVED, HIZ, FULL_RESOLVE, RESOLVED);
E(PASS_THROUGH, HIZ, FULL_RESOLVE, PASS_THROUGH);
E(AUX_INVALID, HIZ, FULL_RESOLVE, ASSERT);
@ -282,6 +316,7 @@ TEST(StateTransitionAuxOp, FullResolve) {
E(PARTIAL_CLEAR, CCS_E, FULL_RESOLVE, PASS_THROUGH);
E(COMPRESSED_CLEAR, CCS_E, FULL_RESOLVE, PASS_THROUGH);
E(COMPRESSED_NO_CLEAR, CCS_E, FULL_RESOLVE, PASS_THROUGH);
E(COMPRESSED_HIER_DEPTH, CCS_E, FULL_RESOLVE, ASSERT);
E(RESOLVED, CCS_E, FULL_RESOLVE, PASS_THROUGH);
E(PASS_THROUGH, CCS_E, FULL_RESOLVE, PASS_THROUGH);
E(AUX_INVALID, CCS_E, FULL_RESOLVE, ASSERT);
@ -292,6 +327,7 @@ TEST(StateTransitionAuxOp, Ambiguate) {
E(PARTIAL_CLEAR, NONE, AMBIGUATE, ASSERT);
E(COMPRESSED_CLEAR, NONE, AMBIGUATE, ASSERT);
E(COMPRESSED_NO_CLEAR, NONE, AMBIGUATE, ASSERT);
E(COMPRESSED_HIER_DEPTH, NONE, AMBIGUATE, ASSERT);
E(RESOLVED, NONE, AMBIGUATE, ASSERT);
E(PASS_THROUGH, NONE, AMBIGUATE, ASSERT);
E(AUX_INVALID, NONE, AMBIGUATE, ASSERT);
@ -300,6 +336,7 @@ TEST(StateTransitionAuxOp, Ambiguate) {
E(PARTIAL_CLEAR, MC, AMBIGUATE, ASSERT);
E(COMPRESSED_CLEAR, MC, AMBIGUATE, ASSERT);
E(COMPRESSED_NO_CLEAR, MC, AMBIGUATE, PASS_THROUGH);
E(COMPRESSED_HIER_DEPTH, MC, AMBIGUATE, ASSERT);
E(RESOLVED, MC, AMBIGUATE, PASS_THROUGH);
E(PASS_THROUGH, MC, AMBIGUATE, PASS_THROUGH);
E(AUX_INVALID, MC, AMBIGUATE, PASS_THROUGH);
@ -308,6 +345,7 @@ TEST(StateTransitionAuxOp, Ambiguate) {
E(PARTIAL_CLEAR, HIZ, AMBIGUATE, PASS_THROUGH);
E(COMPRESSED_CLEAR, HIZ, AMBIGUATE, PASS_THROUGH);
E(COMPRESSED_NO_CLEAR, HIZ, AMBIGUATE, PASS_THROUGH);
E(COMPRESSED_HIER_DEPTH, HIZ, AMBIGUATE, PASS_THROUGH);
E(RESOLVED, HIZ, AMBIGUATE, PASS_THROUGH);
E(PASS_THROUGH, HIZ, AMBIGUATE, PASS_THROUGH);
E(AUX_INVALID, HIZ, AMBIGUATE, PASS_THROUGH);
@ -316,6 +354,7 @@ TEST(StateTransitionAuxOp, Ambiguate) {
E(PARTIAL_CLEAR, CCS_E, AMBIGUATE, PASS_THROUGH);
E(COMPRESSED_CLEAR, CCS_E, AMBIGUATE, PASS_THROUGH);
E(COMPRESSED_NO_CLEAR, CCS_E, AMBIGUATE, PASS_THROUGH);
E(COMPRESSED_HIER_DEPTH, CCS_E, AMBIGUATE, ASSERT);
E(RESOLVED, CCS_E, AMBIGUATE, PASS_THROUGH);
E(PASS_THROUGH, CCS_E, AMBIGUATE, PASS_THROUGH);
E(AUX_INVALID, CCS_E, AMBIGUATE, PASS_THROUGH);
@ -337,6 +376,8 @@ TEST(StateTransitionWrite, WritesOnlyTouchMain) {
E(COMPRESSED_CLEAR, NONE, true, AUX_INVALID);
E(COMPRESSED_NO_CLEAR, NONE, false, ASSERT);
E(COMPRESSED_NO_CLEAR, NONE, true, AUX_INVALID);
E(COMPRESSED_HIER_DEPTH, NONE, false, ASSERT);
E(COMPRESSED_HIER_DEPTH, NONE, true, AUX_INVALID);
E(RESOLVED, NONE, false, AUX_INVALID);
E(RESOLVED, NONE, true, AUX_INVALID);
E(PASS_THROUGH, NONE, false, PASS_THROUGH);
@ -354,6 +395,8 @@ TEST(StateTransitionWrite, WritesCompress) {
E(COMPRESSED_CLEAR, MCS, true, COMPRESSED_NO_CLEAR);
E(COMPRESSED_NO_CLEAR, MCS, false, COMPRESSED_NO_CLEAR);
E(COMPRESSED_NO_CLEAR, MCS, true, COMPRESSED_NO_CLEAR);
E(COMPRESSED_HIER_DEPTH, MCS, false, ASSERT);
E(COMPRESSED_HIER_DEPTH, MCS, true, ASSERT);
E(RESOLVED, MCS, false, COMPRESSED_NO_CLEAR);
E(RESOLVED, MCS, true, COMPRESSED_NO_CLEAR);
E(PASS_THROUGH, MCS, false, COMPRESSED_NO_CLEAR);
@ -386,6 +429,8 @@ TEST(StateTransitionWrite, WritesCompressClear) {
E(COMPRESSED_CLEAR, FCV_CCS_E, true, COMPRESSED_CLEAR);
E(COMPRESSED_NO_CLEAR, FCV_CCS_E, false, COMPRESSED_CLEAR);
E(COMPRESSED_NO_CLEAR, FCV_CCS_E, true, COMPRESSED_CLEAR);
E(COMPRESSED_HIER_DEPTH, FCV_CCS_E, false, ASSERT);
E(COMPRESSED_HIER_DEPTH, FCV_CCS_E, true, ASSERT);
E(RESOLVED, FCV_CCS_E, false, COMPRESSED_CLEAR);
E(RESOLVED, FCV_CCS_E, true, COMPRESSED_CLEAR);
E(PASS_THROUGH, FCV_CCS_E, false, COMPRESSED_CLEAR);
@ -403,6 +448,8 @@ TEST(StateTransitionWrite, WritesResolveAmbiguate) {
E(COMPRESSED_CLEAR, CCS_D, true, ASSERT);
E(COMPRESSED_NO_CLEAR, CCS_D, false, ASSERT);
E(COMPRESSED_NO_CLEAR, CCS_D, true, ASSERT);
E(COMPRESSED_HIER_DEPTH, CCS_D, false, ASSERT);
E(COMPRESSED_HIER_DEPTH, CCS_D, true, ASSERT);
E(RESOLVED, CCS_D, false, RESOLVED);
E(RESOLVED, CCS_D, true, PASS_THROUGH);
E(PASS_THROUGH, CCS_D, false, PASS_THROUGH);
@ -426,4 +473,23 @@ TEST(StateTransitionWrite, WritesResolveAmbiguate) {
E(AUX_INVALID, MC, true, ASSERT);
}
TEST(StateTransitionWrite, WritesCompressHiZ) {
E(CLEAR, HIZ_CCS, false, COMPRESSED_HIER_DEPTH);
E(CLEAR, HIZ_CCS, true, COMPRESSED_HIER_DEPTH);
E(PARTIAL_CLEAR, HIZ_CCS, false, COMPRESSED_HIER_DEPTH);
E(PARTIAL_CLEAR, HIZ_CCS, true, COMPRESSED_HIER_DEPTH);
E(COMPRESSED_CLEAR, HIZ_CCS, false, COMPRESSED_HIER_DEPTH);
E(COMPRESSED_CLEAR, HIZ_CCS, true, COMPRESSED_HIER_DEPTH);
E(COMPRESSED_NO_CLEAR, HIZ_CCS, false, COMPRESSED_HIER_DEPTH);
E(COMPRESSED_NO_CLEAR, HIZ_CCS, true, COMPRESSED_HIER_DEPTH);
E(COMPRESSED_HIER_DEPTH, HIZ_CCS, false, COMPRESSED_HIER_DEPTH);
E(COMPRESSED_HIER_DEPTH, HIZ_CCS, true, COMPRESSED_HIER_DEPTH);
E(RESOLVED, HIZ_CCS, false, COMPRESSED_HIER_DEPTH);
E(RESOLVED, HIZ_CCS, true, COMPRESSED_HIER_DEPTH);
E(PASS_THROUGH, HIZ_CCS, false, COMPRESSED_HIER_DEPTH);
E(PASS_THROUGH, HIZ_CCS, true, COMPRESSED_HIER_DEPTH);
E(AUX_INVALID, HIZ_CCS, false, ASSERT);
E(AUX_INVALID, HIZ_CCS, true, ASSERT);
}
#undef E