KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

util/ra: Don't destroy the graph in ra_allocate() 

We want to be able to call ra_allocate() and, when it fails, mutate the
graph and try again rather than re-building the graph from scratch.
This commit moves all the scratch bits except the final register
allocation (which is really an out value not scratch) into sub-structs
named "tmp" to make it clear which things are scratch.  It also adds
bits to the ra_select() initialization loop to initialize things (since
we can't trust rzalloc anymore) and copy q_test and forced_reg over.

Reviewed-by: Eric Anholt <eric@anholt.net>
This commit is contained in:
Jason Ekstrand 2019-05-08 16:41:41 -05:00
parent 9040215f5d
commit e291cd8a7e
1 changed files with 106 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

186
src/util/register_allocate.c
View File

@ -134,6 +134,9 @@ struct ra_node {
unsigned int class; unsigned int class;
/* Client-assigned register, if assigned, or NO_REG. */
unsigned int forced_reg;
/* Register, if assigned, or NO_REG. */ /* Register, if assigned, or NO_REG. */
unsigned int reg; unsigned int reg;
@ -147,6 +150,15 @@ struct ra_node {
* approximate cost of spilling this node. * approximate cost of spilling this node.
*/ */
float spill_cost; float spill_cost;
/* Temporary data for the algorithm to scratch around in */
struct {
/**
* Temporary version of q_total which we decrement as things are placed
* into the stack.
*/
unsigned int q_total;
} tmp;
}; };
struct ra_graph { struct ra_graph {
@ -159,36 +171,39 @@ struct ra_graph {
unsigned int alloc; /**< count of nodes allocated. */ unsigned int alloc; /**< count of nodes allocated. */
unsigned int *stack;
unsigned int stack_count;
/** Bit-set indicating, for each register, if it's in the stack */
BITSET_WORD *in_stack;
/** Bit-set indicating, for each register, if it pre-assigned */
BITSET_WORD *reg_assigned;
/** Bit-set indicating, for each register, the value of the pq test */
BITSET_WORD *pq_test;
/** For each BITSET_WORD, the minimum q value or ~0 if unknown */
unsigned int *min_q_total;
/*
* * For each BITSET_WORD, the node with the minimum q_total if
* min_q_total[i] != ~0.
*/
unsigned int *min_q_node;
/**
* Tracks the start of the set of optimistically-colored registers in the
* stack.
*/
unsigned int stack_optimistic_start;
unsigned int (*select_reg_callback)(struct ra_graph *g, BITSET_WORD *regs, unsigned int (*select_reg_callback)(struct ra_graph *g, BITSET_WORD *regs,
void *data); void *data);
void *select_reg_callback_data; void *select_reg_callback_data;
/* Temporary data for the algorithm to scratch around in */
struct {
unsigned int *stack;
unsigned int stack_count;
/** Bit-set indicating, for each register, if it's in the stack */
BITSET_WORD *in_stack;
/** Bit-set indicating, for each register, if it pre-assigned */
BITSET_WORD *reg_assigned;
/** Bit-set indicating, for each register, the value of the pq test */
BITSET_WORD *pq_test;
/** For each BITSET_WORD, the minimum q value or ~0 if unknown */
unsigned int *min_q_total;
/*
* * For each BITSET_WORD, the node with the minimum q_total if
* min_q_total[i] != ~0.
*/
unsigned int *min_q_node;
/**
* Tracks the start of the set of optimistically-colored registers in the
* stack.
*/
unsigned int stack_optimistic_start;
} tmp;
}; };
/** /**
@ -483,21 +498,23 @@ ra_realloc_interference_graph(struct ra_graph *g, unsigned int alloc)
g->nodes[i].adjacency_count = 0; g->nodes[i].adjacency_count = 0;
g->nodes[i].q_total = 0; g->nodes[i].q_total = 0;
g->nodes[i].forced_reg = NO_REG;
g->nodes[i].reg = NO_REG; g->nodes[i].reg = NO_REG;
} }
g->stack = reralloc(g, g->stack, unsigned int, alloc); /* These are scratch values and don't need to be zeroed. We'll clear them
g->in_stack = rerzalloc(g, g->in_stack, BITSET_WORD, * as part of ra_select() setup.
g_bitset_count, bitset_count); */
g->tmp.stack = reralloc(g, g->tmp.stack, unsigned int, alloc);
g->tmp.in_stack = reralloc(g, g->tmp.in_stack, BITSET_WORD, bitset_count);
g->reg_assigned = rerzalloc(g, g->reg_assigned, BITSET_WORD, g->tmp.reg_assigned = reralloc(g, g->tmp.reg_assigned, BITSET_WORD,
g_bitset_count, bitset_count); bitset_count);
g->pq_test = rerzalloc(g, g->pq_test, BITSET_WORD, g->tmp.pq_test = reralloc(g, g->tmp.pq_test, BITSET_WORD, bitset_count);
g_bitset_count, bitset_count); g->tmp.min_q_total = reralloc(g, g->tmp.min_q_total, unsigned int,
g->min_q_total = rerzalloc(g, g->min_q_total, unsigned int, bitset_count);
g_bitset_count, bitset_count); g->tmp.min_q_node = reralloc(g, g->tmp.min_q_node, unsigned int,
g->min_q_node = rerzalloc(g, g->min_q_node, unsigned int, bitset_count);
g_bitset_count, bitset_count);
g->alloc = alloc; g->alloc = alloc;
} }
@ -577,20 +594,20 @@ update_pq_info(struct ra_graph *g, unsigned int n)
{ {
int i = n / BITSET_WORDBITS; int i = n / BITSET_WORDBITS;
int n_class = g->nodes[n].class; int n_class = g->nodes[n].class;
if (g->nodes[n].q_total < g->regs->classes[n_class]->p) { if (g->nodes[n].tmp.q_total < g->regs->classes[n_class]->p) {
BITSET_SET(g->pq_test, n); BITSET_SET(g->tmp.pq_test, n);
} else if (g->min_q_total[i] != UINT_MAX) { } else if (g->tmp.min_q_total[i] != UINT_MAX) {
/* Only update min_q_total and min_q_node if min_q_total != UINT_MAX so /* Only update min_q_total and min_q_node if min_q_total != UINT_MAX so
* that we don't update while we have stale data and accidentally mark * that we don't update while we have stale data and accidentally mark
* it as non-stale. Also, in order to remain consistent with the old * it as non-stale. Also, in order to remain consistent with the old
* naive implementation of the algorithm, we do a lexicographical sort * naive implementation of the algorithm, we do a lexicographical sort
* to ensure that we always choose the node with the highest node index. * to ensure that we always choose the node with the highest node index.
*/ */
if (g->nodes[n].q_total < g->min_q_total[i] || if (g->nodes[n].tmp.q_total < g->tmp.min_q_total[i] ||
(g->nodes[n].q_total == g->min_q_total[i] && (g->nodes[n].tmp.q_total == g->tmp.min_q_total[i] &&
n > g->min_q_node[i])) { n > g->tmp.min_q_node[i])) {
g->min_q_total[i] = g->nodes[n].q_total; g->tmp.min_q_total[i] = g->nodes[n].tmp.q_total;
g->min_q_node[i] = n; g->tmp.min_q_node[i] = n;
} }
} }
} }
@ -601,25 +618,26 @@ add_node_to_stack(struct ra_graph *g, unsigned int n)
unsigned int i; unsigned int i;
int n_class = g->nodes[n].class; int n_class = g->nodes[n].class;
assert(!BITSET_TEST(g->in_stack, n)); assert(!BITSET_TEST(g->tmp.in_stack, n));
for (i = 0; i < g->nodes[n].adjacency_count; i++) { for (i = 0; i < g->nodes[n].adjacency_count; i++) {
unsigned int n2 = g->nodes[n].adjacency_list[i]; unsigned int n2 = g->nodes[n].adjacency_list[i];
unsigned int n2_class = g->nodes[n2].class; unsigned int n2_class = g->nodes[n2].class;
if (!BITSET_TEST(g->in_stack, n2) && !BITSET_TEST(g->reg_assigned, n2)) { if (!BITSET_TEST(g->tmp.in_stack, n2) &&
assert(g->nodes[n2].q_total >= g->regs->classes[n2_class]->q[n_class]); !BITSET_TEST(g->tmp.reg_assigned, n2)) {
g->nodes[n2].q_total -= g->regs->classes[n2_class]->q[n_class]; assert(g->nodes[n2].tmp.q_total >= g->regs->classes[n2_class]->q[n_class]);
g->nodes[n2].tmp.q_total -= g->regs->classes[n2_class]->q[n_class];
update_pq_info(g, n2); update_pq_info(g, n2);
} }
} }
g->stack[g->stack_count] = n; g->tmp.stack[g->tmp.stack_count] = n;
g->stack_count++; g->tmp.stack_count++;
BITSET_SET(g->in_stack, n); BITSET_SET(g->tmp.in_stack, n);
/* Flag the min_q_total for n's block as dirty so it gets recalculated */ /* Flag the min_q_total for n's block as dirty so it gets recalculated */
g->min_q_total[n / BITSET_WORDBITS] = UINT_MAX; g->tmp.min_q_total[n / BITSET_WORDBITS] = UINT_MAX;
} }
/** /**
@ -644,14 +662,20 @@ ra_simplify(struct ra_graph *g)
const unsigned int top_word_high_bit = (g->count - 1) % BITSET_WORDBITS; const unsigned int top_word_high_bit = (g->count - 1) % BITSET_WORDBITS;
/* Do a quick pre-pass to set things up */ /* Do a quick pre-pass to set things up */
g->tmp.stack_count = 0;
for (int i = BITSET_WORDS(g->count) - 1, high_bit = top_word_high_bit; for (int i = BITSET_WORDS(g->count) - 1, high_bit = top_word_high_bit;
i >= 0; i--, high_bit = BITSET_WORDBITS - 1) { i >= 0; i--, high_bit = BITSET_WORDBITS - 1) {
g->min_q_total[i] = UINT_MAX; g->tmp.in_stack[i] = 0;
g->min_q_node[i] = UINT_MAX; g->tmp.reg_assigned[i] = 0;
g->tmp.pq_test[i] = 0;
g->tmp.min_q_total[i] = UINT_MAX;
g->tmp.min_q_node[i] = UINT_MAX;
for (int j = high_bit; j >= 0; j--) { for (int j = high_bit; j >= 0; j--) {
unsigned int n = i * BITSET_WORDBITS + j; unsigned int n = i * BITSET_WORDBITS + j;
g->nodes[n].reg = g->nodes[n].forced_reg;
g->nodes[n].tmp.q_total = g->nodes[n].q_total;
if (g->nodes[n].reg != NO_REG) if (g->nodes[n].reg != NO_REG)
g->reg_assigned[i] |= BITSET_BIT(j); g->tmp.reg_assigned[i] |= BITSET_BIT(j);
update_pq_info(g, n); update_pq_info(g, n);
} }
} }
@ -666,11 +690,11 @@ ra_simplify(struct ra_graph *g)
i >= 0; i--, high_bit = BITSET_WORDBITS - 1) { i >= 0; i--, high_bit = BITSET_WORDBITS - 1) {
BITSET_WORD mask = ~(BITSET_WORD)0 >> (31 - high_bit); BITSET_WORD mask = ~(BITSET_WORD)0 >> (31 - high_bit);
BITSET_WORD skip = g->in_stack[i] | g->reg_assigned[i]; BITSET_WORD skip = g->tmp.in_stack[i] | g->tmp.reg_assigned[i];
if (skip == mask) if (skip == mask)
continue; continue;
BITSET_WORD pq = g->pq_test[i] & ~skip; BITSET_WORD pq = g->tmp.pq_test[i] & ~skip;
if (pq) { if (pq) {
/* In this case, we have stuff we can immediately take off the /* In this case, we have stuff we can immediately take off the
* stack. This also means that we're guaranteed to make progress * stack. This also means that we're guaranteed to make progress
@ -686,12 +710,12 @@ ra_simplify(struct ra_graph *g)
/* add_node_to_stack() may update pq_test for this word so /* add_node_to_stack() may update pq_test for this word so
* we need to update our local copy. * we need to update our local copy.
*/ */
pq = g->pq_test[i] & ~skip; pq = g->tmp.pq_test[i] & ~skip;
progress = true; progress = true;
} }
} }
} else if (!progress) { } else if (!progress) {
if (g->min_q_total[i] == UINT_MAX) { if (g->tmp.min_q_total[i] == UINT_MAX) {
/* The min_q_total and min_q_node are dirty because we added /* The min_q_total and min_q_node are dirty because we added
* one of these nodes to the stack. It needs to be * one of these nodes to the stack. It needs to be
* recalculated. * recalculated.
@ -702,29 +726,29 @@ ra_simplify(struct ra_graph *g)
unsigned int n = i * BITSET_WORDBITS + j; unsigned int n = i * BITSET_WORDBITS + j;
assert(n < g->count); assert(n < g->count);
if (g->nodes[n].q_total < g->min_q_total[i]) { if (g->nodes[n].tmp.q_total < g->tmp.min_q_total[i]) {
g->min_q_total[i] = g->nodes[n].q_total; g->tmp.min_q_total[i] = g->nodes[n].tmp.q_total;
g->min_q_node[i] = n; g->tmp.min_q_node[i] = n;
} }
} }
} }
if (g->min_q_total[i] < min_q_total) { if (g->tmp.min_q_total[i] < min_q_total) {
min_q_node = g->min_q_node[i]; min_q_node = g->tmp.min_q_node[i];
min_q_total = g->min_q_total[i]; min_q_total = g->tmp.min_q_total[i];
} }
} }
} }
if (!progress && min_q_total != UINT_MAX) { if (!progress && min_q_total != UINT_MAX) {
if (stack_optimistic_start == UINT_MAX) if (stack_optimistic_start == UINT_MAX)
stack_optimistic_start = g->stack_count; stack_optimistic_start = g->tmp.stack_count;
add_node_to_stack(g, min_q_node); add_node_to_stack(g, min_q_node);
progress = true; progress = true;
} }
} }
g->stack_optimistic_start = stack_optimistic_start; g->tmp.stack_optimistic_start = stack_optimistic_start;
} }
static bool static bool
@ -735,7 +759,7 @@ ra_any_neighbors_conflict(struct ra_graph *g, unsigned int n, unsigned int r)
for (i = 0; i < g->nodes[n].adjacency_count; i++) { for (i = 0; i < g->nodes[n].adjacency_count; i++) {
unsigned int n2 = g->nodes[n].adjacency_list[i]; unsigned int n2 = g->nodes[n].adjacency_list[i];
if (!BITSET_TEST(g->in_stack, n2) && if (!BITSET_TEST(g->tmp.in_stack, n2) &&
BITSET_TEST(g->regs->regs[r].conflicts, g->nodes[n2].reg)) { BITSET_TEST(g->regs->regs[r].conflicts, g->nodes[n2].reg)) {
return true; return true;
} }
@ -765,7 +789,7 @@ ra_compute_available_regs(struct ra_graph *g, unsigned int n, BITSET_WORD *regs)
unsigned int n2 = g->nodes[n].adjacency_list[i]; unsigned int n2 = g->nodes[n].adjacency_list[i];
unsigned int r = g->nodes[n2].reg; unsigned int r = g->nodes[n2].reg;
if (!BITSET_TEST(g->in_stack, n2)) { if (!BITSET_TEST(g->tmp.in_stack, n2)) {
for (int j = 0; j < BITSET_WORDS(g->regs->count); j++) for (int j = 0; j < BITSET_WORDS(g->regs->count); j++)
regs[j] &= ~g->regs->regs[r].conflicts[j]; regs[j] &= ~g->regs->regs[r].conflicts[j];
} }
@ -795,16 +819,16 @@ ra_select(struct ra_graph *g)
if (g->select_reg_callback) if (g->select_reg_callback)
select_regs = malloc(BITSET_WORDS(g->regs->count) * sizeof(BITSET_WORD)); select_regs = malloc(BITSET_WORDS(g->regs->count) * sizeof(BITSET_WORD));
while (g->stack_count != 0) { while (g->tmp.stack_count != 0) {
unsigned int ri; unsigned int ri;
unsigned int r = -1; unsigned int r = -1;
int n = g->stack[g->stack_count - 1]; int n = g->tmp.stack[g->tmp.stack_count - 1];
struct ra_class *c = g->regs->classes[g->nodes[n].class]; struct ra_class *c = g->regs->classes[g->nodes[n].class];
/* set this to false even if we return here so that /* set this to false even if we return here so that
* ra_get_best_spill_node() considers this node later. * ra_get_best_spill_node() considers this node later.
*/ */
BITSET_CLEAR(g->in_stack, n); BITSET_CLEAR(g->tmp.in_stack, n);
if (g->select_reg_callback) { if (g->select_reg_callback) {
if (!ra_compute_available_regs(g, n, select_regs)) { if (!ra_compute_available_regs(g, n, select_regs)) {
@ -831,7 +855,7 @@ ra_select(struct ra_graph *g)
} }
g->nodes[n].reg = r; g->nodes[n].reg = r;
g->stack_count--; g->tmp.stack_count--;
/* Rotate the starting point except for any nodes above the lowest /* Rotate the starting point except for any nodes above the lowest
* optimistically colorable node. The likelihood that we will succeed * optimistically colorable node. The likelihood that we will succeed
@ -843,7 +867,7 @@ ra_select(struct ra_graph *g)
* dense packing strategy. * dense packing strategy.
*/ */
if (g->regs->round_robin && if (g->regs->round_robin &&
g->stack_count - 1 <= g->stack_optimistic_start) g->tmp.stack_count - 1 <= g->tmp.stack_optimistic_start)
start_search_reg = r + 1; start_search_reg = r + 1;
} }
@ -862,7 +886,10 @@ ra_allocate(struct ra_graph *g)
unsigned int unsigned int
ra_get_node_reg(struct ra_graph *g, unsigned int n) ra_get_node_reg(struct ra_graph *g, unsigned int n)
{ {
return g->nodes[n].reg; if (g->nodes[n].forced_reg != NO_REG)
return g->nodes[n].forced_reg;
else
return g->nodes[n].reg;
} }
/** /**
@ -881,8 +908,7 @@ ra_get_node_reg(struct ra_graph *g, unsigned int n)
void void
ra_set_node_reg(struct ra_graph *g, unsigned int n, unsigned int reg) ra_set_node_reg(struct ra_graph *g, unsigned int n, unsigned int reg)
{ {
g->nodes[n].reg = reg; g->nodes[n].forced_reg = reg;
BITSET_CLEAR(g->in_stack, n);
} }
static float static float
@ -930,7 +956,7 @@ ra_get_best_spill_node(struct ra_graph *g)
if (cost <= 0.0f) if (cost <= 0.0f)
continue; continue;
if (BITSET_TEST(g->in_stack, n)) if (BITSET_TEST(g->tmp.in_stack, n))
continue; continue;
benefit = ra_get_spill_benefit(g, n); benefit = ra_get_spill_benefit(g, n);