Lines Matching refs:interval
32 * that multiple values may share the same register interval. From the
37 * instruction, are "locked" to their parent interval. The details of this are
55 const struct ir3_reg_interval *interval =
57 if (interval->reg->interval_start > reg)
59 else if (interval->reg->interval_end <= reg)
80 /* Get the interval covering the reg, or the closest to the right if it
86 struct ir3_reg_interval *interval =
88 if (!interval) {
90 } else if (interval->reg->interval_end > offset) {
91 return interval;
93 /* There is no interval covering reg, and ra_file_search_sloppy()
94 * returned the closest range to the left, so the next interval to the
97 return ir3_reg_interval_next_or_null(interval);
111 struct ir3_reg_interval *interval)
114 ir3_reg_interval_search_right(tree, interval->reg->interval_start);
115 if (right && right->reg->interval_start < interval->reg->interval_end) {
132 assert((interval->reg->flags & IR3_REG_HALF) ==
135 if (right->reg->interval_end <= interval->reg->interval_end &&
136 right->reg->interval_start >= interval->reg->interval_start) {
138 assert(interval != right);
140 /* "right" is contained in "interval" and must become a child of
144 right && right->reg->interval_start < interval->reg->interval_end;
146 /* "right" must be contained in "interval." */
147 assert(right->reg->interval_end <= interval->reg->interval_end);
148 assert((interval->reg->flags & IR3_REG_HALF) ==
152 right->parent = interval;
154 rb_tree_insert(&interval->children, &right->node,
158 /* "right" must contain "interval," since intervals must form a
161 assert(right->reg->interval_start <= interval->reg->interval_start);
162 interval->parent = right;
163 interval_insert(ctx, &right->children, interval);
168 if (!interval->parent)
169 ctx->interval_add(ctx, interval);
170 rb_tree_insert(tree, &interval->node, ir3_reg_interval_insert_cmp);
171 interval->inserted = true;
176 struct ir3_reg_interval *interval)
178 rb_tree_init(&interval->children);
179 interval->parent = NULL;
180 interval_insert(ctx, &ctx->intervals, interval);
183 /* Call after ir3_reg_interval_remove_temp() to reinsert the interval */
186 struct ir3_reg_interval *interval)
188 interval->parent = NULL;
189 interval_insert(ctx, &ctx->intervals, interval);
194 struct ir3_reg_interval *interval)
196 if (interval->parent) {
197 rb_tree_remove(&interval->parent->children, &interval->node);
199 ctx->interval_delete(ctx, interval);
200 rb_tree_remove(&ctx->intervals, &interval->node);
203 rb_tree_foreach_safe (struct ir3_reg_interval, child, &interval->children,
205 rb_tree_remove(&interval->children, &child->node);
206 child->parent = interval->parent;
208 if (interval->parent) {
212 ctx->interval_readd(ctx, interval, child);
218 interval->inserted = false;
222 _mark_free(struct ir3_reg_interval *interval)
224 interval->inserted = false;
225 rb_tree_foreach (struct ir3_reg_interval, child, &interval->children, node) {
230 /* Remove an interval and all its children from the tree. */
233 struct ir3_reg_interval *interval)
235 assert(!interval->parent);
237 ctx->interval_delete(ctx, interval);
238 rb_tree_remove(&ctx->intervals, &interval->node);
239 _mark_free(interval);
242 /* Used when popping an interval to be shuffled around. Don't disturb children
247 struct ir3_reg_interval *interval)
249 assert(!interval->parent);
251 ctx->interval_delete(ctx, interval);
252 rb_tree_remove(&ctx->intervals, &interval->node);
256 interval_dump(struct log_stream *stream, struct ir3_reg_interval *interval,
261 mesa_log_stream_printf(stream, "reg %u start %u\n", interval->reg->name,
262 interval->reg->interval_start);
264 rb_tree_foreach (struct ir3_reg_interval, child, &interval->children, node) {
270 mesa_log_stream_printf(stream, "reg %u end %u\n", interval->reg->name,
271 interval->reg->interval_end);
275 ir3_reg_interval_dump(struct log_stream *stream, struct ir3_reg_interval *interval)
277 interval_dump(stream, interval, 0);
286 struct ir3_reg_interval interval;
297 /* True if this interval cannot be moved from its position. This is only
344 struct ra_interval *interval;
380 #define foreach_interval(interval, file) \
381 rb_tree_foreach (struct ra_interval, interval, &(file)->physreg_intervals, \
383 #define foreach_interval_rev(interval, file) \
384 rb_tree_foreach (struct ra_interval, interval, &(file)->physreg_intervals, \
386 #define foreach_interval_safe(interval, file) \
387 rb_tree_foreach_safe (struct ra_interval, interval, \
389 #define foreach_interval_rev_safe(interval, file) \
390 rb_tree_foreach_rev_safe(struct ra_interval, interval, \
406 ra_interval_next(struct ra_interval *interval)
408 struct rb_node *next = rb_node_next(&interval->physreg_node);
413 ra_interval_next_or_null(struct ra_interval *interval)
415 return interval ? ra_interval_next(interval) : NULL;
422 const struct ra_interval *interval = rb_node_to_interval_const(node);
423 if (interval->physreg_start > reg)
425 else if (interval->physreg_end <= reg)
438 /* Get the interval covering the reg, or the closest to the right if it
444 struct ra_interval *interval = ra_interval_search_sloppy(tree, reg);
445 if (!interval) {
447 } else if (interval->physreg_end > reg) {
448 return interval;
450 /* There is no interval covering reg, and ra_file_search_sloppy()
451 * returned the closest range to the left, so the next interval to the
454 return ra_interval_next_or_null(interval);
473 ir3_reg_interval_to_ra_interval(struct ir3_reg_interval *interval)
475 return rb_node_data(struct ra_interval, interval, interval);
487 struct ra_interval *interval = ir3_reg_interval_to_ra_interval(_interval);
493 for (physreg_t i = interval->physreg_start; i < interval->physreg_end; i++) {
498 rb_tree_insert(&file->physreg_intervals, &interval->physreg_node,
505 struct ra_interval *interval = ir3_reg_interval_to_ra_interval(_interval);
508 for (physreg_t i = interval->physreg_start; i < interval->physreg_end; i++) {
513 rb_tree_remove(&file->physreg_intervals, &interval->physreg_node);
524 parent->physreg_start + (child->interval.reg->interval_start -
525 parent->interval.reg->interval_start);
528 (child->interval.reg->interval_end - child->interval.reg->interval_start);
550 ra_file_insert(struct ra_file *file, struct ra_interval *interval)
552 assert(interval->physreg_start < interval->physreg_end);
553 assert(interval->physreg_end <= file->size);
554 if (interval->interval.reg->flags & IR3_REG_HALF)
555 assert(interval->physreg_end <= RA_HALF_SIZE);
557 ir3_reg_interval_insert(&file->reg_ctx, &interval->interval);
561 ra_file_remove(struct ra_file *file, struct ra_interval *interval)
563 ir3_reg_interval_remove(&file->reg_ctx, &interval->interval);
567 ra_file_mark_killed(struct ra_file *file, struct ra_interval *interval)
569 assert(!interval->interval.parent);
571 for (physreg_t i = interval->physreg_start; i < interval->physreg_end; i++) {
575 interval->is_killed = true;
579 ra_file_unmark_killed(struct ra_file *file, struct ra_interval *interval)
581 assert(!interval->interval.parent);
583 for (physreg_t i = interval->physreg_start; i < interval->physreg_end; i++) {
587 interval->is_killed = false;
591 ra_interval_get_physreg(const struct ra_interval *interval)
593 unsigned child_start = interval->interval.reg->interval_start;
595 while (interval->interval.parent) {
596 interval = ir3_reg_interval_to_ra_interval(interval->interval.parent);
599 return interval->physreg_start +
600 (child_start - interval->interval.reg->interval_start);
604 ra_interval_get_num(const struct ra_interval *interval)
606 return ra_physreg_to_num(ra_interval_get_physreg(interval),
607 interval->interval.reg->flags);
611 ra_interval_init(struct ra_interval *interval, struct ir3_register *reg)
613 ir3_reg_interval_init(&interval->interval, reg);
614 interval->is_killed = false;
615 interval->frozen = false;
619 ra_interval_dump(struct log_stream *stream, struct ra_interval *interval)
621 mesa_log_stream_printf(stream, "physreg %u ", interval->physreg_start);
623 ir3_reg_interval_dump(stream, &interval->interval);
629 rb_tree_foreach (struct ra_interval, interval, &file->physreg_intervals,
631 ra_interval_dump(stream, interval);
678 struct ra_interval *interval;
684 struct ra_interval *interval)
686 assert(!interval->interval.parent);
692 if (ctx->parallel_copies[pcopy_index].interval == interval)
699 .interval = interval,
700 .src = interval->physreg_start,
704 ir3_reg_interval_remove_temp(&file->reg_ctx, &interval->interval);
707 .interval = interval,
708 .size = interval->physreg_end - interval->physreg_start,
716 struct ra_interval *interval = removed->interval;
718 interval->physreg_start = dst;
719 interval->physreg_end = dst + removed->size;
721 assert(interval->physreg_end <= file->size);
722 if (interval->interval.reg->flags & IR3_REG_HALF)
723 assert(interval->physreg_end <= RA_HALF_SIZE);
725 ir3_reg_interval_reinsert(&file->reg_ctx, &interval->interval);
728 /* Pick up the interval and place it at "dst". */
731 struct ra_interval *interval, physreg_t dst)
733 struct ra_removed_interval temp = ra_pop_interval(ctx, file, interval);
769 assert(!other_interval->interval.parent);
848 reg_file_size(file, conflicting->interval.reg);
856 if (!(conflicting->interval.reg->flags & IR3_REG_HALF) &&
894 conflicting->physreg_end > reg_file_size(file, killed->interval.reg))
917 if ((!(killed->interval.reg->flags & IR3_REG_HALF) ||
918 !(conflicting->interval.reg->flags & IR3_REG_HALF)) &&
980 unsigned i1_align = reg_elem_size(i1->interval->interval.reg);
981 unsigned i2_align = reg_elem_size(i2->interval->interval.reg);
988 if (i2->interval->is_killed)
990 if (i1->interval->is_killed)
993 if (i2->interval->is_killed)
995 if (i1->interval->is_killed)
1034 * destination register. As there can be gaps when a more-aligned interval
1035 * follows a less-aligned interval, this also sorts them to remove such
1071 foreach_interval_rev_safe (interval, file) {
1073 physreg_t candidate_start = interval->physreg_end;
1085 /* if the destination partially overlaps this interval, we need to
1108 other_interval->interval.reg->name,
1115 if (other_interval->interval.reg->flags & IR3_REG_HALF)
1119 if (other_interval->interval.reg->flags & IR3_REG_HALF)
1143 assert(!interval->frozen);
1148 unsigned interval_size = interval->physreg_end - interval->physreg_start;
1149 if (interval->is_killed) {
1151 if (interval->interval.reg->flags & IR3_REG_HALF)
1155 if (interval->interval.reg->flags & IR3_REG_HALF)
1160 d("popping interval %u physreg %u%s\n", interval->interval.reg->name,
1161 interval->physreg_start, interval->is_killed ? ", killed" : "");
1162 array_insert(ctx, intervals, ra_pop_interval(ctx, file, interval));
1189 struct ra_interval *live_interval = intervals[live_index].interval;
1191 bool live_half = live_interval->interval.reg->flags & IR3_REG_HALF;
1220 intervals[live_index].interval->interval.reg;
1229 struct ra_interval *live_interval = intervals[live_index].interval;
1246 d("ran out of room for interval %u!\n",
1256 struct ra_interval *interval = &ctx->intervals[cur_reg->name];
1257 interval->physreg_start = physreg;
1258 interval->physreg_end = physreg + interval_size;
1470 struct ra_interval *interval = &ctx->intervals[src->def->name];
1472 if (!(src->flags & IR3_REG_FIRST_KILL) || interval->is_killed ||
1473 interval->interval.parent ||
1474 !rb_tree_is_empty(&interval->interval.children))
1477 ra_file_mark_killed(ra_get_file(ctx, src), interval);
1484 struct ra_interval *interval = &ctx->intervals[dst->name];
1486 d("insert dst %u physreg %u", dst->name, ra_interval_get_physreg(interval));
1489 ra_file_insert(file, interval);
1491 assign_reg(dst->instr, dst, ra_interval_get_num(interval));
1499 struct ra_interval *interval = &ctx->intervals[dst->name];
1502 ra_interval_init(interval, dst);
1503 interval->physreg_start = physreg;
1504 interval->physreg_end = physreg + reg_size(dst);
1534 .interval = dst_interval,
1566 struct ra_interval *interval = &ctx->intervals[src->def->name];
1575 physreg = ra_interval_get_physreg(interval);
1581 ra_file_remove(file, interval);
1601 entry->interval->interval.reg->flags &
1603 reg->size = entry->interval->interval.reg->size;
1604 reg->wrmask = entry->interval->interval.reg->wrmask;
1605 assign_reg(pcopy, reg, ra_interval_get_num(entry->interval));
1612 entry->interval->interval.reg->flags &
1614 reg->size = entry->interval->interval.reg->size;
1615 reg->wrmask = entry->interval->interval.reg->wrmask;
1690 /* We need to check if any of the sources are contained in an interval
1692 * the vector inside that larger interval. (There should be one
1712 struct ra_interval *interval = &ctx->intervals[src->def->name];
1714 if (src->def->merge_set != dst_set || interval->is_killed)
1716 while (interval->interval.parent != NULL) {
1717 interval = ir3_reg_interval_to_ra_interval(interval->interval.parent);
1719 if (reg_size(interval->interval.reg) >= reg_size(instr->dsts[0])) {
1720 dst_fixed = interval->physreg_start -
1721 interval->interval.reg->merge_set_offset + dst_offset;
1723 /* For sources whose root interval is smaller than the
1729 ra_file_mark_killed(ra_get_file(ctx, src), interval);
1740 struct ra_interval *interval = &ctx->intervals[src->def->name];
1741 while (interval->interval.parent != NULL) {
1742 interval = ir3_reg_interval_to_ra_interval(interval->interval.parent);
1746 if (interval != &ctx->intervals[src->def->name] ||
1748 ra_file_unmark_killed(ra_get_file(ctx, src), interval);
1801 struct ra_interval *interval = &ctx->intervals[instr->dsts[0]->name];
1806 ra_interval_get_physreg(interval));
1808 ra_file_insert(file, interval);
1809 interval->frozen = true;
1821 struct ra_interval *interval = &ctx->intervals[instr->dsts[0]->name];
1822 ra_file_insert(file, interval);
1828 struct ra_interval *interval = &ctx->intervals[instr->dsts[0]->name];
1832 assign_reg(instr, instr->dsts[0], ra_interval_get_num(interval));
1834 interval->frozen = false;
1838 ra_file_remove(file, interval);
1864 struct ra_interval *interval = &ctx->intervals[src->def->name];
1867 if (ra_interval_get_num(interval) == src->num)
1883 ra_move_interval(ctx, file, interval, physreg);
1901 struct ra_interval *interval = &ctx->intervals[src->def->name];
1903 ra_file_remove(file, interval);
1941 struct ra_interval *interval = &ctx->intervals[def->name];
1943 ra_interval_init(interval, def);
1944 interval->physreg_start = physreg;
1945 interval->physreg_end = physreg + reg_size(def);
1946 ra_file_insert(file, interval);
1960 struct ra_interval *interval = &ctx->intervals[def->name];
1961 physreg_t physreg = ra_interval_get_physreg(interval);
1973 struct ra_interval *interval = &ctx->intervals[def->name];
1992 ra_file_insert(file, interval);
1999 struct ra_interval *interval = &ctx->intervals[phi->dsts[0]->name];
2000 assert(!interval->interval.parent);
2001 unsigned num = ra_interval_get_num(interval);
2013 ra_file_remove(file, interval);
2080 insert_live_in_move(struct ra_ctx *ctx, struct ra_interval *interval)
2082 physreg_t physreg = ra_interval_get_physreg(interval);
2084 bool shared = interval->interval.reg->flags & IR3_REG_SHARED;
2098 physreg_t pred_reg = read_register(ctx, pred, interval->interval.reg);
2100 insert_liveout_copy(pred, physreg, pred_reg, interval->interval.reg);
2120 _mesa_hash_table_insert(pred_state->renames, interval->interval.reg,
2130 rb_tree_foreach (struct ra_interval, interval, &file->physreg_intervals,
2136 if (BITSET_TEST(live_in, interval->interval.reg->name))
2137 insert_live_in_move(ctx, interval);
2144 rb_tree_foreach (struct ra_interval, interval, &file->physreg_intervals,
2146 _mesa_hash_table_insert(state->entry_regs, interval->interval.reg,
2147 (void *)(uintptr_t)interval->physreg_start);
2180 insert_live_out_move(struct ra_ctx *ctx, struct ra_interval *interval)
2193 succ_state->entry_regs, interval->interval.reg);
2198 if (new_reg != interval->physreg_start) {
2199 insert_liveout_copy(ctx->block, new_reg, interval->physreg_start,
2200 interval->interval.reg);
2208 rb_tree_foreach (struct ra_interval, interval, &file->physreg_intervals,
2210 insert_live_out_move(ctx, interval);
2269 /* After this point, every live-in/phi/input has an interval assigned to
2359 dummy_interval_add(struct ir3_reg_ctx *ctx, struct ir3_reg_interval *interval)
2364 dummy_interval_delete(struct ir3_reg_ctx *ctx, struct ir3_reg_interval *interval)
2462 struct ir3_reg_interval *interval = &intervals[src->def->name];
2463 while (interval->parent)
2464 interval = interval->parent;
2465 add_pressure(&cur_pressure, interval->reg, v->mergedregs);