KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

d3d12: Update varying creation logic to handle location_frac 

When multiple variables are packed into the same location, we need
to re-construct variables that read/write the same components of that
register so that the DXIL signature is correct. We could try to
merge these variables, but getting the types right sounds harder than
just preserving the multiple individual variables.

Reviewed-by: Boris Brezillon <boris.brezillon@collabora.com>
Reviewed-by: Bill Kristiansen <billkris@microsoft.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/14399>
This commit is contained in:
Jesse Natalie 2022-01-05 07:38:38 -08:00 committed by Marge Bot
parent 1a231ec805
commit df302f5f90
4 changed files with 121 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
src/gallium/drivers/d3d12/d3d12_compiler.cpp
View File

@ -512,26 +512,36 @@ needs_vertex_reordering(struct d3d12_selection_context *sel_ctx, const struct pi
static nir_variable *
create_varying_from_info(nir_shader *nir, struct d3d12_varying_info *info,
unsigned slot, nir_variable_mode mode, bool patch)
unsigned slot, unsigned slot_frac, nir_variable_mode mode, bool patch)
{
nir_variable *var;
char tmp[100];
snprintf(tmp, ARRAY_SIZE(tmp),
mode == nir_var_shader_in ? "in_%d" : "out_%d",
info->vars[slot].driver_location);
var = nir_variable_create(nir, mode, info->vars[slot].type, tmp);
info->slots[slot].vars[slot_frac].driver_location);
var = nir_variable_create(nir, mode, info->slots[slot].types[slot_frac], tmp);
var->data.location = slot;
var->data.driver_location = info->vars[slot].driver_location;
var->data.interpolation = info->vars[slot].interpolation;
var->data.patch = info->vars[slot].patch;
var->data.compact = info->vars[slot].compact;
var->data.location_frac = slot_frac;
var->data.driver_location = info->slots[slot].vars[slot_frac].driver_location;
var->data.interpolation = info->slots[slot].vars[slot_frac].interpolation;
var->data.patch = info->slots[slot].patch;
var->data.compact = info->slots[slot].vars[slot_frac].compact;
if (patch)
var->data.location += VARYING_SLOT_PATCH0;
return var;
}
void
create_varyings_from_info(nir_shader *nir, struct d3d12_varying_info *info,
unsigned slot, nir_variable_mode mode, bool patch)
{
unsigned mask = info->slots[slot].location_frac_mask;
while (mask)
create_varying_from_info(nir, info, slot, u_bit_scan(&mask), mode, patch);
}
static void
fill_varyings(struct d3d12_varying_info *info, nir_shader *s,
nir_variable_mode modes, uint64_t mask, bool patch)
@ -547,12 +557,14 @@ fill_varyings(struct d3d12_varying_info *info, nir_shader *s,
if (!(mask & slot_bit))
continue;
info->vars[slot].driver_location = var->data.driver_location;
info->vars[slot].type = var->type;
info->vars[slot].interpolation = var->data.interpolation;
info->vars[slot].patch = var->data.patch;
info->vars[slot].compact = var->data.compact;
info->slots[slot].types[var->data.location_frac] = var->type;
info->slots[slot].patch = var->data.patch;
auto& var_slot = info->slots[slot].vars[var->data.location_frac];
var_slot.driver_location = var->data.driver_location;
var_slot.interpolation = var->data.interpolation;
var_slot.compact = var->data.compact;
info->mask |= slot_bit;
info->slots[slot].location_frac_mask |= (1 << var->data.location_frac);
}
}
@ -1066,14 +1078,14 @@ select_shader_variant(struct d3d12_selection_context *sel_ctx, d3d12_shader_sele
uint64_t mask = key.required_varying_inputs.mask & ~new_nir_variant->info.inputs_read;
while (mask) {
int slot = u_bit_scan64(&mask);
create_varying_from_info(new_nir_variant, &key.required_varying_inputs, slot, nir_var_shader_in, false);
create_varyings_from_info(new_nir_variant, &key.required_varying_inputs, slot, nir_var_shader_in, false);
}
if (sel->stage == PIPE_SHADER_TESS_EVAL) {
uint32_t patch_mask = (uint32_t)key.ds.required_patch_inputs.mask & ~new_nir_variant->info.patch_inputs_read;
while (patch_mask) {
int slot = u_bit_scan(&patch_mask);
create_varying_from_info(new_nir_variant, &key.ds.required_patch_inputs, slot, nir_var_shader_in, true);
create_varyings_from_info(new_nir_variant, &key.ds.required_patch_inputs, slot, nir_var_shader_in, true);
}
}
dxil_reassign_driver_locations(new_nir_variant, nir_var_shader_in,
@ -1085,14 +1097,14 @@ select_shader_variant(struct d3d12_selection_context *sel_ctx, d3d12_shader_sele
uint64_t mask = key.required_varying_outputs.mask & ~new_nir_variant->info.outputs_written;
while (mask) {
int slot = u_bit_scan64(&mask);
create_varying_from_info(new_nir_variant, &key.required_varying_outputs, slot, nir_var_shader_out, false);
create_varyings_from_info(new_nir_variant, &key.required_varying_outputs, slot, nir_var_shader_out, false);
}
if (sel->stage == PIPE_SHADER_TESS_CTRL) {
uint32_t patch_mask = (uint32_t)key.hs.required_patch_outputs.mask & ~new_nir_variant->info.patch_outputs_written;
while (patch_mask) {
int slot = u_bit_scan(&patch_mask);
create_varying_from_info(new_nir_variant, &key.ds.required_patch_inputs, slot, nir_var_shader_out, true);
create_varyings_from_info(new_nir_variant, &key.ds.required_patch_inputs, slot, nir_var_shader_out, true);
}
}
dxil_reassign_driver_locations(new_nir_variant, nir_var_shader_out,

15
src/gallium/drivers/d3d12/d3d12_compiler.h
View File

@ -70,12 +70,15 @@ d3d12_get_compiler_options(struct pipe_screen *screen,
struct d3d12_varying_info {
struct {
const struct glsl_type *type;
unsigned interpolation:3; // INTERP_MODE_COUNT = 5
unsigned driver_location:6; // VARYING_SLOT_MAX = 64
unsigned patch:1;
unsigned compact:1;
} vars[VARYING_SLOT_MAX];
const struct glsl_type *types[4];
uint8_t location_frac_mask:2;
uint8_t patch:1;
struct {
unsigned interpolation:3; // INTERP_MODE_COUNT = 5
unsigned driver_location:6; // VARYING_SLOT_MAX = 64
unsigned compact:1;
} vars[4];
} slots[VARYING_SLOT_MAX];
uint64_t mask;
};

107
src/gallium/drivers/d3d12/d3d12_gs_variant.cpp
View File

@ -77,31 +77,40 @@ d3d12_make_passthrough_gs(struct d3d12_context *ctx, struct d3d12_gs_variant_key
/* Copy inputs to outputs. */
while (varyings) {
nir_variable *in, *out;
char tmp[100];
const int i = u_bit_scan64(&varyings);
snprintf(tmp, ARRAY_SIZE(tmp), "in_%d", key->varyings.vars[i].driver_location);
in = nir_variable_create(nir,
nir_var_shader_in,
glsl_array_type(key->varyings.vars[i].type, 1, false),
tmp);
in->data.location = i;
in->data.driver_location = key->varyings.vars[i].driver_location;
in->data.interpolation = key->varyings.vars[i].interpolation;
unsigned frac_slots = key->varyings.slots[i].location_frac_mask;
while (frac_slots) {
nir_variable *in, *out;
int j = u_bit_scan(&frac_slots);
snprintf(tmp, ARRAY_SIZE(tmp), "out_%d", key->varyings.vars[i].driver_location);
out = nir_variable_create(nir,
nir_var_shader_out,
key->varyings.vars[i].type,
tmp);
out->data.location = i;
out->data.driver_location = key->varyings.vars[i].driver_location;
out->data.interpolation = key->varyings.vars[i].interpolation;
snprintf(tmp, ARRAY_SIZE(tmp), "in_%d", key->varyings.slots[i].vars[j].driver_location);
in = nir_variable_create(nir,
nir_var_shader_in,
glsl_array_type(key->varyings.slots[i].types[j], 1, false),
tmp);
in->data.location = i;
in->data.location_frac = j;
in->data.driver_location = key->varyings.slots[i].vars[j].driver_location;
in->data.interpolation = key->varyings.slots[i].vars[j].interpolation;
in->data.compact = key->varyings.slots[i].vars[j].compact;
nir_deref_instr *in_value = nir_build_deref_array(&b, nir_build_deref_var(&b, in),
nir_imm_int(&b, 0));
nir_copy_deref(&b, nir_build_deref_var(&b, out), in_value);
snprintf(tmp, ARRAY_SIZE(tmp), "out_%d", key->varyings.slots[i].vars[j].driver_location);
out = nir_variable_create(nir,
nir_var_shader_out,
key->varyings.slots[i].types[j],
tmp);
out->data.location = i;
out->data.location_frac = j;
out->data.driver_location = key->varyings.slots[i].vars[j].driver_location;
out->data.interpolation = key->varyings.slots[i].vars[j].interpolation;
out->data.compact = key->varyings.slots[i].vars[j].compact;
nir_deref_instr *in_value = nir_build_deref_array(&b, nir_build_deref_var(&b, in),
nir_imm_int(&b, 0));
nir_copy_deref(&b, nir_build_deref_var(&b, out), in_value);
}
}
nir_emit_vertex(&b, 0);
@ -168,33 +177,41 @@ d3d12_begin_emit_primitives_gs(struct emit_primitives_context *emit_ctx,
char tmp[100];
const int i = u_bit_scan64(&varyings);
snprintf(tmp, ARRAY_SIZE(tmp), "in_%d", emit_ctx->num_vars);
emit_ctx->in[emit_ctx->num_vars] = nir_variable_create(nir,
nir_var_shader_in,
glsl_array_type(key->varyings.vars[i].type, 3, 0),
tmp);
emit_ctx->in[emit_ctx->num_vars]->data.location = i;
emit_ctx->in[emit_ctx->num_vars]->data.driver_location = key->varyings.vars[i].driver_location;
emit_ctx->in[emit_ctx->num_vars]->data.interpolation = key->varyings.vars[i].interpolation;
unsigned frac_slots = key->varyings.slots[i].location_frac_mask;
while (frac_slots) {
int j = u_bit_scan(&frac_slots);
snprintf(tmp, ARRAY_SIZE(tmp), "in_%d", emit_ctx->num_vars);
emit_ctx->in[emit_ctx->num_vars] = nir_variable_create(nir,
nir_var_shader_in,
glsl_array_type(key->varyings.slots[i].types[j], 3, 0),
tmp);
emit_ctx->in[emit_ctx->num_vars]->data.location = i;
emit_ctx->in[emit_ctx->num_vars]->data.location_frac = j;
emit_ctx->in[emit_ctx->num_vars]->data.driver_location = key->varyings.slots[i].vars[j].driver_location;
emit_ctx->in[emit_ctx->num_vars]->data.interpolation = key->varyings.slots[i].vars[j].interpolation;
emit_ctx->in[emit_ctx->num_vars]->data.compact = key->varyings.slots[i].vars[j].compact;
/* Don't create an output for the edge flag variable */
if (i == VARYING_SLOT_EDGE) {
edgeflag_var = emit_ctx->in[emit_ctx->num_vars];
continue;
} else if (i == VARYING_SLOT_POS) {
pos_var = emit_ctx->in[emit_ctx->num_vars];
/* Don't create an output for the edge flag variable */
if (i == VARYING_SLOT_EDGE) {
edgeflag_var = emit_ctx->in[emit_ctx->num_vars];
continue;
} else if (i == VARYING_SLOT_POS) {
pos_var = emit_ctx->in[emit_ctx->num_vars];
}
snprintf(tmp, ARRAY_SIZE(tmp), "out_%d", emit_ctx->num_vars);
emit_ctx->out[emit_ctx->num_vars] = nir_variable_create(nir,
nir_var_shader_out,
key->varyings.slots[i].types[j],
tmp);
emit_ctx->out[emit_ctx->num_vars]->data.location = i;
emit_ctx->out[emit_ctx->num_vars]->data.location_frac = j;
emit_ctx->out[emit_ctx->num_vars]->data.driver_location = key->varyings.slots[i].vars[j].driver_location;
emit_ctx->out[emit_ctx->num_vars]->data.interpolation = key->varyings.slots[i].vars[j].interpolation;
emit_ctx->out[emit_ctx->num_vars]->data.compact = key->varyings.slots[i].vars[j].compact;
emit_ctx->num_vars++;
}
snprintf(tmp, ARRAY_SIZE(tmp), "out_%d", emit_ctx->num_vars);
emit_ctx->out[emit_ctx->num_vars] = nir_variable_create(nir,
nir_var_shader_out,
key->varyings.vars[i].type,
tmp);
emit_ctx->out[emit_ctx->num_vars]->data.location = i;
emit_ctx->out[emit_ctx->num_vars]->data.driver_location = key->varyings.vars[i].driver_location;
emit_ctx->out[emit_ctx->num_vars]->data.interpolation = key->varyings.vars[i].interpolation;
emit_ctx->num_vars++;
}
if (key->has_front_face) {

42
src/gallium/drivers/d3d12/d3d12_tcs_variant.cpp
View File

@ -69,28 +69,30 @@ create_tess_ctrl_shader_variant(struct d3d12_context *ctx, struct d3d12_tcs_vari
while(varying_mask) {
int var_idx = u_bit_scan64(&varying_mask);
auto var = &key->varyings.vars[var_idx];
const struct glsl_type *type = var->type;
const struct glsl_type *in_type = var->type;
const struct glsl_type *out_type = var->type;
in_type = glsl_array_type(type, key->vertices_out, 0);
out_type = glsl_array_type(type, key->vertices_out, 0);
auto slot = &key->varyings.slots[var_idx];
unsigned frac_mask = slot->location_frac_mask;
while (frac_mask) {
int frac = u_bit_scan(&frac_mask);
auto var = &slot->vars[frac];
const struct glsl_type *type = glsl_array_type(slot->types[frac], key->vertices_out, 0);
char buf[1024];
snprintf(buf, sizeof(buf), "in_%d", var->driver_location);
nir_variable *in = nir_variable_create(nir, nir_var_shader_in, in_type, buf);
snprintf(buf, sizeof(buf), "out_%d", var->driver_location);
nir_variable *out = nir_variable_create(nir, nir_var_shader_out, out_type, buf);
out->data.location = in->data.location = var_idx;
out->data.driver_location = in->data.driver_location = var->driver_location;
char buf[1024];
snprintf(buf, sizeof(buf), "in_%d", var->driver_location);
nir_variable *in = nir_variable_create(nir, nir_var_shader_in, type, buf);
snprintf(buf, sizeof(buf), "out_%d", var->driver_location);
nir_variable *out = nir_variable_create(nir, nir_var_shader_out, type, buf);
out->data.location = in->data.location = var_idx;
out->data.location_frac = in->data.location_frac = frac;
out->data.driver_location = in->data.driver_location = var->driver_location;
for (unsigned i = 0; i < key->vertices_out; i++) {
nir_if *start_block = nir_push_if(&b, nir_ieq(&b, invocation_id, nir_imm_int(&b, i)));
nir_deref_instr *in_array_var = nir_build_deref_array(&b, nir_build_deref_var(&b, in), invocation_id);
nir_ssa_def *load = nir_load_deref(&b, in_array_var);
nir_deref_instr *out_array_var = nir_build_deref_array_imm(&b, nir_build_deref_var(&b, out), i);
nir_store_deref(&b, out_array_var, load, 0xff);
nir_pop_if(&b, start_block);
for (unsigned i = 0; i < key->vertices_out; i++) {
nir_if *start_block = nir_push_if(&b, nir_ieq(&b, invocation_id, nir_imm_int(&b, i)));
nir_deref_instr *in_array_var = nir_build_deref_array(&b, nir_build_deref_var(&b, in), invocation_id);
nir_ssa_def *load = nir_load_deref(&b, in_array_var);
nir_deref_instr *out_array_var = nir_build_deref_array_imm(&b, nir_build_deref_var(&b, out), i);
nir_store_deref(&b, out_array_var, load, 0xff);
nir_pop_if(&b, start_block);
}
}
}
nir_variable *gl_TessLevelInner = nir_variable_create(nir, nir_var_shader_out, glsl_array_type(glsl_float_type(), 2, 0), "gl_TessLevelInner");