mesa/src/intel/compiler/test_opt_combine_constants.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

64 lines
1.5 KiB
C++
Raw Normal View History

/*
* Copyright (c) 2024 Intel Corporation
* SPDX-License-Identifier: MIT
*/
brw: Simplify the test code for brw passes 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>
2025-03-05 16:58:32 -08:00
#include "test_helpers.h"
#include "brw_builder.h"
brw: Simplify the test code for brw passes 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>
2025-03-05 16:58:32 -08:00
class CombineConstantsTest : public brw_shader_pass_test {};
brw: Simplify the test code for brw passes 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>
2025-03-05 16:58:32 -08:00
TEST_F(CombineConstantsTest, Simple)
{
brw: Simplify the test code for brw passes 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>
2025-03-05 16:58:32 -08:00
brw_builder bld = make_shader(MESA_SHADER_COMPUTE);
brw_builder exp = make_shader(MESA_SHADER_COMPUTE);
brw_reg r = brw_vec8_grf(1, 0);
brw: Simplify the test code for brw passes 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>
2025-03-05 16:58:32 -08:00
brw_reg imm_a = brw_imm_d(1);
brw_reg imm_b = brw_imm_d(2);
bld.SEL(r, imm_a, imm_b);
brw: Simplify the test code for brw passes 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>
2025-03-05 16:58:32 -08:00
EXPECT_PROGRESS(brw_opt_combine_constants, bld);
brw_reg tmp = component(exp.vgrf(BRW_TYPE_D), 0);
exp.uniform().MOV(tmp, imm_a);
exp .SEL(r, tmp, imm_b);
brw: Simplify the test code for brw passes 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>
2025-03-05 16:58:32 -08:00
EXPECT_SHADERS_MATCH(bld, exp);
}
brw: Simplify the test code for brw passes 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>
2025-03-05 16:58:32 -08:00
TEST_F(CombineConstantsTest, DoContainingDo)
{
brw: Simplify the test code for brw passes 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>
2025-03-05 16:58:32 -08:00
brw_builder bld = make_shader(MESA_SHADER_COMPUTE);
brw_builder exp = make_shader(MESA_SHADER_COMPUTE);
brw_reg r1 = brw_vec8_grf(1, 0);
brw_reg r2 = brw_vec8_grf(2, 0);
brw: Simplify the test code for brw passes 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>
2025-03-05 16:58:32 -08:00
brw_reg imm_a = brw_imm_d(1);
brw_reg imm_b = brw_imm_d(2);
bld.DO();
bld.DO();
bld.SEL(r1, imm_a, imm_b);
bld.WHILE();
bld.WHILE();
bld.SEL(r2, imm_a, imm_b);
brw: Simplify the test code for brw passes 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>
2025-03-05 16:58:32 -08:00
EXPECT_PROGRESS(brw_opt_combine_constants, bld);
brw: Simplify the test code for brw passes 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>
2025-03-05 16:58:32 -08:00
/* Explicit emit the expected FLOW instruction. */
exp.emit(BRW_OPCODE_DO);
brw_reg tmp = component(exp.vgrf(BRW_TYPE_D), 0);
exp.uniform().MOV(tmp, imm_a);
brw: Simplify the test code for brw passes 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>
2025-03-05 16:58:32 -08:00
exp.emit(SHADER_OPCODE_FLOW);
exp.DO();
exp.SEL(r1, tmp, imm_b);
exp.WHILE();
exp.WHILE();
exp.SEL(r2, tmp, imm_b);
brw: Simplify the test code for brw passes 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>
2025-03-05 16:58:32 -08:00
EXPECT_SHADERS_MATCH(bld, exp);
}