mirror of
https://gitlab.freedesktop.org/mesa/mesa.git
synced 2025-12-23 17:40:11 +01:00
91feef40db
The key change is to use a builder to write the expected shader result
and compare that. To make this less error prone, a few helper functions
were added
- a way to allocate VGRFs from both shaders in parallel, that way the
same brw_reg can be used in both of them;
- assertions that a pass will make progress or not, and proper output
when the unexpected happens;
- use a common brw_shader_pass_test class so to collect some of the helpers;
- make some helpers work directly with builder.
The idea is to improve the signal in tests, so that the disasm comments
are not necessary anymore. For example
```
TEST_F(saturate_propagation_test, basic)
{
brw_reg dst1 = bld.vgrf(BRW_TYPE_F);
brw_reg src0 = bld.vgrf(BRW_TYPE_F);
brw_reg src1 = bld.vgrf(BRW_TYPE_F);
brw_reg dst0 = bld.ADD(src0, src1);
set_saturate(true, bld.MOV(dst1, dst0));
/* = Before =
*
* 0: add(16) dst0 src0 src1
* 1: mov.sat(16) dst1 dst0
*
* = After =
* 0: add.sat(16) dst0 src0 src1
* 1: mov(16) dst1 dst0
*/
brw_calculate_cfg(*v);
bblock_t *block0 = v->cfg->blocks[0];
EXPECT_EQ(0, block0->start_ip);
EXPECT_EQ(1, block0->end_ip);
EXPECT_TRUE(saturate_propagation(v));
EXPECT_EQ(0, block0->start_ip);
EXPECT_EQ(1, block0->end_ip);
EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode);
EXPECT_TRUE(instruction(block0, 0)->saturate);
EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode);
EXPECT_FALSE(instruction(block0, 1)->saturate);
}
```
becomes
```
TEST_F(saturate_propagation_test, basic)
{
brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16);
brw_builder exp = make_shader(MESA_SHADER_FRAGMENT, 16);
brw_reg dst0 = vgrf(bld, exp, BRW_TYPE_F);
brw_reg dst1 = vgrf(bld, exp, BRW_TYPE_F);
brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F);
brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F);
bld.ADD(dst0, src0, src1);
bld.MOV(dst1, dst0)->saturate = true;
EXPECT_PROGRESS(brw_opt_saturate_propagation, bld);
exp.ADD(dst0, src0, src1)->saturate = true;
exp.MOV(dst1, dst0);
EXPECT_SHADERS_MATCH(bld, exp);
}
```
Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/33936>
115 lines
3.2 KiB
C++
115 lines
3.2 KiB
C++
/*
|
|
* Copyright © 2016 Intel Corporation
|
|
* SPDX-License-Identifier: MIT
|
|
*/
|
|
|
|
#include "test_helpers.h"
|
|
#include "brw_builder.h"
|
|
|
|
class copy_propagation_test : public brw_shader_pass_test {};
|
|
|
|
TEST_F(copy_propagation_test, basic)
|
|
{
|
|
brw_builder bld = make_shader();
|
|
brw_builder exp = make_shader();
|
|
|
|
brw_reg v0 = vgrf(bld, exp, BRW_TYPE_F);
|
|
brw_reg v1 = vgrf(bld, exp, BRW_TYPE_F);
|
|
brw_reg v2 = vgrf(bld, exp, BRW_TYPE_F);
|
|
brw_reg v3 = vgrf(bld, exp, BRW_TYPE_F);
|
|
|
|
bld.MOV(v0, v2);
|
|
bld.ADD(v1, v0, v3);
|
|
|
|
/* Propagation makes ADD use v2 as source. */
|
|
EXPECT_PROGRESS(brw_opt_copy_propagation, bld);
|
|
|
|
exp.MOV(v0, v2);
|
|
exp.ADD(v1, v2, v3);
|
|
|
|
EXPECT_SHADERS_MATCH(bld, exp);
|
|
}
|
|
|
|
TEST_F(copy_propagation_test, maxmax_sat_imm)
|
|
{
|
|
static const struct {
|
|
enum brw_conditional_mod conditional_mod;
|
|
float immediate;
|
|
bool expected_result;
|
|
} test[] = {
|
|
/* conditional mod, imm, expected_result */
|
|
{ BRW_CONDITIONAL_GE , 0.1f, false },
|
|
{ BRW_CONDITIONAL_L , 0.1f, false },
|
|
{ BRW_CONDITIONAL_GE , 0.5f, false },
|
|
{ BRW_CONDITIONAL_L , 0.5f, false },
|
|
{ BRW_CONDITIONAL_GE , 0.9f, false },
|
|
{ BRW_CONDITIONAL_L , 0.9f, false },
|
|
{ BRW_CONDITIONAL_GE , -1.5f, false },
|
|
{ BRW_CONDITIONAL_L , -1.5f, false },
|
|
{ BRW_CONDITIONAL_GE , 1.5f, false },
|
|
{ BRW_CONDITIONAL_L , 1.5f, false },
|
|
|
|
{ BRW_CONDITIONAL_NONE, 0.5f, false },
|
|
{ BRW_CONDITIONAL_Z , 0.5f, false },
|
|
{ BRW_CONDITIONAL_NZ , 0.5f, false },
|
|
{ BRW_CONDITIONAL_G , 0.5f, false },
|
|
{ BRW_CONDITIONAL_LE , 0.5f, false },
|
|
{ BRW_CONDITIONAL_R , 0.5f, false },
|
|
{ BRW_CONDITIONAL_O , 0.5f, false },
|
|
{ BRW_CONDITIONAL_U , 0.5f, false },
|
|
};
|
|
|
|
for (unsigned i = 0; i < ARRAY_SIZE(test); i++) {
|
|
brw_builder bld = make_shader();
|
|
|
|
enum brw_conditional_mod cmod = test[i].conditional_mod;
|
|
brw_reg imm = brw_imm_f(test[i].immediate);
|
|
|
|
brw_reg v0 = bld.vgrf(BRW_TYPE_F);
|
|
brw_reg v1 = bld.vgrf(BRW_TYPE_F);
|
|
brw_reg v2 = bld.vgrf(BRW_TYPE_F);
|
|
|
|
bld.MOV(v0, v1)->saturate = true;
|
|
bld.SEL(v2, v0, imm)->conditional_mod = cmod;
|
|
|
|
EXPECT_PROGRESS_RESULT(test[i].expected_result,
|
|
brw_opt_copy_propagation, bld);
|
|
}
|
|
}
|
|
|
|
TEST_F(copy_propagation_test, mixed_integer_sign)
|
|
{
|
|
brw_builder bld = make_shader();
|
|
brw_builder exp = make_shader();
|
|
|
|
brw_reg v0 = vgrf(bld, exp, BRW_TYPE_UD);
|
|
brw_reg v1 = vgrf(bld, exp, BRW_TYPE_D);
|
|
brw_reg v2 = vgrf(bld, exp, BRW_TYPE_UD);
|
|
brw_reg v3 = vgrf(bld, exp, BRW_TYPE_UD);
|
|
brw_reg v4 = vgrf(bld, exp, BRW_TYPE_UD);
|
|
|
|
bld.MOV(v1, v0);
|
|
bld.BFE(v2, v3, v4, retype(v1, BRW_TYPE_UD));
|
|
|
|
/* Propagation makes BFE use v0 as source. */
|
|
EXPECT_PROGRESS(brw_opt_copy_propagation, bld);
|
|
|
|
exp.MOV(v1, v0);
|
|
exp.BFE(v2, v3, v4, v0);
|
|
|
|
EXPECT_SHADERS_MATCH(bld, exp);
|
|
}
|
|
|
|
TEST_F(copy_propagation_test, mixed_integer_sign_with_vector_imm)
|
|
{
|
|
brw_builder bld = make_shader();
|
|
|
|
brw_reg v0 = bld.vgrf(BRW_TYPE_W);
|
|
brw_reg v1 = bld.vgrf(BRW_TYPE_UD);
|
|
brw_reg v2 = bld.vgrf(BRW_TYPE_UD);
|
|
|
|
bld.MOV(v0, brw_imm_uv(0xffff));
|
|
bld.ADD(v1, v2, retype(v0, BRW_TYPE_UW));
|
|
|
|
EXPECT_NO_PROGRESS(brw_opt_copy_propagation, bld);
|
|
}
|