fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-01-08 12:50:12 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

mesa/st/glsl_to_tgsi:rename lifetime to register_live_range

Browse source 
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.

v4: Fix indentions and white spaces

Reviewed-by: Nicolai Hähnle <nicolai.haehnle@amd.com> (v3)
Signed-off-by: Gert Wollny <gw.fossdev@gmail.com>
Acked-by: Dave Airlie <airlied@redhat.com>
This commit is contained in:
Gert Wollny 2018-06-05 22:26:38 +02:00
parent f40c9d0225
commit 331ae3cde5
6 changed files with 90 additions and 83 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
src/mesa/state_tracker/st_glsl_to_tgsi.cpp
View file

@ -5593,19 +5593,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

82
src/mesa/state_tracker/st_glsl_to_tgsi_temprename.cpp
View file

@ -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");
RENAME_DEBUG(debug_log << setw(4) << i);
live_ranges[i] = acc[i].get_required_live_range();
RENAME_DEBUG(debug_log << ": [" << live_ranges[i].begin << ", "
<< live_ranges[i].end << "]\n");
}
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;
@ -1285,4 +1285,4 @@ void dump_instruction(ostream& os, int line, prog_scope *scope,
os << setw(indent * 4) << " ";
os << inst << "\n";
}
#endif
#endif

36
src/mesa/state_tracker/st_glsl_to_tgsi_temprename.h
View file

@ -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

16
src/mesa/state_tracker/tests/st_tests_common.cpp
View file

@ -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(), &lt[0]);
this->run(lt, expect);
}

13
src/mesa/state_tracker/tests/st_tests_common.h
View file

@ -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

10
src/mesa/state_tracker/tests/test_glsl_to_tgsi_lifetime.cpp
View file

@ -1709,7 +1709,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},
@ -1724,7 +1724,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},
@ -1736,7 +1736,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},
@ -1748,7 +1748,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},
@ -1761,7 +1761,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},