[Mesa-dev] [PATCH v4 04/10] mesa/st/tests: unify MockCodeLine* classes
Gert Wollny
gw.fossdev at gmail.com
Tue Dec 12 13:40:54 UTC 2017
* Merge the classes MockCodeLine and MockCodelineWithSwizzle into
one, and refactor tests accordingly.
* Change memory allocations to use ralloc* interface.
v4:
* move the test classes into a conveniance library
* rename the Mock* classes to Fake* since they are not really
Mocks
* Base assertion of correct number of src and dst registers in tests
on what the operatand actually expects
* Fix number of destinations in one test
* Rename typedef "expectation" to "temp_lt_expect"
Signed-off-by: Gert Wollny <gw.fossdev at gmail.com>
---
src/mesa/state_tracker/tests/Makefile.am | 7 +
src/mesa/state_tracker/tests/st_tests_common.cpp | 397 ++++++++++++
src/mesa/state_tracker/tests/st_tests_common.h | 163 +++++
.../tests/test_glsl_to_tgsi_lifetime.cpp | 720 +++++----------------
4 files changed, 739 insertions(+), 548 deletions(-)
create mode 100644 src/mesa/state_tracker/tests/st_tests_common.cpp
create mode 100644 src/mesa/state_tracker/tests/st_tests_common.h
diff --git a/src/mesa/state_tracker/tests/Makefile.am b/src/mesa/state_tracker/tests/Makefile.am
index 6c58d36769..dcd396918d 100644
--- a/src/mesa/state_tracker/tests/Makefile.am
+++ b/src/mesa/state_tracker/tests/Makefile.am
@@ -18,8 +18,13 @@ AM_CPPFLAGS = \
if HAVE_STD_CXX11
TESTS = st-renumerate-test
check_PROGRAMS = st-renumerate-test
+
+noinst_LIBRARIES = libmesa-st-tests-common.a
endif
+libmesa_st_tests_common_a_SOURCES = \
+ st_tests_common.cpp
+
st_renumerate_test_SOURCES = \
test_glsl_to_tgsi_lifetime.cpp
@@ -27,6 +32,7 @@ st_renumerate_test_LDFLAGS = \
$(LLVM_LDFLAGS)
st_renumerate_test_LDADD = \
+ libmesa-st-tests-common.a \
$(top_builddir)/src/mesa/libmesagallium.la \
$(top_builddir)/src/mapi/shared-glapi/libglapi.la \
$(top_builddir)/src/gallium/auxiliary/libgallium.la \
@@ -34,3 +40,4 @@ st_renumerate_test_LDADD = \
$(top_builddir)/src/gtest/libgtest.la \
$(GALLIUM_COMMON_LIB_DEPS) \
$(LLVM_LIBS)
+
diff --git a/src/mesa/state_tracker/tests/st_tests_common.cpp b/src/mesa/state_tracker/tests/st_tests_common.cpp
new file mode 100644
index 0000000000..91fd39343f
--- /dev/null
+++ b/src/mesa/state_tracker/tests/st_tests_common.cpp
@@ -0,0 +1,397 @@
+/*
+ * Copyright © 2017 Gert Wollny
+ *
+ * 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.
+ */
+
+#include "st_tests_common.h"
+
+#include <mesa/program/prog_instruction.h>
+#include <tgsi/tgsi_info.h>
+#include <tgsi/tgsi_ureg.h>
+#include <compiler/glsl/list.h>
+
+
+
+#include <gtest/gtest.h>
+
+#include <utility>
+#include <algorithm>
+
+using std::vector;
+using std::pair;
+using std::make_pair;
+using std::transform;
+using std::copy;
+using std::tuple;
+
+
+/* Implementation of helper and test classes */
+void *FakeCodeline::mem_ctx = nullptr;
+
+FakeCodeline::FakeCodeline(unsigned _op, const vector<int>& _dst,
+ const vector<int>& _src, const vector<int>&_to):
+ op(_op),
+ max_temp_id(0)
+{
+ transform(_dst.begin(), _dst.end(), std::back_inserter(dst),
+ [this](int i) { return create_dst_register(i);});
+
+ transform(_src.begin(), _src.end(), std::back_inserter(src),
+ [this](int i) { return create_src_register(i);});
+
+ transform(_to.begin(), _to.end(), std::back_inserter(tex_offsets),
+ [this](int i) { return create_src_register(i);});
+
+}
+
+FakeCodeline::FakeCodeline(unsigned _op, const vector<pair<int,int>>& _dst,
+ const vector<pair<int, const char *>>& _src,
+ const vector<pair<int, const char *>>&_to,
+ SWZ with_swizzle):
+ op(_op),
+ max_temp_id(0)
+{
+ (void)with_swizzle;
+
+ transform(_dst.begin(), _dst.end(), std::back_inserter(dst),
+ [this](pair<int,int> r) {
+ return create_dst_register(r.first, r.second);
+ });
+
+ transform(_src.begin(), _src.end(), std::back_inserter(src),
+ [this](const pair<int,const char *>& r) {
+ return create_src_register(r.first, r.second);
+ });
+
+ transform(_to.begin(), _to.end(), std::back_inserter(tex_offsets),
+ [this](const pair<int,const char *>& r) {
+ return create_src_register(r.first, r.second);
+ });
+}
+
+FakeCodeline::FakeCodeline(const glsl_to_tgsi_instruction& instr):
+ op(instr.op),
+ max_temp_id(0)
+{
+ int nsrc = num_inst_src_regs(&instr);
+ int ndst = num_inst_dst_regs(&instr);
+
+ copy(instr.src, instr.src + nsrc, std::back_inserter(src));
+ copy(instr.dst, instr.dst + ndst, std::back_inserter(dst));
+
+ for(auto& s: src)
+ read_reg(s);
+
+ for(auto& d: dst)
+ read_reg(d);
+
+}
+
+template <typename st_reg>
+void FakeCodeline::read_reg(const st_reg& s)
+{
+ if (s.file == PROGRAM_TEMPORARY) {
+ if (s.index > max_temp_id)
+ max_temp_id = s.index;
+ }
+}
+
+void FakeCodeline::print(std::ostream& os) const
+{
+ const struct tgsi_opcode_info *info = tgsi_get_opcode_info(op);
+ os << tgsi_get_opcode_name(info->opcode) << " ";
+
+ for (auto d: dst) {
+ os << d << " ";
+ }
+ os << " <- ";
+ for (auto s: src) {
+ os << s << " ";
+ }
+ os << "\n";
+}
+
+bool operator == (const FakeCodeline& lhs, const FakeCodeline& rhs)
+{
+ if ((lhs.op != rhs.op) ||
+ (lhs.src.size() != rhs.src.size()) ||
+ (lhs.dst.size() != rhs.dst.size()))
+ return false;
+
+ return std::equal(lhs.src.begin(), lhs.src.end(), rhs.src.begin()) &&
+ std::equal(lhs.dst.begin(), lhs.dst.end(), rhs.dst.begin());
+}
+
+st_src_reg FakeCodeline::create_src_register(int src_idx)
+{
+ return create_src_register(src_idx,
+ src_idx < 0 ? PROGRAM_INPUT : PROGRAM_TEMPORARY);
+}
+
+static int swizzle_from_char(const char *sw)
+{
+ int swizzle = 0;
+ if (!sw || sw[0] == 0)
+ return SWIZZLE_XYZW;
+
+ const char *isw = sw;
+ for (int i = 0; i < 4; ++i) {
+ switch (*isw) {
+ case 'x': break; /* is zero */
+ case 'y': swizzle |= SWIZZLE_Y << 3 * i; break;
+ case 'z': swizzle |= SWIZZLE_Z << 3 * i; break;
+ case 'w': swizzle |= SWIZZLE_W << 3 * i; break;
+ default:
+ assert(!"This test uses an unknown swizzle character");
+ }
+ if (isw[1] != 0)
+ ++isw;
+ }
+ return swizzle;
+}
+
+st_src_reg FakeCodeline::create_src_register(int src_idx, const char *sw)
+{
+ st_src_reg result = create_src_register(src_idx);
+ result.swizzle = swizzle_from_char(sw);
+ return result;
+}
+
+st_src_reg FakeCodeline::create_src_register(int src_idx, gl_register_file file)
+{
+ st_src_reg retval;
+ retval.file = file;
+ retval.index = src_idx >= 0 ? src_idx : 1 - src_idx;
+
+ if (file == PROGRAM_TEMPORARY) {
+ if (max_temp_id < src_idx)
+ max_temp_id = src_idx;
+ } else if (file == PROGRAM_ARRAY) {
+ retval.array_id = 1;
+ }
+ retval.swizzle = SWIZZLE_XYZW;
+ retval.type = GLSL_TYPE_INT;
+
+ return retval;
+}
+
+st_dst_reg FakeCodeline::create_dst_register(int dst_idx)
+{
+ return create_dst_register(dst_idx, dst_idx < 0 ?
+ PROGRAM_OUTPUT : PROGRAM_TEMPORARY);
+}
+
+st_dst_reg FakeCodeline::create_dst_register(int dst_idx,int writemask)
+{
+ gl_register_file file;
+ int idx = 0;
+ if (dst_idx >= 0) {
+ file = PROGRAM_TEMPORARY;
+ idx = dst_idx;
+ if (max_temp_id < idx)
+ max_temp_id = idx;
+ } else {
+ file = PROGRAM_OUTPUT;
+ idx = 1 - dst_idx;
+ }
+ return st_dst_reg(file, writemask, GLSL_TYPE_INT, idx);
+}
+
+st_dst_reg FakeCodeline::create_dst_register(int dst_idx, gl_register_file file)
+{
+ st_dst_reg retval;
+ retval.file = file;
+ retval.index = dst_idx >= 0 ? dst_idx : 1 - dst_idx;
+
+ if (file == PROGRAM_TEMPORARY) {
+ if (max_temp_id < dst_idx)
+ max_temp_id = dst_idx;
+ } else if (file == PROGRAM_ARRAY) {
+ retval.array_id = 1;
+ }
+ retval.writemask = 0xF;
+ retval.type = GLSL_TYPE_INT;
+
+ return retval;
+}
+
+glsl_to_tgsi_instruction *FakeCodeline::get_codeline() const
+{
+ glsl_to_tgsi_instruction *next_instr = new(mem_ctx) glsl_to_tgsi_instruction();
+ next_instr->op = op;
+ next_instr->info = tgsi_get_opcode_info(op);
+
+ assert(src.size() == num_inst_src_regs(next_instr));
+ assert(dst.size() == num_inst_dst_regs(next_instr));
+ assert(tex_offsets.size() < 3);
+
+ copy(src.begin(), src.end(), next_instr->src);
+ copy(dst.begin(), dst.end(), next_instr->dst);
+
+ next_instr->tex_offset_num_offset = tex_offsets.size();
+
+ if (next_instr->tex_offset_num_offset > 0) {
+ next_instr->tex_offsets = ralloc_array(mem_ctx, st_src_reg, tex_offsets.size());
+ copy(tex_offsets.begin(), tex_offsets.end(), next_instr->tex_offsets);
+ } else {
+ next_instr->tex_offsets = nullptr;
+ }
+ return next_instr;
+}
+
+void FakeCodeline::set_mem_ctx(void *ctx)
+{
+ mem_ctx = ctx;
+}
+
+FakeShader::FakeShader(const vector<FakeCodeline>& source):
+ program(source),
+ num_temps(0)
+{
+ for (const FakeCodeline& i: source) {
+ int t = i.get_max_reg_id();
+ if (t > num_temps)
+ num_temps = t;
+ }
+ ++num_temps;
+}
+
+FakeShader::FakeShader(exec_list *tgsi_prog):
+ num_temps(0)
+{
+ FakeCodeline nop(TGSI_OPCODE_NOP);
+ FakeCodeline& last = nop;
+
+ foreach_in_list(glsl_to_tgsi_instruction, inst, tgsi_prog) {
+ program.push_back(last = FakeCodeline(*inst));
+ if (num_temps < last.get_max_reg_id())
+ num_temps = last.get_max_reg_id();
+ }
+ ++num_temps;
+}
+
+int FakeShader::get_num_temps() const
+{
+ return num_temps;
+}
+
+exec_list* FakeShader::get_program(void *ctx) const
+{
+ exec_list *prog = new(ctx) exec_list();
+
+ for (const FakeCodeline& i: program) {
+ prog->push_tail(i.get_codeline());
+ }
+
+ return prog;
+}
+
+void MesaTestWithMemCtx::SetUp()
+{
+ mem_ctx = ralloc_context(nullptr);
+ FakeCodeline::set_mem_ctx(mem_ctx);
+}
+
+void MesaTestWithMemCtx::TearDown()
+{
+ ralloc_free(mem_ctx);
+ FakeCodeline::set_mem_ctx(nullptr);
+ mem_ctx = nullptr;
+}
+
+
+LifetimeEvaluatorTest::lifetime_result
+LifetimeEvaluatorTest::run(const vector<FakeCodeline>& code, bool& success)
+{
+ FakeShader shader(code);
+ lifetime_result result(shader.get_num_temps());
+
+ success =
+ get_temp_registers_required_lifetimes(mem_ctx, shader.get_program(mem_ctx),
+ shader.get_num_temps(),
+ &result[0]);
+
+ return result;
+}
+
+void LifetimeEvaluatorTest::run(const vector<FakeCodeline>& code, const temp_lt_expect& e)
+{
+ FakeShader shader(code);
+ lifetime_result result(shader.get_num_temps());
+ bool success =
+ get_temp_registers_required_lifetimes(mem_ctx, shader.get_program(mem_ctx),
+ shader.get_num_temps(),
+ &result[0]);
+ ASSERT_TRUE(success);
+ ASSERT_EQ(result.size(), e.size());
+ check(result, e);
+}
+
+void LifetimeEvaluatorExactTest::check( const vector<lifetime>& lifetimes,
+ const temp_lt_expect& e)
+{
+ for (unsigned i = 1; i < lifetimes.size(); ++i) {
+ EXPECT_EQ(lifetimes[i].begin, e[i][0]);
+ EXPECT_EQ(lifetimes[i].end, e[i][1]);
+ }
+}
+
+void LifetimeEvaluatorAtLeastTest::check( const vector<lifetime>& lifetimes,
+ const temp_lt_expect& e)
+{
+ for (unsigned i = 1; i < lifetimes.size(); ++i) {
+ EXPECT_LE(lifetimes[i].begin, e[i][0]);
+ EXPECT_GE(lifetimes[i].end, e[i][1]);
+ }
+}
+
+void RegisterRemappingTest::run(const vector<lifetime>& lt,
+ const vector<int>& expect)
+{
+ rename_reg_pair proto{false,0};
+ vector<rename_reg_pair> result(lt.size(), proto);
+
+ get_temp_registers_remapping(mem_ctx, lt.size(), <[0], &result[0]);
+
+ vector<int> remap(lt.size());
+ for (unsigned i = 0; i < lt.size(); ++i) {
+ remap[i] = result[i].valid ? result[i].new_reg : i;
+ }
+
+ std::transform(remap.begin(), remap.end(), result.begin(), remap.begin(),
+ [](int x, const rename_reg_pair& rn) {
+ return rn.valid ? rn.new_reg : x;
+ });
+
+ for(unsigned i = 1; i < remap.size(); ++i) {
+ EXPECT_EQ(remap[i], expect[i]);
+ }
+}
+
+void RegisterLifetimeAndRemappingTest::run(const vector<FakeCodeline>& code,
+ const vector<int>& expect)
+{
+ FakeShader shader(code);
+ std::vector<lifetime> lt(shader.get_num_temps());
+ get_temp_registers_required_lifetimes(mem_ctx, shader.get_program(mem_ctx),
+ shader.get_num_temps(), <[0]);
+ this->run(lt, expect);
+}
diff --git a/src/mesa/state_tracker/tests/st_tests_common.h b/src/mesa/state_tracker/tests/st_tests_common.h
new file mode 100644
index 0000000000..cea8a5ce08
--- /dev/null
+++ b/src/mesa/state_tracker/tests/st_tests_common.h
@@ -0,0 +1,163 @@
+/*
+ * Copyright © 2017 Gert Wollny
+ *
+ * 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.
+ */
+
+#ifndef mesa_st_tests_h
+#define mesa_st_tests_h
+
+#include <state_tracker/st_glsl_to_tgsi_temprename.h>
+#include <gtest/gtest.h>
+#include <utility>
+
+#define MP(X, W) std::make_pair(X, W)
+#define MT(X,Y,Z) std::make_tuple(X,Y,Z)
+
+
+/* Use this to make the compiler pick the swizzle constructor below */
+struct SWZ {};
+
+/* A line to describe a TGSI instruction for building mock shaders. */
+struct FakeCodeline {
+ FakeCodeline(unsigned _op): op(_op), max_temp_id(0){}
+ FakeCodeline(unsigned _op, const std::vector<int>& _dst, const std::vector<int>& _src,
+ const std::vector<int>&_to);
+
+ FakeCodeline(unsigned _op, const std::vector<std::pair<int,int>>& _dst,
+ const std::vector<std::pair<int, const char *>>& _src,
+ const std::vector<std::pair<int, const char *>>&_to, SWZ with_swizzle);
+
+ FakeCodeline(const glsl_to_tgsi_instruction& inst);
+
+ int get_max_reg_id() const { return max_temp_id;}
+
+ glsl_to_tgsi_instruction *get_codeline() const;
+
+ static void set_mem_ctx(void *ctx);
+
+ friend bool operator == (const FakeCodeline& lsh, const FakeCodeline& rhs);
+
+ void print(std::ostream& os) const;
+private:
+ st_src_reg create_src_register(int src_idx);
+ st_src_reg create_src_register(int src_idx, const char *swizzle);
+ st_src_reg create_src_register(int src_idx, gl_register_file file);
+
+ st_dst_reg create_dst_register(int dst_idx);
+ st_dst_reg create_dst_register(int dst_idx, int writemask);
+ st_dst_reg create_dst_register(int dst_idx, gl_register_file file);
+
+ template <typename st_reg>
+ void read_reg(const st_reg& s);
+
+ unsigned op;
+ std::vector<st_dst_reg> dst;
+ std::vector<st_src_reg> src;
+ std::vector<st_src_reg> tex_offsets;
+
+ int max_temp_id;
+ static void *mem_ctx;
+};
+
+inline std::ostream& operator << (std::ostream& os, const FakeCodeline& line)
+{
+ line.print(os);
+ return os;
+}
+
+/* A few constants that will not be tracked as temporary registers
+ by the fake shader.
+ */
+const int in0 = -1;
+const int in1 = -2;
+const int in2 = -3;
+
+const int out0 = -1;
+const int out1 = -2;
+const int out2 = -3;
+
+class FakeShader {
+public:
+ FakeShader(const std::vector<FakeCodeline>& source);
+ FakeShader(exec_list *tgsi_prog);
+
+ exec_list* get_program(void *ctx) const;
+ int get_num_temps() const;
+
+private:
+
+ std::vector<FakeCodeline> program;
+ int num_temps;
+};
+
+using temp_lt_expect = std::vector<std::vector<int>>;
+
+class MesaTestWithMemCtx : public testing::Test {
+ void SetUp();
+ void TearDown();
+protected:
+ void *mem_ctx;
+};
+
+class LifetimeEvaluatorTest : public MesaTestWithMemCtx {
+protected:
+ void run(const std::vector<FakeCodeline>& code, const temp_lt_expect& e);
+private:
+ using lifetime_result=std::vector<lifetime>;
+ lifetime_result run(const std::vector<FakeCodeline>& code, bool& success);
+
+ virtual void check(const std::vector<lifetime>& result, const temp_lt_expect& e) = 0;
+};
+
+/* This is a test class to check the exact life times of
+ * registers. */
+class LifetimeEvaluatorExactTest : public LifetimeEvaluatorTest {
+protected:
+ void check(const std::vector<lifetime>& result, const temp_lt_expect& e);
+
+};
+
+/* This test class checks that the life time covers at least
+ * in the expected range. It is used for cases where we know that
+ * a the implementation could be improved on estimating the minimal
+ * life time.
+ */
+class LifetimeEvaluatorAtLeastTest : public LifetimeEvaluatorTest {
+protected:
+ void check(const std::vector<lifetime>& result, const temp_lt_expect& e);
+};
+
+/* With this test class the renaming mapping estimation is tested */
+class RegisterRemappingTest : public MesaTestWithMemCtx {
+protected:
+ void run(const std::vector<lifetime>& lt, const std::vector<int> &expect);
+};
+
+/* With this test class the combined lifetime estimation and renaming
+ * mepping estimation is tested
+ */
+class RegisterLifetimeAndRemappingTest : public RegisterRemappingTest {
+protected:
+ using RegisterRemappingTest::run;
+ void run(const std::vector<FakeCodeline>& code, const std::vector<int> &expect);
+};
+
+#endif
diff --git a/src/mesa/state_tracker/tests/test_glsl_to_tgsi_lifetime.cpp b/src/mesa/state_tracker/tests/test_glsl_to_tgsi_lifetime.cpp
index d0ac8b1020..4f226429af 100644
--- a/src/mesa/state_tracker/tests/test_glsl_to_tgsi_lifetime.cpp
+++ b/src/mesa/state_tracker/tests/test_glsl_to_tgsi_lifetime.cpp
@@ -21,155 +21,43 @@
* DEALINGS IN THE SOFTWARE.
*/
-#include <state_tracker/st_glsl_to_tgsi_temprename.h>
#include <tgsi/tgsi_ureg.h>
#include <tgsi/tgsi_info.h>
-#include <compiler/glsl/list.h>
#include <mesa/program/prog_instruction.h>
-#include <utility>
#include <gtest/gtest.h>
+#include <utility>
+#include <algorithm>
+#include <iostream>
+
+#include "st_tests_common.h"
using std::vector;
using std::pair;
using std::make_pair;
+using std::transform;
+using std::copy;
-/* A line to describe a TGSI instruction for building mock shaders. */
-struct MockCodeline {
- MockCodeline(unsigned _op): op(_op) {}
- MockCodeline(unsigned _op, const vector<int>& _dst, const vector<int>& _src, const vector<int>&_to):
- op(_op), dst(_dst), src(_src), tex_offsets(_to){}
- unsigned op;
- vector<int> dst;
- vector<int> src;
- vector<int> tex_offsets;
-};
-
-/* A line to describe a TGSI instruction with swizzeling and write makss
- * for building mock shaders.
- */
-struct MockCodelineWithSwizzle {
- MockCodelineWithSwizzle(unsigned _op): op(_op) {}
- MockCodelineWithSwizzle(unsigned _op, const vector<pair<int,int>>& _dst,
- const vector<pair<int, const char *>>& _src,
- const vector<pair<int, const char *>>&_to):
- op(_op), dst(_dst), src(_src), tex_offsets(_to){}
- unsigned op;
- vector<pair<int,int>> dst;
- vector<pair<int, const char *>> src;
- vector<pair<int, const char *>> tex_offsets;
-};
-
-/* A few constants that will notbe tracked as temporary registers by the
- * mock shader.
- */
-const int in0 = -1;
-const int in1 = -2;
-const int in2 = -3;
-
-const int out0 = -1;
-const int out1 = -2;
-
-class MockShader {
-public:
- MockShader(const vector<MockCodeline>& source);
- MockShader(const vector<MockCodelineWithSwizzle>& source);
- ~MockShader();
-
- void free();
-
- exec_list* get_program() const;
- int get_num_temps() const;
-private:
- st_src_reg create_src_register(int src_idx);
- st_dst_reg create_dst_register(int dst_idx);
- st_src_reg create_src_register(int src_idx, const char *swizzle);
- st_dst_reg create_dst_register(int dst_idx,int writemask);
- exec_list* program;
- int num_temps;
- void *mem_ctx;
-};
-
-using expectation = vector<vector<int>>;
-
-class MesaTestWithMemCtx : public testing::Test {
- void SetUp();
- void TearDown();
-protected:
- void *mem_ctx;
-};
-
-class LifetimeEvaluatorTest : public MesaTestWithMemCtx {
-protected:
- void run(const vector<MockCodeline>& code, const expectation& e);
- void run(const vector<MockCodelineWithSwizzle>& code, const expectation& e);
-private:
- virtual void check(const vector<lifetime>& result, const expectation& e) = 0;
-};
-
-/* This is a test class to check the exact life times of
- * registers. */
-class LifetimeEvaluatorExactTest : public LifetimeEvaluatorTest {
-protected:
- void check(const vector<lifetime>& result, const expectation& e);
-};
-
-/* This test class checks that the life time covers at least
- * in the expected range. It is used for cases where we know that
- * a the implementation could be improved on estimating the minimal
- * life time.
- */
-class LifetimeEvaluatorAtLeastTest : public LifetimeEvaluatorTest {
-protected:
- void check(const vector<lifetime>& result, const expectation& e);
-};
-
-/* With this test class the renaming mapping estimation is tested */
-class RegisterRemappingTest : public MesaTestWithMemCtx {
-protected:
- void run(const vector<lifetime>& lt, const vector<int>& expect);
-};
-
-/* With this test class the combined lifetime estimation and renaming
- * mepping estimation is tested
- */
-class RegisterLifetimeAndRemappingTest : public RegisterRemappingTest {
-protected:
- using RegisterRemappingTest::run;
- template <typename CodeLine>
- void run(const vector<CodeLine>& code, const vector<int>& expect);
-};
-
-template <typename CodeLine>
-void RegisterLifetimeAndRemappingTest::run(const vector<CodeLine>& code,
- const vector<int>& expect)
-{
- MockShader shader(code);
- std::vector<lifetime> lt(shader.get_num_temps());
- get_temp_registers_required_lifetimes(mem_ctx, shader.get_program(),
- shader.get_num_temps(), <[0]);
- this->run(lt, expect);
-}
TEST_F(LifetimeEvaluatorExactTest, SimpleMoveAdd)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_UADD, {out0}, {1,in0}, {}},
{ TGSI_OPCODE_END}
};
- run(code, expectation({{-1,-1}, {0,1}}));
+ run(code, temp_lt_expect({{-1,-1}, {0,1}}));
}
TEST_F(LifetimeEvaluatorExactTest, SimpleMoveAddMove)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_UADD, {2}, {1,in0}, {}},
{ TGSI_OPCODE_MOV, {out0}, {2}, {}},
{ TGSI_OPCODE_END}
};
- run(code, expectation({{-1, -1}, {0,1}, {1,2}}));
+ run(code, temp_lt_expect({{-1, -1}, {0,1}, {1,2}}));
}
/* Test whether the texoffst are actually visited by the
@@ -180,13 +68,13 @@ TEST_F(LifetimeEvaluatorExactTest, SimpleMoveAddMove)
*/
TEST_F(LifetimeEvaluatorExactTest, SimpleOpWithTexoffset)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_MOV, {2}, {in1}, {}},
{ TGSI_OPCODE_TEX, {out0}, {in0}, {1,2}},
{ TGSI_OPCODE_END}
};
- run(code, expectation({{-1, -1}, {0,2}, {1,2}}));
+ run(code, temp_lt_expect({{-1, -1}, {0,2}, {1,2}}));
}
/* Simple register access involving a loop
@@ -196,7 +84,7 @@ TEST_F(LifetimeEvaluatorExactTest, SimpleOpWithTexoffset)
*/
TEST_F(LifetimeEvaluatorExactTest, SimpleMoveInLoop)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_UADD, {2}, {1,in0}, {}},
@@ -206,7 +94,7 @@ TEST_F(LifetimeEvaluatorExactTest, SimpleMoveInLoop)
{ TGSI_OPCODE_MOV, {out0}, {3}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,5}, {2,3}, {3,6}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,5}, {2,3}, {3,6}}));
}
/* In loop if/else value written only in one path, and read later
@@ -214,7 +102,7 @@ TEST_F(LifetimeEvaluatorExactTest, SimpleMoveInLoop)
*/
TEST_F(LifetimeEvaluatorExactTest, MoveInIfInLoop)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {in1}, {}},
@@ -226,7 +114,7 @@ TEST_F(LifetimeEvaluatorExactTest, MoveInIfInLoop)
{ TGSI_OPCODE_MOV, {out0}, {3}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,7}, {1,7}, {5,8}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,7}, {1,7}, {5,8}}));
}
/* A non-dominant write within an IF can be ignored (if it is read
@@ -234,7 +122,7 @@ TEST_F(LifetimeEvaluatorExactTest, MoveInIfInLoop)
*/
TEST_F(LifetimeEvaluatorExactTest, NonDominantWriteinIfInLoop)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_IF, {}, {in1}, {}},
@@ -248,7 +136,7 @@ TEST_F(LifetimeEvaluatorExactTest, NonDominantWriteinIfInLoop)
{ TGSI_OPCODE_MOV, {out0}, {2}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {1,5}, {5,10}}));
+ run (code, temp_lt_expect({{-1,-1}, {1,5}, {5,10}}));
}
/* In Nested loop if/else value written only in one path, and read later
@@ -256,7 +144,7 @@ TEST_F(LifetimeEvaluatorExactTest, NonDominantWriteinIfInLoop)
*/
TEST_F(LifetimeEvaluatorExactTest, MoveInIfInNestedLoop)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_BGNLOOP },
@@ -269,7 +157,7 @@ TEST_F(LifetimeEvaluatorExactTest, MoveInIfInNestedLoop)
{ TGSI_OPCODE_MOV, {out0}, {3}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,8}, {1,8}, {6,9}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,8}, {1,8}, {6,9}}));
}
/* In loop if/else value written in both path, and read later
@@ -278,7 +166,7 @@ TEST_F(LifetimeEvaluatorExactTest, MoveInIfInNestedLoop)
*/
TEST_F(LifetimeEvaluatorAtLeastTest, WriteInIfAndElseInLoop)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {1}, {}},
@@ -292,7 +180,7 @@ TEST_F(LifetimeEvaluatorAtLeastTest, WriteInIfAndElseInLoop)
{ TGSI_OPCODE_MOV, {out0}, {3}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,9}, {3,7}, {7,10}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,9}, {3,7}, {7,10}}));
}
/* In loop if/else value written in both path, read in else path
@@ -301,7 +189,7 @@ TEST_F(LifetimeEvaluatorAtLeastTest, WriteInIfAndElseInLoop)
*/
TEST_F(LifetimeEvaluatorExactTest, WriteInIfAndElseReadInElseInLoop)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {1}, {}},
@@ -315,7 +203,7 @@ TEST_F(LifetimeEvaluatorExactTest, WriteInIfAndElseReadInElseInLoop)
{ TGSI_OPCODE_MOV, {out0}, {3}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,9}, {1,9}, {7,10}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,9}, {1,9}, {7,10}}));
}
/* In loop if/else read in one path before written in the same loop
@@ -323,7 +211,7 @@ TEST_F(LifetimeEvaluatorExactTest, WriteInIfAndElseReadInElseInLoop)
*/
TEST_F(LifetimeEvaluatorExactTest, ReadInIfInLoopBeforeWrite)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {in0}, {}},
@@ -335,7 +223,7 @@ TEST_F(LifetimeEvaluatorExactTest, ReadInIfInLoopBeforeWrite)
{ TGSI_OPCODE_MOV, {out0}, {3}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,7}, {1,7}, {1,8}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,7}, {1,7}, {1,8}}));
}
/* In loop if/else read in one path before written in the same loop
@@ -344,7 +232,7 @@ TEST_F(LifetimeEvaluatorExactTest, ReadInIfInLoopBeforeWrite)
*/
TEST_F(LifetimeEvaluatorExactTest, ReadInLoopInIfBeforeWriteAndLifeToTheEnd)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {in0}, {}},
{ TGSI_OPCODE_MUL, {1}, {1,in1}, {}},
@@ -354,7 +242,7 @@ TEST_F(LifetimeEvaluatorExactTest, ReadInLoopInIfBeforeWriteAndLifeToTheEnd)
{ TGSI_OPCODE_MOV, {out0}, {1}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,6}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,6}}));
}
/* In loop if/else read in one path before written in the same loop
@@ -363,7 +251,7 @@ TEST_F(LifetimeEvaluatorExactTest, ReadInLoopInIfBeforeWriteAndLifeToTheEnd)
*/
TEST_F(LifetimeEvaluatorExactTest, ReadInLoopBeforeWriteAndLifeToTheEnd)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_MUL, {1}, {1,in1}, {}},
{ TGSI_OPCODE_UADD, {1}, {1,in1}, {}},
@@ -371,7 +259,7 @@ TEST_F(LifetimeEvaluatorExactTest, ReadInLoopBeforeWriteAndLifeToTheEnd)
{ TGSI_OPCODE_MOV, {out0}, {1}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,4}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,4}}));
}
@@ -381,7 +269,7 @@ TEST_F(LifetimeEvaluatorExactTest, ReadInLoopBeforeWriteAndLifeToTheEnd)
*/
TEST_F(LifetimeEvaluatorAtLeastTest, NestedIfInLoopAlwaysWriteButNotPropagated)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {in0}, {}},
{ TGSI_OPCODE_IF, {}, {in0}, {}},
@@ -400,7 +288,7 @@ TEST_F(LifetimeEvaluatorAtLeastTest, NestedIfInLoopAlwaysWriteButNotPropagated)
{ TGSI_OPCODE_ENDLOOP },
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {3,14}}));
+ run (code, temp_lt_expect({{-1,-1}, {3,14}}));
}
/* The value is written in a loop and in a nested if, but
@@ -408,7 +296,7 @@ TEST_F(LifetimeEvaluatorAtLeastTest, NestedIfInLoopAlwaysWriteButNotPropagated)
*/
TEST_F(LifetimeEvaluatorExactTest, NestedIfInLoopWriteNotAlways)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {in0}, {}},
{ TGSI_OPCODE_IF, {}, {in0}, {}},
@@ -425,13 +313,13 @@ TEST_F(LifetimeEvaluatorExactTest, NestedIfInLoopWriteNotAlways)
{ TGSI_OPCODE_ENDLOOP },
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,13}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,13}}));
}
/* A continue in the loop is not relevant */
TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAfterContinue)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {in0}, {}},
{ TGSI_OPCODE_CONT},
@@ -441,7 +329,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAfterContinue)
{ TGSI_OPCODE_MOV, {out0}, {1}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {4,6}}));
+ run (code, temp_lt_expect({{-1,-1}, {4,6}}));
}
/* Temporary used to in case must live up to the case
@@ -451,7 +339,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAfterContinue)
*/
TEST_F(LifetimeEvaluatorExactTest, UseSwitchCase)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_MOV, {2}, {in1}, {}},
{ TGSI_OPCODE_MOV, {3}, {in2}, {}},
@@ -463,7 +351,7 @@ TEST_F(LifetimeEvaluatorExactTest, UseSwitchCase)
{ TGSI_OPCODE_ENDSWITCH},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,5}, {1,4}, {2,3}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,5}, {1,4}, {2,3}}));
}
/* With two destinations, if one result is thrown away, the
@@ -471,14 +359,14 @@ TEST_F(LifetimeEvaluatorExactTest, UseSwitchCase)
*/
TEST_F(LifetimeEvaluatorExactTest, WriteTwoOnlyUseOne)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_DFRACEXP , {1,2}, {in0}, {}},
{ TGSI_OPCODE_ADD , {3}, {2,in0}, {}},
{ TGSI_OPCODE_MOV, {out1}, {3}, {}},
{ TGSI_OPCODE_END},
};
- run (code, expectation({{-1,-1}, {0,1}, {0,1}, {1,2}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,1}, {0,1}, {1,2}}));
}
/* If a break is in the loop, all variables written after the
@@ -487,7 +375,7 @@ TEST_F(LifetimeEvaluatorExactTest, WriteTwoOnlyUseOne)
*/
TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAfterBreak)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {in0}, {}},
{ TGSI_OPCODE_BRK},
@@ -497,7 +385,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAfterBreak)
{ TGSI_OPCODE_MOV, {out0}, {1}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,6}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,6}}));
}
/* If a break is in the loop, all variables written after the
@@ -506,7 +394,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAfterBreak)
*/
TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAfterBreak2Breaks)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {in0}, {}},
{ TGSI_OPCODE_BRK},
@@ -517,7 +405,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAfterBreak2Breaks)
{ TGSI_OPCODE_MOV, {out0}, {1}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,7}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,7}}));
}
/* Loop with a break at the beginning and read/write in the post
@@ -529,7 +417,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAfterBreak2Breaks)
*/
TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAndReadAfterBreak)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {in0}, {}},
{ TGSI_OPCODE_BRK},
@@ -540,7 +428,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAndReadAfterBreak)
{ TGSI_OPCODE_MOV, {out0}, {2}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {4,5}, {0,7}}));
+ run (code, temp_lt_expect({{-1,-1}, {4,5}, {0,7}}));
}
/* Same as above, just make sure that the life time of the local variable
@@ -548,7 +436,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAndReadAfterBreak)
*/
TEST_F(LifetimeEvaluatorExactTest, NestedLoopWithWriteAndReadAfterBreak)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {in1}, {}},
{ TGSI_OPCODE_BRK},
@@ -566,7 +454,7 @@ TEST_F(LifetimeEvaluatorExactTest, NestedLoopWithWriteAndReadAfterBreak)
{ TGSI_OPCODE_MOV, {out0}, {4}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {8,9}, {0,13}, {11,12}, {0,14}}));
+ run (code, temp_lt_expect({{-1,-1}, {8,9}, {0,13}, {11,12}, {0,14}}));
}
/* If a break is in the loop inside a switch case, make sure it is
@@ -575,7 +463,7 @@ TEST_F(LifetimeEvaluatorExactTest, NestedLoopWithWriteAndReadAfterBreak)
*/
TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAfterBreakInSwitchInLoop)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_SWITCH, {}, {in1}, {}},
{ TGSI_OPCODE_CASE, {}, {in1}, {}},
{ TGSI_OPCODE_BGNLOOP },
@@ -589,7 +477,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAfterBreakInSwitchInLoop)
{ TGSI_OPCODE_MOV, {out0}, {1}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {2,10}}));
+ run (code, temp_lt_expect({{-1,-1}, {2,10}}));
}
/* Value written conditionally in one loop and read in another loop,
@@ -598,7 +486,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteAfterBreakInSwitchInLoop)
*/
TEST_F(LifetimeEvaluatorExactTest, LoopsWithDifferntScopesConditionalWrite)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {in0}, {}},
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
@@ -609,7 +497,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopsWithDifferntScopesConditionalWrite)
{ TGSI_OPCODE_ENDLOOP },
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,7}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,7}}));
}
/* Value written and read in one loop and last read in another loop,
@@ -617,7 +505,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopsWithDifferntScopesConditionalWrite)
*/
TEST_F(LifetimeEvaluatorExactTest, LoopsWithDifferntScopesFirstReadBeforeWrite)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_MUL, {1}, {1,in0}, {}},
{ TGSI_OPCODE_ENDLOOP },
@@ -626,7 +514,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopsWithDifferntScopesFirstReadBeforeWrite)
{ TGSI_OPCODE_ENDLOOP },
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,5}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,5}}));
}
@@ -635,7 +523,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopsWithDifferntScopesFirstReadBeforeWrite)
*/
TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteInSwitch)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_SWITCH, {}, {in0}, {} },
{ TGSI_OPCODE_CASE, {}, {in0}, {} },
@@ -648,7 +536,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteInSwitch)
{ TGSI_OPCODE_ENDLOOP },
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,9}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,9}}));
}
/* Value written in one case, and read in other,in loop
@@ -656,7 +544,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithWriteInSwitch)
*/
TEST_F(LifetimeEvaluatorExactTest, LoopWithReadWriteInSwitchDifferentCase)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_SWITCH, {}, {in0}, {} },
{ TGSI_OPCODE_CASE, {}, {in0}, {} },
@@ -669,7 +557,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithReadWriteInSwitchDifferentCase)
{ TGSI_OPCODE_ENDLOOP },
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,9}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,9}}));
}
/* Value written in one case, and read in other,in loop
@@ -677,7 +565,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithReadWriteInSwitchDifferentCase)
*/
TEST_F(LifetimeEvaluatorExactTest, LoopWithReadWriteInSwitchDifferentCaseFallThrough)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_SWITCH, {}, {in0}, {} },
{ TGSI_OPCODE_CASE, {}, {in0}, {} },
@@ -689,7 +577,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithReadWriteInSwitchDifferentCaseFallThr
{ TGSI_OPCODE_ENDLOOP },
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,8}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,8}}));
}
@@ -699,7 +587,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithReadWriteInSwitchDifferentCaseFallThr
*/
TEST_F(LifetimeEvaluatorExactTest, WriteSelectFromSelf)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{TGSI_OPCODE_USEQ, {5}, {in0,in1}, {}},
{TGSI_OPCODE_UCMP, {1}, {5,in1,1}, {}},
{TGSI_OPCODE_UCMP, {1}, {5,in1,1}, {}},
@@ -716,7 +604,7 @@ TEST_F(LifetimeEvaluatorExactTest, WriteSelectFromSelf)
{TGSI_OPCODE_MOV, {out1}, {3}, {}},
{TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {1,5}, {5,6}, {7,13}, {9,11}, {0,4}}));
+ run (code, temp_lt_expect({{-1,-1}, {1,5}, {5,6}, {7,13}, {9,11}, {0,4}}));
}
/* This test checks wheter the ENDSWITCH is handled properly if the
@@ -724,7 +612,7 @@ TEST_F(LifetimeEvaluatorExactTest, WriteSelectFromSelf)
*/
TEST_F(LifetimeEvaluatorExactTest, LoopRWInSwitchCaseLastCaseWithoutBreak)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_SWITCH, {}, {in0}, {} },
{ TGSI_OPCODE_CASE, {}, {in0}, {} },
@@ -736,13 +624,13 @@ TEST_F(LifetimeEvaluatorExactTest, LoopRWInSwitchCaseLastCaseWithoutBreak)
{ TGSI_OPCODE_ENDLOOP },
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,8}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,8}}));
}
/* Value read/write in same case, stays there */
TEST_F(LifetimeEvaluatorExactTest, LoopWithReadWriteInSwitchSameCase)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_SWITCH, {}, {in0}, {} },
{ TGSI_OPCODE_CASE, {}, {in0}, {} },
@@ -755,7 +643,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithReadWriteInSwitchSameCase)
{ TGSI_OPCODE_ENDLOOP },
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {3,4}}));
+ run (code, temp_lt_expect({{-1,-1}, {3,4}}));
}
/* Value read/write in all cases, should only live from first
@@ -763,7 +651,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithReadWriteInSwitchSameCase)
*/
TEST_F(LifetimeEvaluatorAtLeastTest, LoopWithReadWriteInSwitchSameCase)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_SWITCH, {}, {in0}, {}},
{ TGSI_OPCODE_CASE, {}, {in0}, {} },
@@ -777,13 +665,13 @@ TEST_F(LifetimeEvaluatorAtLeastTest, LoopWithReadWriteInSwitchSameCase)
{ TGSI_OPCODE_ENDLOOP },
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {3,9}}));
+ run (code, temp_lt_expect({{-1,-1}, {3,9}}));
}
/* First read before first write with nested loops */
TEST_F(LifetimeEvaluatorExactTest, LoopsWithDifferentScopesCondReadBeforeWrite)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {in0}, {}},
@@ -796,7 +684,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopsWithDifferentScopesCondReadBeforeWrite)
{ TGSI_OPCODE_ENDLOOP },
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,9}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,9}}));
}
/* First read before first write wiredness with nested loops.
@@ -805,7 +693,7 @@ TEST_F(LifetimeEvaluatorExactTest, LoopsWithDifferentScopesCondReadBeforeWrite)
*/
TEST_F(LifetimeEvaluatorExactTest, FirstWriteAtferReadInNestedLoop)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_BGNLOOP },
@@ -817,7 +705,7 @@ TEST_F(LifetimeEvaluatorExactTest, FirstWriteAtferReadInNestedLoop)
{ TGSI_OPCODE_MOV, {out0}, {3}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,7}, {1,7}, {4,8}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,7}, {1,7}, {4,8}}));
}
@@ -831,82 +719,83 @@ TEST_F(LifetimeEvaluatorExactTest, FirstWriteAtferReadInNestedLoop)
*/
TEST_F(LifetimeEvaluatorExactTest, LoopWithConditionalComponentWrite_X)
{
- const vector<MockCodelineWithSwizzle> code = {
- MockCodelineWithSwizzle(TGSI_OPCODE_BGNLOOP),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(1, WRITEMASK_Y), SRC(in1, "x"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_IF, {}, SRC(in0, "xxxx"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(1, WRITEMASK_X), SRC(in1, "y"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_ENDIF),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(2, WRITEMASK_XY), SRC(1, "xy"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_ENDLOOP),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(out0, WRITEMASK_XYZW), SRC(2, "xyxy"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_END)
+ const vector<FakeCodeline> code = {
+ { TGSI_OPCODE_BGNLOOP},
+ { TGSI_OPCODE_MOV, DST(1, WRITEMASK_Y), SRC(in1, "x"), {}, SWZ()},
+ { TGSI_OPCODE_IF, {}, SRC(in0, "xxxx"), {}, SWZ()},
+ { TGSI_OPCODE_MOV, DST(1, WRITEMASK_X), SRC(in1, "y"), {}, SWZ()},
+ { TGSI_OPCODE_ENDIF},
+ { TGSI_OPCODE_MOV, DST(2, WRITEMASK_XY), SRC(1, "xy"), {}, SWZ()},
+ { TGSI_OPCODE_ENDLOOP},
+ { TGSI_OPCODE_MOV, DST(out0, WRITEMASK_XYZW), SRC(2, "xyxy"), {}, SWZ()},
+ { TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,6}, {5,7}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,6}, {5,7}}));
}
TEST_F(LifetimeEvaluatorExactTest, LoopWithConditionalComponentWrite_Y)
{
- const vector<MockCodelineWithSwizzle> code = {
- MockCodelineWithSwizzle(TGSI_OPCODE_BGNLOOP),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(1, WRITEMASK_X), SRC(in1, "x"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_IF, {}, SRC(in0, "xxxx"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(1, WRITEMASK_Y), SRC(in1, "y"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_ENDIF),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(2, WRITEMASK_XY), SRC(1, "xy"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_ENDLOOP),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(out0, WRITEMASK_XYZW), SRC(2, "xyxy"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_END)
+ const vector<FakeCodeline> code = {
+ { TGSI_OPCODE_BGNLOOP},
+ { TGSI_OPCODE_MOV, DST(1, WRITEMASK_X), SRC(in1, "x"), {}, SWZ()},
+ { TGSI_OPCODE_IF, {}, SRC(in0, "xxxx"), {}, SWZ()},
+ { TGSI_OPCODE_MOV, DST(1, WRITEMASK_Y), SRC(in1, "y"), {}, SWZ()},
+ { TGSI_OPCODE_ENDIF},
+ { TGSI_OPCODE_MOV, DST(2, WRITEMASK_XY), SRC(1, "xy"), {}, SWZ()},
+ { TGSI_OPCODE_ENDLOOP},
+ { TGSI_OPCODE_MOV, DST(out0, WRITEMASK_XYZW), SRC(2, "xyxy"), {}, SWZ()},
+ { TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,6}, {5,7}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,6}, {5,7}}));
}
TEST_F(LifetimeEvaluatorExactTest, LoopWithConditionalComponentWrite_Z)
{
- const vector<MockCodelineWithSwizzle> code = {
- MockCodelineWithSwizzle(TGSI_OPCODE_BGNLOOP),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(1, WRITEMASK_X), SRC(in1, "x"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_IF, {}, SRC(in0, "xxxx"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(1, WRITEMASK_Z), SRC(in1, "y"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_ENDIF),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(2, WRITEMASK_XY), SRC(1, "xz"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_ENDLOOP),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(out0, WRITEMASK_XYZW), SRC(2, "xyxy"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_END)
+ const vector<FakeCodeline> code = {
+ { TGSI_OPCODE_BGNLOOP},
+ { TGSI_OPCODE_MOV, DST(1, WRITEMASK_X), SRC(in1, "x"), {}, SWZ()},
+ { TGSI_OPCODE_IF, {}, SRC(in0, "xxxx"), {}, SWZ()},
+ { TGSI_OPCODE_MOV, DST(1, WRITEMASK_Z), SRC(in1, "y"), {}, SWZ()},
+ { TGSI_OPCODE_ENDIF},
+ { TGSI_OPCODE_MOV, DST(2, WRITEMASK_XY), SRC(1, "xz"), {}, SWZ()},
+ { TGSI_OPCODE_ENDLOOP},
+ { TGSI_OPCODE_MOV, DST(out0, WRITEMASK_XYZW), SRC(2, "xyxy"), {}, SWZ()},
+ { TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,6}, {5,7}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,6}, {5,7}}));
}
TEST_F(LifetimeEvaluatorExactTest, LoopWithConditionalComponentWrite_W)
{
- const vector<MockCodelineWithSwizzle> code = {
- MockCodelineWithSwizzle(TGSI_OPCODE_BGNLOOP),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(1, WRITEMASK_X), SRC(in1, "x"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_IF, {}, SRC(in0, "xxxx"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(1, WRITEMASK_W), SRC(in1, "y"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_ENDIF),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(2, WRITEMASK_XY), SRC(1, "xw"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_ENDLOOP),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(out0, WRITEMASK_XYZW), SRC(2, "xyxy"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_END)
+ const vector<FakeCodeline> code = {
+ { TGSI_OPCODE_BGNLOOP},
+ { TGSI_OPCODE_MOV, DST(1, WRITEMASK_X), SRC(in1, "x"), {}, SWZ()},
+ { TGSI_OPCODE_IF, {}, SRC(in0, "xxxx"), {}, SWZ()},
+ { TGSI_OPCODE_MOV, DST(1, WRITEMASK_W), SRC(in1, "y"), {}, SWZ()},
+ { TGSI_OPCODE_ENDIF},
+ { TGSI_OPCODE_MOV, DST(2, WRITEMASK_XY), SRC(1, "xw"), {}, SWZ()},
+ { TGSI_OPCODE_ENDLOOP},
+ { TGSI_OPCODE_MOV, DST(out0, WRITEMASK_XYZW), SRC(2, "xyxy"), {}, SWZ()},
+ { TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,6}, {5,7}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,6}, {5,7}}));
}
TEST_F(LifetimeEvaluatorExactTest, LoopWithConditionalComponentWrite_X_Read_Y_Before)
{
- const vector<MockCodelineWithSwizzle> code = {
- MockCodelineWithSwizzle(TGSI_OPCODE_BGNLOOP),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(1, WRITEMASK_X), SRC(in1, "x"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_IF, {}, SRC(in0, "xxxx"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(2, WRITEMASK_XYZW), SRC(1, "yyyy"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_ENDIF),
- MockCodelineWithSwizzle(TGSI_OPCODE_MOV, DST(1, WRITEMASK_YZW), SRC(2, "yyzw"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_ENDLOOP),
- MockCodelineWithSwizzle(TGSI_OPCODE_ADD, DST(out0, WRITEMASK_XYZW), SRC2(2, "yyzw", 1, "xyxy"), {}),
- MockCodelineWithSwizzle(TGSI_OPCODE_END)
+ const vector<FakeCodeline> code = {
+ { TGSI_OPCODE_BGNLOOP},
+ { TGSI_OPCODE_MOV, DST(1, WRITEMASK_X), SRC(in1, "x"), {}, SWZ()},
+ { TGSI_OPCODE_IF, {}, SRC(in0, "xxxx"), {}, SWZ()},
+ { TGSI_OPCODE_MOV, DST(2, WRITEMASK_XYZW), SRC(1, "yyyy"), {}, SWZ()},
+ { TGSI_OPCODE_ENDIF},
+ { TGSI_OPCODE_MOV, DST(1, WRITEMASK_YZW), SRC(2, "yyzw"), {}, SWZ()},
+ { TGSI_OPCODE_ENDLOOP},
+ { TGSI_OPCODE_ADD, DST(out0, WRITEMASK_XYZW),
+ SRC2(2, "yyzw", 1, "xyxy"), {}, SWZ()},
+ { TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,7}, {0,7}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,7}, {0,7}}));
}
/* The variable is conditionally read before first written, so
@@ -914,10 +803,10 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithConditionalComponentWrite_X_Read_Y_Be
*/
TEST_F(LifetimeEvaluatorExactTest, FRaWSameInstructionInLoopAndCondition)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_BGNLOOP },
- { TGSI_OPCODE_IF, {0}, {in0}, {} },
+ { TGSI_OPCODE_IF, {}, {in0}, {} },
{ TGSI_OPCODE_ADD, {1}, {1,in0}, {}},
{ TGSI_OPCODE_ENDIF},
{ TGSI_OPCODE_MOV, {1}, {in1}, {}},
@@ -926,7 +815,7 @@ TEST_F(LifetimeEvaluatorExactTest, FRaWSameInstructionInLoopAndCondition)
{ TGSI_OPCODE_END},
};
- run (code, expectation({{-1,-1}, {0,7}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,7}}));
}
/* If unconditionally first written and read in the same
@@ -935,12 +824,12 @@ TEST_F(LifetimeEvaluatorExactTest, FRaWSameInstructionInLoopAndCondition)
*/
TEST_F(LifetimeEvaluatorExactTest, FRaWSameInstruction)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_ADD, {1}, {1,in0}, {}},
{ TGSI_OPCODE_END},
};
- run (code, expectation({{-1,-1}, {0,1}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,1}}));
}
/* If unconditionally written and read in the same
@@ -949,14 +838,14 @@ TEST_F(LifetimeEvaluatorExactTest, FRaWSameInstruction)
*/
TEST_F(LifetimeEvaluatorExactTest, FRaWSameInstructionMoreThenOnce)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_ADD, {1}, {1,in0}, {}},
{ TGSI_OPCODE_ADD, {1}, {1,in0}, {}},
{ TGSI_OPCODE_MOV, {out0}, {in0}, {}},
{ TGSI_OPCODE_END},
};
- run (code, expectation({{-1,-1}, {0,2}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,2}}));
}
/* Register is only written. This should not happen,
@@ -965,52 +854,51 @@ TEST_F(LifetimeEvaluatorExactTest, FRaWSameInstructionMoreThenOnce)
*/
TEST_F(LifetimeEvaluatorExactTest, WriteOnly)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,1}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,1}}));
}
/* Register is read in IF.
*/
TEST_F(LifetimeEvaluatorExactTest, SimpleReadForIf)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_ADD, {out0}, {in0,in1}, {}},
{ TGSI_OPCODE_IF, {}, {1}, {}},
{ TGSI_OPCODE_ENDIF}
};
- run (code, expectation({{-1,-1}, {0,2}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,2}}));
}
TEST_F(LifetimeEvaluatorExactTest, WriteTwoReadOne)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_DFRACEXP , {1,2}, {in0}, {}},
{ TGSI_OPCODE_ADD , {3}, {2,in0}, {}},
{ TGSI_OPCODE_MOV, {out1}, {3}, {}},
{ TGSI_OPCODE_END},
};
- run (code, expectation({{-1,-1}, {0,1}, {0,1}, {1,2}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,1}, {0,1}, {1,2}}));
}
TEST_F(LifetimeEvaluatorExactTest, ReadOnly)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {out0}, {1}, {}},
{ TGSI_OPCODE_END},
};
- run (code, expectation({{-1,-1}, {-1,-1}}));
+ run (code, temp_lt_expect({{-1,-1}, {-1,-1}}));
}
-
/* Test handling of missing END marker
*/
TEST_F(LifetimeEvaluatorExactTest, SomeScopesAndNoEndProgramId)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_IF, {}, {1}, {}},
{ TGSI_OPCODE_MOV, {2}, {1}, {}},
@@ -1019,30 +907,30 @@ TEST_F(LifetimeEvaluatorExactTest, SomeScopesAndNoEndProgramId)
{ TGSI_OPCODE_MOV, {out0}, {2}, {}},
{ TGSI_OPCODE_ENDIF},
};
- run (code, expectation({{-1,-1}, {0,4}, {2,5}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,4}, {2,5}}));
}
TEST_F(LifetimeEvaluatorExactTest, SerialReadWrite)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_MOV, {2}, {1}, {}},
{ TGSI_OPCODE_MOV, {3}, {2}, {}},
{ TGSI_OPCODE_MOV, {out0}, {3}, {}},
{ TGSI_OPCODE_END},
};
- run (code, expectation({{-1,-1}, {0,1}, {1,2}, {2,3}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,1}, {1,2}, {2,3}}));
}
/* Check that two destination registers are used */
TEST_F(LifetimeEvaluatorExactTest, TwoDestRegisters)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_DFRACEXP , {1,2}, {in0}, {}},
{ TGSI_OPCODE_ADD, {out0}, {1,2}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,1}, {0,1}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,1}, {0,1}}));
}
/* Check that writing within a loop in a conditional is propagated
@@ -1050,7 +938,7 @@ TEST_F(LifetimeEvaluatorExactTest, TwoDestRegisters)
*/
TEST_F(LifetimeEvaluatorExactTest, WriteInLoopInConditionalReadOutside)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP},
{ TGSI_OPCODE_IF, {}, {in0}, {}},
{ TGSI_OPCODE_BGNLOOP},
@@ -1062,7 +950,7 @@ TEST_F(LifetimeEvaluatorExactTest, WriteInLoopInConditionalReadOutside)
{ TGSI_OPCODE_MOV, {out0}, {2}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,7}, {6,8}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,7}, {6,8}}));
}
/* Check that a register written in a loop that is inside a conditional
@@ -1071,7 +959,7 @@ TEST_F(LifetimeEvaluatorExactTest, WriteInLoopInConditionalReadOutside)
*/
TEST_F(LifetimeEvaluatorExactTest, WriteInLoopInCondReadInCondOutsideLoop)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP},
{ TGSI_OPCODE_IF, {}, {in0}, {}},
{ TGSI_OPCODE_BGNLOOP},
@@ -1083,7 +971,7 @@ TEST_F(LifetimeEvaluatorExactTest, WriteInLoopInCondReadInCondOutsideLoop)
{ TGSI_OPCODE_MOV, {out0}, {2}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {3,5}, {0,8}}));
+ run (code, temp_lt_expect({{-1,-1}, {3,5}, {0,8}}));
}
/* Check that a register read before written in a loop that is
@@ -1091,7 +979,7 @@ TEST_F(LifetimeEvaluatorExactTest, WriteInLoopInCondReadInCondOutsideLoop)
*/
TEST_F(LifetimeEvaluatorExactTest, ReadWriteInLoopInCondReadInCondOutsideLoop)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP},
{ TGSI_OPCODE_IF, {}, {in0}, {}},
{ TGSI_OPCODE_BGNLOOP},
@@ -1103,7 +991,7 @@ TEST_F(LifetimeEvaluatorExactTest, ReadWriteInLoopInCondReadInCondOutsideLoop)
{ TGSI_OPCODE_MOV, {out0}, {2}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,7}, {0,8}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,7}, {0,8}}));
}
/* With two destinations if one value is thrown away, we must
@@ -1114,7 +1002,7 @@ TEST_F(LifetimeEvaluatorExactTest, ReadWriteInLoopInCondReadInCondOutsideLoop)
*/
TEST_F(LifetimeEvaluatorExactTest, WritePastLastRead2)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_MOV, {2}, {in0}, {}},
{ TGSI_OPCODE_ADD, {3}, {1,2}, {}},
@@ -1122,30 +1010,30 @@ TEST_F(LifetimeEvaluatorExactTest, WritePastLastRead2)
{ TGSI_OPCODE_MOV, {out1}, {4}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,2}, {1,4}, {2,3}, {3,4}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,2}, {1,4}, {2,3}, {3,4}}));
}
/* Check that three source registers are used */
TEST_F(LifetimeEvaluatorExactTest, ThreeSourceRegisters)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_DFRACEXP , {1,2}, {in0}, {}},
{ TGSI_OPCODE_ADD , {3}, {in0,in1}, {}},
{ TGSI_OPCODE_MAD, {out0}, {1,2,3}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,2}, {0,2}, {1,2}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,2}, {0,2}, {1,2}}));
}
/* Check minimal lifetime for registers only written to */
TEST_F(LifetimeEvaluatorExactTest, OverwriteWrittenOnlyTemps)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV , {1}, {in0}, {}},
{ TGSI_OPCODE_MOV , {2}, {in1}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,1}, {1,2}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,1}, {1,2}}));
}
/* Same register is only written twice. This should not happen,
@@ -1154,12 +1042,12 @@ TEST_F(LifetimeEvaluatorExactTest, OverwriteWrittenOnlyTemps)
*/
TEST_F(LifetimeEvaluatorExactTest, WriteOnlyTwiceSame)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,2}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,2}}));
}
/* Dead code elimination should catch and remove the case
@@ -1171,14 +1059,14 @@ TEST_F(LifetimeEvaluatorExactTest, WriteOnlyTwiceSame)
*/
TEST_F(LifetimeEvaluatorExactTest, WritePastLastRead)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_MOV, {1}, {in0}, {}},
{ TGSI_OPCODE_MOV, {2}, {1}, {}},
{ TGSI_OPCODE_MOV, {1}, {2}, {}},
{ TGSI_OPCODE_END},
};
- run (code, expectation({{-1,-1}, {0,3}, {1,2}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,3}, {1,2}}));
}
/* If a break is in the loop, all variables written after the
@@ -1187,7 +1075,7 @@ TEST_F(LifetimeEvaluatorExactTest, WritePastLastRead)
*/
TEST_F(LifetimeEvaluatorExactTest, NestedLoopWithWriteAfterBreak)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_BGNLOOP },
{ TGSI_OPCODE_IF, {}, {in0}, {}},
@@ -1199,7 +1087,7 @@ TEST_F(LifetimeEvaluatorExactTest, NestedLoopWithWriteAfterBreak)
{ TGSI_OPCODE_ENDLOOP },
{ TGSI_OPCODE_END}
};
- run (code, expectation({{-1,-1}, {0,8}}));
+ run (code, temp_lt_expect({{-1,-1}, {0,8}}));
}
/* Test remapping table of registers. The tests don't assume
@@ -1273,7 +1161,7 @@ TEST_F(RegisterRemappingTest, RegisterRemappingMergeZeroLifetimeRegisters)
TEST_F(RegisterLifetimeAndRemappingTest, LifetimeAndRemapping)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{TGSI_OPCODE_USEQ, {5}, {in0,in1}, {}},
{TGSI_OPCODE_UCMP, {1}, {5,in1,1}, {}},
{TGSI_OPCODE_UCMP, {1}, {5,in1,1}, {}},
@@ -1295,7 +1183,7 @@ TEST_F(RegisterLifetimeAndRemappingTest, LifetimeAndRemapping)
TEST_F(RegisterLifetimeAndRemappingTest, LifetimeAndRemappingWithUnusedReadOnlyIgnored)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{TGSI_OPCODE_USEQ, {1}, {in0,in1}, {}},
{TGSI_OPCODE_UCMP, {2}, {1,in1,2}, {}},
{TGSI_OPCODE_UCMP, {4}, {2,in1,1}, {}},
@@ -1312,7 +1200,7 @@ TEST_F(RegisterLifetimeAndRemappingTest, LifetimeAndRemappingWithUnusedReadOnlyI
TEST_F(RegisterLifetimeAndRemappingTest, LifetimeAndRemappingWithUnusedReadOnlyRemappedTo)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{TGSI_OPCODE_USEQ, {1}, {in0,in1}, {}},
{TGSI_OPCODE_UIF, {}, {7}, {}},
{ TGSI_OPCODE_UCMP, {2}, {1,in1,2}, {}},
@@ -1329,7 +1217,7 @@ TEST_F(RegisterLifetimeAndRemappingTest, LifetimeAndRemappingWithUnusedReadOnlyR
TEST_F(RegisterLifetimeAndRemappingTest, LifetimeAndRemappingWithUnusedReadOnlyRemapped)
{
- const vector<MockCodeline> code = {
+ const vector<FakeCodeline> code = {
{TGSI_OPCODE_USEQ, {0}, {in0,in1}, {}},
{TGSI_OPCODE_UCMP, {2}, {0,in1,2}, {}},
{TGSI_OPCODE_UCMP, {4}, {2,in1,0}, {}},
@@ -1343,267 +1231,3 @@ TEST_F(RegisterLifetimeAndRemappingTest, LifetimeAndRemappingWithUnusedReadOnlyR
/* lt: 0: 0-2 1: u 2: 1-2 3: u 4: 2-5 5: 4-5 6: u 7:ro 8: 5-7 */
run (code, vector<int>({0,1,2,3,0,2,6,7,0}));
}
-
-/* Implementation of helper and test classes */
-MockShader::~MockShader()
-{
- free();
- ralloc_free(mem_ctx);
-}
-
-MockShader::MockShader(const vector<MockCodelineWithSwizzle>& source):
- num_temps(0)
-{
- mem_ctx = ralloc_context(NULL);
-
- program = new(mem_ctx) exec_list();
-
- for (MockCodelineWithSwizzle i: source) {
- glsl_to_tgsi_instruction *next_instr = new(mem_ctx) glsl_to_tgsi_instruction();
- next_instr->op = i.op;
- next_instr->info = tgsi_get_opcode_info(i.op);
-
- assert(i.src.size() < 4);
- assert(i.dst.size() < 3);
- assert(i.tex_offsets.size() < 3);
-
- for (unsigned k = 0; k < i.src.size(); ++k) {
- next_instr->src[k] = create_src_register(i.src[k].first, i.src[k].second);
- }
- for (unsigned k = 0; k < i.dst.size(); ++k) {
- next_instr->dst[k] = create_dst_register(i.dst[k].first, i.dst[k].second);
- }
- next_instr->tex_offset_num_offset = i.tex_offsets.size();
- if (next_instr->tex_offset_num_offset > 0) {
- next_instr->tex_offsets = new st_src_reg[i.tex_offsets.size()];
- for (unsigned k = 0; k < i.tex_offsets.size(); ++k) {
- next_instr->tex_offsets[k] = create_src_register(i.tex_offsets[k].first,
- i.tex_offsets[k].second);
- }
- } else {
- next_instr->tex_offsets = nullptr;
- }
- program->push_tail(next_instr);
- }
- ++num_temps;
-}
-
-MockShader::MockShader(const vector<MockCodeline>& source):
- num_temps(0)
-{
- mem_ctx = ralloc_context(NULL);
-
- program = new(mem_ctx) exec_list();
-
- for (MockCodeline i: source) {
- glsl_to_tgsi_instruction *next_instr = new(mem_ctx) glsl_to_tgsi_instruction();
- next_instr->op = i.op;
- next_instr->info = tgsi_get_opcode_info(i.op);
-
- assert(i.src.size() < 4);
- assert(i.dst.size() < 3);
- assert(i.tex_offsets.size() < 3);
-
- for (unsigned k = 0; k < i.src.size(); ++k) {
- next_instr->src[k] = create_src_register(i.src[k]);
- }
- for (unsigned k = 0; k < i.dst.size(); ++k) {
- next_instr->dst[k] = create_dst_register(i.dst[k]);
- }
- next_instr->tex_offset_num_offset = i.tex_offsets.size();
- if (next_instr->tex_offset_num_offset > 0) {
- next_instr->tex_offsets = new st_src_reg[i.tex_offsets.size()];
- for (unsigned k = 0; k < i.tex_offsets.size(); ++k) {
- next_instr->tex_offsets[k] = create_src_register(i.tex_offsets[k]);
- }
- } else {
- next_instr->tex_offsets = nullptr;
- }
-
- program->push_tail(next_instr);
- }
- ++num_temps;
-}
-
-int MockShader::get_num_temps() const
-{
- return num_temps;
-}
-
-
-exec_list* MockShader::get_program() const
-{
- return program;
-}
-
-void MockShader::free()
-{
- /* The list is not fully initialized, so
- * tearing it down also must be done manually. */
- exec_node *p;
- while ((p = program->pop_head())) {
- glsl_to_tgsi_instruction * instr = static_cast<glsl_to_tgsi_instruction *>(p);
- if (instr->tex_offset_num_offset > 0)
- delete[] instr->tex_offsets;
- delete p;
- }
- program = 0;
- num_temps = 0;
-}
-
-st_src_reg MockShader::create_src_register(int src_idx)
-{
- gl_register_file file;
- int idx = 0;
- if (src_idx >= 0) {
- file = PROGRAM_TEMPORARY;
- idx = src_idx;
- if (num_temps < idx)
- num_temps = idx;
- } else {
- file = PROGRAM_INPUT;
- idx = 1 - src_idx;
- }
- return st_src_reg(file, idx, GLSL_TYPE_INT);
-}
-
-st_src_reg MockShader::create_src_register(int src_idx, const char *sw)
-{
- uint16_t swizzle = 0;
- for (int i = 0; i < 4; ++i) {
- switch (sw[i]) {
- case 'x': break; /* is zero */
- case 'y': swizzle |= SWIZZLE_Y << 3 * i; break;
- case 'z': swizzle |= SWIZZLE_Z << 3 * i; break;
- case 'w': swizzle |= SWIZZLE_W << 3 * i; break;
- }
- }
-
- gl_register_file file;
- int idx = 0;
- if (src_idx >= 0) {
- file = PROGRAM_TEMPORARY;
- idx = src_idx;
- if (num_temps < idx)
- num_temps = idx;
- } else {
- file = PROGRAM_INPUT;
- idx = 1 - src_idx;
- }
- st_src_reg result(file, idx, GLSL_TYPE_INT);
- result.swizzle = swizzle;
- return result;
-}
-
-st_dst_reg MockShader::create_dst_register(int dst_idx,int writemask)
-{
- gl_register_file file;
- int idx = 0;
- if (dst_idx >= 0) {
- file = PROGRAM_TEMPORARY;
- idx = dst_idx;
- if (num_temps < idx)
- num_temps = idx;
- } else {
- file = PROGRAM_OUTPUT;
- idx = 1 - dst_idx;
- }
- return st_dst_reg(file, writemask, GLSL_TYPE_INT, idx);
-}
-
-st_dst_reg MockShader::create_dst_register(int dst_idx)
-{
- gl_register_file file;
- int idx = 0;
- if (dst_idx >= 0) {
- file = PROGRAM_TEMPORARY;
- idx = dst_idx;
- if (num_temps < idx)
- num_temps = idx;
- } else {
- file = PROGRAM_OUTPUT;
- idx = 1 - dst_idx;
- }
- return st_dst_reg(file,0xF, GLSL_TYPE_INT, idx);
-}
-
-
-void MesaTestWithMemCtx::SetUp()
-{
- mem_ctx = ralloc_context(nullptr);
-}
-
-void MesaTestWithMemCtx::TearDown()
-{
- ralloc_free(mem_ctx);
- mem_ctx = nullptr;
-}
-
-void LifetimeEvaluatorTest::run(const vector<MockCodeline>& code, const expectation& e)
-{
- MockShader shader(code);
- std::vector<lifetime> result(shader.get_num_temps());
-
- bool success =
- get_temp_registers_required_lifetimes(mem_ctx, shader.get_program(),
- shader.get_num_temps(), &result[0]);
-
- ASSERT_TRUE(success);
- ASSERT_EQ(result.size(), e.size());
- check(result, e);
-}
-
-void LifetimeEvaluatorTest::run(const vector<MockCodelineWithSwizzle>& code,
- const expectation& e)
-{
- MockShader shader(code);
- std::vector<lifetime> result(shader.get_num_temps());
-
- bool success =
- get_temp_registers_required_lifetimes(mem_ctx, shader.get_program(),
- shader.get_num_temps(), &result[0]);
- ASSERT_TRUE(success);
- ASSERT_EQ(result.size(), e.size());
- check(result, e);
-}
-
-void LifetimeEvaluatorExactTest::check( const vector<lifetime>& lifetimes,
- const expectation& e)
-{
- for (unsigned i = 1; i < lifetimes.size(); ++i) {
- EXPECT_EQ(lifetimes[i].begin, e[i][0]);
- EXPECT_EQ(lifetimes[i].end, e[i][1]);
- }
-}
-
-void LifetimeEvaluatorAtLeastTest::check( const vector<lifetime>& lifetimes,
- const expectation& e)
-{
- for (unsigned i = 1; i < lifetimes.size(); ++i) {
- EXPECT_LE(lifetimes[i].begin, e[i][0]);
- EXPECT_GE(lifetimes[i].end, e[i][1]);
- }
-}
-
-void RegisterRemappingTest::run(const vector<lifetime>& lt,
- const vector<int>& expect)
-{
- rename_reg_pair proto{false,0};
- vector<rename_reg_pair> result(lt.size(), proto);
-
- get_temp_registers_remapping(mem_ctx, lt.size(), <[0], &result[0]);
-
- vector<int> remap(lt.size());
- for (unsigned i = 0; i < lt.size(); ++i) {
- remap[i] = result[i].valid ? result[i].new_reg : i;
- }
-
- std::transform(remap.begin(), remap.end(), result.begin(), remap.begin(),
- [](int x, const rename_reg_pair& rn) {
- return rn.valid ? rn.new_reg : x;
- });
-
- for(unsigned i = 1; i < remap.size(); ++i) {
- EXPECT_EQ(remap[i], expect[i]);
- }
-}
--
2.13.6
More information about the mesa-dev
mailing list