[Mesa-dev] [PATCH v5 5/6] mesa/st: glsl_to_tgsi: Add test set for evaluation of rename mapping

[Nicolai Hähnle]

On 25.06.2017 09:22, Gert Wollny wrote:
> The patch adds tests for the register rename mapping evaluation.
> ---
>   .../tests/test_glsl_to_tgsi_lifetime.cpp           | 94 ++++++++++++++++++++++
>   1 file changed, 94 insertions(+)
> 
> 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 5f3378637a..f53b5c23a1 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
> @@ -89,6 +89,13 @@ protected:
>      void check(const vector<lifetime>& result, const expectation& e);
>   };
>   
> +/* With this test class the renaming mepping estimation is tested */
> +class RegisterRemapping : public MesaTestWithMemCtx {
> +protected:
> +   void run(const vector<lifetime>& lt, const vector<int>& expect);
> +};
> +
> +
>   /* 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
> @@ -466,6 +473,29 @@ TEST_F(LifetimeEvaluatorExactTest, LoopWithReadWriteInSwitchDifferentCase)
>      run (code, expectation({{-1,-1},{0, 9}}));
>   }
>   
> +/* Here we read and write to the same temp, but it is conditional,
> + * so the lifetime must start with the first read */
> +TEST_F(LifetimeEvaluatorExactTest, WriteConditionallyFromSelf)
> +{
> +   const vector<MockCodeline> code = {
> +      {TGSI_OPCODE_USEQ, {0}, {in0, in1}, {}},
> +      {TGSI_OPCODE_UCMP, {1}, {0, in1, 1},  {}},
> +      {TGSI_OPCODE_UCMP, {1}, {0, in1, 1},  {}},
> +      {TGSI_OPCODE_UCMP, {1}, {0, in1, 1},  {}},
> +      {TGSI_OPCODE_UCMP, {1}, {0, in1, 1},  {}},
> +      {TGSI_OPCODE_FSLT, {2}, {1, in1},  {}},
> +      {TGSI_OPCODE_UIF, {2},  {},  {}},

Shouldn't 2 be a src here?


> +      {TGSI_OPCODE_MOV, {3},  {in1}, {}},
> +      {TGSI_OPCODE_ELSE},
> +      {TGSI_OPCODE_MOV, {4}, {in1}, {}},
> +      {TGSI_OPCODE_MOV, {4}, {4}, {}},
> +      {TGSI_OPCODE_MOV, {3}, {4}, {}},
> +      {TGSI_OPCODE_ENDIF},
> +      {TGSI_OPCODE_MOV,{out1}, {3}, {}},
> +      {TGSI_OPCODE_END}
> +   };
> +   run (code, expectation({{-1,-1},{1, 5}, {5, 6}, {7, 13}, {9, 11}}));

How can this work? The lifetime of 0 should be {0, 4}.


> +}
>   
>   TEST_F(LifetimeEvaluatorExactTest, LoopRWInSwitchCaseLastCaseWithoutBreak)
>   {
> @@ -831,6 +861,47 @@ TEST_F(LifetimeEvaluatorExactTest, NestedLoopWithWriteAfterBreak)
>      run (code, expectation({{-1,-1},{0, 8}}));
>   }
>   
> +TEST_F(RegisterRemapping, RegisterRemapping1)
> +{
> +   vector<lifetime> lt({{-1,-1},
> +                        {0, 1},
> +                        {0, 2},
> +                        {1, 2},
> +                        {2, 10},
> +                        {3, 5},
> +                        {5, 10}
> +                       });
> +
> +   vector<int> expect({0, 1, 2, 1, 1, 2, 2});
> +   run(lt, expect);
> +}
> +
> +
> +TEST_F(RegisterRemapping, RegisterRemapping2)
> +{
> +   vector<lifetime> lt({{-1,-1},
> +                        {0, 1},
> +                        {0, 2},
> +                        {3, 3},
> +                        {4, 4},

Is {3, 3} ever a legitimate lifetime?

Cheers,
Nicolai


> +                       });
> +   vector<int> expect({0, 1, 2, 1, 1});
> +   run(lt, expect);
> +}
> +
> +TEST_F(RegisterRemapping, RegisterRemappingMergeAll)
> +{
> +   vector<lifetime> lt({{-1,-1},
> +                        {0, 1},
> +                        {1, 2},
> +                        {2, 3},
> +                        {3, 4},
> +                       });
> +   vector<int> expect({0, 1, 1, 1, 1});
> +   run(lt, expect);
> +}
> +
> +
>   /* Implementation of helper and test classes */
>   
>   MockShader::~MockShader()
> @@ -974,3 +1045,26 @@ void LifetimeEvaluatorAtLeastTest::check( const vector<lifetime>& lifetimes,
>         EXPECT_GE(lifetimes[i].end, e[i][1]);
>      }
>   }
> +
> +void RegisterRemapping::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(), &lt[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]);
> +   }
> +}
> 


-- 
Lerne, wie die Welt wirklich ist,
Aber vergiss niemals, wie sie sein sollte.