[Mesa-dev] [PATCH v3 04/13] mesa/st/glsl_to_tgsi:rename lifetime to register_live_range
Nicolai Hähnle
nhaehnle at gmail.com
Tue May 1 10:04:05 UTC 2018
On 28.04.2018 21:30, Gert Wollny wrote:
> On one hand "live range" is the term used in the literature, and on the
> other hand a distinction is needed from the array live ranges.
>
> Signed-off-by: Gert Wollny <gw.fossdev at gmail.com>
> ---
> src/mesa/state_tracker/st_glsl_to_tgsi.cpp | 16 ++---
> .../state_tracker/st_glsl_to_tgsi_temprename.cpp | 78 +++++++++++-----------
> .../state_tracker/st_glsl_to_tgsi_temprename.h | 36 +++++-----
> src/mesa/state_tracker/tests/st_tests_common.cpp | 16 +++--
> src/mesa/state_tracker/tests/st_tests_common.h | 13 ++--
> .../tests/test_glsl_to_tgsi_lifetime.cpp | 10 +--
> 6 files changed, 88 insertions(+), 81 deletions(-)
>
> diff --git a/src/mesa/state_tracker/st_glsl_to_tgsi.cpp b/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
> index e778807b7c..a390dd0b74 100644
> --- a/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
> +++ b/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
> @@ -5513,19 +5513,19 @@ glsl_to_tgsi_visitor::split_arrays(void)
> void
> glsl_to_tgsi_visitor::merge_registers(void)
> {
> - struct lifetime *lifetimes =
> - rzalloc_array(mem_ctx, struct lifetime, this->next_temp);
> + struct register_live_range *reg_live_ranges =
> + rzalloc_array(mem_ctx, struct register_live_range, this->next_temp);
>
> - if (get_temp_registers_required_lifetimes(mem_ctx, &this->instructions,
> - this->next_temp, lifetimes)) {
> + if (get_temp_registers_required_live_ranges(reg_live_ranges, &this->instructions,
> + this->next_temp, reg_live_ranges)) {
> struct rename_reg_pair *renames =
> - rzalloc_array(mem_ctx, struct rename_reg_pair, this->next_temp);
> - get_temp_registers_remapping(mem_ctx, this->next_temp, lifetimes, renames);
> + rzalloc_array(reg_live_ranges, struct rename_reg_pair, this->next_temp);
> + get_temp_registers_remapping(reg_live_ranges, this->next_temp,
> + reg_live_ranges, renames);
> rename_temp_registers(renames);
> ralloc_free(renames);
> }
> -
> - ralloc_free(lifetimes);
> + ralloc_free(reg_live_ranges);
> }
>
> /* Reassign indices to temporary registers by reusing unused indices created
> diff --git a/src/mesa/state_tracker/st_glsl_to_tgsi_temprename.cpp b/src/mesa/state_tracker/st_glsl_to_tgsi_temprename.cpp
> index 56f812c8bf..f000fc89a0 100644
> --- a/src/mesa/state_tracker/st_glsl_to_tgsi_temprename.cpp
> +++ b/src/mesa/state_tracker/st_glsl_to_tgsi_temprename.cpp
> @@ -154,9 +154,9 @@ public:
>
> void record_read(int line, prog_scope *scope);
> void record_write(int line, prog_scope *scope);
> - lifetime get_required_lifetime();
> + register_live_range get_required_live_range();
> private:
> - void propagate_lifetime_to_dominant_write_scope();
> + void propagate_live_range_to_dominant_write_scope();
> bool conditional_ifelse_write_in_loop() const;
>
> void record_ifelse_write(const prog_scope& scope);
> @@ -230,7 +230,7 @@ public:
> temp_access();
> void record_read(int line, prog_scope *scope, int swizzle);
> void record_write(int line, prog_scope *scope, int writemask);
> - lifetime get_required_lifetime();
> + register_live_range get_required_live_range();
> private:
> void update_access_mask(int mask);
>
> @@ -513,22 +513,22 @@ void temp_access::record_read(int line, prog_scope *scope, int swizzle)
> comp[3].record_read(line, scope);
> }
>
> -inline static lifetime make_lifetime(int b, int e)
> +inline static register_live_range make_live_range(int b, int e)
> {
> - lifetime lt;
> + register_live_range lt;
> lt.begin = b;
> lt.end = e;
> return lt;
> }
>
> -lifetime temp_access::get_required_lifetime()
> +register_live_range temp_access::get_required_live_range()
> {
> - lifetime result = make_lifetime(-1, -1);
> + register_live_range result = make_live_range(-1, -1);
>
> unsigned mask = access_mask;
> while (mask) {
> unsigned chan = u_bit_scan(&mask);
> - lifetime lt = comp[chan].get_required_lifetime();
> + register_live_range lt = comp[chan].get_required_live_range();
>
> if (lt.begin >= 0) {
> if ((result.begin < 0) || (result.begin > lt.begin))
> @@ -780,7 +780,7 @@ bool temp_comp_access::conditional_ifelse_write_in_loop() const
> return conditionality_in_loop_id <= conditionality_unresolved;
> }
>
> -void temp_comp_access::propagate_lifetime_to_dominant_write_scope()
> +void temp_comp_access::propagate_live_range_to_dominant_write_scope()
> {
> first_write = first_write_scope->begin();
> int lr = first_write_scope->end();
> @@ -789,7 +789,7 @@ void temp_comp_access::propagate_lifetime_to_dominant_write_scope()
> last_read = lr;
> }
>
> -lifetime temp_comp_access::get_required_lifetime()
> +register_live_range temp_comp_access::get_required_live_range()
> {
> bool keep_for_full_loop = false;
>
> @@ -799,7 +799,7 @@ lifetime temp_comp_access::get_required_lifetime()
> * eliminating registers that are not written to.
> */
> if (last_write < 0)
> - return make_lifetime(-1, -1);
> + return make_live_range(-1, -1);
>
> assert(first_write_scope);
>
> @@ -807,7 +807,7 @@ lifetime temp_comp_access::get_required_lifetime()
> * reused in the range it is used to write to
> */
> if (!last_read_scope)
> - return make_lifetime(first_write, last_write + 1);
> + return make_live_range(first_write, last_write + 1);
>
> const prog_scope *enclosing_scope_first_read = first_read_scope;
> const prog_scope *enclosing_scope_first_write = first_write_scope;
> @@ -851,7 +851,7 @@ lifetime temp_comp_access::get_required_lifetime()
> /* Propagate the last read scope to the target scope */
> while (enclosing_scope->nesting_depth() < last_read_scope->nesting_depth()) {
> /* If the read is in a loop and we have to move up the scope we need to
> - * extend the life time to the end of this current loop because at this
> + * extend the live range to the end of this current loop because at this
> * point we don't know whether the component was written before
> * un-conditionally in the same loop.
> */
> @@ -862,42 +862,42 @@ lifetime temp_comp_access::get_required_lifetime()
> }
>
> /* If the variable has to be kept for the whole loop, and we
> - * are currently in a loop, then propagate the life time.
> + * are currently in a loop, then propagate the live range.
> */
> if (keep_for_full_loop && first_write_scope->is_loop())
> - propagate_lifetime_to_dominant_write_scope();
> + propagate_live_range_to_dominant_write_scope();
>
> /* Propagate the first_dominant_write scope to the target scope */
> while (enclosing_scope->nesting_depth() < first_write_scope->nesting_depth()) {
> - /* Propagate lifetime if there was a break in a loop and the write was
> + /* Propagate live_range if there was a break in a loop and the write was
> * after the break inside that loop. Note, that this is only needed if
> * we move up in the scopes.
> */
> if (first_write_scope->loop_break_line() < first_write) {
> keep_for_full_loop = true;
> - propagate_lifetime_to_dominant_write_scope();
> + propagate_live_range_to_dominant_write_scope();
> }
>
> first_write_scope = first_write_scope->parent();
>
> - /* Propagte lifetime if we are now in a loop */
> + /* Propagte live_range if we are now in a loop */
> if (keep_for_full_loop && first_write_scope->is_loop())
> - propagate_lifetime_to_dominant_write_scope();
> + propagate_live_range_to_dominant_write_scope();
> }
>
> /* The last write past the last read is dead code, but we have to
> * ensure that the component is not reused too early, hence extend the
> - * lifetime past the last write.
> + * live_range past the last write.
> */
> if (last_write >= last_read)
> last_read = last_write + 1;
>
> /* Here we are at the same scope, all is resolved */
> - return make_lifetime(first_write, last_read);
> + return make_live_range(first_write, last_read);
> }
>
> /* Helper class for sorting and searching the registers based
> - * on life times. */
> + * on live ranges. */
> class access_record {
> public:
> int begin;
> @@ -918,7 +918,7 @@ public:
> void record_read(const st_src_reg& src, int line, prog_scope *scope);
> void record_write(const st_dst_reg& src, int line, prog_scope *scope);
>
> - void get_required_lifetimes(struct lifetime *lifetimes);
> + void get_required_live_ranges(register_live_range *live_ranges);
> private:
>
> int ntemps;
> @@ -961,14 +961,14 @@ void access_recorder::record_write(const st_dst_reg& dst, int line,
> record_read(*dst.reladdr2, line, scope);
> }
>
> -void access_recorder::get_required_lifetimes(struct lifetime *lifetimes)
> +void access_recorder::get_required_live_ranges(struct register_live_range *live_ranges)
> {
> - RENAME_DEBUG(debug_log << "========= lifetimes ==============\n");
> + RENAME_DEBUG(debug_log << "=========live_ranges ==============\n");
> for(int i = 0; i < ntemps; ++i) {
> RENAME_DEBUG(debug_log<< setw(4) << i);
> - lifetimes[i] = acc[i].get_required_lifetime();
> - RENAME_DEBUG(debug_log << ": [" << lifetimes[i].begin << ", "
> - << lifetimes[i].end << "]\n");
> + live_ranges[i] = acc[i].get_required_live_range();
> + RENAME_DEBUG(debug_log << ": [" <<live_ranges[i].begin << ", "
> + <<live_ranges[i].end << "]\n");
Inconsistent indentation, and please keep spaces around operators (<<).
Apart from that:
Reviewed-by: Nicolai Hähnle <nicolai.haehnle at amd.com>
> }
> RENAME_DEBUG(debug_log << "==================================\n\n");
> }
> @@ -981,12 +981,12 @@ static void dump_instruction(ostream& os, int line, prog_scope *scope,
> const glsl_to_tgsi_instruction& inst);
> #endif
>
> -/* Scan the program and estimate the required register life times.
> - * The array lifetimes must be pre-allocated
> +/* Scan the program and estimate the required register live ranges.
> + * The arraylive_ranges must be pre-allocated
> */
> bool
> -get_temp_registers_required_lifetimes(void *mem_ctx, exec_list *instructions,
> - int ntemps, struct lifetime *lifetimes)
> +get_temp_registers_required_live_ranges(void *mem_ctx, exec_list *instructions,
> + int ntemps, struct register_live_range *live_ranges)
> {
> int line = 0;
> int loop_id = 1;
> @@ -1124,7 +1124,7 @@ get_temp_registers_required_lifetimes(void *mem_ctx, exec_list *instructions,
> case TGSI_OPCODE_CAL:
> case TGSI_OPCODE_RET:
> /* These opcodes are not supported and if a subroutine would
> - * be called in a shader, then the lifetime tracking would have
> + * be called in a shader, then the live_range tracking would have
> * to follow that call to see which registers are used there.
> * Since this is not done, we have to bail out here and signal
> * that no register merge will take place.
> @@ -1153,11 +1153,11 @@ get_temp_registers_required_lifetimes(void *mem_ctx, exec_list *instructions,
> if (cur_scope->end() < 0)
> cur_scope->set_end(line - 1);
>
> - access.get_required_lifetimes(lifetimes);
> + access.get_required_live_ranges(live_ranges);
> return true;
> }
>
> -/* Find the next register between [start, end) that has a life time starting
> +/* Find the next register between [start, end) that has a live range starting
> * at or after bound by using a binary search.
> * start points at the beginning of the search range,
> * end points at the element past the end of the search range, and
> @@ -1195,16 +1195,16 @@ static int access_record_compare (const void *a, const void *b) {
> /* This functions evaluates the register merges by using a binary
> * search to find suitable merge candidates. */
> void get_temp_registers_remapping(void *mem_ctx, int ntemps,
> - const struct lifetime* lifetimes,
> + const struct register_live_range *live_ranges,
> struct rename_reg_pair *result)
> {
> access_record *reg_access = ralloc_array(mem_ctx, access_record, ntemps);
>
> int used_temps = 0;
> for (int i = 0; i < ntemps; ++i) {
> - if (lifetimes[i].begin >= 0) {
> - reg_access[used_temps].begin = lifetimes[i].begin;
> - reg_access[used_temps].end = lifetimes[i].end;
> + if (live_ranges[i].begin >= 0) {
> + reg_access[used_temps].begin =live_ranges[i].begin;
> + reg_access[used_temps].end =live_ranges[i].end;
> reg_access[used_temps].reg = i;
> reg_access[used_temps].erase = false;
> ++used_temps;
> diff --git a/src/mesa/state_tracker/st_glsl_to_tgsi_temprename.h b/src/mesa/state_tracker/st_glsl_to_tgsi_temprename.h
> index 3f21b1317a..375d5b88ec 100644
> --- a/src/mesa/state_tracker/st_glsl_to_tgsi_temprename.h
> +++ b/src/mesa/state_tracker/st_glsl_to_tgsi_temprename.h
> @@ -26,46 +26,48 @@
>
> #include "st_glsl_to_tgsi_private.h"
>
> -/** Storage to record the required life time of a temporary register
> +/** Storage to record the required live range of a temporary register
> * begin == end == -1 indicates that the register can be reused without
> * limitations. Otherwise, "begin" indicates the first instruction in which
> * a write operation may target this temporary, and end indicates the
> * last instruction in which a value can be read from this temporary.
> * Hence, a register R2 can be merged with a register R1 if R1.end <= R2.begin.
> */
> -struct lifetime {
> +struct register_live_range {
> int begin;
> int end;
> };
>
> -/** Evaluates the required life times of temporary registers in a shader.
> - * The life time estimation can only be run sucessfully if the shader doesn't
> +/** Evaluates the required live ranges of temporary registers in a shader.
> + * The live range estimation can only be run sucessfully if the shader doesn't
> * call a subroutine.
> - * @param[in] mem_ctx a memory context that can be used with the ralloc_* functions
> + * @param[in] mem_ctx a memory context that can be used with the ralloc_*
> + * functions
> * @param[in] instructions the shader to be anlzyed
> * @param[in] ntemps number of temporaries reserved for this shader
> - * @param[in,out] lifetimes memory location to store the estimated required
> - * life times for each temporary register. The parameter must point to
> - * allocated memory that can hold ntemps lifetime structures. On output
> - * the life times contains the life times for the registers with the
> - * exception of TEMP[0].
> + * @param[in,out] reg_live_ranges memory location to store the estimated
> + * required live ranges for each temporary register. The parameter must
> + * point to allocated memory that can hold ntemps register_live_range
> + * structures. On output the live ranges contains the live ranges for
> + * the registers with the exception of TEMP[0]
> * @returns: true if the lifetimes were estimated, false if not (i.e. if a
> * subroutine was called).
> */
> bool
> -get_temp_registers_required_lifetimes(void *mem_ctx, exec_list *instructions,
> - int ntemps, struct lifetime *lifetimes);
> +get_temp_registers_required_live_ranges(void *mem_ctx, exec_list *instructions,
> + int ntemps, struct register_live_range *live_ranges);
> +
> /** Estimate the merge remapping of the registers.
> - * @param[in] mem_ctx a memory context that can be used with the ralloc_* functions
> + * @param[in] mem_ctx a memory context that can be used with the ralloc_*
> + * functions
> * @param[in] ntemps number of temporaries reserved for this shader
> - * @param[in] lifetimes required life time for each temporary register.
> + * @param[in] reg_live_ranges required live range for each temporary register.
> * @param[in,out] result memory location to store the register remapping table.
> * On input the parameter must point to allocated memory that can hold the
> * renaming information for ntemps registers, on output the mapping is stored.
> * Note that TEMP[0] is not considered for register renaming.
> */
> void get_temp_registers_remapping(void *mem_ctx, int ntemps,
> - const struct lifetime* lifetimes,
> - struct rename_reg_pair *result);
> -
> + const struct register_live_range* reg_live_ranges,
> + struct rename_reg_pair *result);
> #endif
> \ No newline at end of file
> diff --git a/src/mesa/state_tracker/tests/st_tests_common.cpp b/src/mesa/state_tracker/tests/st_tests_common.cpp
> index 63e3d6b2c4..375d058e77 100644
> --- a/src/mesa/state_tracker/tests/st_tests_common.cpp
> +++ b/src/mesa/state_tracker/tests/st_tests_common.cpp
> @@ -411,7 +411,7 @@ LifetimeEvaluatorTest::run(const vector<FakeCodeline>& code, bool& success)
> lifetime_result result(shader.get_num_temps());
>
> success =
> - get_temp_registers_required_lifetimes(mem_ctx, shader.get_program(mem_ctx),
> + get_temp_registers_required_live_ranges(mem_ctx, shader.get_program(mem_ctx),
> shader.get_num_temps(),
> &result[0]);
>
> @@ -422,8 +422,9 @@ void LifetimeEvaluatorTest::run(const vector<FakeCodeline>& code, const temp_lt_
> {
> FakeShader shader(code);
> lifetime_result result(shader.get_num_temps());
> +
> bool success =
> - get_temp_registers_required_lifetimes(mem_ctx, shader.get_program(mem_ctx),
> + get_temp_registers_required_live_ranges(mem_ctx, shader.get_program(mem_ctx),
> shader.get_num_temps(),
> &result[0]);
> ASSERT_TRUE(success);
> @@ -431,7 +432,7 @@ void LifetimeEvaluatorTest::run(const vector<FakeCodeline>& code, const temp_lt_
> check(result, e);
> }
>
> -void LifetimeEvaluatorExactTest::check( const vector<lifetime>& lifetimes,
> +void LifetimeEvaluatorExactTest::check( const vector<register_live_range>& lifetimes,
> const temp_lt_expect& e)
> {
> for (unsigned i = 1; i < lifetimes.size(); ++i) {
> @@ -440,7 +441,7 @@ void LifetimeEvaluatorExactTest::check( const vector<lifetime>& lifetimes,
> }
> }
>
> -void LifetimeEvaluatorAtLeastTest::check( const vector<lifetime>& lifetimes,
> +void LifetimeEvaluatorAtLeastTest::check( const vector<register_live_range>& lifetimes,
> const temp_lt_expect& e)
> {
> for (unsigned i = 1; i < lifetimes.size(); ++i) {
> @@ -449,7 +450,7 @@ void LifetimeEvaluatorAtLeastTest::check( const vector<lifetime>& lifetimes,
> }
> }
>
> -void RegisterRemappingTest::run(const vector<lifetime>& lt,
> +void RegisterRemappingTest::run(const vector<register_live_range>& lt,
> const vector<int>& expect)
> {
> rename_reg_pair proto{false,0};
> @@ -476,8 +477,9 @@ 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),
> + std::vector<register_live_range> lt(shader.get_num_temps());
> +
> + get_temp_registers_required_live_ranges(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
> index 6d855fe581..03baf50753 100644
> --- a/src/mesa/state_tracker/tests/st_tests_common.h
> +++ b/src/mesa/state_tracker/tests/st_tests_common.h
> @@ -131,17 +131,19 @@ class LifetimeEvaluatorTest : public MesaTestWithMemCtx {
> protected:
> void run(const std::vector<FakeCodeline>& code, const temp_lt_expect& e);
> private:
> - using lifetime_result=std::vector<lifetime>;
> + using lifetime_result=std::vector<register_live_range>;
> lifetime_result run(const std::vector<FakeCodeline>& code, bool& success);
>
> - virtual void check(const std::vector<lifetime>& result, const temp_lt_expect& e) = 0;
> + virtual void check(const std::vector<register_live_range>& 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);
> + void check(const std::vector<register_live_range>& result,
> + const temp_lt_expect& e);
>
> };
>
> @@ -152,13 +154,14 @@ protected:
> */
> class LifetimeEvaluatorAtLeastTest : public LifetimeEvaluatorTest {
> protected:
> - void check(const std::vector<lifetime>& result, const temp_lt_expect& e);
> + void check(const std::vector<register_live_range>& 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);
> + void run(const std::vector<register_live_range>& lt,
> + const std::vector<int> &expect);
> };
>
> /* With this test class the combined lifetime estimation and renaming
> 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 a9655379ee..10fd0fc65b 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
> @@ -1707,7 +1707,7 @@ TEST_F(LifetimeEvaluatorExactTest, WriteIndirectReladdr2)
> */
> TEST_F(RegisterRemappingTest, RegisterRemapping1)
> {
> - vector<lifetime> lt({{-1,-1},
> + vector<register_live_range> lt({{-1,-1},
> {0,1},
> {0,2},
> {1,2},
> @@ -1722,7 +1722,7 @@ TEST_F(RegisterRemappingTest, RegisterRemapping1)
>
> TEST_F(RegisterRemappingTest, RegisterRemapping2)
> {
> - vector<lifetime> lt({{-1,-1},
> + vector<register_live_range> lt({{-1,-1},
> {0,1},
> {0,2},
> {3,4},
> @@ -1734,7 +1734,7 @@ TEST_F(RegisterRemappingTest, RegisterRemapping2)
>
> TEST_F(RegisterRemappingTest, RegisterRemappingMergeAllToOne)
> {
> - vector<lifetime> lt({{-1,-1},
> + vector<register_live_range> lt({{-1,-1},
> {0,1},
> {1,2},
> {2,3},
> @@ -1746,7 +1746,7 @@ TEST_F(RegisterRemappingTest, RegisterRemappingMergeAllToOne)
>
> TEST_F(RegisterRemappingTest, RegisterRemappingIgnoreUnused)
> {
> - vector<lifetime> lt({{-1,-1},
> + vector<register_live_range> lt({{-1,-1},
> {0,1},
> {1,2},
> {2,3},
> @@ -1759,7 +1759,7 @@ TEST_F(RegisterRemappingTest, RegisterRemappingIgnoreUnused)
>
> TEST_F(RegisterRemappingTest, RegisterRemappingMergeZeroLifetimeRegisters)
> {
> - vector<lifetime> lt({{-1,-1},
> + vector<register_live_range> lt({{-1,-1},
> {0,1},
> {1,2},
> {2,3},
>
--
Lerne, wie die Welt wirklich ist,
Aber vergiss niemals, wie sie sein sollte.
More information about the mesa-dev
mailing list