From 9e9f3f4e71e763ad71c4572377380f42e54f542f Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Mon, 18 Apr 2016 15:53:14 -0700 Subject: [PATCH] anv/gen8_pipeline: Use the new emit macro MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Acked-by: Kristian Høgsberg --- src/intel/vulkan/gen8_pipeline.c | 368 ++++++++++++++++--------------- 1 file changed, 191 insertions(+), 177 deletions(-) diff --git a/src/intel/vulkan/gen8_pipeline.c b/src/intel/vulkan/gen8_pipeline.c index 6f6868ea5ea..f4224e0a2e3 100644 --- a/src/intel/vulkan/gen8_pipeline.c +++ b/src/intel/vulkan/gen8_pipeline.c @@ -39,8 +39,9 @@ emit_ia_state(struct anv_pipeline *pipeline, const VkPipelineInputAssemblyStateCreateInfo *info, const struct anv_graphics_pipeline_create_info *extra) { - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_VF_TOPOLOGY), - .PrimitiveTopologyType = pipeline->topology); + anv_batch_emit_blk(&pipeline->batch, GENX(3DSTATE_VF_TOPOLOGY), vft) { + vft.PrimitiveTopologyType = pipeline->topology; + } } static void @@ -191,26 +192,28 @@ emit_cb_state(struct anv_pipeline *pipeline, struct GENX(BLEND_STATE_ENTRY) *bs0 = &blend_state.Entry[0]; - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_PS_BLEND), - .AlphaToCoverageEnable = blend_state.AlphaToCoverageEnable, - .HasWriteableRT = has_writeable_rt, - .ColorBufferBlendEnable = bs0->ColorBufferBlendEnable, - .SourceAlphaBlendFactor = bs0->SourceAlphaBlendFactor, - .DestinationAlphaBlendFactor = - bs0->DestinationAlphaBlendFactor, - .SourceBlendFactor = bs0->SourceBlendFactor, - .DestinationBlendFactor = bs0->DestinationBlendFactor, - .AlphaTestEnable = false, - .IndependentAlphaBlendEnable = - blend_state.IndependentAlphaBlendEnable); + anv_batch_emit_blk(&pipeline->batch, GENX(3DSTATE_PS_BLEND), blend) { + blend.AlphaToCoverageEnable = blend_state.AlphaToCoverageEnable; + blend.HasWriteableRT = has_writeable_rt; + blend.ColorBufferBlendEnable = bs0->ColorBufferBlendEnable; + blend.SourceAlphaBlendFactor = bs0->SourceAlphaBlendFactor; + blend.DestinationAlphaBlendFactor = bs0->DestinationAlphaBlendFactor; + blend.SourceBlendFactor = bs0->SourceBlendFactor; + blend.DestinationBlendFactor = bs0->DestinationBlendFactor; + blend.AlphaTestEnable = false; + blend.IndependentAlphaBlendEnable = + blend_state.IndependentAlphaBlendEnable; + } GENX(BLEND_STATE_pack)(NULL, pipeline->blend_state.map, &blend_state); if (!device->info.has_llc) anv_state_clflush(pipeline->blend_state); - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_BLEND_STATE_POINTERS), - .BlendStatePointer = pipeline->blend_state.offset, - .BlendStatePointerValid = true); + anv_batch_emit_blk(&pipeline->batch, + GENX(3DSTATE_BLEND_STATE_POINTERS), bsp) { + bsp.BlendStatePointer = pipeline->blend_state.offset; + bsp.BlendStatePointerValid = true; + } } static void @@ -288,20 +291,21 @@ emit_ms_state(struct anv_pipeline *pipeline, if (info && info->sampleShadingEnable) anv_finishme("VkPipelineMultisampleStateCreateInfo::sampleShadingEnable"); - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_MULTISAMPLE), - + anv_batch_emit_blk(&pipeline->batch, GENX(3DSTATE_MULTISAMPLE), ms) { /* The PRM says that this bit is valid only for DX9: * * SW can choose to set this bit only for DX9 API. DX10/OGL API's * should not have any effect by setting or not setting this bit. */ - .PixelPositionOffsetEnable = false, + ms.PixelPositionOffsetEnable = false; - .PixelLocation = CENTER, - .NumberofMultisamples = log2_samples); + ms.PixelLocation = CENTER; + ms.NumberofMultisamples = log2_samples; + } - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_SAMPLE_MASK), - .SampleMask = sample_mask); + anv_batch_emit_blk(&pipeline->batch, GENX(3DSTATE_SAMPLE_MASK), sm) { + sm.SampleMask = sample_mask; + } } VkResult @@ -347,85 +351,88 @@ genX(graphics_pipeline_create)( emit_urb_setup(pipeline); const struct brw_wm_prog_data *wm_prog_data = get_wm_prog_data(pipeline); - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_CLIP), - .ClipEnable = !(extra && extra->use_rectlist), - .EarlyCullEnable = true, - .APIMode = 1, /* D3D */ - .ViewportXYClipTestEnable = true, - - .ClipMode = - pCreateInfo->pRasterizationState->rasterizerDiscardEnable ? - REJECT_ALL : NORMAL, - - .NonPerspectiveBarycentricEnable = wm_prog_data ? - (wm_prog_data->barycentric_interp_modes & 0x38) != 0 : 0, - - .TriangleStripListProvokingVertexSelect = 0, - .LineStripListProvokingVertexSelect = 0, - .TriangleFanProvokingVertexSelect = 1, - - .MinimumPointWidth = 0.125, - .MaximumPointWidth = 255.875, - .MaximumVPIndex = pCreateInfo->pViewportState->viewportCount - 1); - - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_WM), - .StatisticsEnable = true, - .LineEndCapAntialiasingRegionWidth = _05pixels, - .LineAntialiasingRegionWidth = _10pixels, - .EarlyDepthStencilControl = NORMAL, - .ForceThreadDispatchEnable = NORMAL, - .PointRasterizationRule = RASTRULE_UPPER_RIGHT, - .BarycentricInterpolationMode = - pipeline->ps_ksp0 == NO_KERNEL ? - 0 : wm_prog_data->barycentric_interp_modes); + anv_batch_emit_blk(&pipeline->batch, GENX(3DSTATE_CLIP), clip) { + clip.ClipEnable = !(extra && extra->use_rectlist); + clip.EarlyCullEnable = true; + clip.APIMode = 1; /* D3D */ + clip.ViewportXYClipTestEnable = true; + + clip.ClipMode = + pCreateInfo->pRasterizationState->rasterizerDiscardEnable ? + REJECT_ALL : NORMAL; + + clip.NonPerspectiveBarycentricEnable = wm_prog_data ? + (wm_prog_data->barycentric_interp_modes & 0x38) != 0 : 0; + + clip.TriangleStripListProvokingVertexSelect = 0; + clip.LineStripListProvokingVertexSelect = 0; + clip.TriangleFanProvokingVertexSelect = 1; + + clip.MinimumPointWidth = 0.125; + clip.MaximumPointWidth = 255.875; + clip.MaximumVPIndex = pCreateInfo->pViewportState->viewportCount - 1; + } + + anv_batch_emit_blk(&pipeline->batch, GENX(3DSTATE_WM), wm) { + wm.StatisticsEnable = true; + wm.LineEndCapAntialiasingRegionWidth = _05pixels; + wm.LineAntialiasingRegionWidth = _10pixels; + wm.EarlyDepthStencilControl = NORMAL; + wm.ForceThreadDispatchEnable = NORMAL; + wm.PointRasterizationRule = RASTRULE_UPPER_RIGHT; + + wm.BarycentricInterpolationMode = pipeline->ps_ksp0 == NO_KERNEL ? + 0 : wm_prog_data->barycentric_interp_modes; + } if (pipeline->gs_kernel == NO_KERNEL) { - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_GS), .Enable = false); + anv_batch_emit_blk(&pipeline->batch, GENX(3DSTATE_GS), gs); } else { const struct brw_gs_prog_data *gs_prog_data = get_gs_prog_data(pipeline); offset = 1; length = (gs_prog_data->base.vue_map.num_slots + 1) / 2 - offset; - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_GS), - .SingleProgramFlow = false, - .KernelStartPointer = pipeline->gs_kernel, - .VectorMaskEnable = false, - .SamplerCount = 0, - .BindingTableEntryCount = 0, - .ExpectedVertexCount = gs_prog_data->vertices_in, - - .ScratchSpaceBasePointer = pipeline->scratch_start[MESA_SHADER_GEOMETRY], - .PerThreadScratchSpace = scratch_space(&gs_prog_data->base.base), - - .OutputVertexSize = gs_prog_data->output_vertex_size_hwords * 2 - 1, - .OutputTopology = gs_prog_data->output_topology, - .VertexURBEntryReadLength = gs_prog_data->base.urb_read_length, - .IncludeVertexHandles = gs_prog_data->base.include_vue_handles, - .DispatchGRFStartRegisterForURBData = - gs_prog_data->base.base.dispatch_grf_start_reg, - - .MaximumNumberofThreads = device->info.max_gs_threads / 2 - 1, - .ControlDataHeaderSize = gs_prog_data->control_data_header_size_hwords, - .DispatchMode = gs_prog_data->base.dispatch_mode, - .StatisticsEnable = true, - .IncludePrimitiveID = gs_prog_data->include_primitive_id, - .ReorderMode = TRAILING, - .Enable = true, - - .ControlDataFormat = gs_prog_data->control_data_format, - - .StaticOutput = gs_prog_data->static_vertex_count >= 0, - .StaticOutputVertexCount = - gs_prog_data->static_vertex_count >= 0 ? - gs_prog_data->static_vertex_count : 0, - - /* FIXME: mesa sets this based on ctx->Transform.ClipPlanesEnabled: - * UserClipDistanceClipTestEnableBitmask_3DSTATE_GS(v) - * UserClipDistanceCullTestEnableBitmask(v) - */ - - .VertexURBEntryOutputReadOffset = offset, - .VertexURBEntryOutputLength = length); + anv_batch_emit_blk(&pipeline->batch, GENX(3DSTATE_GS), gs) { + gs.SingleProgramFlow = false; + gs.KernelStartPointer = pipeline->gs_kernel; + gs.VectorMaskEnable = false; + gs.SamplerCount = 0; + gs.BindingTableEntryCount = 0; + gs.ExpectedVertexCount = gs_prog_data->vertices_in; + + gs.ScratchSpaceBasePointer = pipeline->scratch_start[MESA_SHADER_GEOMETRY]; + gs.PerThreadScratchSpace = scratch_space(&gs_prog_data->base.base); + gs.OutputVertexSize = gs_prog_data->output_vertex_size_hwords * 2 - 1; + gs.OutputTopology = gs_prog_data->output_topology; + gs.VertexURBEntryReadLength = gs_prog_data->base.urb_read_length; + gs.IncludeVertexHandles = gs_prog_data->base.include_vue_handles; + + gs.DispatchGRFStartRegisterForURBData = + gs_prog_data->base.base.dispatch_grf_start_reg; + + gs.MaximumNumberofThreads = device->info.max_gs_threads / 2 - 1; + gs.ControlDataHeaderSize = gs_prog_data->control_data_header_size_hwords; + gs.DispatchMode = gs_prog_data->base.dispatch_mode; + gs.StatisticsEnable = true; + gs.IncludePrimitiveID = gs_prog_data->include_primitive_id; + gs.ReorderMode = TRAILING; + gs.Enable = true; + + gs.ControlDataFormat = gs_prog_data->control_data_format; + + gs.StaticOutput = gs_prog_data->static_vertex_count >= 0; + gs.StaticOutputVertexCount = + gs_prog_data->static_vertex_count >= 0 ? + gs_prog_data->static_vertex_count : 0; + + /* FIXME: mesa sets this based on ctx->Transform.ClipPlanesEnabled: + * UserClipDistanceClipTestEnableBitmask_3DSTATE_GS(v) + * UserClipDistanceCullTestEnableBitmask(v) + */ + + gs.VertexURBEntryOutputReadOffset = offset; + gs.VertexURBEntryOutputLength = length; + } } const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); @@ -436,100 +443,107 @@ genX(graphics_pipeline_create)( uint32_t vs_start = pipeline->vs_simd8 != NO_KERNEL ? pipeline->vs_simd8 : pipeline->vs_vec4; - if (vs_start == NO_KERNEL || (extra && extra->disable_vs)) - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_VS), - .FunctionEnable = false, - /* Even if VS is disabled, SBE still gets the amount of - * vertex data to read from this field. */ - .VertexURBEntryOutputReadOffset = offset, - .VertexURBEntryOutputLength = length); - else - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_VS), - .KernelStartPointer = vs_start, - .SingleVertexDispatch = false, - .VectorMaskEnable = false, - .SamplerCount = 0, - .BindingTableEntryCount = - vs_prog_data->base.base.binding_table.size_bytes / 4, - .ThreadDispatchPriority = false, - .FloatingPointMode = IEEE754, - .IllegalOpcodeExceptionEnable = false, - .AccessesUAV = false, - .SoftwareExceptionEnable = false, - - .ScratchSpaceBasePointer = pipeline->scratch_start[MESA_SHADER_VERTEX], - .PerThreadScratchSpace = scratch_space(&vs_prog_data->base.base), - - .DispatchGRFStartRegisterForURBData = - vs_prog_data->base.base.dispatch_grf_start_reg, - .VertexURBEntryReadLength = vs_prog_data->base.urb_read_length, - .VertexURBEntryReadOffset = 0, - - .MaximumNumberofThreads = device->info.max_vs_threads - 1, - .StatisticsEnable = false, - .SIMD8DispatchEnable = pipeline->vs_simd8 != NO_KERNEL, - .VertexCacheDisable = false, - .FunctionEnable = true, - - .VertexURBEntryOutputReadOffset = offset, - .VertexURBEntryOutputLength = length, - .UserClipDistanceClipTestEnableBitmask = 0, - .UserClipDistanceCullTestEnableBitmask = 0); + if (vs_start == NO_KERNEL || (extra && extra->disable_vs)) { + anv_batch_emit_blk(&pipeline->batch, GENX(3DSTATE_VS), vs) { + vs.FunctionEnable = false; + /* Even if VS is disabled, SBE still gets the amount of + * vertex data to read from this field. */ + vs.VertexURBEntryOutputReadOffset = offset; + vs.VertexURBEntryOutputLength = length; + } + } else { + anv_batch_emit_blk(&pipeline->batch, GENX(3DSTATE_VS), vs) { + vs.KernelStartPointer = vs_start; + vs.SingleVertexDispatch = false; + vs.VectorMaskEnable = false; + vs.SamplerCount = 0; + + vs.BindingTableEntryCount = + vs_prog_data->base.base.binding_table.size_bytes / 4, + + vs.ThreadDispatchPriority = false; + vs.FloatingPointMode = IEEE754; + vs.IllegalOpcodeExceptionEnable = false; + vs.AccessesUAV = false; + vs.SoftwareExceptionEnable = false; + + vs.ScratchSpaceBasePointer = pipeline->scratch_start[MESA_SHADER_VERTEX], + vs.PerThreadScratchSpace = scratch_space(&vs_prog_data->base.base); + + vs.DispatchGRFStartRegisterForURBData = + vs_prog_data->base.base.dispatch_grf_start_reg; + + vs.VertexURBEntryReadLength = vs_prog_data->base.urb_read_length; + vs.VertexURBEntryReadOffset = 0; + + vs.MaximumNumberofThreads = device->info.max_vs_threads - 1; + vs.StatisticsEnable = false; + vs.SIMD8DispatchEnable = pipeline->vs_simd8 != NO_KERNEL; + vs.VertexCacheDisable = false; + vs.FunctionEnable = true; + + vs.VertexURBEntryOutputReadOffset = offset; + vs.VertexURBEntryOutputLength = length; + + /* TODO */ + vs.UserClipDistanceClipTestEnableBitmask = 0; + vs.UserClipDistanceCullTestEnableBitmask = 0; + } + } const int num_thread_bias = GEN_GEN == 8 ? 2 : 1; if (pipeline->ps_ksp0 == NO_KERNEL) { - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_PS)); - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_PS_EXTRA), - .PixelShaderValid = false); + anv_batch_emit_blk(&pipeline->batch, GENX(3DSTATE_PS), ps); + anv_batch_emit_blk(&pipeline->batch, GENX(3DSTATE_PS_EXTRA), extra) { + extra.PixelShaderValid = false; + } } else { emit_3dstate_sbe(pipeline); - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_PS), - .KernelStartPointer0 = pipeline->ps_ksp0, - - .SingleProgramFlow = false, - .VectorMaskEnable = true, - .SamplerCount = 1, - - .ScratchSpaceBasePointer = pipeline->scratch_start[MESA_SHADER_FRAGMENT], - .PerThreadScratchSpace = scratch_space(&wm_prog_data->base), - - .MaximumNumberofThreadsPerPSD = 64 - num_thread_bias, - .PositionXYOffsetSelect = wm_prog_data->uses_pos_offset ? - POSOFFSET_SAMPLE: POSOFFSET_NONE, - .PushConstantEnable = wm_prog_data->base.nr_params > 0, - ._8PixelDispatchEnable = pipeline->ps_simd8 != NO_KERNEL, - ._16PixelDispatchEnable = pipeline->ps_simd16 != NO_KERNEL, - ._32PixelDispatchEnable = false, - - .DispatchGRFStartRegisterForConstantSetupData0 = pipeline->ps_grf_start0, - .DispatchGRFStartRegisterForConstantSetupData1 = 0, - .DispatchGRFStartRegisterForConstantSetupData2 = pipeline->ps_grf_start2, - - .KernelStartPointer1 = 0, - .KernelStartPointer2 = pipeline->ps_ksp2); + anv_batch_emit_blk(&pipeline->batch, GENX(3DSTATE_PS), ps) { + ps.KernelStartPointer0 = pipeline->ps_ksp0; + ps.KernelStartPointer1 = 0; + ps.KernelStartPointer2 = pipeline->ps_ksp2; + ps._8PixelDispatchEnable = pipeline->ps_simd8 != NO_KERNEL; + ps._16PixelDispatchEnable = pipeline->ps_simd16 != NO_KERNEL; + ps._32PixelDispatchEnable = false; + ps.SingleProgramFlow = false; + ps.VectorMaskEnable = true; + ps.SamplerCount = 1; + ps.PushConstantEnable = wm_prog_data->base.nr_params > 0; + ps.PositionXYOffsetSelect = wm_prog_data->uses_pos_offset ? + POSOFFSET_SAMPLE: POSOFFSET_NONE; + + ps.MaximumNumberofThreadsPerPSD = 64 - num_thread_bias; + + ps.ScratchSpaceBasePointer = pipeline->scratch_start[MESA_SHADER_FRAGMENT]; + ps.PerThreadScratchSpace = scratch_space(&wm_prog_data->base); + + ps.DispatchGRFStartRegisterForConstantSetupData0 = pipeline->ps_grf_start0; + ps.DispatchGRFStartRegisterForConstantSetupData1 = 0; + ps.DispatchGRFStartRegisterForConstantSetupData2 = pipeline->ps_grf_start2; + } bool per_sample_ps = pCreateInfo->pMultisampleState && pCreateInfo->pMultisampleState->sampleShadingEnable; - anv_batch_emit(&pipeline->batch, GENX(3DSTATE_PS_EXTRA), - .PixelShaderValid = true, - .PixelShaderKillsPixel = wm_prog_data->uses_kill, - .PixelShaderComputedDepthMode = wm_prog_data->computed_depth_mode, - .AttributeEnable = wm_prog_data->num_varying_inputs > 0, - .oMaskPresenttoRenderTarget = wm_prog_data->uses_omask, - .PixelShaderIsPerSample = per_sample_ps, - .PixelShaderUsesSourceDepth = wm_prog_data->uses_src_depth, - .PixelShaderUsesSourceW = wm_prog_data->uses_src_w, + anv_batch_emit_blk(&pipeline->batch, GENX(3DSTATE_PS_EXTRA), ps) { + ps.PixelShaderValid = true; + ps.PixelShaderKillsPixel = wm_prog_data->uses_kill; + ps.PixelShaderComputedDepthMode = wm_prog_data->computed_depth_mode; + ps.AttributeEnable = wm_prog_data->num_varying_inputs > 0; + ps.oMaskPresenttoRenderTarget = wm_prog_data->uses_omask; + ps.PixelShaderIsPerSample = per_sample_ps; + ps.PixelShaderUsesSourceDepth = wm_prog_data->uses_src_depth; + ps.PixelShaderUsesSourceW = wm_prog_data->uses_src_w; #if GEN_GEN >= 9 - .PixelShaderPullsBary = wm_prog_data->pulls_bary, - .InputCoverageMaskState = wm_prog_data->uses_sample_mask ? - ICMS_INNER_CONSERVATIVE : ICMS_NONE, + ps.PixelShaderPullsBary = wm_prog_data->pulls_bary; + ps.InputCoverageMaskState = wm_prog_data->uses_sample_mask ? + ICMS_INNER_CONSERVATIVE : ICMS_NONE; #else - .PixelShaderUsesInputCoverageMask = - wm_prog_data->uses_sample_mask, + ps.PixelShaderUsesInputCoverageMask = wm_prog_data->uses_sample_mask; #endif - ); + } } *pPipeline = anv_pipeline_to_handle(pipeline); -- 2.30.2