Lines Matching refs:file
30 /* This file implements an SSA-based register allocator. Unlike other
352 * half of this file too.
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) \
388 &(file)->physreg_intervals, physreg_node)
389 #define foreach_interval_rev_safe(interval, file) \
391 &(file)->physreg_intervals, physreg_node)
459 ra_file_search_right(struct ra_file *file, physreg_t reg)
461 return ra_interval_search_right(&file->physreg_intervals, reg);
488 struct ra_file *file = ir3_reg_ctx_to_file(ctx);
494 BITSET_CLEAR(file->available, i);
495 BITSET_CLEAR(file->available_to_evict, i);
498 rb_tree_insert(&file->physreg_intervals, &interval->physreg_node,
506 struct ra_file *file = ir3_reg_ctx_to_file(ctx);
509 BITSET_SET(file->available, i);
510 BITSET_SET(file->available_to_evict, i);
513 rb_tree_remove(&file->physreg_intervals, &interval->physreg_node);
534 ra_file_init(struct ra_file *file)
536 for (unsigned i = 0; i < file->size; i++) {
537 BITSET_SET(file->available, i);
538 BITSET_SET(file->available_to_evict, i);
541 rb_tree_init(&file->reg_ctx.intervals);
542 rb_tree_init(&file->physreg_intervals);
544 file->reg_ctx.interval_add = interval_add;
545 file->reg_ctx.interval_delete = interval_delete;
546 file->reg_ctx.interval_readd = interval_readd;
550 ra_file_insert(struct ra_file *file, struct ra_interval *interval)
553 assert(interval->physreg_end <= file->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)
572 BITSET_SET(file->available, i);
579 ra_file_unmark_killed(struct ra_file *file, struct ra_interval *interval)
584 BITSET_CLEAR(file->available, i);
627 ra_file_dump(struct log_stream *stream, struct ra_file *file)
629 rb_tree_foreach (struct ra_interval, interval, &file->physreg_intervals,
636 BITSET_FOREACH_RANGE (start, end, file->available, file->size) {
642 BITSET_FOREACH_RANGE (start, end, file->available_to_evict, file->size) {
646 mesa_log_stream_printf(stream, "start: %u\n", file->start);
663 reg_file_size(struct ra_file *file, struct ir3_register *reg)
667 return MIN2(file->size, RA_HALF_SIZE);
669 return file->size;
683 ra_pop_interval(struct ra_ctx *ctx, struct ra_file *file,
704 ir3_reg_interval_remove_temp(&file->reg_ctx, &interval->interval);
713 ra_push_interval(struct ra_ctx *ctx, struct ra_file *file,
721 assert(interval->physreg_end <= file->size);
725 ir3_reg_interval_reinsert(&file->reg_ctx, &interval->interval);
730 ra_move_interval(struct ra_ctx *ctx, struct ra_file *file,
733 struct ra_removed_interval temp = ra_pop_interval(ctx, file, interval);
734 ra_push_interval(ctx, file, &temp, dst);
753 check_dst_overlap(struct ra_ctx *ctx, struct ra_file *file,
765 if (ra_get_file(ctx, other_dst) != file)
793 get_reg_specified(struct ra_ctx *ctx, struct ra_file *file,
798 file->available_to_evict : file->available,
804 check_dst_overlap(ctx, file, reg, physreg, physreg + reg_size(reg)))
816 try_evict_regs(struct ra_ctx *ctx, struct ra_file *file,
821 memcpy(available_to_evict, file->available_to_evict,
825 memcpy(available, file->available, sizeof(available));
834 for (struct ra_interval *conflicting = ra_file_search_right(file, physreg),
848 reg_file_size(file, conflicting->interval.reg);
865 !check_dst_overlap(ctx, file, reg, avail_start, avail_start +
873 ra_move_interval(ctx, file, conflicting, avail_start);
885 foreach_interval (killed, file) {
894 conflicting->physreg_end > reg_file_size(file, killed->interval.reg))
912 if (check_dst_overlap(ctx, file, reg, killed->physreg_start,
934 ra_pop_interval(ctx, file, killed);
936 ra_pop_interval(ctx, file, conflicting);
937 ra_push_interval(ctx, file, &killed_removed, conflicting_start);
938 ra_push_interval(ctx, file, &conflicting_removed, killed_start);
973 * the register file. Then half and full killed must stay together so that
1037 * amazing, but should be used only as a last resort in case the register file
1043 compress_regs_left(struct ra_ctx *ctx, struct ra_file *file,
1068 align == 1 ? MIN2(file->size, RA_HALF_SIZE) : file->size;
1071 foreach_interval_rev_safe (interval, file) {
1079 if (ra_get_file(ctx, other_dst) != file)
1132 MAX2(removed_killed_size, dst_size) <= file->size &&
1162 array_insert(ctx, intervals, ra_pop_interval(ctx, file, interval));
1245 reg_file_size(file, cur_reg)) {
1262 ra_push_interval(ctx, file, &intervals[live_index], physreg);
1300 update_affinity(struct ra_file *file, struct ir3_register *reg,
1309 if ((physreg - reg->merge_set_offset + reg->merge_set->size) > file->size)
1319 find_best_gap(struct ra_ctx *ctx, struct ra_file *file,
1330 is_early_clobber(dst) ? file->available_to_evict : file->available;
1332 unsigned start = ALIGN(file->start, align) % (file_size - size + align);
1345 !check_dst_overlap(ctx, file, dst, candidate, candidate + size);
1349 file->start = (candidate + size) % file_size;
1371 get_reg(struct ra_ctx *ctx, struct ra_file *file, struct ir3_register *reg)
1373 unsigned file_size = reg_file_size(file, reg);
1379 get_reg_specified(ctx, file, reg, preferred_reg, false))
1390 physreg_t best_reg = find_best_gap(ctx, file, reg, file_size,
1409 if (ra_get_file(ctx, src) == file && reg_size(src) >= size) {
1414 get_reg_specified(ctx, file, reg, src_physreg, false))
1421 find_best_gap(ctx, file, reg, file_size, size, reg_elem_size(reg));
1433 if (try_evict_regs(ctx, file, reg, i, &eviction_count, false, true)) {
1443 ctx, file, reg, best_reg, &best_eviction_count, false, false);
1449 return compress_regs_left(ctx, file, reg);
1483 struct ra_file *file = ra_get_file(ctx, dst);
1489 ra_file_insert(file, interval);
1498 struct ra_file *file = ra_get_file(ctx, dst);
1500 update_affinity(file, dst, physreg);
1542 struct ra_file *file = ra_get_file(ctx, dst);
1557 physreg_t physreg = get_reg(ctx, file, dst);
1567 struct ra_file *file = ra_get_file(ctx, src);
1581 ra_file_remove(file, interval);
1800 struct ra_file *file = ra_get_file(ctx, instr->dsts[0]);
1808 ra_file_insert(file, interval);
1820 struct ra_file *file = ra_get_file(ctx, instr->dsts[0]);
1822 ra_file_insert(file, interval);
1829 struct ra_file *file = ra_get_file(ctx, instr->dsts[0]);
1838 ra_file_remove(file, interval);
1863 struct ra_file *file = ra_get_file(ctx, src);
1874 if (!get_reg_specified(ctx, file, src, physreg, true)) {
1876 if (!try_evict_regs(ctx, file, src, physreg, &eviction_count, true,
1883 ra_move_interval(ctx, file, interval, physreg);
1900 struct ra_file *file = ra_get_file(ctx, src);
1903 ra_file_remove(file, interval);
1942 struct ra_file *file = ra_get_file(ctx, def);
1946 ra_file_insert(file, interval);
1972 struct ra_file *file = ra_get_file(ctx, def);
1980 ir3_reg_interval_search(&file->reg_ctx.intervals, def->interval_start);
1987 physreg = get_reg(ctx, file, def);
1992 ra_file_insert(file, interval);
1998 struct ra_file *file = ra_get_file(ctx, phi->dsts[0]);
2013 ra_file_remove(file, interval);
2127 insert_file_live_in_moves(struct ra_ctx *ctx, struct ra_file *file)
2130 rb_tree_foreach (struct ra_interval, interval, &file->physreg_intervals,
2142 insert_entry_regs(struct ra_block_state *state, struct ra_file *file)
2144 rb_tree_foreach (struct ra_interval, interval, &file->physreg_intervals,
2206 insert_file_live_out_moves(struct ra_ctx *ctx, struct ra_file *file)
2208 rb_tree_foreach (struct ra_interval, interval, &file->physreg_intervals,
2235 * have to allocate all of them, inserting them into the file, and then
2511 /* The register file is grouped into reg_size_vec4 number of parts.
2514 * each wave-pair would consume two parts of the register file to get
2577 * because on some gens the register file is not big enough to hold a