* pressure-prioritizing scheduling heuristic.
*/
int threshold;
+
+ /* Mask of stages that share memory for inputs and outputs */
+ unsigned stages_with_shared_io_memory;
} nir_schedule_scoreboard;
/* When walking the instructions in reverse, we use this flag to swap
enum direction { F, R };
typedef struct {
- nir_shader *shader;
+ nir_schedule_scoreboard *scoreboard;
- /* Map from nir_instr to nir_schedule_node * */
- struct hash_table *instr_map;
/* Map from nir_register to nir_schedule_node * */
struct hash_table *reg_map;
return true;
nir_schedule_node *dst_n = entry->data;
- nir_schedule_node *src_n = nir_schedule_get_node(state->instr_map,
- src->parent_instr);
+ nir_schedule_node *src_n =
+ nir_schedule_get_node(state->scoreboard->instr_map,
+ src->parent_instr);
add_dep(state, dst_n, src_n);
if (dest->is_ssa)
return true;
- nir_schedule_node *dest_n = nir_schedule_get_node(state->instr_map,
- dest->reg.parent_instr);
+ nir_schedule_node *dest_n =
+ nir_schedule_get_node(state->scoreboard->instr_map,
+ dest->reg.parent_instr);
struct hash_entry *entry = _mesa_hash_table_search(state->reg_map,
dest->reg.reg);
nir_schedule_ssa_deps(nir_ssa_def *def, void *in_state)
{
nir_deps_state *state = in_state;
- nir_schedule_node *def_n = nir_schedule_get_node(state->instr_map, def->parent_instr);
+ struct hash_table *instr_map = state->scoreboard->instr_map;
+ nir_schedule_node *def_n = nir_schedule_get_node(instr_map, def->parent_instr);
nir_foreach_use(src, def) {
- nir_schedule_node *use_n = nir_schedule_get_node(state->instr_map,
+ nir_schedule_node *use_n = nir_schedule_get_node(instr_map,
src->parent_instr);
add_read_dep(state, def_n, use_n);
nir_schedule_intrinsic_deps(nir_deps_state *state,
nir_intrinsic_instr *instr)
{
- nir_schedule_node *n = nir_schedule_get_node(state->instr_map, &instr->instr);
+ nir_schedule_node *n = nir_schedule_get_node(state->scoreboard->instr_map,
+ &instr->instr);
switch (instr->intrinsic) {
case nir_intrinsic_load_uniform:
break;
case nir_intrinsic_store_output:
- /* For some non-FS shader stages, or for some hardware, output stores
- * affect the same shared memory as input loads.
+ /* For some hardware and stages, output stores affect the same shared
+ * memory as input loads.
*/
- if (state->shader->info.stage != MESA_SHADER_FRAGMENT)
+ if ((state->scoreboard->stages_with_shared_io_memory &
+ (1 << state->scoreboard->shader->info.stage)))
add_write_dep(state, &state->load_input, n);
/* Make sure that preceding discards stay before the store_output */
break;
case nir_intrinsic_load_input:
+ case nir_intrinsic_load_per_vertex_input:
add_read_dep(state, state->load_input, n);
break;
calculate_forward_deps(nir_schedule_scoreboard *scoreboard, nir_block *block)
{
nir_deps_state state = {
- .shader = scoreboard->shader,
+ .scoreboard = scoreboard,
.dir = F,
- .instr_map = scoreboard->instr_map,
.reg_map = _mesa_pointer_hash_table_create(NULL),
};
calculate_reverse_deps(nir_schedule_scoreboard *scoreboard, nir_block *block)
{
nir_deps_state state = {
- .shader = scoreboard->shader,
+ .scoreboard = scoreboard,
.dir = R,
- .instr_map = scoreboard->instr_map,
.reg_map = _mesa_pointer_hash_table_create(NULL),
};
}
static nir_schedule_scoreboard *
-nir_schedule_get_scoreboard(nir_shader *shader, int threshold)
+nir_schedule_get_scoreboard(nir_shader *shader,
+ const nir_schedule_options *options)
{
nir_schedule_scoreboard *scoreboard = rzalloc(NULL, nir_schedule_scoreboard);
scoreboard->shader = shader;
scoreboard->live_values = _mesa_pointer_set_create(scoreboard);
scoreboard->remaining_uses = _mesa_pointer_hash_table_create(scoreboard);
- scoreboard->threshold = threshold;
+ scoreboard->threshold = options->threshold;
+ scoreboard->stages_with_shared_io_memory =
+ options->stages_with_shared_io_memory;
scoreboard->pressure = 0;
nir_foreach_function(function, shader) {
* tune.
*/
void
-nir_schedule(nir_shader *shader, int threshold)
+nir_schedule(nir_shader *shader,
+ const nir_schedule_options *options)
{
nir_schedule_scoreboard *scoreboard = nir_schedule_get_scoreboard(shader,
- threshold);
+ options);
if (debug) {
fprintf(stderr, "NIR shader before scheduling:\n");