Lines Matching refs:regs
94 struct ra_regs *regs;
96 regs = rzalloc(mem_ctx, struct ra_regs);
97 regs->count = count;
98 regs->regs = rzalloc_array(regs, struct ra_reg, count);
101 regs->regs[i].conflicts = rzalloc_array(regs->regs, BITSET_WORD,
103 BITSET_SET(regs->regs[i].conflicts, i);
105 util_dynarray_init(®s->regs[i].conflict_list,
106 need_conflict_lists ? regs->regs : NULL);
108 util_dynarray_append(®s->regs[i].conflict_list, unsigned int, i);
111 return regs;
125 ra_set_allocate_round_robin(struct ra_regs *regs)
127 regs->round_robin = true;
131 ra_add_conflict_list(struct ra_regs *regs, unsigned int r1, unsigned int r2)
133 struct ra_reg *reg1 = ®s->regs[r1];
142 ra_add_reg_conflict(struct ra_regs *regs, unsigned int r1, unsigned int r2)
144 if (!BITSET_TEST(regs->regs[r1].conflicts, r2)) {
145 ra_add_conflict_list(regs, r1, r2);
146 ra_add_conflict_list(regs, r2, r1);
159 ra_add_transitive_reg_conflict(struct ra_regs *regs,
162 ra_add_reg_conflict(regs, reg, base_reg);
164 util_dynarray_foreach(®s->regs[base_reg].conflict_list, unsigned int,
166 ra_add_reg_conflict(regs, reg, *r2p);
178 ra_add_transitive_reg_pair_conflict(struct ra_regs *regs,
181 ra_add_reg_conflict(regs, reg0, base_reg);
182 ra_add_reg_conflict(regs, reg1, base_reg);
184 util_dynarray_foreach(®s->regs[base_reg].conflict_list, unsigned int, i) {
187 ra_add_reg_conflict(regs, reg0, conflict);
189 ra_add_reg_conflict(regs, reg1, conflict);
203 ra_make_reg_conflicts_transitive(struct ra_regs *regs, unsigned int r)
205 struct ra_reg *reg = ®s->regs[r];
208 BITSET_FOREACH_SET(c, reg->conflicts, regs->count) {
209 struct ra_reg *other = ®s->regs[c];
211 for (i = 0; i < BITSET_WORDS(regs->count); i++)
217 ra_alloc_reg_class(struct ra_regs *regs)
221 regs->classes = reralloc(regs->regs, regs->classes, struct ra_class *,
222 regs->class_count + 1);
224 class = rzalloc(regs, struct ra_class);
225 class->regset = regs;
228 class->index = regs->class_count++;
229 regs->classes[class->index] = class;
231 class->regs = rzalloc_array(class, BITSET_WORD, BITSET_WORDS(regs->count));
244 ra_alloc_contig_reg_class(struct ra_regs *regs, int contig_len)
246 struct ra_class *c = ra_alloc_reg_class(regs);
255 ra_get_class_from_index(struct ra_regs *regs, unsigned int class)
257 return regs->classes[class];
272 BITSET_SET(class->regs, r);
282 return BITSET_TEST(c->regs, r);
292 ra_set_finalize(struct ra_regs *regs, unsigned int **q_values)
296 for (b = 0; b < regs->class_count; b++) {
297 regs->classes[b]->q = ralloc_array(regs, unsigned int, regs->class_count);
301 for (b = 0; b < regs->class_count; b++) {
302 for (c = 0; c < regs->class_count; c++) {
303 regs->classes[b]->q[c] = q_values[b][c];
307 /* Compute, for each class B and C, how many regs of B an
310 for (b = 0; b < regs->class_count; b++) {
311 for (c = 0; c < regs->class_count; c++) {
312 struct ra_class *class_b = regs->classes[b];
313 struct ra_class *class_c = regs->classes[c];
318 * conflict if there are any regs shared between them. This
322 for (int i = 0; i < BITSET_WORDS(regs->count); i++) {
323 if (class_b->regs[i] & class_c->regs[i]) {
333 BITSET_FOREACH_SET(rc, regs->classes[c]->regs, regs->count) {
335 int end = MIN2(regs->count, rc + class_c->contig_len);
338 if (BITSET_TEST(class_b->regs, i))
360 BITSET_FOREACH_SET(rc, regs->classes[c]->regs, regs->count) {
363 util_dynarray_foreach(®s->regs[rc].conflict_list,
366 if (reg_belongs_to_class(rb, regs->classes[b]))
371 regs->classes[b]->q[c] = max_conflicts;
377 for (b = 0; b < regs->count; b++) {
378 util_dynarray_fini(®s->regs[b].conflict_list);
382 for (int c = 0; c < regs->class_count; c++)
383 all_contig &= regs->classes[c]->contig_len != 0;
389 for (int i = 0; i < regs->count; i++) {
390 ralloc_free(regs->regs[i].conflicts);
391 regs->regs[i].conflicts = NULL;
397 ra_set_serialize(const struct ra_regs *regs, struct blob *blob)
399 blob_write_uint32(blob, regs->count);
400 blob_write_uint32(blob, regs->class_count);
402 bool is_contig = regs->classes[0]->contig_len != 0;
406 for (unsigned int r = 0; r < regs->count; r++) {
407 struct ra_reg *reg = ®s->regs[r];
408 blob_write_bytes(blob, reg->conflicts, BITSET_WORDS(regs->count) *
414 for (unsigned int c = 0; c < regs->class_count; c++) {
415 struct ra_class *class = regs->classes[c];
416 blob_write_bytes(blob, class->regs, BITSET_WORDS(regs->count) *
420 blob_write_bytes(blob, class->q, regs->class_count * sizeof(*class->q));
423 blob_write_uint32(blob, regs->round_robin);
433 struct ra_regs *regs = ra_alloc_reg_set(mem_ctx, reg_count, false);
434 assert(regs->count == reg_count);
437 for (int i = 0; i < regs->count; i++) {
438 ralloc_free(regs->regs[i].conflicts);
439 regs->regs[i].conflicts = NULL;
443 struct ra_reg *reg = ®s->regs[r];
449 assert(regs->classes == NULL);
450 regs->classes = ralloc_array(regs->regs, struct ra_class *, class_count);
451 regs->class_count = class_count;
454 struct ra_class *class = rzalloc(regs, struct ra_class);
455 regs->classes[c] = class;
456 class->regset = regs;
459 class->regs = ralloc_array(class, BITSET_WORD, BITSET_WORDS(reg_count));
460 blob_copy_bytes(blob, class->regs, BITSET_WORDS(reg_count) *
466 class->q = ralloc_array(regs->classes[c], unsigned int, class_count);
470 regs->round_robin = blob_read_uint32(blob);
472 return regs;
518 g->nodes[n1].q_total += g->regs->classes[n1_class]->q[n2_class];
531 g->nodes[n1].q_total -= g->regs->classes[n1_class]->q[n2_class];
581 ra_alloc_interference_graph(struct ra_regs *regs, unsigned int count)
586 g->regs = regs;
620 return g->regs->classes[g->nodes[n].class];
661 if (g->nodes[n].tmp.q_total < g->regs->classes[n_class]->p) {
692 assert(g->nodes[n2].tmp.q_total >= g->regs->classes[n2_class]->q[n_class]);
693 g->nodes[n2].tmp.q_total -= g->regs->classes[n2_class]->q[n_class];
828 return BITSET_TEST(c1->regset->regs[r1].conflicts, r2);
840 ra_class_allocations_conflict(g->regs->classes[g->nodes[n].class], r,
841 g->regs->classes[g->nodes[n2].class], g->nodes[n2].reg)) {
849 /* Computes a bitfield of what regs are available for a given register
856 ra_compute_available_regs(struct ra_graph *g, unsigned int n, BITSET_WORD *regs)
858 struct ra_class *c = g->regs->classes[g->nodes[n].class];
860 /* Populate with the set of regs that are in the node's class. */
861 memcpy(regs, c->regs, BITSET_WORDS(g->regs->count) * sizeof(BITSET_WORD));
863 /* Remove any regs that conflict with nodes that we're adjacent to and have
868 struct ra_class *n2c = g->regs->classes[n2->class];
873 int end = MIN2(g->regs->count, n2->reg + n2c->contig_len);
875 BITSET_CLEAR(regs, i);
877 for (int j = 0; j < BITSET_WORDS(g->regs->count); j++)
878 regs[j] &= ~g->regs->regs[n2->reg].conflicts[j];
883 for (int i = 0; i < BITSET_WORDS(g->regs->count); i++) {
884 if (regs[i])
905 select_regs = malloc(BITSET_WORDS(g->regs->count) * sizeof(BITSET_WORD));
911 struct ra_class *c = g->regs->classes[g->nodes[n].class];
925 assert(r < g->regs->count);
930 for (ri = 0; ri < g->regs->count; ri++) {
931 r = (start_search_reg + ri) % g->regs->count;
940 if (g->regs->classes[conflicting->class]->contig_len) {
946 g->regs->classes[conflicting->class]->contig_len - 1);
952 if (ri >= g->regs->count)
968 if (g->regs->round_robin &&
1027 benefit += ((float)g->regs->classes[n_class]->q[n2_class] /
1028 g->regs->classes[n_class]->p);