mirror of
https://gitlab.freedesktop.org/mesa/mesa.git
synced 2025-12-30 07:50:11 +01:00
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>
This commit is contained in:
Caio Oliveira
Marge Bot
parent
bdfb478be1
commit
91feef40db
8 changed files with 1260 additions and 2465 deletions
|
|
@ -210,6 +210,8 @@ if with_tests
|
|||
files(
|
||||
'test_eu_compact.cpp',
|
||||
'test_eu_validate.cpp',
|
||||
'test_helpers.cpp',
|
||||
'test_helpers.h',
|
||||
'test_lower_scoreboard.cpp',
|
||||
'test_opt_cmod_propagation.cpp',
|
||||
'test_opt_combine_constants.cpp',
|
||||
|
|
|
|||
257
src/intel/compiler/test_helpers.cpp
Normal file
257
src/intel/compiler/test_helpers.cpp
Normal file
|
|
@ -0,0 +1,257 @@
|
|||
/*
|
||||
* Copyright © 2025 Intel Corporation
|
||||
* SPDX-License-Identifier: MIT
|
||||
*/
|
||||
|
||||
#include "test_helpers.h"
|
||||
#include "brw_builder.h"
|
||||
|
||||
std::string
|
||||
brw_shader_to_string(brw_shader *s)
|
||||
{
|
||||
if (!s->cfg)
|
||||
brw_calculate_cfg(*s);
|
||||
|
||||
char *str = NULL;
|
||||
size_t size = 0;
|
||||
|
||||
FILE *f = open_memstream(&str, &size);
|
||||
brw_print_instructions(*s, f);
|
||||
fclose(f);
|
||||
|
||||
std::string result(str);
|
||||
free(str);
|
||||
return result;
|
||||
}
|
||||
|
||||
void
|
||||
brw_reindex_vgrfs(brw_shader *s)
|
||||
{
|
||||
struct Entry {
|
||||
int new_nr;
|
||||
int size;
|
||||
bool valid;
|
||||
};
|
||||
|
||||
unsigned next_nr = 0;
|
||||
Entry *map = rzalloc_array(NULL, Entry, s->alloc.count);
|
||||
|
||||
/* Build map and update references to VGRFs instructions as
|
||||
* they are seen. First destination then sources.
|
||||
*/
|
||||
foreach_block_and_inst(block, brw_inst, inst, s->cfg) {
|
||||
if (inst->dst.file == VGRF) {
|
||||
Entry &entry = map[inst->dst.nr];
|
||||
if (!entry.valid) {
|
||||
entry.new_nr = next_nr++;
|
||||
entry.size = s->alloc.sizes[inst->dst.nr];
|
||||
entry.valid = true;
|
||||
}
|
||||
inst->dst.nr = entry.new_nr;
|
||||
}
|
||||
|
||||
for (int i = 0; i < inst->sources; i++) {
|
||||
if (inst->src[i].file == VGRF) {
|
||||
Entry &entry = map[inst->src[i].nr];
|
||||
if (!entry.valid) {
|
||||
entry.new_nr = next_nr++;
|
||||
entry.size = s->alloc.sizes[inst->src[i].nr];
|
||||
entry.valid = true;
|
||||
}
|
||||
inst->src[i].nr = entry.new_nr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Move unused entries to the end. */
|
||||
for (unsigned i = 0; i < s->alloc.count; i++) {
|
||||
Entry &entry = map[i];
|
||||
if (!entry.valid) {
|
||||
entry.new_nr = next_nr++;
|
||||
entry.size = s->alloc.sizes[i];
|
||||
entry.valid = true;
|
||||
}
|
||||
}
|
||||
|
||||
assert(next_nr == s->alloc.count);
|
||||
|
||||
/* Update sizes. */
|
||||
for (unsigned i = 0; i < s->alloc.count; i++)
|
||||
s->alloc.sizes[map[i].new_nr] = map[i].size;
|
||||
|
||||
ralloc_free(map);
|
||||
|
||||
s->invalidate_analysis(BRW_DEPENDENCY_VARIABLES);
|
||||
}
|
||||
|
||||
void
|
||||
EXPECT_SHADERS_MATCH(brw_shader *a, brw_shader *b)
|
||||
{
|
||||
if (!a->cfg)
|
||||
brw_calculate_cfg(*a);
|
||||
if (!b->cfg)
|
||||
brw_calculate_cfg(*b);
|
||||
|
||||
brw_validate(*a);
|
||||
brw_validate(*b);
|
||||
|
||||
brw_reindex_vgrfs(a);
|
||||
brw_reindex_vgrfs(b);
|
||||
|
||||
std::string sa = brw_shader_to_string(a);
|
||||
std::string sb = brw_shader_to_string(b);
|
||||
|
||||
EXPECT_EQ(sa, sb);
|
||||
}
|
||||
|
||||
class TestHelpers : public brw_shader_pass_test {};
|
||||
|
||||
TEST_F(TestHelpers, ReindexVGRFsDestinations)
|
||||
{
|
||||
brw_builder bld = make_shader();
|
||||
|
||||
brw_reg d = bld.vgrf(BRW_TYPE_UD);
|
||||
brw_reg c = bld.vgrf(BRW_TYPE_UD);
|
||||
brw_reg b = bld.vgrf(BRW_TYPE_UD);
|
||||
brw_reg a = bld.vgrf(BRW_TYPE_UD);
|
||||
|
||||
brw_inst *mov_a = bld.MOV(a, brw_vec8_grf(0, 0));
|
||||
brw_inst *mov_b = bld.MOV(b, a);
|
||||
brw_inst *mov_c = bld.MOV(c, b);
|
||||
brw_inst *add_d = bld.ADD(d, a, b);
|
||||
|
||||
EXPECT_EQ(mov_a->dst.nr, 3);
|
||||
EXPECT_EQ(mov_b->dst.nr, 2);
|
||||
EXPECT_EQ(mov_c->dst.nr, 1);
|
||||
EXPECT_EQ(add_d->dst.nr, 0);
|
||||
|
||||
brw_calculate_cfg(*bld.shader);
|
||||
brw_reindex_vgrfs(bld.shader);
|
||||
|
||||
EXPECT_EQ(mov_a->dst.nr, 0);
|
||||
EXPECT_EQ(mov_b->dst.nr, 1);
|
||||
EXPECT_EQ(mov_c->dst.nr, 2);
|
||||
EXPECT_EQ(add_d->dst.nr, 3);
|
||||
}
|
||||
|
||||
TEST_F(TestHelpers, ReindexVGRFsSources)
|
||||
{
|
||||
brw_builder bld = make_shader();
|
||||
|
||||
brw_reg d = bld.vgrf(BRW_TYPE_UD);
|
||||
brw_reg c = bld.vgrf(BRW_TYPE_UD);
|
||||
brw_reg b = bld.vgrf(BRW_TYPE_UD);
|
||||
brw_reg a = bld.vgrf(BRW_TYPE_UD);
|
||||
|
||||
brw_inst *mov_a = bld.MOV(brw_vec8_grf(0, 0), a);
|
||||
brw_inst *mov_b = bld.MOV(brw_vec8_grf(7, 0), b);
|
||||
brw_inst *add_cd = bld.ADD(brw_vec8_grf(14, 0), c, d);
|
||||
|
||||
EXPECT_EQ(mov_a->src[0].nr, 3);
|
||||
EXPECT_EQ(mov_b->src[0].nr, 2);
|
||||
EXPECT_EQ(add_cd->src[0].nr, 1);
|
||||
EXPECT_EQ(add_cd->src[1].nr, 0);
|
||||
|
||||
brw_calculate_cfg(*bld.shader);
|
||||
brw_reindex_vgrfs(bld.shader);
|
||||
|
||||
EXPECT_EQ(mov_a->src[0].nr, 0);
|
||||
EXPECT_EQ(mov_b->src[0].nr, 1);
|
||||
EXPECT_EQ(add_cd->src[0].nr, 2);
|
||||
EXPECT_EQ(add_cd->src[1].nr, 3);
|
||||
}
|
||||
|
||||
TEST_F(TestHelpers, ReindexVGRFsIncludesSizes)
|
||||
{
|
||||
brw_builder bld = make_shader();
|
||||
|
||||
brw_reg d = bld.vgrf(BRW_TYPE_UD, 1);
|
||||
brw_reg c = bld.vgrf(BRW_TYPE_UD, 6);
|
||||
brw_reg b = bld.vgrf(BRW_TYPE_UD, 8);
|
||||
brw_reg a = bld.vgrf(BRW_TYPE_UD, 2);
|
||||
|
||||
brw_inst *mov_a = bld.MOV(a, brw_imm_d(2222));
|
||||
brw_inst *mov_b = bld.MOV(b, brw_imm_d(8888));
|
||||
brw_inst *mov_c = bld.MOV(c, brw_imm_d(6666));
|
||||
brw_inst *mov_d = bld.MOV(d, brw_imm_d(1111));
|
||||
|
||||
EXPECT_EQ(mov_a->dst.nr, 3);
|
||||
EXPECT_EQ(mov_b->dst.nr, 2);
|
||||
EXPECT_EQ(mov_c->dst.nr, 1);
|
||||
EXPECT_EQ(mov_d->dst.nr, 0);
|
||||
|
||||
brw_calculate_cfg(*bld.shader);
|
||||
brw_reindex_vgrfs(bld.shader);
|
||||
|
||||
EXPECT_EQ(mov_a->dst.nr, 0);
|
||||
EXPECT_EQ(mov_b->dst.nr, 1);
|
||||
EXPECT_EQ(mov_c->dst.nr, 2);
|
||||
EXPECT_EQ(mov_d->dst.nr, 3);
|
||||
|
||||
brw_shader *s = bld.shader;
|
||||
EXPECT_EQ(s->alloc.count, 4);
|
||||
EXPECT_EQ(s->alloc.sizes[0], 2);
|
||||
EXPECT_EQ(s->alloc.sizes[1], 8);
|
||||
EXPECT_EQ(s->alloc.sizes[2], 6);
|
||||
EXPECT_EQ(s->alloc.sizes[3], 1);
|
||||
}
|
||||
|
||||
TEST_F(TestHelpers, ReindexVGRFsUnusedAreMovedToTheEnd)
|
||||
{
|
||||
brw_builder bld = make_shader();
|
||||
|
||||
brw_reg a = bld.vgrf(BRW_TYPE_UD, 4);
|
||||
UNUSED brw_reg b = bld.vgrf(BRW_TYPE_UD, 6);
|
||||
brw_reg c = bld.vgrf(BRW_TYPE_UD, 8);
|
||||
|
||||
brw_inst *add = bld.ADD(a, a, c);
|
||||
|
||||
brw_calculate_cfg(*bld.shader);
|
||||
brw_reindex_vgrfs(bld.shader);
|
||||
|
||||
EXPECT_EQ(add->src[0].nr, 0);
|
||||
EXPECT_EQ(add->src[1].nr, 1);
|
||||
|
||||
brw_shader *s = bld.shader;
|
||||
EXPECT_EQ(s->alloc.count, 3);
|
||||
EXPECT_EQ(s->alloc.sizes[0], 4);
|
||||
EXPECT_EQ(s->alloc.sizes[1], 8);
|
||||
EXPECT_EQ(s->alloc.sizes[2], 6);
|
||||
}
|
||||
|
||||
TEST_F(TestHelpers, MatchShadersSameStructureDifferentNumbers)
|
||||
{
|
||||
brw_builder a = make_shader();
|
||||
brw_builder b = make_shader();
|
||||
|
||||
int nr_from_a;
|
||||
int nr_from_b;
|
||||
|
||||
/* Build using the builder automatic allocations. */
|
||||
{
|
||||
brw_inst *add = NULL;
|
||||
|
||||
brw_reg src0 = a.MOV(brw_ud8_grf(1, 0));
|
||||
brw_reg src1 = a.MOV(brw_ud8_grf(7, 0));
|
||||
a.ADD(src0, src1, &add);
|
||||
|
||||
EXPECT_EQ(add->dst.file, VGRF);
|
||||
nr_from_a = add->dst.nr;
|
||||
}
|
||||
|
||||
/* Build using explicitly created VGRFs. */
|
||||
{
|
||||
brw_reg dst = b.vgrf(BRW_TYPE_UD);
|
||||
brw_reg src0 = b.vgrf(BRW_TYPE_UD);
|
||||
brw_reg src1 = b.vgrf(BRW_TYPE_UD);
|
||||
|
||||
b.MOV(src0, brw_ud8_grf(1, 0));
|
||||
b.MOV(src1, brw_ud8_grf(7, 0));
|
||||
b.ADD(dst, src0, src1);
|
||||
|
||||
nr_from_b = dst.nr;
|
||||
}
|
||||
|
||||
EXPECT_NE(nr_from_a, nr_from_b);
|
||||
EXPECT_SHADERS_MATCH(a, b);
|
||||
}
|
||||
199
src/intel/compiler/test_helpers.h
Normal file
199
src/intel/compiler/test_helpers.h
Normal file
|
|
@ -0,0 +1,199 @@
|
|||
/*
|
||||
* Copyright © 2025 Intel Corporation
|
||||
* SPDX-License-Identifier: MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include "brw_shader.h"
|
||||
#include "brw_builder.h"
|
||||
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
std::string brw_shader_to_string(brw_shader *s);
|
||||
|
||||
void brw_reindex_vgrfs(brw_shader *s);
|
||||
|
||||
/* Note: the order of instructions must be the same for shaders to match
|
||||
* so be careful when using patterns like bld.ADD(bld.MOV(), bld.MOV())
|
||||
* in the tests since order of argument evaluation is unspecified.
|
||||
*/
|
||||
void EXPECT_SHADERS_MATCH(brw_shader *a, brw_shader *b);
|
||||
|
||||
inline void
|
||||
EXPECT_SHADERS_MATCH(brw_builder &a, brw_builder &b)
|
||||
{
|
||||
EXPECT_SHADERS_MATCH(a.shader, b.shader);
|
||||
}
|
||||
|
||||
template <typename PASS>
|
||||
inline void
|
||||
EXPECT_PROGRESS_RESULT(bool should_progress, PASS pass, brw_shader *s)
|
||||
{
|
||||
if (!s->cfg)
|
||||
brw_calculate_cfg(*s);
|
||||
|
||||
brw_validate(*s);
|
||||
|
||||
auto before = brw_shader_to_string(s);
|
||||
bool progress = pass(*s);
|
||||
auto after = brw_shader_to_string(s);
|
||||
|
||||
brw_validate(*s);
|
||||
|
||||
if (progress != should_progress || getenv("TEST_DEBUG")) {
|
||||
fprintf(stderr, "= Before =\n"
|
||||
"%s\n"
|
||||
"\n"
|
||||
"= After =\n"
|
||||
"%s\n",
|
||||
before.c_str(),
|
||||
after.c_str());
|
||||
}
|
||||
|
||||
EXPECT_EQ(progress, should_progress);
|
||||
if (should_progress)
|
||||
EXPECT_NE(before, after);
|
||||
else
|
||||
EXPECT_EQ(before, after);
|
||||
}
|
||||
|
||||
template <typename PASS>
|
||||
inline void
|
||||
EXPECT_PROGRESS(PASS pass, brw_shader *s)
|
||||
{
|
||||
EXPECT_PROGRESS_RESULT(true, pass, s);
|
||||
}
|
||||
|
||||
template <typename PASS>
|
||||
inline void
|
||||
EXPECT_NO_PROGRESS(PASS pass, brw_shader *s)
|
||||
{
|
||||
EXPECT_PROGRESS_RESULT(false, pass, s);
|
||||
}
|
||||
|
||||
template <typename PASS>
|
||||
inline void
|
||||
EXPECT_PROGRESS_RESULT(bool should_progress, PASS pass, brw_builder &bld)
|
||||
{
|
||||
EXPECT_PROGRESS_RESULT(should_progress, pass, bld.shader);
|
||||
}
|
||||
|
||||
template <typename PASS>
|
||||
inline void
|
||||
EXPECT_PROGRESS(PASS pass, brw_builder &bld)
|
||||
{
|
||||
EXPECT_PROGRESS(pass, bld.shader);
|
||||
}
|
||||
|
||||
template <typename PASS>
|
||||
inline void
|
||||
EXPECT_NO_PROGRESS(PASS pass, brw_builder &bld)
|
||||
{
|
||||
EXPECT_NO_PROGRESS(pass, bld.shader);
|
||||
}
|
||||
|
||||
class brw_shader_pass_test : public ::testing::Test {
|
||||
protected:
|
||||
void *mem_ctx;
|
||||
struct brw_compiler *compiler;
|
||||
struct intel_device_info *devinfo;
|
||||
|
||||
/* TODO: Once brw_shader is ralloc-able, we can simply get rid of this. */
|
||||
std::vector<std::unique_ptr<brw_shader>> shaders;
|
||||
|
||||
brw_shader_pass_test()
|
||||
{
|
||||
mem_ctx = ralloc_context(NULL);
|
||||
compiler = rzalloc(mem_ctx, struct brw_compiler);
|
||||
devinfo = rzalloc(mem_ctx, struct intel_device_info);
|
||||
compiler->devinfo = devinfo;
|
||||
|
||||
set_gfx_verx10(90);
|
||||
}
|
||||
|
||||
~brw_shader_pass_test() override
|
||||
{
|
||||
ralloc_free(mem_ctx);
|
||||
}
|
||||
|
||||
void
|
||||
set_gfx_verx10(unsigned verx10)
|
||||
{
|
||||
devinfo->verx10 = verx10;
|
||||
devinfo->ver = verx10 / 10;
|
||||
assert(devinfo->ver > 0);
|
||||
brw_init_isa_info(&compiler->isa, devinfo);
|
||||
}
|
||||
|
||||
brw_builder
|
||||
make_shader(gl_shader_stage stage = MESA_SHADER_FRAGMENT,
|
||||
unsigned dispatch_width = 0)
|
||||
{
|
||||
if (dispatch_width == 0)
|
||||
dispatch_width = devinfo->ver >= 20 ? 16 : 8;
|
||||
|
||||
nir_shader *nir = nir_shader_create(mem_ctx, stage, NULL, NULL);
|
||||
brw_stage_prog_data *pd =
|
||||
(struct brw_stage_prog_data *)rzalloc(mem_ctx, brw_any_prog_data);
|
||||
|
||||
brw_compile_params params = {};
|
||||
params.mem_ctx = mem_ctx;
|
||||
|
||||
shaders.push_back(std::make_unique<brw_shader>(compiler, ¶ms, nullptr, pd, nir,
|
||||
dispatch_width, false, false));
|
||||
|
||||
brw_shader *s = shaders.back().get();
|
||||
s->phase = BRW_SHADER_PHASE_AFTER_OPT_LOOP;
|
||||
return brw_builder(s);
|
||||
}
|
||||
|
||||
/* Helper to allocate same vgrf number in two shaders. */
|
||||
static brw_reg
|
||||
vgrf(brw_shader *a, brw_shader *b,
|
||||
brw_reg_type type, unsigned n = 1,
|
||||
unsigned dispatch_width = 0)
|
||||
{
|
||||
assert(a && b && a->dispatch_width == b->dispatch_width);
|
||||
|
||||
if (dispatch_width == 0)
|
||||
dispatch_width = a->dispatch_width;
|
||||
|
||||
brw_reg reg_a = brw_allocate_vgrf(*a, type, n * dispatch_width);
|
||||
brw_reg reg_b = brw_allocate_vgrf(*b, type, n * dispatch_width);
|
||||
assert(brw_regs_equal(®_a, ®_b));
|
||||
|
||||
return reg_a;
|
||||
}
|
||||
|
||||
static brw_reg
|
||||
vgrf(brw_builder &a, brw_builder &b,
|
||||
brw_reg_type type, unsigned n = 1,
|
||||
unsigned dispatch_width = 0)
|
||||
{
|
||||
return vgrf(a.shader, b.shader, type, n, dispatch_width);
|
||||
}
|
||||
|
||||
static brw_reg
|
||||
vgrf(brw_shader *a,
|
||||
brw_reg_type type, unsigned n = 1,
|
||||
unsigned dispatch_width = 0)
|
||||
{
|
||||
assert(a);
|
||||
|
||||
if (dispatch_width == 0)
|
||||
dispatch_width = a->dispatch_width;
|
||||
|
||||
return brw_allocate_vgrf(*a, type, n * dispatch_width);
|
||||
}
|
||||
|
||||
static brw_reg
|
||||
vgrf(brw_builder &a,
|
||||
brw_reg_type type, unsigned n = 1,
|
||||
unsigned dispatch_width = 0)
|
||||
{
|
||||
return vgrf(a.shader, type, n, dispatch_width);
|
||||
}
|
||||
};
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -3,101 +3,41 @@
|
|||
* SPDX-License-Identifier: MIT
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include "brw_shader.h"
|
||||
#include "test_helpers.h"
|
||||
#include "brw_builder.h"
|
||||
#include "brw_cfg.h"
|
||||
|
||||
struct FSCombineConstantsTest : public ::testing::Test {
|
||||
FSCombineConstantsTest() {
|
||||
mem_ctx = ralloc_context(NULL);
|
||||
class CombineConstantsTest : public brw_shader_pass_test {};
|
||||
|
||||
devinfo = {};
|
||||
devinfo.ver = 9;
|
||||
devinfo.verx10 = 90;
|
||||
|
||||
compiler = {};
|
||||
compiler.devinfo = &devinfo;
|
||||
brw_init_isa_info(&compiler.isa, &devinfo);
|
||||
|
||||
params = {};
|
||||
params.mem_ctx = mem_ctx;
|
||||
|
||||
prog_data = {};
|
||||
nir_shader *nir =
|
||||
nir_shader_create(mem_ctx, MESA_SHADER_COMPUTE, NULL, NULL);
|
||||
|
||||
shader = new brw_shader(&compiler, ¶ms, NULL,
|
||||
&prog_data.base, nir, 8, false, false);
|
||||
}
|
||||
|
||||
~FSCombineConstantsTest() override {
|
||||
delete shader;
|
||||
ralloc_free(mem_ctx);
|
||||
mem_ctx = NULL;
|
||||
}
|
||||
|
||||
void *mem_ctx;
|
||||
brw_compiler compiler;
|
||||
brw_compile_params params;
|
||||
intel_device_info devinfo;
|
||||
struct brw_wm_prog_data prog_data;
|
||||
struct gl_shader_program *shader_prog;
|
||||
|
||||
brw_shader *shader;
|
||||
|
||||
bool opt_combine_constants(brw_shader *s) {
|
||||
const bool print = getenv("TEST_DEBUG");
|
||||
|
||||
if (print) {
|
||||
fprintf(stderr, "= Before =\n");
|
||||
s->cfg->dump();
|
||||
}
|
||||
|
||||
bool ret = brw_opt_combine_constants(*s);
|
||||
|
||||
if (print) {
|
||||
fprintf(stderr, "\n= After =\n");
|
||||
s->cfg->dump();
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(FSCombineConstantsTest, Simple)
|
||||
TEST_F(CombineConstantsTest, Simple)
|
||||
{
|
||||
brw_builder bld = brw_builder(shader);
|
||||
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_reg imm_a = brw_imm_ud(1);
|
||||
brw_reg imm_b = brw_imm_ud(2);
|
||||
brw_reg imm_a = brw_imm_d(1);
|
||||
brw_reg imm_b = brw_imm_d(2);
|
||||
|
||||
bld.SEL(r, imm_a, imm_b);
|
||||
brw_calculate_cfg(*shader);
|
||||
|
||||
bool progress = opt_combine_constants(shader);
|
||||
ASSERT_TRUE(progress);
|
||||
EXPECT_PROGRESS(brw_opt_combine_constants, bld);
|
||||
|
||||
ASSERT_EQ(shader->cfg->num_blocks, 1);
|
||||
bblock_t *block = shader->cfg->first_block();
|
||||
ASSERT_NE(block, nullptr);
|
||||
brw_reg tmp = component(exp.vgrf(BRW_TYPE_D), 0);
|
||||
|
||||
/* We can do better but for now sanity check that
|
||||
* there's a MOV and a SEL.
|
||||
*/
|
||||
ASSERT_EQ(block->start()->opcode, BRW_OPCODE_MOV);
|
||||
ASSERT_EQ(block->end()->opcode, BRW_OPCODE_SEL);
|
||||
exp.group(1, 0).exec_all().MOV(tmp, imm_a);
|
||||
exp .SEL(r, tmp, imm_b);
|
||||
|
||||
EXPECT_SHADERS_MATCH(bld, exp);
|
||||
}
|
||||
|
||||
TEST_F(FSCombineConstantsTest, DoContainingDo)
|
||||
TEST_F(CombineConstantsTest, DoContainingDo)
|
||||
{
|
||||
brw_builder bld = brw_builder(shader);
|
||||
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_reg imm_a = brw_imm_ud(1);
|
||||
brw_reg imm_b = brw_imm_ud(2);
|
||||
brw_reg imm_a = brw_imm_d(1);
|
||||
brw_reg imm_b = brw_imm_d(2);
|
||||
|
||||
bld.DO();
|
||||
bld.DO();
|
||||
|
|
@ -105,18 +45,19 @@ TEST_F(FSCombineConstantsTest, DoContainingDo)
|
|||
bld.WHILE();
|
||||
bld.WHILE();
|
||||
bld.SEL(r2, imm_a, imm_b);
|
||||
brw_calculate_cfg(*shader);
|
||||
|
||||
unsigned original_num_blocks = shader->cfg->num_blocks;
|
||||
EXPECT_PROGRESS(brw_opt_combine_constants, bld);
|
||||
|
||||
bool progress = opt_combine_constants(shader);
|
||||
ASSERT_TRUE(progress);
|
||||
/* Explicit emit the expected FLOW instruction. */
|
||||
exp.emit(BRW_OPCODE_DO);
|
||||
brw_reg tmp = component(exp.vgrf(BRW_TYPE_D), 0);
|
||||
exp.group(1, 0).exec_all().MOV(tmp, imm_a);
|
||||
exp.emit(SHADER_OPCODE_FLOW);
|
||||
exp.DO();
|
||||
exp.SEL(r1, tmp, imm_b);
|
||||
exp.WHILE();
|
||||
exp.WHILE();
|
||||
exp.SEL(r2, tmp, imm_b);
|
||||
|
||||
/* We can do better but for now sanity check there's
|
||||
* enough blocks, since the original issue motivating this
|
||||
* test is that the shader would be empty.
|
||||
*/
|
||||
ASSERT_GE(shader->cfg->num_blocks, original_num_blocks);
|
||||
brw_validate(*shader);
|
||||
EXPECT_SHADERS_MATCH(bld, exp);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,155 +1,37 @@
|
|||
/*
|
||||
* Copyright © 2016 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 (including the next
|
||||
* paragraph) 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.
|
||||
* SPDX-License-Identifier: MIT
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include "brw_shader.h"
|
||||
#include "test_helpers.h"
|
||||
#include "brw_builder.h"
|
||||
#include "brw_cfg.h"
|
||||
|
||||
class copy_propagation_test : public ::testing::Test {
|
||||
protected:
|
||||
copy_propagation_test();
|
||||
~copy_propagation_test() override;
|
||||
|
||||
struct brw_compiler *compiler;
|
||||
struct brw_compile_params params;
|
||||
struct intel_device_info *devinfo;
|
||||
void *ctx;
|
||||
struct brw_wm_prog_data *prog_data;
|
||||
struct gl_shader_program *shader_prog;
|
||||
brw_shader *v;
|
||||
brw_builder bld;
|
||||
};
|
||||
|
||||
copy_propagation_test::copy_propagation_test()
|
||||
{
|
||||
ctx = ralloc_context(NULL);
|
||||
compiler = rzalloc(ctx, struct brw_compiler);
|
||||
devinfo = rzalloc(ctx, struct intel_device_info);
|
||||
compiler->devinfo = devinfo;
|
||||
|
||||
params = {};
|
||||
params.mem_ctx = ctx;
|
||||
|
||||
prog_data = ralloc(ctx, struct brw_wm_prog_data);
|
||||
nir_shader *shader =
|
||||
nir_shader_create(ctx, MESA_SHADER_FRAGMENT, NULL, NULL);
|
||||
|
||||
v = new brw_shader(compiler, ¶ms, NULL, &prog_data->base, shader,
|
||||
8, false, false);
|
||||
|
||||
bld = brw_builder(v);
|
||||
|
||||
devinfo->ver = 9;
|
||||
devinfo->verx10 = devinfo->ver * 10;
|
||||
}
|
||||
|
||||
copy_propagation_test::~copy_propagation_test()
|
||||
{
|
||||
delete v;
|
||||
v = NULL;
|
||||
|
||||
ralloc_free(ctx);
|
||||
ctx = NULL;
|
||||
}
|
||||
|
||||
static brw_inst *
|
||||
instruction(bblock_t *block, int num)
|
||||
{
|
||||
brw_inst *inst = (brw_inst *)block->start();
|
||||
for (int i = 0; i < num; i++) {
|
||||
inst = (brw_inst *)inst->next;
|
||||
}
|
||||
return inst;
|
||||
}
|
||||
|
||||
static bool
|
||||
copy_propagation(brw_shader *v)
|
||||
{
|
||||
const bool print = getenv("TEST_DEBUG");
|
||||
|
||||
if (print) {
|
||||
fprintf(stderr, "= Before =\n");
|
||||
v->cfg->dump();
|
||||
}
|
||||
|
||||
bool ret = brw_opt_copy_propagation(*v);
|
||||
|
||||
if (print) {
|
||||
fprintf(stderr, "\n= After =\n");
|
||||
v->cfg->dump();
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
class copy_propagation_test : public brw_shader_pass_test {};
|
||||
|
||||
TEST_F(copy_propagation_test, basic)
|
||||
{
|
||||
brw_reg vgrf0 = bld.vgrf(BRW_TYPE_F);
|
||||
brw_reg vgrf1 = bld.vgrf(BRW_TYPE_F);
|
||||
brw_reg vgrf2 = bld.vgrf(BRW_TYPE_F);
|
||||
brw_reg vgrf3 = bld.vgrf(BRW_TYPE_F);
|
||||
bld.MOV(vgrf0, vgrf2);
|
||||
bld.ADD(vgrf1, vgrf0, vgrf3);
|
||||
brw_builder bld = make_shader();
|
||||
brw_builder exp = make_shader();
|
||||
|
||||
/* = Before =
|
||||
*
|
||||
* 0: mov(8) vgrf0 vgrf2
|
||||
* 1: add(8) vgrf1 vgrf0 vgrf3
|
||||
*
|
||||
* = After =
|
||||
* 0: mov(8) vgrf0 vgrf2
|
||||
* 1: add(8) vgrf1 vgrf2 vgrf3
|
||||
*/
|
||||
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);
|
||||
|
||||
brw_calculate_cfg(*v);
|
||||
bblock_t *block0 = v->cfg->blocks[0];
|
||||
bld.MOV(v0, v2);
|
||||
bld.ADD(v1, v0, v3);
|
||||
|
||||
EXPECT_EQ(0, block0->start_ip);
|
||||
EXPECT_EQ(1, block0->end_ip);
|
||||
/* Propagation makes ADD use v2 as source. */
|
||||
EXPECT_PROGRESS(brw_opt_copy_propagation, bld);
|
||||
|
||||
EXPECT_TRUE(copy_propagation(v));
|
||||
EXPECT_EQ(0, block0->start_ip);
|
||||
EXPECT_EQ(1, block0->end_ip);
|
||||
exp.MOV(v0, v2);
|
||||
exp.ADD(v1, v2, v3);
|
||||
|
||||
brw_inst *mov = instruction(block0, 0);
|
||||
EXPECT_EQ(BRW_OPCODE_MOV, mov->opcode);
|
||||
EXPECT_TRUE(mov->dst.equals(vgrf0));
|
||||
EXPECT_TRUE(mov->src[0].equals(vgrf2));
|
||||
|
||||
brw_inst *add = instruction(block0, 1);
|
||||
EXPECT_EQ(BRW_OPCODE_ADD, add->opcode);
|
||||
EXPECT_TRUE(add->dst.equals(vgrf1));
|
||||
EXPECT_TRUE(add->src[0].equals(vgrf2));
|
||||
EXPECT_TRUE(add->src[1].equals(vgrf3));
|
||||
EXPECT_SHADERS_MATCH(bld, exp);
|
||||
}
|
||||
|
||||
TEST_F(copy_propagation_test, maxmax_sat_imm)
|
||||
{
|
||||
brw_reg vgrf0 = bld.vgrf(BRW_TYPE_F);
|
||||
brw_reg vgrf1 = bld.vgrf(BRW_TYPE_F);
|
||||
brw_reg vgrf2 = bld.vgrf(BRW_TYPE_F);
|
||||
|
||||
static const struct {
|
||||
enum brw_conditional_mod conditional_mod;
|
||||
float immediate;
|
||||
|
|
@ -177,126 +59,57 @@ TEST_F(copy_propagation_test, maxmax_sat_imm)
|
|||
{ BRW_CONDITIONAL_U , 0.5f, false },
|
||||
};
|
||||
|
||||
for (unsigned i = 0; i < sizeof(test) / sizeof(test[0]); i++) {
|
||||
brw_inst *mov = set_saturate(true, bld.MOV(vgrf0, vgrf1));
|
||||
brw_inst *sel = set_condmod(test[i].conditional_mod,
|
||||
bld.SEL(vgrf2, vgrf0,
|
||||
brw_imm_f(test[i].immediate)));
|
||||
for (unsigned i = 0; i < ARRAY_SIZE(test); i++) {
|
||||
brw_builder bld = make_shader();
|
||||
|
||||
brw_calculate_cfg(*v);
|
||||
enum brw_conditional_mod cmod = test[i].conditional_mod;
|
||||
brw_reg imm = brw_imm_f(test[i].immediate);
|
||||
|
||||
bblock_t *block0 = v->cfg->blocks[0];
|
||||
brw_reg v0 = bld.vgrf(BRW_TYPE_F);
|
||||
brw_reg v1 = bld.vgrf(BRW_TYPE_F);
|
||||
brw_reg v2 = bld.vgrf(BRW_TYPE_F);
|
||||
|
||||
EXPECT_EQ(0, block0->start_ip);
|
||||
EXPECT_EQ(1, block0->end_ip);
|
||||
bld.MOV(v0, v1)->saturate = true;
|
||||
bld.SEL(v2, v0, imm)->conditional_mod = cmod;
|
||||
|
||||
EXPECT_EQ(test[i].expected_result, copy_propagation(v));
|
||||
EXPECT_EQ(0, block0->start_ip);
|
||||
EXPECT_EQ(1, block0->end_ip);
|
||||
|
||||
EXPECT_EQ(BRW_OPCODE_MOV, mov->opcode);
|
||||
EXPECT_TRUE(mov->saturate);
|
||||
EXPECT_TRUE(mov->dst.equals(vgrf0));
|
||||
EXPECT_TRUE(mov->src[0].equals(vgrf1));
|
||||
|
||||
EXPECT_EQ(BRW_OPCODE_SEL, sel->opcode);
|
||||
EXPECT_EQ(test[i].conditional_mod, sel->conditional_mod);
|
||||
EXPECT_EQ(test[i].expected_result, sel->saturate);
|
||||
EXPECT_TRUE(sel->dst.equals(vgrf2));
|
||||
if (test[i].expected_result) {
|
||||
EXPECT_TRUE(sel->src[0].equals(vgrf1));
|
||||
} else {
|
||||
EXPECT_TRUE(sel->src[0].equals(vgrf0));
|
||||
}
|
||||
EXPECT_TRUE(sel->src[1].equals(brw_imm_f(test[i].immediate)));
|
||||
|
||||
delete v->cfg;
|
||||
v->cfg = NULL;
|
||||
EXPECT_PROGRESS_RESULT(test[i].expected_result,
|
||||
brw_opt_copy_propagation, bld);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(copy_propagation_test, mixed_integer_sign)
|
||||
{
|
||||
brw_reg vgrf0 = bld.vgrf(BRW_TYPE_UD);
|
||||
brw_reg vgrf1 = bld.vgrf(BRW_TYPE_D);
|
||||
brw_reg vgrf2 = bld.vgrf(BRW_TYPE_UD);
|
||||
brw_reg vgrf3 = bld.vgrf(BRW_TYPE_UD);
|
||||
brw_reg vgrf4 = bld.vgrf(BRW_TYPE_UD);
|
||||
brw_builder bld = make_shader();
|
||||
brw_builder exp = make_shader();
|
||||
|
||||
bld.MOV(vgrf1, vgrf0);
|
||||
bld.BFE(vgrf2, vgrf3, vgrf4, retype(vgrf1, BRW_TYPE_UD));
|
||||
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);
|
||||
|
||||
/* = Before =
|
||||
*
|
||||
* 0: mov(8) vgrf1:D vgrf0:UD
|
||||
* 1: bfe(8) vgrf2:UD vgrf3:UD vgrf4:UD vgrf1:UD
|
||||
*
|
||||
* = After =
|
||||
* 0: mov(8) vgrf1:D vgrf0:UD
|
||||
* 1: bfe(8) vgrf2:UD vgrf3:UD vgrf4:UD vgrf0:UD
|
||||
*/
|
||||
bld.MOV(v1, v0);
|
||||
bld.BFE(v2, v3, v4, retype(v1, BRW_TYPE_UD));
|
||||
|
||||
brw_calculate_cfg(*v);
|
||||
bblock_t *block0 = v->cfg->blocks[0];
|
||||
/* Propagation makes BFE use v0 as source. */
|
||||
EXPECT_PROGRESS(brw_opt_copy_propagation, bld);
|
||||
|
||||
EXPECT_EQ(0, block0->start_ip);
|
||||
EXPECT_EQ(1, block0->end_ip);
|
||||
exp.MOV(v1, v0);
|
||||
exp.BFE(v2, v3, v4, v0);
|
||||
|
||||
EXPECT_TRUE(copy_propagation(v));
|
||||
EXPECT_EQ(0, block0->start_ip);
|
||||
EXPECT_EQ(1, block0->end_ip);
|
||||
|
||||
brw_inst *mov = instruction(block0, 0);
|
||||
EXPECT_EQ(BRW_OPCODE_MOV, mov->opcode);
|
||||
EXPECT_TRUE(mov->dst.equals(vgrf1));
|
||||
EXPECT_TRUE(mov->src[0].equals(vgrf0));
|
||||
|
||||
brw_inst *bfe = instruction(block0, 1);
|
||||
EXPECT_EQ(BRW_OPCODE_BFE, bfe->opcode);
|
||||
EXPECT_TRUE(bfe->dst.equals(vgrf2));
|
||||
EXPECT_TRUE(bfe->src[0].equals(vgrf3));
|
||||
EXPECT_TRUE(bfe->src[1].equals(vgrf4));
|
||||
EXPECT_TRUE(bfe->src[2].equals(vgrf0));
|
||||
EXPECT_SHADERS_MATCH(bld, exp);
|
||||
}
|
||||
|
||||
TEST_F(copy_propagation_test, mixed_integer_sign_with_vector_imm)
|
||||
{
|
||||
brw_reg vgrf0 = bld.vgrf(BRW_TYPE_W);
|
||||
brw_reg vgrf1 = bld.vgrf(BRW_TYPE_UD);
|
||||
brw_reg vgrf2 = bld.vgrf(BRW_TYPE_UD);
|
||||
brw_builder bld = make_shader();
|
||||
|
||||
bld.MOV(vgrf0, brw_imm_uv(0xffff));
|
||||
bld.ADD(vgrf1, vgrf2, retype(vgrf0, BRW_TYPE_UW));
|
||||
brw_reg v0 = bld.vgrf(BRW_TYPE_W);
|
||||
brw_reg v1 = bld.vgrf(BRW_TYPE_UD);
|
||||
brw_reg v2 = bld.vgrf(BRW_TYPE_UD);
|
||||
|
||||
/* = Before =
|
||||
*
|
||||
* 0: mov(8) vgrf0:W ...:UV
|
||||
* 1: add(8) vgrf1:UD vgrf2:UD vgrf0:UW
|
||||
*
|
||||
* = After =
|
||||
* No change
|
||||
*/
|
||||
bld.MOV(v0, brw_imm_uv(0xffff));
|
||||
bld.ADD(v1, v2, retype(v0, BRW_TYPE_UW));
|
||||
|
||||
brw_calculate_cfg(*v);
|
||||
bblock_t *block0 = v->cfg->blocks[0];
|
||||
|
||||
const brw_reg src1 = instruction(block0, 1)->src[1];
|
||||
|
||||
EXPECT_EQ(0, block0->start_ip);
|
||||
EXPECT_EQ(1, block0->end_ip);
|
||||
|
||||
EXPECT_FALSE(copy_propagation(v));
|
||||
EXPECT_EQ(0, block0->start_ip);
|
||||
EXPECT_EQ(1, block0->end_ip);
|
||||
|
||||
brw_inst *mov = instruction(block0, 0);
|
||||
EXPECT_EQ(BRW_OPCODE_MOV, mov->opcode);
|
||||
EXPECT_TRUE(mov->dst.equals(vgrf0));
|
||||
EXPECT_TRUE(mov->src[0].file == IMM);
|
||||
|
||||
brw_inst *add = instruction(block0, 1);
|
||||
EXPECT_EQ(BRW_OPCODE_ADD, add->opcode);
|
||||
EXPECT_TRUE(add->dst.equals(vgrf1));
|
||||
EXPECT_TRUE(add->src[0].equals(vgrf2));
|
||||
EXPECT_TRUE(add->src[1].equals(src1));
|
||||
EXPECT_NO_PROGRESS(brw_opt_copy_propagation, bld);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,91 +3,17 @@
|
|||
* SPDX-License-Identifier: MIT
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include "brw_shader.h"
|
||||
#include "test_helpers.h"
|
||||
#include "brw_builder.h"
|
||||
#include "brw_cfg.h"
|
||||
|
||||
class cse_test : public ::testing::Test {
|
||||
protected:
|
||||
cse_test();
|
||||
~cse_test() override;
|
||||
|
||||
struct brw_compiler *compiler;
|
||||
struct brw_compile_params params;
|
||||
struct intel_device_info *devinfo;
|
||||
void *ctx;
|
||||
struct brw_wm_prog_data *prog_data;
|
||||
struct gl_shader_program *shader_prog;
|
||||
brw_shader *v;
|
||||
brw_builder bld;
|
||||
};
|
||||
|
||||
cse_test::cse_test()
|
||||
{
|
||||
ctx = ralloc_context(NULL);
|
||||
compiler = rzalloc(ctx, struct brw_compiler);
|
||||
devinfo = rzalloc(ctx, struct intel_device_info);
|
||||
compiler->devinfo = devinfo;
|
||||
|
||||
params = {};
|
||||
params.mem_ctx = ctx;
|
||||
|
||||
prog_data = ralloc(ctx, struct brw_wm_prog_data);
|
||||
nir_shader *shader =
|
||||
nir_shader_create(ctx, MESA_SHADER_FRAGMENT, NULL, NULL);
|
||||
|
||||
v = new brw_shader(compiler, ¶ms, NULL, &prog_data->base, shader,
|
||||
16, false, false);
|
||||
|
||||
bld = brw_builder(v);
|
||||
|
||||
devinfo->verx10 = 125;
|
||||
devinfo->ver = devinfo->verx10 / 10;
|
||||
}
|
||||
|
||||
cse_test::~cse_test()
|
||||
{
|
||||
delete v;
|
||||
v = NULL;
|
||||
|
||||
ralloc_free(ctx);
|
||||
ctx = NULL;
|
||||
}
|
||||
|
||||
|
||||
static brw_inst *
|
||||
instruction(bblock_t *block, int num)
|
||||
{
|
||||
brw_inst *inst = (brw_inst *)block->start();
|
||||
for (int i = 0; i < num; i++) {
|
||||
inst = (brw_inst *)inst->next;
|
||||
}
|
||||
return inst;
|
||||
}
|
||||
|
||||
static bool
|
||||
cse(brw_shader *v)
|
||||
{
|
||||
const bool print = false;
|
||||
|
||||
if (print) {
|
||||
fprintf(stderr, "= Before =\n");
|
||||
v->cfg->dump();
|
||||
}
|
||||
|
||||
bool ret = brw_opt_cse_defs(*v);
|
||||
|
||||
if (print) {
|
||||
fprintf(stderr, "\n= After =\n");
|
||||
v->cfg->dump();
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
class cse_test : public brw_shader_pass_test {};
|
||||
|
||||
TEST_F(cse_test, add3_invalid)
|
||||
{
|
||||
set_gfx_verx10(125);
|
||||
|
||||
brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16);
|
||||
|
||||
brw_reg dst0 = bld.null_reg_d();
|
||||
brw_reg src0 = bld.vgrf(BRW_TYPE_D);
|
||||
brw_reg src1 = bld.vgrf(BRW_TYPE_D);
|
||||
|
|
@ -99,24 +25,5 @@ TEST_F(cse_test, add3_invalid)
|
|||
bld.ADD3(dst0, src0, src1, src3)
|
||||
->conditional_mod = BRW_CONDITIONAL_NZ;
|
||||
|
||||
/* = Before =
|
||||
*
|
||||
* 0: add3.nz(16) null src0 src1 src2
|
||||
* 1: add3.nz(16) null src0 src1 src3
|
||||
*
|
||||
* = After =
|
||||
* Same
|
||||
*/
|
||||
|
||||
brw_calculate_cfg(*v);
|
||||
bblock_t *block0 = v->cfg->blocks[0];
|
||||
|
||||
EXPECT_EQ(0, block0->start_ip);
|
||||
EXPECT_EQ(1, block0->end_ip);
|
||||
|
||||
EXPECT_FALSE(cse(v));
|
||||
EXPECT_EQ(0, block0->start_ip);
|
||||
EXPECT_EQ(1, block0->end_ip);
|
||||
EXPECT_EQ(BRW_OPCODE_ADD3, instruction(block0, 0)->opcode);
|
||||
EXPECT_EQ(BRW_OPCODE_ADD3, instruction(block0, 1)->opcode);
|
||||
EXPECT_NO_PROGRESS(brw_opt_cse_defs, bld);
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
Loading…
Add table
Reference in a new issue