This extension provides new GLSL built-in functions beginInvocationInterlockARB() and endInvocationInterlockARB() that delimit a critical section of fragment shader code. For pairs of shader invocations with "overlapping" coverage in a given pixel, the OpenGL implementation will guarantee that the critical section of the fragment shader will be executed for only one fragment at a time.
Signed-off-by: Plamena Manolova <[email protected]> --- src/compiler/glsl/ast.h | 10 ++++ src/compiler/glsl/ast_to_hir.cpp | 10 ++++ src/compiler/glsl/ast_type.cpp | 30 +++++++++++- src/compiler/glsl/builtin_functions.cpp | 79 ++++++++++++++++++++++++++++++++ src/compiler/glsl/glsl_parser.yy | 46 +++++++++++++++++++ src/compiler/glsl/glsl_parser_extras.cpp | 13 ++++++ src/compiler/glsl/glsl_parser_extras.h | 7 +++ src/compiler/glsl/glsl_to_nir.cpp | 12 +++++ src/compiler/glsl/ir.h | 2 + src/compiler/glsl/linker.cpp | 8 ++++ src/compiler/nir/nir_intrinsics.h | 2 + src/compiler/shader_info.h | 5 ++ src/mesa/main/extensions_table.h | 1 + src/mesa/main/mtypes.h | 5 ++ 14 files changed, 229 insertions(+), 1 deletion(-) diff --git a/src/compiler/glsl/ast.h b/src/compiler/glsl/ast.h index a1ec0d566f..319a6a82c1 100644 --- a/src/compiler/glsl/ast.h +++ b/src/compiler/glsl/ast.h @@ -620,6 +620,16 @@ struct ast_type_qualifier { * Flag set if GL_ARB_post_depth_coverage layout qualifier is used. */ unsigned post_depth_coverage:1; + + /** + * Flags for the layout qualifers added by ARB_fragment_shader_interlock + */ + + unsigned pixel_interlock_ordered:1; + unsigned pixel_interlock_unordered:1; + unsigned sample_interlock_ordered:1; + unsigned sample_interlock_unordered:1; + /** * Flag set if GL_INTEL_conservartive_rasterization layout qualifier * is used. diff --git a/src/compiler/glsl/ast_to_hir.cpp b/src/compiler/glsl/ast_to_hir.cpp index badfbe6816..2358153c5f 100644 --- a/src/compiler/glsl/ast_to_hir.cpp +++ b/src/compiler/glsl/ast_to_hir.cpp @@ -3897,6 +3897,16 @@ apply_layout_qualifier_to_variable(const struct ast_type_qualifier *qual, if (state->has_bindless()) apply_bindless_qualifier_to_variable(qual, var, state, loc); + + if (qual->flags.q.pixel_interlock_ordered || + qual->flags.q.pixel_interlock_unordered || + qual->flags.q.sample_interlock_ordered || + qual->flags.q.sample_interlock_unordered) { + _mesa_glsl_error(loc, state, "interlock layout qualifiers: " + "pixel_interlock_ordered, pixel_interlock_unordered, " + "sample_interlock_ordered and sample_interlock_unordered, " + "only valid in fragment shader input layout declaration."); + } } static void diff --git a/src/compiler/glsl/ast_type.cpp b/src/compiler/glsl/ast_type.cpp index 14ea936f24..49697d3411 100644 --- a/src/compiler/glsl/ast_type.cpp +++ b/src/compiler/glsl/ast_type.cpp @@ -637,6 +637,10 @@ ast_type_qualifier::validate_in_qualifier(YYLTYPE *loc, valid_in_mask.flags.q.early_fragment_tests = 1; valid_in_mask.flags.q.inner_coverage = 1; valid_in_mask.flags.q.post_depth_coverage = 1; + valid_in_mask.flags.q.pixel_interlock_ordered = 1; + valid_in_mask.flags.q.pixel_interlock_unordered = 1; + valid_in_mask.flags.q.sample_interlock_ordered = 1; + valid_in_mask.flags.q.sample_interlock_unordered = 1; break; case MESA_SHADER_COMPUTE: valid_in_mask.flags.q.local_size = 7; @@ -708,6 +712,26 @@ ast_type_qualifier::merge_into_in_qualifier(YYLTYPE *loc, r = false; } + if (state->in_qualifier->flags.q.pixel_interlock_ordered) { + state->fs_pixel_interlock_ordered = true; + state->in_qualifier->flags.q.pixel_interlock_ordered = false; + } + + if (state->in_qualifier->flags.q.pixel_interlock_unordered) { + state->fs_pixel_interlock_unordered = true; + state->in_qualifier->flags.q.pixel_interlock_unordered = false; + } + + if (state->in_qualifier->flags.q.sample_interlock_ordered) { + state->fs_sample_interlock_ordered = true; + state->in_qualifier->flags.q.sample_interlock_ordered = false; + } + + if (state->in_qualifier->flags.q.sample_interlock_unordered) { + state->fs_sample_interlock_unordered = true; + state->in_qualifier->flags.q.sample_interlock_unordered = false; + } + /* We allow the creation of multiple cs_input_layout nodes. Coherence among * all existing nodes is checked later, when the AST node is transformed * into HIR. @@ -776,7 +800,7 @@ ast_type_qualifier::validate_flags(YYLTYPE *loc, "%s '%s':" "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s" "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s" - "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n", + "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n", message, name, bad.flags.q.invariant ? " invariant" : "", bad.flags.q.precise ? " precise" : "", @@ -840,6 +864,10 @@ ast_type_qualifier::validate_flags(YYLTYPE *loc, bad.flags.q.bound_sampler ? " bound_sampler" : "", bad.flags.q.bound_image ? " bound_image" : "", bad.flags.q.post_depth_coverage ? " post_depth_coverage" : "", + bad.flags.q.pixel_interlock_ordered ? " pixel_interlock_ordered" : "", + bad.flags.q.pixel_interlock_unordered ? " pixel_interlock_unordered": "", + bad.flags.q.sample_interlock_ordered ? " sample_interlock_ordered": "", + bad.flags.q.sample_interlock_unordered ? " sample_interlock_unordered": "", bad.flags.q.non_coherent ? " noncoherent" : ""); return false; } diff --git a/src/compiler/glsl/builtin_functions.cpp b/src/compiler/glsl/builtin_functions.cpp index 5f772c9eab..52c05feb35 100644 --- a/src/compiler/glsl/builtin_functions.cpp +++ b/src/compiler/glsl/builtin_functions.cpp @@ -513,6 +513,12 @@ shader_ballot(const _mesa_glsl_parse_state *state) } static bool +supports_arb_fragment_shader_interlock(const _mesa_glsl_parse_state *state) +{ + return state->ARB_fragment_shader_interlock_enable; +} + +static bool shader_clock(const _mesa_glsl_parse_state *state) { return state->ARB_shader_clock_enable; @@ -982,6 +988,21 @@ private: ir_function_signature *_read_invocation_intrinsic(const glsl_type *type); ir_function_signature *_read_invocation(const glsl_type *type); + + ir_function_signature *_begin_invocation_interlock_ARB_intrinsic( + builtin_available_predicate avail, + enum ir_intrinsic_id id); + ir_function_signature *_begin_invocation_interlock_ARB( + const char *intrinsic_name, + builtin_available_predicate avail); + + ir_function_signature *_end_invocation_interlock_ARB_intrinsic( + builtin_available_predicate avail, + enum ir_intrinsic_id id); + ir_function_signature *_end_invocation_interlock_ARB( + const char *intrinsic_name, + builtin_available_predicate avail); + ir_function_signature *_shader_clock_intrinsic(builtin_available_predicate avail, const glsl_type *type); ir_function_signature *_shader_clock(builtin_available_predicate avail, @@ -1219,6 +1240,16 @@ builtin_builder::create_intrinsics() ir_intrinsic_memory_barrier_shared), NULL); + add_function("__intrinsic_begin_invocation_interlock_ARB", + _begin_invocation_interlock_ARB_intrinsic( + supports_arb_fragment_shader_interlock, + ir_intrinsic_begin_invocation_interlock_ARB), NULL); + + add_function("__intrinsic_end_invocation_interlock_ARB", + _end_invocation_interlock_ARB_intrinsic( + supports_arb_fragment_shader_interlock, + ir_intrinsic_end_invocation_interlock_ARB), NULL); + add_function("__intrinsic_shader_clock", _shader_clock_intrinsic(shader_clock, glsl_type::uvec2_type), @@ -3294,6 +3325,18 @@ builtin_builder::create_builtins() glsl_type::uint64_t_type), NULL); + add_function("beginInvocationInterlockARB", + _begin_invocation_interlock_ARB( + "__intrinsic_begin_invocation_interlock_ARB", + supports_arb_fragment_shader_interlock), + NULL); + + add_function("endInvocationInterlockARB", + _end_invocation_interlock_ARB( + "__intrinsic_end_invocation_interlock_ARB", + supports_arb_fragment_shader_interlock), + NULL); + add_function("anyInvocationARB", _vote("__intrinsic_vote_any", vote), NULL); @@ -6228,6 +6271,42 @@ builtin_builder::_read_invocation(const glsl_type *type) } ir_function_signature * +builtin_builder::_begin_invocation_interlock_ARB_intrinsic(builtin_available_predicate avail, + enum ir_intrinsic_id id) +{ + MAKE_INTRINSIC(glsl_type::void_type, id, avail, 0); + return sig; +} + +ir_function_signature * +builtin_builder::_begin_invocation_interlock_ARB(const char *intrinsic_name, + builtin_available_predicate avail) +{ + MAKE_SIG(glsl_type::void_type, avail, 0); + body.emit(call(shader->symbols->get_function(intrinsic_name), + NULL, sig->parameters)); + return sig; +} + +ir_function_signature * +builtin_builder::_end_invocation_interlock_ARB_intrinsic(builtin_available_predicate avail, + enum ir_intrinsic_id id) +{ + MAKE_INTRINSIC(glsl_type::void_type, id, avail, 0); + return sig; +} + +ir_function_signature * +builtin_builder::_end_invocation_interlock_ARB(const char *intrinsic_name, + builtin_available_predicate avail) +{ + MAKE_SIG(glsl_type::void_type, avail, 0); + body.emit(call(shader->symbols->get_function(intrinsic_name), + NULL, sig->parameters)); + return sig; +} + +ir_function_signature * builtin_builder::_shader_clock_intrinsic(builtin_available_predicate avail, const glsl_type *type) { diff --git a/src/compiler/glsl/glsl_parser.yy b/src/compiler/glsl/glsl_parser.yy index e5ea41d4df..49f562551d 100644 --- a/src/compiler/glsl/glsl_parser.yy +++ b/src/compiler/glsl/glsl_parser.yy @@ -1432,6 +1432,52 @@ layout_qualifier_id: } } + int pixel_interlock_ordered = match_layout_qualifier($1, + "pixel_interlock_ordered", state) == 0 ? 1 : 0; + int pixel_interlock_unordered = match_layout_qualifier($1, + "pixel_interlock_unordered", state) == 0 ? 1 : 0; + int sample_interlock_ordered = match_layout_qualifier($1, + "sample_interlock_ordered", state) == 0 ? 1 : 0; + int sample_interlock_unordered = match_layout_qualifier($1, + "sample_interlock_unordered", state) == 0 ? 1 : 0; + + if (pixel_interlock_ordered + pixel_interlock_unordered + + sample_interlock_ordered + sample_interlock_unordered > 0 && + state->stage != MESA_SHADER_FRAGMENT) { + _mesa_glsl_error(& @1, state, "interlock layout qualifiers: " + "pixel_interlock_ordered, pixel_interlock_unordered, " + "sample_interlock_ordered and sample_interlock_unordered, " + "only valid in fragment shader input layout declaration."); + } else if (pixel_interlock_ordered + pixel_interlock_unordered + + sample_interlock_ordered + sample_interlock_unordered > 0 && + !state->ARB_fragment_shader_interlock_enable) { + _mesa_glsl_error(& @1, state, + "interlock layout qualifier present, but the " + "GL_ARB_fragment_shader_interlock extension is not " + "enabled."); + } else if (pixel_interlock_ordered + pixel_interlock_unordered + + sample_interlock_ordered + sample_interlock_unordered > 1) { + _mesa_glsl_error(& @1, state, + "only one interlock mode can be used at any time."); + } else if (pixel_interlock_ordered + pixel_interlock_unordered > 0 && + state->ctx->Multisample.Enabled) { + _mesa_glsl_error(& @1, state, + "pixel_interlock_ordered and " + "pixel_interlock_unordered can only be used when " + "multisampling is disabled."); + } else if (sample_interlock_ordered + sample_interlock_unordered > 0 && + !state->ctx->Multisample.Enabled) { + _mesa_glsl_error(& @1, state, + "sample_interlock_ordered and " + "sample_interlock_unordered can only be used when " + "multisampling is enabled."); + } else { + $$.flags.q.pixel_interlock_ordered = pixel_interlock_ordered; + $$.flags.q.pixel_interlock_unordered = pixel_interlock_unordered; + $$.flags.q.sample_interlock_ordered = sample_interlock_ordered; + $$.flags.q.sample_interlock_unordered = sample_interlock_unordered; + } + /* Layout qualifiers for tessellation evaluation shaders. */ if (!$$.flags.i) { static const struct { diff --git a/src/compiler/glsl/glsl_parser_extras.cpp b/src/compiler/glsl/glsl_parser_extras.cpp index 275c4d7571..0819a900fc 100644 --- a/src/compiler/glsl/glsl_parser_extras.cpp +++ b/src/compiler/glsl/glsl_parser_extras.cpp @@ -300,6 +300,10 @@ _mesa_glsl_parse_state::_mesa_glsl_parse_state(struct gl_context *_ctx, this->fs_early_fragment_tests = false; this->fs_inner_coverage = false; this->fs_post_depth_coverage = false; + this->fs_pixel_interlock_ordered = false; + this->fs_pixel_interlock_unordered = false; + this->fs_sample_interlock_ordered = false; + this->fs_sample_interlock_unordered = false; this->fs_blend_support = 0; memset(this->atomic_counter_offsets, 0, sizeof(this->atomic_counter_offsets)); @@ -629,6 +633,7 @@ static const _mesa_glsl_extension _mesa_glsl_supported_extensions[] = { EXT(ARB_explicit_uniform_location), EXT(ARB_fragment_coord_conventions), EXT(ARB_fragment_layer_viewport), + EXT(ARB_fragment_shader_interlock), EXT(ARB_gpu_shader5), EXT(ARB_gpu_shader_fp64), EXT(ARB_gpu_shader_int64), @@ -1720,6 +1725,10 @@ set_shader_inout_layout(struct gl_shader *shader, assert(!state->fs_early_fragment_tests); assert(!state->fs_inner_coverage); assert(!state->fs_post_depth_coverage); + assert(!state->fs_pixel_interlock_ordered); + assert(!state->fs_pixel_interlock_unordered); + assert(!state->fs_sample_interlock_ordered); + assert(!state->fs_sample_interlock_unordered); } for (unsigned i = 0; i < MAX_FEEDBACK_BUFFERS; i++) { @@ -1841,6 +1850,10 @@ set_shader_inout_layout(struct gl_shader *shader, shader->EarlyFragmentTests = state->fs_early_fragment_tests; shader->InnerCoverage = state->fs_inner_coverage; shader->PostDepthCoverage = state->fs_post_depth_coverage; + shader->PixelInterlockOrdered = state->fs_pixel_interlock_ordered; + shader->PixelInterlockUnordered = state->fs_pixel_interlock_unordered; + shader->SampleInterlockOrdered = state->fs_sample_interlock_ordered; + shader->SampleInterlockUnordered = state->fs_sample_interlock_unordered; shader->BlendSupport = state->fs_blend_support; break; diff --git a/src/compiler/glsl/glsl_parser_extras.h b/src/compiler/glsl/glsl_parser_extras.h index 66bd1a3db6..03b7fa9310 100644 --- a/src/compiler/glsl/glsl_parser_extras.h +++ b/src/compiler/glsl/glsl_parser_extras.h @@ -634,6 +634,8 @@ struct _mesa_glsl_parse_state { bool ARB_fragment_coord_conventions_warn; bool ARB_fragment_layer_viewport_enable; bool ARB_fragment_layer_viewport_warn; + bool ARB_fragment_shader_interlock_enable; + bool ARB_fragment_shader_interlock_warn; bool ARB_gpu_shader5_enable; bool ARB_gpu_shader5_warn; bool ARB_gpu_shader_fp64_enable; @@ -828,6 +830,11 @@ struct _mesa_glsl_parse_state { bool fs_post_depth_coverage; + bool fs_pixel_interlock_ordered; + bool fs_pixel_interlock_unordered; + bool fs_sample_interlock_ordered; + bool fs_sample_interlock_unordered; + unsigned fs_blend_support; /** diff --git a/src/compiler/glsl/glsl_to_nir.cpp b/src/compiler/glsl/glsl_to_nir.cpp index 80eb15f1ab..c5666bd443 100644 --- a/src/compiler/glsl/glsl_to_nir.cpp +++ b/src/compiler/glsl/glsl_to_nir.cpp @@ -750,6 +750,12 @@ nir_visitor::visit(ir_call *ir) case ir_intrinsic_shader_clock: op = nir_intrinsic_shader_clock; break; + case ir_intrinsic_begin_invocation_interlock_ARB: + op = nir_intrinsic_begin_invocation_interlock_ARB; + break; + case ir_intrinsic_end_invocation_interlock_ARB: + op = nir_intrinsic_end_invocation_interlock_ARB; + break; case ir_intrinsic_group_memory_barrier: op = nir_intrinsic_group_memory_barrier; break; @@ -968,6 +974,12 @@ nir_visitor::visit(ir_call *ir) instr->num_components = 2; nir_builder_instr_insert(&b, &instr->instr); break; + case nir_intrinsic_begin_invocation_interlock_ARB: + nir_builder_instr_insert(&b, &instr->instr); + break; + case nir_intrinsic_end_invocation_interlock_ARB: + nir_builder_instr_insert(&b, &instr->instr); + break; case nir_intrinsic_store_ssbo: { exec_node *param = ir->actual_parameters.get_head(); ir_rvalue *block = ((ir_instruction *)param)->as_rvalue(); diff --git a/src/compiler/glsl/ir.h b/src/compiler/glsl/ir.h index 6d3ef89eb8..e36666650d 100644 --- a/src/compiler/glsl/ir.h +++ b/src/compiler/glsl/ir.h @@ -1121,6 +1121,8 @@ enum ir_intrinsic_id { ir_intrinsic_memory_barrier_buffer, ir_intrinsic_memory_barrier_image, ir_intrinsic_memory_barrier_shared, + ir_intrinsic_begin_invocation_interlock_ARB, + ir_intrinsic_end_invocation_interlock_ARB, ir_intrinsic_vote_all, ir_intrinsic_vote_any, diff --git a/src/compiler/glsl/linker.cpp b/src/compiler/glsl/linker.cpp index 1444b68cb0..8d41d2ba04 100644 --- a/src/compiler/glsl/linker.cpp +++ b/src/compiler/glsl/linker.cpp @@ -1977,6 +1977,14 @@ link_fs_inout_layout_qualifiers(struct gl_shader_program *prog, linked_shader->Program->info.fs.inner_coverage |= shader->InnerCoverage; linked_shader->Program->info.fs.post_depth_coverage |= shader->PostDepthCoverage; + linked_shader->Program->info.fs.pixel_interlock_ordered |= + shader->PixelInterlockOrdered; + linked_shader->Program->info.fs.pixel_interlock_unordered |= + shader->PixelInterlockUnordered; + linked_shader->Program->info.fs.sample_interlock_ordered |= + shader->SampleInterlockOrdered; + linked_shader->Program->info.fs.sample_interlock_unordered |= + shader->SampleInterlockUnordered; linked_shader->Program->sh.fs.BlendSupport |= shader->BlendSupport; } diff --git a/src/compiler/nir/nir_intrinsics.h b/src/compiler/nir/nir_intrinsics.h index 7b737559d5..b227051fd8 100644 --- a/src/compiler/nir/nir_intrinsics.h +++ b/src/compiler/nir/nir_intrinsics.h @@ -129,6 +129,8 @@ BARRIER(memory_barrier_buffer) BARRIER(memory_barrier_image) BARRIER(memory_barrier_shared) +BARRIER(begin_invocation_interlock_ARB) +BARRIER(end_invocation_interlock_ARB) /** A conditional discard, with a single boolean source. */ INTRINSIC(discard_if, 1, ARR(1), false, 0, 0, 0, xx, xx, xx, 0) diff --git a/src/compiler/shader_info.h b/src/compiler/shader_info.h index b1e200070f..0570c08939 100644 --- a/src/compiler/shader_info.h +++ b/src/compiler/shader_info.h @@ -174,6 +174,11 @@ typedef struct shader_info { bool pixel_center_integer; + bool pixel_interlock_ordered; + bool pixel_interlock_unordered; + bool sample_interlock_ordered; + bool sample_interlock_unordered; + /** gl_FragDepth layout for ARB_conservative_depth. */ enum gl_frag_depth_layout depth_layout; } fs; diff --git a/src/mesa/main/extensions_table.h b/src/mesa/main/extensions_table.h index 492f7c3d20..79842a5f5d 100644 --- a/src/mesa/main/extensions_table.h +++ b/src/mesa/main/extensions_table.h @@ -68,6 +68,7 @@ EXT(ARB_fragment_layer_viewport , ARB_fragment_layer_viewport EXT(ARB_fragment_program , ARB_fragment_program , GLL, x , x , x , 2002) EXT(ARB_fragment_program_shadow , ARB_fragment_program_shadow , GLL, x , x , x , 2003) EXT(ARB_fragment_shader , ARB_fragment_shader , GLL, GLC, x , x , 2002) +EXT(ARB_fragment_shader_interlock , ARB_fragment_shader_interlock , GLL, GLC, x , x , 2015) EXT(ARB_framebuffer_no_attachments , ARB_framebuffer_no_attachments , GLL, GLC, x , x , 2012) EXT(ARB_framebuffer_object , ARB_framebuffer_object , GLL, GLC, x , x , 2005) EXT(ARB_framebuffer_sRGB , EXT_framebuffer_sRGB , GLL, GLC, x , x , 1998) diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h index 2df2288899..8bc76ab9b7 100644 --- a/src/mesa/main/mtypes.h +++ b/src/mesa/main/mtypes.h @@ -2738,6 +2738,10 @@ struct gl_shader bool uses_gl_fragcoord; bool PostDepthCoverage; + bool PixelInterlockOrdered; + bool PixelInterlockUnordered; + bool SampleInterlockOrdered; + bool SampleInterlockUnordered; bool InnerCoverage; /** @@ -4199,6 +4203,7 @@ struct gl_extensions GLboolean ARB_fragment_shader; GLboolean ARB_framebuffer_no_attachments; GLboolean ARB_framebuffer_object; + GLboolean ARB_fragment_shader_interlock; GLboolean ARB_enhanced_layouts; GLboolean ARB_explicit_attrib_location; GLboolean ARB_explicit_uniform_location; -- 2.11.0 _______________________________________________ mesa-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/mesa-dev
