diff --git a/src/intel/compiler/test_lower_scoreboard.cpp b/src/intel/compiler/test_lower_scoreboard.cpp index c8b76d449cf..eb05fd84d95 100644 --- a/src/intel/compiler/test_lower_scoreboard.cpp +++ b/src/intel/compiler/test_lower_scoreboard.cpp @@ -1,134 +1,53 @@ /* * Copyright © 2019 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 -#include "brw_shader.h" +#include "test_helpers.h" #include "brw_builder.h" -#include "brw_cfg.h" -class scoreboard_test : public ::testing::Test { +class scoreboard_test : public brw_shader_pass_test { protected: - scoreboard_test(); - ~scoreboard_test() override; - - struct brw_compiler *compiler; - struct intel_device_info *devinfo; - void *ctx; - brw_shader *v; - brw_builder bld; - - void - set_gfx_verx10(unsigned verx10) + scoreboard_test() { - devinfo->verx10 = verx10; - devinfo->ver = verx10 / 10; - assert(devinfo->ver > 0); - brw_init_isa_info(&compiler->isa, devinfo); + set_gfx_verx10(120); + } - if (v) - delete v; + static brw_reg * + vgrf_array(brw_builder &a, brw_reg_type type, int count) + { + brw_reg *r = rzalloc_array(a.shader->mem_ctx, brw_reg, count); + for (int i = 0; i < count; i++) + r[i] = vgrf(a, type); + return r; + } - brw_compile_params params = { - .mem_ctx = ctx, - }; - - struct brw_wm_prog_data *prog_data = rzalloc(ctx, struct brw_wm_prog_data); - nir_shader *shader = - nir_shader_create(ctx, MESA_SHADER_FRAGMENT, NULL, NULL); - - unsigned dispatch_width = devinfo->ver >= 20 ? 16 : 8; - v = new brw_shader(compiler, ¶ms, NULL, &prog_data->base, shader, dispatch_width, - false, false); - bld = brw_builder(v); + static brw_reg * + vgrf_array(brw_builder &a, brw_builder &b, brw_reg_type type, int count) + { + brw_reg *r = rzalloc_array(a.shader->mem_ctx, brw_reg, count); + for (int i = 0; i < count; i++) + r[i] = vgrf(a, b, type); + return r; } }; -scoreboard_test::scoreboard_test() +brw_inst * +SYNC_NOP(const brw_builder &bld) { - ctx = ralloc_context(NULL); - compiler = rzalloc(ctx, struct brw_compiler); - devinfo = rzalloc(ctx, struct intel_device_info); - compiler->devinfo = devinfo; - v = NULL; - - set_gfx_verx10(120); -} - -scoreboard_test::~scoreboard_test() -{ - delete v; - v = NULL; - - ralloc_free(ctx); - ctx = NULL; -} - -static brw_inst * -instruction(bblock_t *block, unsigned num) -{ - assert(num < block->num_instructions); - brw_inst *inst = block->start(); - for (unsigned i = 0; i < num; i++) { - inst = (brw_inst *)inst->next; - } - return inst; -} - -static void -lower_scoreboard(brw_shader *v) -{ - const bool print = getenv("TEST_DEBUG"); - - if (print) { - fprintf(stderr, "= Before =\n"); - brw_print_instructions(*v, stderr); - } - - brw_lower_scoreboard(*v); - - if (print) { - fprintf(stderr, "\n= After =\n"); - brw_print_instructions(*v, stderr); - } + return bld.group(1, 0).exec_all().SYNC(TGL_SYNC_NOP); } brw_inst * emit_SEND(const brw_builder &bld, const brw_reg &dst, const brw_reg &desc, const brw_reg &payload) { - brw_inst *inst = bld.emit(SHADER_OPCODE_SEND, dst, desc, desc, payload); + brw_reg uniform_desc = component(desc, 0); + brw_inst *inst = bld.emit(SHADER_OPCODE_SEND, dst, uniform_desc, uniform_desc, payload); inst->mlen = 1; return inst; } -static inline struct tgl_swsb -regdist(enum tgl_pipe pipe, unsigned d) -{ - assert(d); - const struct tgl_swsb swsb = { d, pipe }; - return swsb; -} - bool operator ==(const tgl_swsb &a, const tgl_swsb &b) { return a.mode == b.mode && @@ -137,25 +56,6 @@ bool operator ==(const tgl_swsb &a, const tgl_swsb &b) (a.mode == TGL_SBID_NULL || a.sbid == b.sbid); } -std::ostream &operator<<(std::ostream &os, const tgl_swsb &swsb) { - char *buf; - size_t len; - FILE *f = open_memstream(&buf, &len); - - /* Because we don't have a devinfo to pass here, for TGL we'll see - * F@1 annotations instead of @1 since the float pipe is the only one - * used there. - */ - brw_print_swsb(f, NULL, swsb); - fflush(f); - fclose(f); - - os << buf; - free(buf); - - return os; -} - /* Parse SWSB for setting test expected results. */ static tgl_swsb SWSB(const char *input) @@ -272,368 +172,290 @@ TEST_F(scoreboard_test, parse_swsb) TEST_F(scoreboard_test, RAW_inorder_inorder) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); + brw_reg y = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); - brw_reg y = bld.vgrf(BRW_TYPE_D); bld.ADD( x, g[1], g[2]); bld.MUL( y, g[3], g[4]); bld.AND(g[5], x, y); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(3, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + exp.ADD( x, g[1], g[2]); + exp.MUL( y, g[3], g[4]); + exp.AND(g[5], x, y)->sched = SWSB("F@1"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 2)->sched, regdist(TGL_PIPE_FLOAT, 1)); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, RAW_inorder_outoforder) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.ADD( x, g[1], g[2]); bld.MUL( g[3], g[4], g[5]); emit_SEND(bld, g[6], g[7], x); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(3, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + exp.ADD( x, g[1], g[2]); + exp.MUL( g[3], g[4], g[5]); + emit_SEND(exp, g[6], g[7], x)->sched = SWSB("$0 @2"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_null()); - - tgl_swsb expected = { - .regdist = 2, - .pipe = TGL_PIPE_FLOAT, - .mode = TGL_SBID_SET, - }; - - EXPECT_EQ(instruction(block0, 2)->sched, expected); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, RAW_outoforder_inorder) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); + brw_reg y = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); - brw_reg y = bld.vgrf(BRW_TYPE_D); emit_SEND(bld, x, g[1], g[2]); bld.MUL( y, g[3], g[4]); bld.AND( g[5], x, y); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(3, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + emit_SEND(exp, x, g[1], g[2])->sched = SWSB("$0"); + exp.MUL( y, g[3], g[4]); + exp.AND( g[5], x, y)->sched = SWSB("@1 $0.dst"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_sbid(TGL_SBID_SET, 0)); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_null()); - - tgl_swsb expected = { - .regdist = 1, - .pipe = TGL_PIPE_FLOAT, - .mode = TGL_SBID_DST, - }; - - EXPECT_EQ(instruction(block0, 2)->sched, expected); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, RAW_outoforder_outoforder) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); /* The second SEND depends on the first, and would need to refer to two * SBIDs. Since it is not possible we expect a SYNC instruction to be * added. */ - brw_reg x = bld.vgrf(BRW_TYPE_D); emit_SEND(bld, x, g[1], g[2]); emit_SEND(bld, g[3], x, g[4]); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(2, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + emit_SEND(exp, x, g[1], g[2])->sched = SWSB("$0"); + SYNC_NOP (exp )->sched = SWSB("$0.dst"); + emit_SEND(exp, g[3], x, g[4])->sched = SWSB("$1"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_sbid(TGL_SBID_SET, 0)); - - brw_inst *sync = instruction(block0, 1); - EXPECT_EQ(sync->opcode, BRW_OPCODE_SYNC); - EXPECT_EQ(sync->sched, tgl_swsb_sbid(TGL_SBID_DST, 0)); - - EXPECT_EQ(instruction(block0, 2)->sched, tgl_swsb_sbid(TGL_SBID_SET, 1)); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, WAR_inorder_inorder) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + + brw_reg *g = vgrf_array(bld, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.ADD(g[1], x, g[2]); bld.MUL(g[3], g[4], g[5]); bld.AND( x, g[6], g[7]); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(3, block0->num_instructions); - - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); - - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 2)->sched, tgl_swsb_null()); + EXPECT_NO_PROGRESS(brw_lower_scoreboard, bld); } TEST_F(scoreboard_test, WAR_inorder_outoforder) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.ADD( g[1], x, g[2]); bld.MUL( g[3], g[4], g[5]); emit_SEND(bld, x, g[6], g[7]); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(3, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + exp.ADD( g[1], x, g[2]); + exp.MUL( g[3], g[4], g[5]); + emit_SEND(exp, x, g[6], g[7])->sched = SWSB("@2 $0"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_null()); - - tgl_swsb expected = { - .regdist = 2, - .pipe = TGL_PIPE_FLOAT, - .mode = TGL_SBID_SET, - }; - - EXPECT_EQ(instruction(block0, 2)->sched, expected); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, WAR_outoforder_inorder) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); emit_SEND(bld, g[1], g[2], x); bld.MUL( g[4], g[5], g[6]); bld.AND( x, g[7], g[8]); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(3, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + emit_SEND(exp, g[1], g[2], x)->sched = SWSB("$0"); + exp.MUL( g[4], g[5], g[6]); + exp.AND( x, g[7], g[8])->sched = SWSB("$0.src"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_sbid(TGL_SBID_SET, 0)); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 2)->sched, tgl_swsb_sbid(TGL_SBID_SRC, 0)); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, WAR_outoforder_outoforder) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); emit_SEND(bld, g[1], g[2], x); emit_SEND(bld, x, g[3], g[4]); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(2, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + emit_SEND(exp, g[1], g[2], x)->sched = SWSB("$0"); + SYNC_NOP (exp )->sched = SWSB("$0.src"); + emit_SEND(exp, x, g[3], g[4])->sched = SWSB("$1"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_sbid(TGL_SBID_SET, 0)); - - brw_inst *sync = instruction(block0, 1); - EXPECT_EQ(sync->opcode, BRW_OPCODE_SYNC); - EXPECT_EQ(sync->sched, tgl_swsb_sbid(TGL_SBID_SRC, 0)); - - EXPECT_EQ(instruction(block0, 2)->sched, tgl_swsb_sbid(TGL_SBID_SET, 1)); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, WAW_inorder_inorder) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.ADD( x, g[1], g[2]); bld.MUL(g[3], g[4], g[5]); bld.AND( x, g[6], g[7]); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(3, block0->num_instructions); - - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); - - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_null()); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); /* NOTE: We only need this RegDist if a long instruction is followed by a * short one. The pass is currently conservative about this and adding the * annotation. */ - EXPECT_EQ(instruction(block0, 2)->sched, regdist(TGL_PIPE_FLOAT, 2)); + + exp.ADD( x, g[1], g[2]); + exp.MUL(g[3], g[4], g[5]); + exp.AND( x, g[6], g[7])->sched = SWSB("@2"); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, WAW_inorder_outoforder) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.ADD( x, g[1], g[2]); bld.MUL( g[3], g[4], g[5]); emit_SEND(bld, x, g[6], g[7]); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(3, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + exp.ADD( x, g[1], g[2]); + exp.MUL( g[3], g[4], g[5]); + emit_SEND(exp, x, g[6], g[7])->sched = SWSB("@2 $0"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_null()); - - tgl_swsb expected = { - .regdist = 2, - .pipe = TGL_PIPE_FLOAT, - .mode = TGL_SBID_SET, - }; - - EXPECT_EQ(instruction(block0, 2)->sched, expected); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, WAW_outoforder_inorder) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); emit_SEND(bld, x, g[1], g[2]); bld.MUL( g[3], g[4], g[5]); bld.AND( x, g[6], g[7]); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(3, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + emit_SEND(exp, x, g[1], g[2])->sched = SWSB("$0"); + exp.MUL( g[3], g[4], g[5]); + exp.AND( x, g[6], g[7])->sched = SWSB("$0.dst"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_sbid(TGL_SBID_SET, 0)); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 2)->sched, tgl_swsb_sbid(TGL_SBID_DST, 0)); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, WAW_outoforder_outoforder) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); emit_SEND(bld, x, g[1], g[2]); emit_SEND(bld, x, g[3], g[4]); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(2, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + emit_SEND(exp, x, g[1], g[2])->sched = SWSB("$0"); + SYNC_NOP (exp )->sched = SWSB("$0.dst"); + emit_SEND(exp, x, g[3], g[4])->sched = SWSB("$1"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_sbid(TGL_SBID_SET, 0)); - - brw_inst *sync = instruction(block0, 1); - EXPECT_EQ(sync->opcode, BRW_OPCODE_SYNC); - EXPECT_EQ(sync->sched, tgl_swsb_sbid(TGL_SBID_DST, 0)); - - EXPECT_EQ(instruction(block0, 2)->sched, tgl_swsb_sbid(TGL_SBID_SET, 1)); + EXPECT_SHADERS_MATCH(bld, exp); } - TEST_F(scoreboard_test, loop1) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.XOR( x, g[1], g[2]); - bld.DO(); - bld.ADD( x, g[1], g[2]); bld.WHILE(BRW_PREDICATE_NORMAL); - bld.MUL( x, g[1], g[2]); - brw_calculate_cfg(*v); - lower_scoreboard(v); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - const int num_blocks = v->cfg->num_blocks; + exp.XOR( x, g[1], g[2]); + exp.DO(); + exp.ADD( x, g[1], g[2])->sched = SWSB("@1"); + exp.WHILE()->predicate = BRW_PREDICATE_NORMAL; + exp.MUL( x, g[1], g[2])->sched = SWSB("@1"); - bblock_t *body = v->cfg->blocks[num_blocks - 2]; - brw_inst *add = instruction(body, 0); - EXPECT_EQ(add->opcode, BRW_OPCODE_ADD); - EXPECT_EQ(add->sched, regdist(TGL_PIPE_FLOAT, 1)); - - bblock_t *last_block = v->cfg->blocks[num_blocks - 1]; - brw_inst *mul = instruction(last_block, 0); - EXPECT_EQ(mul->opcode, BRW_OPCODE_MUL); - EXPECT_EQ(mul->sched, regdist(TGL_PIPE_FLOAT, 1)); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, loop2) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.XOR( x, g[1], g[2]); bld.XOR(g[3], g[1], g[2]); bld.XOR(g[4], g[1], g[2]); @@ -646,31 +468,33 @@ TEST_F(scoreboard_test, loop2) bld.MUL( x, g[1], g[2]); - brw_calculate_cfg(*v); - lower_scoreboard(v); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); /* Now the write in ADD has the tightest RegDist for both ADD and MUL. */ - const int num_blocks = v->cfg->num_blocks; + exp.XOR( x, g[1], g[2]); + exp.XOR(g[3], g[1], g[2]); + exp.XOR(g[4], g[1], g[2]); + exp.XOR(g[5], g[1], g[2]); - bblock_t *body = v->cfg->blocks[num_blocks - 2]; - brw_inst *add = instruction(body, 0); - EXPECT_EQ(add->opcode, BRW_OPCODE_ADD); - EXPECT_EQ(add->sched, regdist(TGL_PIPE_FLOAT, 2)); + exp.DO(); - bblock_t *last_block = v->cfg->blocks[num_blocks - 1]; - brw_inst *mul = instruction(last_block, 0); - EXPECT_EQ(mul->opcode, BRW_OPCODE_MUL); - EXPECT_EQ(mul->sched, regdist(TGL_PIPE_FLOAT, 2)); + exp.ADD( x, g[1], g[2])->sched = SWSB("@2"); + exp.WHILE()->predicate = BRW_PREDICATE_NORMAL; + + exp.MUL( x, g[1], g[2])->sched = SWSB("@2"); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, loop3) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.XOR( x, g[1], g[2]); bld.DO(); @@ -686,59 +510,61 @@ TEST_F(scoreboard_test, loop3) bld.MUL( x, g[1], g[2]); - brw_calculate_cfg(*v); - lower_scoreboard(v); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - const int num_blocks = v->cfg->num_blocks; + exp.XOR( x, g[1], g[2]); - bblock_t *body = v->cfg->blocks[num_blocks - 2]; - brw_inst *add = instruction(body, 4); - EXPECT_EQ(add->opcode, BRW_OPCODE_ADD); - EXPECT_EQ(add->sched, regdist(TGL_PIPE_FLOAT, 5)); + exp.DO(); - bblock_t *last_block = v->cfg->blocks[num_blocks - 1]; - brw_inst *mul = instruction(last_block, 0); - EXPECT_EQ(mul->opcode, BRW_OPCODE_MUL); - EXPECT_EQ(mul->sched, regdist(TGL_PIPE_FLOAT, 1)); + /* Note these are inside the loop, and now depend on their previous + * iteration. + */ + exp.XOR(g[3], g[1], g[2])->sched = SWSB("@6"); + exp.XOR(g[4], g[1], g[2])->sched = SWSB("@6"); + exp.XOR(g[5], g[1], g[2])->sched = SWSB("@6"); + exp.XOR(g[6], g[1], g[2])->sched = SWSB("@6"); + + exp.ADD( x, g[1], g[2])->sched = SWSB("@5"); + exp.WHILE()->predicate = BRW_PREDICATE_NORMAL; + + exp.MUL( x, g[1], g[2])->sched = SWSB("@1"); + + EXPECT_SHADERS_MATCH(bld, exp); } - TEST_F(scoreboard_test, conditional1) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.XOR( x, g[1], g[2]); bld.IF(); - bld.ADD( x, g[1], g[2]); - bld.ENDIF(); bld.MUL( x, g[1], g[2]); - brw_calculate_cfg(*v); - lower_scoreboard(v); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - bblock_t *body = v->cfg->blocks[1]; - brw_inst *add = instruction(body, 0); - EXPECT_EQ(add->opcode, BRW_OPCODE_ADD); - EXPECT_EQ(add->sched, regdist(TGL_PIPE_FLOAT, 2)); + exp.XOR( x, g[1], g[2]); + exp.IF(); + exp.ADD( x, g[1], g[2])->sched = SWSB("@2"); + exp.ENDIF(); + exp.MUL( x, g[1], g[2])->sched = SWSB("@2"); - bblock_t *last_block = v->cfg->blocks[2]; - brw_inst *mul = instruction(last_block, 1); - EXPECT_EQ(mul->opcode, BRW_OPCODE_MUL); - EXPECT_EQ(mul->sched, regdist(TGL_PIPE_FLOAT, 2)); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, conditional2) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.XOR( x, g[1], g[2]); bld.XOR(g[3], g[1], g[2]); bld.XOR(g[4], g[1], g[2]); @@ -750,27 +576,30 @@ TEST_F(scoreboard_test, conditional2) bld.ENDIF(); bld.MUL( x, g[1], g[2]); - brw_calculate_cfg(*v); - lower_scoreboard(v); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - bblock_t *body = v->cfg->blocks[1]; - brw_inst *add = instruction(body, 0); - EXPECT_EQ(add->opcode, BRW_OPCODE_ADD); - EXPECT_EQ(add->sched, regdist(TGL_PIPE_FLOAT, 5)); + exp.XOR( x, g[1], g[2]); + exp.XOR(g[3], g[1], g[2]); + exp.XOR(g[4], g[1], g[2]); + exp.XOR(g[5], g[1], g[2]); + exp.IF(); - bblock_t *last_block = v->cfg->blocks[2]; - brw_inst *mul = instruction(last_block, 1); - EXPECT_EQ(mul->opcode, BRW_OPCODE_MUL); - EXPECT_EQ(mul->sched, regdist(TGL_PIPE_FLOAT, 2)); + exp.ADD( x, g[1], g[2])->sched = SWSB("@5"); + + exp.ENDIF(); + exp.MUL( x, g[1], g[2])->sched = SWSB("@2"); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, conditional3) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.XOR( x, g[1], g[2]); bld.IF(); @@ -782,27 +611,30 @@ TEST_F(scoreboard_test, conditional3) bld.ENDIF(); bld.MUL( x, g[1], g[2]); - brw_calculate_cfg(*v); - lower_scoreboard(v); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - bblock_t *body = v->cfg->blocks[1]; - brw_inst *add = instruction(body, 3); - EXPECT_EQ(add->opcode, BRW_OPCODE_ADD); - EXPECT_EQ(add->sched, regdist(TGL_PIPE_FLOAT, 5)); + exp.XOR( x, g[1], g[2]); + exp.IF(); - bblock_t *last_block = v->cfg->blocks[2]; - brw_inst *mul = instruction(last_block, 1); - EXPECT_EQ(mul->opcode, BRW_OPCODE_MUL); - EXPECT_EQ(mul->sched, regdist(TGL_PIPE_FLOAT, 2)); + exp.XOR(g[3], g[1], g[2]); + exp.XOR(g[4], g[1], g[2]); + exp.XOR(g[5], g[1], g[2]); + exp.ADD( x, g[1], g[2])->sched = SWSB("@5"); + + exp.ENDIF(); + exp.MUL( x, g[1], g[2])->sched = SWSB("@2"); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, conditional4) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.XOR( x, g[1], g[2]); bld.IF(); @@ -814,27 +646,30 @@ TEST_F(scoreboard_test, conditional4) bld.ENDIF(); bld.MUL( x, g[1], g[2]); - brw_calculate_cfg(*v); - lower_scoreboard(v); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - bblock_t *body = v->cfg->blocks[1]; - brw_inst *add = instruction(body, 0); - EXPECT_EQ(add->opcode, BRW_OPCODE_ADD); - EXPECT_EQ(add->sched, regdist(TGL_PIPE_FLOAT, 2)); + exp.XOR( x, g[1], g[2]); + exp.IF(); - bblock_t *last_block = v->cfg->blocks[2]; - brw_inst *mul = instruction(last_block, 1); - EXPECT_EQ(mul->opcode, BRW_OPCODE_MUL); - EXPECT_EQ(mul->sched, regdist(TGL_PIPE_FLOAT, 3)); + exp.ADD( x, g[1], g[2])->sched = SWSB("@2"); + exp.XOR(g[3], g[1], g[2]); + exp.XOR(g[4], g[1], g[2]); + exp.XOR(g[5], g[1], g[2]); + + exp.ENDIF(); + exp.MUL( x, g[1], g[2])->sched = SWSB("@3"); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, conditional5) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.XOR( x, g[1], g[2]); bld.IF(); @@ -846,32 +681,30 @@ TEST_F(scoreboard_test, conditional5) bld.ENDIF(); bld.MUL( x, g[1], g[2]); - brw_calculate_cfg(*v); - lower_scoreboard(v); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - bblock_t *then_body = v->cfg->blocks[1]; - brw_inst *add = instruction(then_body, 0); - EXPECT_EQ(add->opcode, BRW_OPCODE_ADD); - EXPECT_EQ(add->sched, regdist(TGL_PIPE_FLOAT, 2)); + exp.XOR( x, g[1], g[2]); + exp.IF(); - bblock_t *else_body = v->cfg->blocks[2]; - brw_inst *rol = instruction(else_body, 0); - EXPECT_EQ(rol->opcode, BRW_OPCODE_ROL); - EXPECT_EQ(rol->sched, regdist(TGL_PIPE_FLOAT, 2)); + exp.ADD( x, g[1], g[2])->sched = SWSB("@2"); + exp.ELSE(); - bblock_t *last_block = v->cfg->blocks[3]; - brw_inst *mul = instruction(last_block, 1); - EXPECT_EQ(mul->opcode, BRW_OPCODE_MUL); - EXPECT_EQ(mul->sched, regdist(TGL_PIPE_FLOAT, 2)); + exp.ROL( x, g[1], g[2])->sched = SWSB("@2"); + + exp.ENDIF(); + exp.MUL( x, g[1], g[2])->sched = SWSB("@2"); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, conditional6) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 10); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.XOR( x, g[1], g[2]); bld.IF(); @@ -890,32 +723,37 @@ TEST_F(scoreboard_test, conditional6) bld.ENDIF(); bld.MUL( x, g[1], g[2]); - brw_calculate_cfg(*v); - lower_scoreboard(v); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - bblock_t *then_body = v->cfg->blocks[1]; - brw_inst *add = instruction(then_body, 3); - EXPECT_EQ(add->opcode, BRW_OPCODE_ADD); - EXPECT_EQ(add->sched, regdist(TGL_PIPE_FLOAT, 5)); + exp.XOR( x, g[1], g[2]); + exp.IF(); - bblock_t *else_body = v->cfg->blocks[2]; - brw_inst *rol = instruction(else_body, 4); - EXPECT_EQ(rol->opcode, BRW_OPCODE_ROL); - EXPECT_EQ(rol->sched, regdist(TGL_PIPE_FLOAT, 6)); + exp.XOR(g[3], g[1], g[2]); + exp.XOR(g[4], g[1], g[2]); + exp.XOR(g[5], g[1], g[2]); + exp.ADD( x, g[1], g[2])->sched = SWSB("@5"); + exp.ELSE(); - bblock_t *last_block = v->cfg->blocks[3]; - brw_inst *mul = instruction(last_block, 1); - EXPECT_EQ(mul->opcode, BRW_OPCODE_MUL); - EXPECT_EQ(mul->sched, regdist(TGL_PIPE_FLOAT, 2)); + exp.XOR(g[6], g[1], g[2]); + exp.XOR(g[7], g[1], g[2]); + exp.XOR(g[8], g[1], g[2]); + exp.XOR(g[9], g[1], g[2]); + exp.ROL( x, g[1], g[2])->sched = SWSB("@6"); + + exp.ENDIF(); + exp.MUL( x, g[1], g[2])->sched = SWSB("@2"); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, conditional7) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 10); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.XOR( x, g[1], g[2]); bld.IF(); @@ -934,32 +772,37 @@ TEST_F(scoreboard_test, conditional7) bld.ENDIF(); bld.MUL( x, g[1], g[2]); - brw_calculate_cfg(*v); - lower_scoreboard(v); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - bblock_t *then_body = v->cfg->blocks[1]; - brw_inst *add = instruction(then_body, 0); - EXPECT_EQ(add->opcode, BRW_OPCODE_ADD); - EXPECT_EQ(add->sched, regdist(TGL_PIPE_FLOAT, 2)); + exp.XOR( x, g[1], g[2]); + exp.IF(); - bblock_t *else_body = v->cfg->blocks[2]; - brw_inst *rol = instruction(else_body, 0); - EXPECT_EQ(rol->opcode, BRW_OPCODE_ROL); - EXPECT_EQ(rol->sched, regdist(TGL_PIPE_FLOAT, 2)); + exp.ADD( x, g[1], g[2])->sched = SWSB("@2"); + exp.XOR(g[3], g[1], g[2]); + exp.XOR(g[4], g[1], g[2]); + exp.XOR(g[5], g[1], g[2]); + exp.ELSE(); - bblock_t *last_block = v->cfg->blocks[3]; - brw_inst *mul = instruction(last_block, 1); - EXPECT_EQ(mul->opcode, BRW_OPCODE_MUL); - EXPECT_EQ(mul->sched, regdist(TGL_PIPE_FLOAT, 6)); + exp.ROL( x, g[1], g[2])->sched = SWSB("@2"); + exp.XOR(g[6], g[1], g[2]); + exp.XOR(g[7], g[1], g[2]); + exp.XOR(g[8], g[1], g[2]); + exp.XOR(g[9], g[1], g[2]); + + exp.ENDIF(); + exp.MUL( x, g[1], g[2])->sched = SWSB("@6"); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, conditional8) { - brw_reg g[16]; - for (unsigned i = 0; i < ARRAY_SIZE(g); i++) - g[i] = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg *g = vgrf_array(bld, exp, BRW_TYPE_D, 8); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); - brw_reg x = bld.vgrf(BRW_TYPE_D); bld.XOR( x, g[1], g[2]); bld.XOR(g[3], g[1], g[2]); bld.XOR(g[4], g[1], g[2]); @@ -976,79 +819,83 @@ TEST_F(scoreboard_test, conditional8) bld.ENDIF(); bld.MUL( x, g[1], g[2]); - brw_calculate_cfg(*v); - lower_scoreboard(v); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - bblock_t *then_body = v->cfg->blocks[1]; - brw_inst *add = instruction(then_body, 0); - EXPECT_EQ(add->opcode, BRW_OPCODE_ADD); - EXPECT_EQ(add->sched, regdist(TGL_PIPE_FLOAT, 7)); + exp.XOR( x, g[1], g[2]); + exp.XOR(g[3], g[1], g[2]); + exp.XOR(g[4], g[1], g[2]); + exp.XOR(g[5], g[1], g[2]); + exp.XOR(g[6], g[1], g[2]); + exp.XOR(g[7], g[1], g[2]); + exp.IF(); + + exp.ADD( x, g[1], g[2])->sched = SWSB("@7"); + exp.ELSE(); /* Note that the ROL will have RegDist 2 and not 7, illustrating the * physical CFG edge between the then-block and the else-block. */ - bblock_t *else_body = v->cfg->blocks[2]; - brw_inst *rol = instruction(else_body, 0); - EXPECT_EQ(rol->opcode, BRW_OPCODE_ROL); - EXPECT_EQ(rol->sched, regdist(TGL_PIPE_FLOAT, 2)); + exp.ROL( x, g[1], g[2])->sched = SWSB("@2"); - bblock_t *last_block = v->cfg->blocks[3]; - brw_inst *mul = instruction(last_block, 1); - EXPECT_EQ(mul->opcode, BRW_OPCODE_MUL); - EXPECT_EQ(mul->sched, regdist(TGL_PIPE_FLOAT, 2)); + exp.ENDIF(); + exp.MUL( x, g[1], g[2])->sched = SWSB("@2"); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, gfx125_RaR_over_different_pipes) { set_gfx_verx10(125); - brw_reg a = bld.vgrf(BRW_TYPE_D); - brw_reg b = bld.vgrf(BRW_TYPE_D); - brw_reg f = bld.vgrf(BRW_TYPE_F); - brw_reg x = bld.vgrf(BRW_TYPE_D); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg a = vgrf(bld, exp, BRW_TYPE_D); + brw_reg b = vgrf(bld, exp, BRW_TYPE_D); + brw_reg f = vgrf(bld, exp, BRW_TYPE_F); + brw_reg x = vgrf(bld, exp, BRW_TYPE_D); bld.ADD(f, x, x); bld.ADD(a, x, x); bld.ADD(x, b, b); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(3, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + exp.ADD(f, x, x); + exp.ADD(a, x, x); + exp.ADD(x, b, b)->sched = SWSB("A@1"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 2)->sched, regdist(TGL_PIPE_ALL, 1)); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, gitlab_issue_from_mr_29723) { - brw_init_isa_info(&compiler->isa, devinfo); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); - struct brw_reg a = brw_ud8_grf(29, 0); - struct brw_reg b = brw_ud8_grf(2, 0); + brw_reg a = brw_ud8_grf(29, 0); + brw_reg b = brw_ud8_grf(2, 0); auto bld1 = bld.exec_all().group(1, 0); bld1.ADD( a, stride(b, 0, 1, 0), brw_imm_ud(256)); bld1.CMP(brw_null_reg(), stride(a, 2, 1, 2), stride(b, 0, 1, 0), BRW_CONDITIONAL_L); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(2, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(2, block0->num_instructions); + auto exp1 = exp.exec_all().group(1, 0); + exp1.ADD( a, stride(b, 0, 1, 0), brw_imm_ud(256)); + exp1.CMP(brw_null_reg(), stride(a, 2, 1, 2), stride(b, 0, 1, 0), BRW_CONDITIONAL_L)->sched = SWSB("@1"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 1)->sched, regdist(TGL_PIPE_FLOAT, 1)); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, combine_regdist_float_and_int_with_sbid_set) { set_gfx_verx10(200); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + brw_reg a = retype(brw_ud8_grf(10, 0), BRW_TYPE_F); brw_reg b = brw_ud8_grf(20, 0); brw_reg x = brw_ud8_grf(30, 0); @@ -1057,29 +904,22 @@ TEST_F(scoreboard_test, combine_regdist_float_and_int_with_sbid_set) bld.ADD( b, b, b); emit_SEND(bld, x, a, b); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(3, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + exp.ADD( a, a, a); + exp.ADD( b, b, b); + emit_SEND(exp, x, a, b)->sched = SWSB("A@1 $0"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_null()); - - const tgl_swsb expected = { - .regdist = 1, - .pipe = TGL_PIPE_ALL, - .mode = TGL_SBID_SET, - }; - - EXPECT_EQ(instruction(block0, 2)->sched, expected); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, combine_regdist_float_with_sbid_set) { set_gfx_verx10(200); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + brw_reg a = retype(brw_ud8_grf(10, 0), BRW_TYPE_F); brw_reg b = retype(brw_ud8_grf(20, 0), BRW_TYPE_F); brw_reg x = brw_ud8_grf(30, 0); @@ -1088,29 +928,22 @@ TEST_F(scoreboard_test, combine_regdist_float_with_sbid_set) bld.ADD( b, b, b); emit_SEND(bld, x, a, b); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(3, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + exp.ADD( a, a, a); + exp.ADD( b, b, b); + emit_SEND(exp, x, a, b)->sched = SWSB("F@1 $0"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_null()); - - const tgl_swsb expected = { - .regdist = 1, - .pipe = TGL_PIPE_FLOAT, - .mode = TGL_SBID_SET, - }; - - EXPECT_EQ(instruction(block0, 2)->sched, expected); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, combine_regdist_int_with_sbid_set) { set_gfx_verx10(200); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + brw_reg a = brw_ud8_grf(10, 0); brw_reg b = brw_ud8_grf(20, 0); brw_reg x = brw_ud8_grf(30, 0); @@ -1119,93 +952,95 @@ TEST_F(scoreboard_test, combine_regdist_int_with_sbid_set) bld.ADD( b, b, b); emit_SEND(bld, x, a, b); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(3, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + exp.ADD( a, a, a); + exp.ADD( b, b, b); + emit_SEND(exp, x, a, b)->sched = SWSB("I@1 $0"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_null()); - - const tgl_swsb expected = { - .regdist = 1, - .pipe = TGL_PIPE_INT, - .mode = TGL_SBID_SET, - }; - - EXPECT_EQ(instruction(block0, 2)->sched, expected); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, gitlab_issue_11069) { - brw_init_isa_info(&compiler->isa, devinfo); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); - struct brw_reg a = brw_ud8_grf(76, 0); - struct brw_reg b = brw_ud8_grf(2, 0); + brw_reg a = brw_ud8_grf(76, 0); + brw_reg b = brw_ud8_grf(2, 0); auto bld1 = bld.exec_all().group(1, 0); bld1.ADD(stride(a, 2, 1, 2), stride(b, 0, 1, 0), brw_imm_ud(0x80)); bld1.CMP( brw_null_reg(), stride(a, 0, 1, 0), stride(b, 0, 1, 0), BRW_CONDITIONAL_L); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(2, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(2, block0->num_instructions); + auto exp1 = exp.exec_all().group(1, 0); + exp1.ADD(stride(a, 2, 1, 2), stride(b, 0, 1, 0), brw_imm_ud(0x80)); + exp1.CMP( brw_null_reg(), stride(a, 0, 1, 0), stride(b, 0, 1, 0), BRW_CONDITIONAL_L)->sched = SWSB("@1"); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 1)->sched, regdist(TGL_PIPE_FLOAT, 1)); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, gfx120_can_embed_outoforder_src_dependency_in_send_eot) { + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + brw_reg a = brw_ud8_grf(10, 0); brw_reg b = brw_ud8_grf(20, 0); brw_reg x = brw_ud8_grf(30, 0); brw_reg desc = brw_ud8_grf(40, 0); - emit_SEND(bld, a, desc, x); - emit_SEND(bld, b, desc, x)->eot = true; + brw_inst *send; - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(2, block0->num_instructions); + emit_SEND(bld, a, desc, x); + send = emit_SEND(bld, b, desc, x); + send->eot = true; - lower_scoreboard(v); - ASSERT_EQ(2, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_sbid(TGL_SBID_SET, 0)); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_sbid(TGL_SBID_SRC, 0)); + emit_SEND(exp, a, desc, x)->sched = SWSB("$0"); + send = emit_SEND(exp, b, desc, x); + send->eot = true; + send->sched = SWSB("$0.src"); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, gfx120_can_embed_outoforder_dst_dependency_in_send_eot) { + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + brw_reg a = brw_ud8_grf(10, 0); brw_reg b = brw_ud8_grf(20, 0); brw_reg x = brw_ud8_grf(30, 0); brw_reg desc = brw_ud8_grf(40, 0); - emit_SEND(bld, x, desc, a); - emit_SEND(bld, b, desc, x)->eot = true; + brw_inst *send; - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(2, block0->num_instructions); + emit_SEND(bld, x, desc, a); + send = emit_SEND(bld, b, desc, x); + send->eot = true; - lower_scoreboard(v); - ASSERT_EQ(2, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_sbid(TGL_SBID_SET, 0)); - EXPECT_EQ(instruction(block0, 1)->sched, tgl_swsb_sbid(TGL_SBID_DST, 0)); + emit_SEND(exp, x, desc, a)->sched = SWSB("$0"); + send = emit_SEND(exp, b, desc, x); + send->eot = true; + send->sched = SWSB("$0.dst"); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, gfx200_cannot_embed_outoforder_src_dependency_in_send_eot) { set_gfx_verx10(200); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + brw_reg a = brw_ud8_grf(10, 0); brw_reg b = brw_ud8_grf(20, 0); brw_reg x = brw_ud8_grf(30, 0); @@ -1214,26 +1049,22 @@ TEST_F(scoreboard_test, gfx200_cannot_embed_outoforder_src_dependency_in_send_eo emit_SEND(bld, a, desc, x); emit_SEND(bld, b, desc, x)->eot = true; - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(2, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + emit_SEND(exp, a, desc, x)->sched = SWSB("$0"); + SYNC_NOP (exp )->sched = SWSB("$0.src"); + emit_SEND(exp, b, desc, x)->eot = true; - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_sbid(TGL_SBID_SET, 0)); - - brw_inst *sync = instruction(block0, 1); - EXPECT_EQ(sync->opcode, BRW_OPCODE_SYNC); - EXPECT_EQ(sync->sched, tgl_swsb_sbid(TGL_SBID_SRC, 0)); - - EXPECT_EQ(instruction(block0, 2)->sched, tgl_swsb_null()); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, gfx200_cannot_embed_outoforder_dst_dependency_in_send_eot) { set_gfx_verx10(200); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + brw_reg a = brw_ud8_grf(10, 0); brw_reg b = brw_ud8_grf(20, 0); brw_reg x = brw_ud8_grf(30, 0); @@ -1242,20 +1073,13 @@ TEST_F(scoreboard_test, gfx200_cannot_embed_outoforder_dst_dependency_in_send_eo emit_SEND(bld, x, desc, a); emit_SEND(bld, b, desc, x)->eot = true; - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - ASSERT_EQ(2, block0->num_instructions); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - lower_scoreboard(v); - ASSERT_EQ(3, block0->num_instructions); + emit_SEND(exp, x, desc, a)->sched = SWSB("$0"); + SYNC_NOP (exp )->sched = SWSB("$0.dst"); + emit_SEND(exp, b, desc, x)->eot = true; - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_sbid(TGL_SBID_SET, 0)); - - brw_inst *sync = instruction(block0, 1); - EXPECT_EQ(sync->opcode, BRW_OPCODE_SYNC); - EXPECT_EQ(sync->sched, tgl_swsb_sbid(TGL_SBID_DST, 0)); - - EXPECT_EQ(instruction(block0, 2)->sched, tgl_swsb_null()); + EXPECT_SHADERS_MATCH(bld, exp); } static brw_reg @@ -1278,34 +1102,44 @@ TEST_F(scoreboard_test, scalar_register_mov_immediate_is_in_scalar_pipe) { set_gfx_verx10(300); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + brw_reg scalar = brw_s0_with_region(BRW_TYPE_UW, 0, 0, 1, 0); + brw_reg imm = brw_imm_uw(0x1415); + brw_reg r20 = brw_uw8_grf(20, 0); - bld.group(1, 0).exec_all().MOV(scalar, brw_imm_uw(0x1415)); - bld .MOV(brw_uw8_grf(20, 0), scalar); + bld.group(1, 0).exec_all().MOV(scalar, imm); + bld .MOV(r20, scalar); - brw_calculate_cfg(*v); - lower_scoreboard(v); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - bblock_t *block0 = v->cfg->blocks[0]; + exp.group(1, 0).exec_all().MOV(scalar, imm); + SYNC_NOP(exp )->sched = SWSB("S@1"); + exp .MOV(r20, scalar); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 1)->sched, regdist(TGL_PIPE_SCALAR, 1)); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(scoreboard_test, scalar_register_mov_grf_is_not_in_scalar_pipe) { set_gfx_verx10(300); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + brw_reg scalar = brw_s0_with_region(BRW_TYPE_UW, 0, 0, 1, 0); + brw_reg r10 = brw_uw8_grf(10, 0); + brw_reg r20 = brw_uw8_grf(20, 0); - bld.group(1, 0).exec_all().MOV(scalar, brw_uw8_grf(0, 0)); - bld .MOV(brw_uw8_grf(20, 0), scalar); + bld.group(1, 0).exec_all().MOV(scalar, r10); + bld .MOV(r20, scalar); - brw_calculate_cfg(*v); - lower_scoreboard(v); + EXPECT_PROGRESS(brw_lower_scoreboard, bld); - bblock_t *block0 = v->cfg->blocks[0]; + exp.group(1, 0).exec_all().MOV (scalar, r10); + SYNC_NOP(exp )->sched = SWSB("I@1"); + exp .MOV (r20, scalar); - EXPECT_EQ(instruction(block0, 0)->sched, tgl_swsb_null()); - EXPECT_EQ(instruction(block0, 1)->sched, regdist(TGL_PIPE_INT, 1)); + EXPECT_SHADERS_MATCH(bld, exp); }