Lines Matching refs:regs
95 struct ra_regs *regs;
97 regs = rzalloc(mem_ctx, struct ra_regs);
98 regs->count = count;
99 regs->regs = rzalloc_array(regs, struct ra_reg, count);
102 regs->regs[i].conflicts = rzalloc_array(regs->regs, BITSET_WORD,
104 BITSET_SET(regs->regs[i].conflicts, i);
106 util_dynarray_init(®s->regs[i].conflict_list,
107 need_conflict_lists ? regs->regs : NULL);
109 util_dynarray_append(®s->regs[i].conflict_list, unsigned int, i);
112 return regs;
126 ra_set_allocate_round_robin(struct ra_regs *regs)
128 regs->round_robin = true;
132 ra_add_conflict_list(struct ra_regs *regs, unsigned int r1, unsigned int r2)
134 struct ra_reg *reg1 = ®s->regs[r1];
143 ra_add_reg_conflict(struct ra_regs *regs, unsigned int r1, unsigned int r2)
145 if (!BITSET_TEST(regs->regs[r1].conflicts, r2)) {
146 ra_add_conflict_list(regs, r1, r2);
147 ra_add_conflict_list(regs, r2, r1);
160 ra_add_transitive_reg_conflict(struct ra_regs *regs,
163 ra_add_reg_conflict(regs, reg, base_reg);
165 util_dynarray_foreach(®s->regs[base_reg].conflict_list, unsigned int,
167 ra_add_reg_conflict(regs, reg, *r2p);
179 ra_add_transitive_reg_pair_conflict(struct ra_regs *regs,
182 ra_add_reg_conflict(regs, reg0, base_reg);
183 ra_add_reg_conflict(regs, reg1, base_reg);
185 util_dynarray_foreach(®s->regs[base_reg].conflict_list, unsigned int, i) {
188 ra_add_reg_conflict(regs, reg0, conflict);
190 ra_add_reg_conflict(regs, reg1, conflict);
204 ra_make_reg_conflicts_transitive(struct ra_regs *regs, unsigned int r)
206 struct ra_reg *reg = ®s->regs[r];
209 BITSET_FOREACH_SET(c, reg->conflicts, regs->count) {
210 struct ra_reg *other = ®s->regs[c];
212 for (i = 0; i < BITSET_WORDS(regs->count); i++)
218 ra_alloc_reg_class(struct ra_regs *regs)
222 regs->classes = reralloc(regs->regs, regs->classes, struct ra_class *,
223 regs->class_count + 1);
225 class = rzalloc(regs, struct ra_class);
226 class->regset = regs;
229 class->index = regs->class_count++;
230 regs->classes[class->index] = class;
232 class->regs = rzalloc_array(class, BITSET_WORD, BITSET_WORDS(regs->count));
245 ra_alloc_contig_reg_class(struct ra_regs *regs, int contig_len)
247 struct ra_class *c = ra_alloc_reg_class(regs);
256 ra_get_class_from_index(struct ra_regs *regs, unsigned int class)
258 return regs->classes[class];
273 BITSET_SET(class->regs, r);
283 return BITSET_TEST(c->regs, r);
293 ra_set_finalize(struct ra_regs *regs, unsigned int **q_values)
297 for (b = 0; b < regs->class_count; b++) {
298 regs->classes[b]->q = ralloc_array(regs, unsigned int, regs->class_count);
302 for (b = 0; b < regs->class_count; b++) {
303 for (c = 0; c < regs->class_count; c++) {
304 regs->classes[b]->q[c] = q_values[b][c];
308 /* Compute, for each class B and C, how many regs of B an
311 for (b = 0; b < regs->class_count; b++) {
312 for (c = 0; c < regs->class_count; c++) {
313 struct ra_class *class_b = regs->classes[b];
314 struct ra_class *class_c = regs->classes[c];
319 * conflict if there are any regs shared between them. This
323 for (int i = 0; i < BITSET_WORDS(regs->count); i++) {
324 if (class_b->regs[i] & class_c->regs[i]) {
334 BITSET_FOREACH_SET(rc, regs->classes[c]->regs, regs->count) {
336 int end = MIN2(regs->count, rc + class_c->contig_len);
339 if (BITSET_TEST(class_b->regs, i))
361 BITSET_FOREACH_SET(rc, regs->classes[c]->regs, regs->count) {
364 util_dynarray_foreach(®s->regs[rc].conflict_list,
367 if (reg_belongs_to_class(rb, regs->classes[b]))
372 regs->classes[b]->q[c] = max_conflicts;
378 for (b = 0; b < regs->count; b++) {
379 util_dynarray_fini(®s->regs[b].conflict_list);
383 for (int c = 0; c < regs->class_count; c++)
384 all_contig &= regs->classes[c]->contig_len != 0;
390 for (int i = 0; i < regs->count; i++) {
391 ralloc_free(regs->regs[i].conflicts);
392 regs->regs[i].conflicts = NULL;
398 ra_set_serialize(const struct ra_regs *regs, struct blob *blob)
400 blob_write_uint32(blob, regs->count);
401 blob_write_uint32(blob, regs->class_count);
403 bool is_contig = regs->classes[0]->contig_len != 0;
407 for (unsigned int r = 0; r < regs->count; r++) {
408 struct ra_reg *reg = ®s->regs[r];
409 blob_write_bytes(blob, reg->conflicts, BITSET_WORDS(regs->count) *
415 for (unsigned int c = 0; c < regs->class_count; c++) {
416 struct ra_class *class = regs->classes[c];
417 blob_write_bytes(blob, class->regs, BITSET_WORDS(regs->count) *
421 blob_write_bytes(blob, class->q, regs->class_count * sizeof(*class->q));
424 blob_write_uint32(blob, regs->round_robin);
434 struct ra_regs *regs = ra_alloc_reg_set(mem_ctx, reg_count, false);
435 assert(regs->count == reg_count);
438 for (int i = 0; i < regs->count; i++) {
439 ralloc_free(regs->regs[i].conflicts);
440 regs->regs[i].conflicts = NULL;
444 struct ra_reg *reg = ®s->regs[r];
450 assert(regs->classes == NULL);
451 regs->classes = ralloc_array(regs->regs, struct ra_class *, class_count);
452 regs->class_count = class_count;
455 struct ra_class *class = rzalloc(regs, struct ra_class);
456 regs->classes[c] = class;
457 class->regset = regs;
460 class->regs = ralloc_array(class, BITSET_WORD, BITSET_WORDS(reg_count));
461 blob_copy_bytes(blob, class->regs, BITSET_WORDS(reg_count) *
467 class->q = ralloc_array(regs->classes[c], unsigned int, class_count);
471 regs->round_robin = blob_read_uint32(blob);
473 return regs;
485 g->nodes[n1].q_total += g->regs->classes[n1_class]->q[n2_class];
499 g->nodes[n1].q_total -= g->regs->classes[n1_class]->q[n2_class];
557 ra_alloc_interference_graph(struct ra_regs *regs, unsigned int count)
562 g->regs = regs;
596 return g->regs->classes[g->nodes[n].class];
638 if (g->nodes[n].tmp.q_total < g->regs->classes[n_class]->p) {
669 assert(g->nodes[n2].tmp.q_total >= g->regs->classes[n2_class]->q[n_class]);
670 g->nodes[n2].tmp.q_total -= g->regs->classes[n2_class]->q[n_class];
805 return BITSET_TEST(c1->regset->regs[r1].conflicts, r2);
817 ra_class_allocations_conflict(g->regs->classes[g->nodes[n].class], r,
818 g->regs->classes[g->nodes[n2].class], g->nodes[n2].reg)) {
826 /* Computes a bitfield of what regs are available for a given register
833 ra_compute_available_regs(struct ra_graph *g, unsigned int n, BITSET_WORD *regs)
835 struct ra_class *c = g->regs->classes[g->nodes[n].class];
837 /* Populate with the set of regs that are in the node's class. */
838 memcpy(regs, c->regs, BITSET_WORDS(g->regs->count) * sizeof(BITSET_WORD));
840 /* Remove any regs that conflict with nodes that we're adjacent to and have
845 struct ra_class *n2c = g->regs->classes[n2->class];
850 int end = MIN2(g->regs->count, n2->reg + n2c->contig_len);
852 BITSET_CLEAR(regs, i);
854 for (int j = 0; j < BITSET_WORDS(g->regs->count); j++)
855 regs[j] &= ~g->regs->regs[n2->reg].conflicts[j];
860 for (int i = 0; i < BITSET_WORDS(g->regs->count); i++) {
861 if (regs[i])
882 select_regs = malloc(BITSET_WORDS(g->regs->count) * sizeof(BITSET_WORD));
888 struct ra_class *c = g->regs->classes[g->nodes[n].class];
902 assert(r < g->regs->count);
907 for (ri = 0; ri < g->regs->count; ri++) {
908 r = (start_search_reg + ri) % g->regs->count;
917 if (g->regs->classes[conflicting->class]->contig_len) {
923 g->regs->classes[conflicting->class]->contig_len - 1);
929 if (ri >= g->regs->count)
945 if (g->regs->round_robin &&
1004 benefit += ((float)g->regs->classes[n_class]->q[n2_class] /
1005 g->regs->classes[n_class]->p);