Mesa (main): broadcom/compiler: create a helper for computing VPM config
GitLab Mirror
gitlab-mirror at kemper.freedesktop.org
Mon Jul 12 07:56:03 UTC 2021
Module: Mesa
Branch: main
Commit: 353f0a180f62564d4363a84d0821ff1af3f8ff2c
URL: http://cgit.freedesktop.org/mesa/mesa/commit/?id=353f0a180f62564d4363a84d0821ff1af3f8ff2c
Author: Iago Toral Quiroga <itoral at igalia.com>
Date: Thu Jul 1 13:05:44 2021 +0200
broadcom/compiler: create a helper for computing VPM config
This code is the same across drivers.
Reviewed-by: Alejandro Piñeiro <apinheiro at igalia.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/11783>
---
src/broadcom/compiler/v3d_compiler.h | 19 ++++
src/broadcom/compiler/vir.c | 171 ++++++++++++++++++++++++++++++++
src/broadcom/vulkan/v3dv_pipeline.c | 173 +++------------------------------
src/broadcom/vulkan/v3dv_private.h | 14 ---
src/gallium/drivers/v3d/v3dx_draw.c | 182 ++---------------------------------
5 files changed, 209 insertions(+), 350 deletions(-)
diff --git a/src/broadcom/compiler/v3d_compiler.h b/src/broadcom/compiler/v3d_compiler.h
index cf4ff5d6277..b3dae552201 100644
--- a/src/broadcom/compiler/v3d_compiler.h
+++ b/src/broadcom/compiler/v3d_compiler.h
@@ -956,6 +956,25 @@ struct v3d_compute_prog_data {
bool has_subgroups;
};
+struct vpm_config {
+ uint32_t As;
+ uint32_t Vc;
+ uint32_t Gs;
+ uint32_t Gd;
+ uint32_t Gv;
+ uint32_t Ve;
+ uint32_t gs_width;
+};
+
+bool
+v3d_compute_vpm_config(struct v3d_device_info *devinfo,
+ struct v3d_vs_prog_data *vs_bin,
+ struct v3d_vs_prog_data *vs,
+ struct v3d_gs_prog_data *gs_bin,
+ struct v3d_gs_prog_data *gs,
+ struct vpm_config *vpm_cfg_bin,
+ struct vpm_config *vpm_cfg);
+
static inline bool
vir_has_uniform(struct qinst *inst)
{
diff --git a/src/broadcom/compiler/vir.c b/src/broadcom/compiler/vir.c
index 02ce98df6f6..990648b61a6 100644
--- a/src/broadcom/compiler/vir.c
+++ b/src/broadcom/compiler/vir.c
@@ -1963,3 +1963,174 @@ vir_get_stage_name(struct v3d_compile *c)
else
return gl_shader_stage_name(c->s->info.stage);
}
+
+static inline uint32_t
+compute_vpm_size_in_sectors(const struct v3d_device_info *devinfo)
+{
+ assert(devinfo->vpm_size > 0);
+ const uint32_t sector_size = V3D_CHANNELS * sizeof(uint32_t) * 8;
+ return devinfo->vpm_size / sector_size;
+}
+
+/* Computes various parameters affecting VPM memory configuration for programs
+ * involving geometry shaders to ensure the program fits in memory and honors
+ * requirements described in section "VPM usage" of the programming manual.
+ */
+static bool
+compute_vpm_config_gs(struct v3d_device_info *devinfo,
+ struct v3d_vs_prog_data *vs,
+ struct v3d_gs_prog_data *gs,
+ struct vpm_config *vpm_cfg_out)
+{
+ const uint32_t A = vs->separate_segments ? 1 : 0;
+ const uint32_t Ad = vs->vpm_input_size;
+ const uint32_t Vd = vs->vpm_output_size;
+
+ const uint32_t vpm_size = compute_vpm_size_in_sectors(devinfo);
+
+ /* Try to fit program into our VPM memory budget by adjusting
+ * configurable parameters iteratively. We do this in two phases:
+ * the first phase tries to fit the program into the total available
+ * VPM memory. If we succeed at that, then the second phase attempts
+ * to fit the program into half of that budget so we can run bin and
+ * render programs in parallel.
+ */
+ struct vpm_config vpm_cfg[2];
+ struct vpm_config *final_vpm_cfg = NULL;
+ uint32_t phase = 0;
+
+ vpm_cfg[phase].As = 1;
+ vpm_cfg[phase].Gs = 1;
+ vpm_cfg[phase].Gd = gs->vpm_output_size;
+ vpm_cfg[phase].gs_width = gs->simd_width;
+
+ /* While there is a requirement that Vc >= [Vn / 16], this is
+ * always the case when tessellation is not present because in that
+ * case Vn can only be 6 at most (when input primitive is triangles
+ * with adjacency).
+ *
+ * We always choose Vc=2. We can't go lower than this due to GFXH-1744,
+ * and Broadcom has not found it worth it to increase it beyond this
+ * in general. Increasing Vc also increases VPM memory pressure which
+ * can turn up being detrimental for performance in some scenarios.
+ */
+ vpm_cfg[phase].Vc = 2;
+
+ /* Gv is a constraint on the hardware to not exceed the
+ * specified number of vertex segments per GS batch. If adding a
+ * new primitive to a GS batch would result in a range of more
+ * than Gv vertex segments being referenced by the batch, then
+ * the hardware will flush the batch and start a new one. This
+ * means that we can choose any value we want, we just need to
+ * be aware that larger values improve GS batch utilization
+ * at the expense of more VPM memory pressure (which can affect
+ * other performance aspects, such as GS dispatch width).
+ * We start with the largest value, and will reduce it if we
+ * find that total memory pressure is too high.
+ */
+ vpm_cfg[phase].Gv = 3;
+ do {
+ /* When GS is present in absence of TES, then we need to satisfy
+ * that Ve >= Gv. We go with the smallest value of Ve to avoid
+ * increasing memory pressure.
+ */
+ vpm_cfg[phase].Ve = vpm_cfg[phase].Gv;
+
+ uint32_t vpm_sectors =
+ A * vpm_cfg[phase].As * Ad +
+ (vpm_cfg[phase].Vc + vpm_cfg[phase].Ve) * Vd +
+ vpm_cfg[phase].Gs * vpm_cfg[phase].Gd;
+
+ /* Ideally we want to use no more than half of the available
+ * memory so we can execute a bin and render program in parallel
+ * without stalls. If we achieved that then we are done.
+ */
+ if (vpm_sectors <= vpm_size / 2) {
+ final_vpm_cfg = &vpm_cfg[phase];
+ break;
+ }
+
+ /* At the very least, we should not allocate more than the
+ * total available VPM memory. If we have a configuration that
+ * succeeds at this we save it and continue to see if we can
+ * meet the half-memory-use criteria too.
+ */
+ if (phase == 0 && vpm_sectors <= vpm_size) {
+ vpm_cfg[1] = vpm_cfg[0];
+ phase = 1;
+ }
+
+ /* Try lowering Gv */
+ if (vpm_cfg[phase].Gv > 0) {
+ vpm_cfg[phase].Gv--;
+ continue;
+ }
+
+ /* Try lowering GS dispatch width */
+ if (vpm_cfg[phase].gs_width > 1) {
+ do {
+ vpm_cfg[phase].gs_width >>= 1;
+ vpm_cfg[phase].Gd = align(vpm_cfg[phase].Gd, 2) / 2;
+ } while (vpm_cfg[phase].gs_width == 2);
+
+ /* Reset Gv to max after dropping dispatch width */
+ vpm_cfg[phase].Gv = 3;
+ continue;
+ }
+
+ /* We ran out of options to reduce memory pressure. If we
+ * are at phase 1 we have at least a valid configuration, so we
+ * we use that.
+ */
+ if (phase == 1)
+ final_vpm_cfg = &vpm_cfg[0];
+ break;
+ } while (true);
+
+ if (!final_vpm_cfg)
+ return false;
+
+ assert(final_vpm_cfg);
+ assert(final_vpm_cfg->Gd <= 16);
+ assert(final_vpm_cfg->Gv < 4);
+ assert(final_vpm_cfg->Ve < 4);
+ assert(final_vpm_cfg->Vc >= 2 && final_vpm_cfg->Vc <= 4);
+ assert(final_vpm_cfg->gs_width == 1 ||
+ final_vpm_cfg->gs_width == 4 ||
+ final_vpm_cfg->gs_width == 8 ||
+ final_vpm_cfg->gs_width == 16);
+
+ *vpm_cfg_out = *final_vpm_cfg;
+ return true;
+}
+
+bool
+v3d_compute_vpm_config(struct v3d_device_info *devinfo,
+ struct v3d_vs_prog_data *vs_bin,
+ struct v3d_vs_prog_data *vs,
+ struct v3d_gs_prog_data *gs_bin,
+ struct v3d_gs_prog_data *gs,
+ struct vpm_config *vpm_cfg_bin,
+ struct vpm_config *vpm_cfg)
+{
+ assert(vs && vs_bin);
+ assert((gs != NULL) == (gs_bin != NULL));
+
+ if (!gs) {
+ vpm_cfg_bin->As = 1;
+ vpm_cfg_bin->Ve = 0;
+ vpm_cfg_bin->Vc = vs_bin->vcm_cache_size;
+
+ vpm_cfg->As = 1;
+ vpm_cfg->Ve = 0;
+ vpm_cfg->Vc = vs->vcm_cache_size;
+ } else {
+ if (!compute_vpm_config_gs(devinfo, vs_bin, gs_bin, vpm_cfg_bin))
+ return false;
+
+ if (!compute_vpm_config_gs(devinfo, vs, gs, vpm_cfg))
+ return false;
+ }
+
+ return true;
+}
diff --git a/src/broadcom/vulkan/v3dv_pipeline.c b/src/broadcom/vulkan/v3dv_pipeline.c
index 2fd7f0c457e..fe69f6d0e5e 100644
--- a/src/broadcom/vulkan/v3dv_pipeline.c
+++ b/src/broadcom/vulkan/v3dv_pipeline.c
@@ -2355,148 +2355,6 @@ pipeline_compile_graphics(struct v3dv_pipeline *pipeline,
return compute_vpm_config(pipeline);
}
-static inline uint32_t
-compute_vpm_size_in_sectors(const struct v3d_device_info *devinfo)
-{
- assert(devinfo->vpm_size > 0);
- const uint32_t sector_size = V3D_CHANNELS * sizeof(uint32_t) * 8;
- return devinfo->vpm_size / sector_size;
-}
-
-/* Computes various parameters affecting VPM memory configuration for programs
- * involving geometry shaders to ensure the program fits in memory and honors
- * requirements described in section "VPM usage" of the programming manual.
- *
- * FIXME: put this code in common and share with v3d.
- */
-static bool
-compute_vpm_config_gs(struct v3d_device_info *devinfo,
- struct v3d_vs_prog_data *vs,
- struct v3d_gs_prog_data *gs,
- struct vpm_config *vpm_cfg_out)
-{
- const uint32_t A = vs->separate_segments ? 1 : 0;
- const uint32_t Ad = vs->vpm_input_size;
- const uint32_t Vd = vs->vpm_output_size;
-
- const uint32_t vpm_size = compute_vpm_size_in_sectors(devinfo);
-
- /* Try to fit program into our VPM memory budget by adjusting
- * configurable parameters iteratively. We do this in two phases:
- * the first phase tries to fit the program into the total available
- * VPM memory. If we succeed at that, then the second phase attempts
- * to fit the program into half of that budget so we can run bin and
- * render programs in parallel.
- */
- struct vpm_config vpm_cfg[2];
- struct vpm_config *final_vpm_cfg = NULL;
- uint32_t phase = 0;
-
- vpm_cfg[phase].As = 1;
- vpm_cfg[phase].Gs = 1;
- vpm_cfg[phase].Gd = gs->vpm_output_size;
- vpm_cfg[phase].gs_width = gs->simd_width;
-
- /* While there is a requirement that Vc >= [Vn / 16], this is
- * always the case when tessellation is not present because in that
- * case Vn can only be 6 at most (when input primitive is triangles
- * with adjacency).
- *
- * We always choose Vc=2. We can't go lower than this due to GFXH-1744,
- * and Broadcom has not found it worth it to increase it beyond this
- * in general. Increasing Vc also increases VPM memory pressure which
- * can turn up being detrimental for performance in some scenarios.
- */
- vpm_cfg[phase].Vc = 2;
-
- /* Gv is a constraint on the hardware to not exceed the
- * specified number of vertex segments per GS batch. If adding a
- * new primitive to a GS batch would result in a range of more
- * than Gv vertex segments being referenced by the batch, then
- * the hardware will flush the batch and start a new one. This
- * means that we can choose any value we want, we just need to
- * be aware that larger values improve GS batch utilization
- * at the expense of more VPM memory pressure (which can affect
- * other performance aspects, such as GS dispatch width).
- * We start with the largest value, and will reduce it if we
- * find that total memory pressure is too high.
- */
- vpm_cfg[phase].Gv = 3;
- do {
- /* When GS is present in absence of TES, then we need to satisfy
- * that Ve >= Gv. We go with the smallest value of Ve to avoid
- * increasing memory pressure.
- */
- vpm_cfg[phase].Ve = vpm_cfg[phase].Gv;
-
- uint32_t vpm_sectors =
- A * vpm_cfg[phase].As * Ad +
- (vpm_cfg[phase].Vc + vpm_cfg[phase].Ve) * Vd +
- vpm_cfg[phase].Gs * vpm_cfg[phase].Gd;
-
- /* Ideally we want to use no more than half of the available
- * memory so we can execute a bin and render program in parallel
- * without stalls. If we achieved that then we are done.
- */
- if (vpm_sectors <= vpm_size / 2) {
- final_vpm_cfg = &vpm_cfg[phase];
- break;
- }
-
- /* At the very least, we should not allocate more than the
- * total available VPM memory. If we have a configuration that
- * succeeds at this we save it and continue to see if we can
- * meet the half-memory-use criteria too.
- */
- if (phase == 0 && vpm_sectors <= vpm_size) {
- vpm_cfg[1] = vpm_cfg[0];
- phase = 1;
- }
-
- /* Try lowering Gv */
- if (vpm_cfg[phase].Gv > 0) {
- vpm_cfg[phase].Gv--;
- continue;
- }
-
- /* Try lowering GS dispatch width */
- if (vpm_cfg[phase].gs_width > 1) {
- do {
- vpm_cfg[phase].gs_width >>= 1;
- vpm_cfg[phase].Gd = align(vpm_cfg[phase].Gd, 2) / 2;
- } while (vpm_cfg[phase].gs_width == 2);
-
- /* Reset Gv to max after dropping dispatch width */
- vpm_cfg[phase].Gv = 3;
- continue;
- }
-
- /* We ran out of options to reduce memory pressure. If we
- * are at phase 1 we have at least a valid configuration, so we
- * we use that.
- */
- if (phase == 1)
- final_vpm_cfg = &vpm_cfg[0];
- break;
- } while (true);
-
- if (!final_vpm_cfg)
- return false;
-
- assert(final_vpm_cfg);
- assert(final_vpm_cfg->Gd <= 16);
- assert(final_vpm_cfg->Gv < 4);
- assert(final_vpm_cfg->Ve < 4);
- assert(final_vpm_cfg->Vc >= 2 && final_vpm_cfg->Vc <= 4);
- assert(final_vpm_cfg->gs_width == 1 ||
- final_vpm_cfg->gs_width == 4 ||
- final_vpm_cfg->gs_width == 8 ||
- final_vpm_cfg->gs_width == 16);
-
- *vpm_cfg_out = *final_vpm_cfg;
- return true;
-}
-
static VkResult
compute_vpm_config(struct v3dv_pipeline *pipeline)
{
@@ -2507,31 +2365,22 @@ compute_vpm_config(struct v3dv_pipeline *pipeline)
struct v3d_vs_prog_data *vs = vs_variant->prog_data.vs;
struct v3d_vs_prog_data *vs_bin =vs_bin_variant->prog_data.vs;
- if (!pipeline->has_gs) {
- pipeline->vpm_cfg_bin.As = 1;
- pipeline->vpm_cfg_bin.Ve = 0;
- pipeline->vpm_cfg_bin.Vc = vs_bin->vcm_cache_size;
-
- pipeline->vpm_cfg.As = 1;
- pipeline->vpm_cfg.Ve = 0;
- pipeline->vpm_cfg.Vc = vs->vcm_cache_size;
- } else {
+ struct v3d_gs_prog_data *gs = NULL;
+ struct v3d_gs_prog_data *gs_bin = NULL;
+ if (pipeline->has_gs) {
struct v3dv_shader_variant *gs_variant =
pipeline->shared_data->variants[BROADCOM_SHADER_GEOMETRY];
struct v3dv_shader_variant *gs_bin_variant =
pipeline->shared_data->variants[BROADCOM_SHADER_GEOMETRY_BIN];
- struct v3d_gs_prog_data *gs = gs_variant->prog_data.gs;
- struct v3d_gs_prog_data *gs_bin = gs_bin_variant->prog_data.gs;
-
- if (!compute_vpm_config_gs(&pipeline->device->devinfo,
- vs_bin, gs_bin, &pipeline->vpm_cfg_bin)) {
- return VK_ERROR_OUT_OF_DEVICE_MEMORY;
- }
+ gs = gs_variant->prog_data.gs;
+ gs_bin = gs_bin_variant->prog_data.gs;
+ }
- if (!compute_vpm_config_gs(&pipeline->device->devinfo,
- vs, gs, &pipeline->vpm_cfg)) {
- return VK_ERROR_OUT_OF_DEVICE_MEMORY;
- }
+ if (!v3d_compute_vpm_config(&pipeline->device->devinfo,
+ vs_bin, vs, gs_bin, gs,
+ &pipeline->vpm_cfg_bin,
+ &pipeline->vpm_cfg)) {
+ return VK_ERROR_OUT_OF_DEVICE_MEMORY;
}
return VK_SUCCESS;
diff --git a/src/broadcom/vulkan/v3dv_private.h b/src/broadcom/vulkan/v3dv_private.h
index ca28f111884..6440695246d 100644
--- a/src/broadcom/vulkan/v3dv_private.h
+++ b/src/broadcom/vulkan/v3dv_private.h
@@ -1447,20 +1447,6 @@ struct v3dv_pipeline_stage {
uint32_t program_id;
};
-/* FIXME: although the full vpm_config is not required at this point, as we
- * don't plan to initially support GS, it is more readable and serves as a
- * placeholder, to have the struct and fill it with default values.
- */
-struct vpm_config {
- uint32_t As;
- uint32_t Vc;
- uint32_t Gs;
- uint32_t Gd;
- uint32_t Gv;
- uint32_t Ve;
- uint32_t gs_width;
-};
-
/* We are using the descriptor pool entry for two things:
* * Track the allocated sets, so we can properly free it if needed
* * Track the suballocated pool bo regions, so if some descriptor set is
diff --git a/src/gallium/drivers/v3d/v3dx_draw.c b/src/gallium/drivers/v3d/v3dx_draw.c
index 91a1048a8b9..b9b5254c9f8 100644
--- a/src/gallium/drivers/v3d/v3dx_draw.c
+++ b/src/gallium/drivers/v3d/v3dx_draw.c
@@ -358,16 +358,6 @@ v3d_emit_wait_for_tf_if_needed(struct v3d_context *v3d, struct v3d_job *job)
}
}
-struct vpm_config {
- uint32_t As;
- uint32_t Vc;
- uint32_t Gs;
- uint32_t Gd;
- uint32_t Gv;
- uint32_t Ve;
- uint32_t gs_width;
-};
-
#if V3D_VERSION >= 41
static void
v3d_emit_gs_state_record(struct v3d_job *job,
@@ -484,151 +474,6 @@ v3d_emit_tes_gs_shader_params(struct v3d_job *job,
shader.gbg_min_gs_output_segments_required_in_play = 1;
}
}
-
-static inline uint32_t
-compute_vpm_size_in_sectors(const struct v3d_device_info *devinfo)
-{
- assert(devinfo->vpm_size > 0);
- const uint32_t sector_size = V3D_CHANNELS * sizeof(uint32_t) * 8;
- return devinfo->vpm_size / sector_size;
-}
-
-/* Computes various parameters affecting VPM memory configuration for programs
- * involving geometry shaders to ensure the program fits in memory and honors
- * requirements described in section "VPM usage" of the programming manual.
- */
-static void
-compute_vpm_config_gs(struct v3d_device_info *devinfo,
- struct v3d_vs_prog_data *vs,
- struct v3d_gs_prog_data *gs,
- struct vpm_config *vpm_cfg_out)
-{
- const uint32_t A = vs->separate_segments ? 1 : 0;
- const uint32_t Ad = vs->vpm_input_size;
- const uint32_t Vd = vs->vpm_output_size;
-
- const uint32_t vpm_size = compute_vpm_size_in_sectors(devinfo);
-
- /* Try to fit program into our VPM memory budget by adjusting
- * configurable parameters iteratively. We do this in two phases:
- * the first phase tries to fit the program into the total available
- * VPM memory. If we succeed at that, then the second phase attempts
- * to fit the program into half of that budget so we can run bin and
- * render programs in parallel.
- */
- struct vpm_config vpm_cfg[2];
- struct vpm_config *final_vpm_cfg = NULL;
- uint32_t phase = 0;
-
- vpm_cfg[phase].As = 1;
- vpm_cfg[phase].Gs = 1;
- vpm_cfg[phase].Gd = gs->vpm_output_size;
- vpm_cfg[phase].gs_width = gs->simd_width;
-
- /* While there is a requirement that Vc >= [Vn / 16], this is
- * always the case when tessellation is not present because in that
- * case Vn can only be 6 at most (when input primitive is triangles
- * with adjacency).
- *
- * We always choose Vc=2. We can't go lower than this due to GFXH-1744,
- * and Broadcom has not found it worth it to increase it beyond this
- * in general. Increasing Vc also increases VPM memory pressure which
- * can turn up being detrimental for performance in some scenarios.
- */
- vpm_cfg[phase].Vc = 2;
-
- /* Gv is a constraint on the hardware to not exceed the
- * specified number of vertex segments per GS batch. If adding a
- * new primitive to a GS batch would result in a range of more
- * than Gv vertex segments being referenced by the batch, then
- * the hardware will flush the batch and start a new one. This
- * means that we can choose any value we want, we just need to
- * be aware that larger values improve GS batch utilization
- * at the expense of more VPM memory pressure (which can affect
- * other performance aspects, such as GS dispatch width).
- * We start with the largest value, and will reduce it if we
- * find that total memory pressure is too high.
- */
- vpm_cfg[phase].Gv = 3;
- do {
- /* When GS is present in absence of TES, then we need to satisfy
- * that Ve >= Gv. We go with the smallest value of Ve to avoid
- * increasing memory pressure.
- */
- vpm_cfg[phase].Ve = vpm_cfg[phase].Gv;
-
- uint32_t vpm_sectors =
- A * vpm_cfg[phase].As * Ad +
- (vpm_cfg[phase].Vc + vpm_cfg[phase].Ve) * Vd +
- vpm_cfg[phase].Gs * vpm_cfg[phase].Gd;
-
- /* Ideally we want to use no more than half of the available
- * memory so we can execute a bin and render program in parallel
- * without stalls. If we achieved that then we are done.
- */
- if (vpm_sectors <= vpm_size / 2) {
- final_vpm_cfg = &vpm_cfg[phase];
- break;
- }
-
- /* At the very least, we should not allocate more than the
- * total available VPM memory. If we have a configuration that
- * succeeds at this we save it and continue to see if we can
- * meet the half-memory-use criteria too.
- */
- if (phase == 0 && vpm_sectors <= vpm_size) {
- vpm_cfg[1] = vpm_cfg[0];
- phase = 1;
- }
-
- /* Try lowering Gv */
- if (vpm_cfg[phase].Gv > 0) {
- vpm_cfg[phase].Gv--;
- continue;
- }
-
- /* Try lowering GS dispatch width */
- if (vpm_cfg[phase].gs_width > 1) {
- do {
- vpm_cfg[phase].gs_width >>= 1;
- vpm_cfg[phase].Gd =
- align(vpm_cfg[phase].Gd, 2) / 2;
- } while (vpm_cfg[phase].gs_width == 2);
-
- /* Reset Gv to max after dropping dispatch width */
- vpm_cfg[phase].Gv = 3;
- continue;
- }
-
- /* We ran out of options to reduce memory pressure. If we
- * are at phase 1 we have at least a valid configuration, so we
- * we use that.
- */
- if (phase == 1)
- final_vpm_cfg = &vpm_cfg[0];
- break;
- } while (true);
-
- if (!final_vpm_cfg) {
- /* FIXME: maybe return a boolean to indicate failure and use
- * that to stop the submission for this draw call.
- */
- fprintf(stderr, "Failed to allocate VPM memory.\n");
- abort();
- }
-
- assert(final_vpm_cfg);
- assert(final_vpm_cfg->Gd <= 16);
- assert(final_vpm_cfg->Gv < 4);
- assert(final_vpm_cfg->Ve < 4);
- assert(final_vpm_cfg->Vc >= 2 && final_vpm_cfg->Vc <= 4);
- assert(final_vpm_cfg->gs_width == 1 ||
- final_vpm_cfg->gs_width == 4 ||
- final_vpm_cfg->gs_width == 8 ||
- final_vpm_cfg->gs_width == 16);
-
- *vpm_cfg_out = *final_vpm_cfg;
-}
#endif
static void
@@ -713,43 +558,32 @@ v3d_emit_gl_shader_state(struct v3d_context *v3d,
struct vpm_config vpm_cfg_bin, vpm_cfg;
assert(v3d->screen->devinfo.ver >= 41 || !v3d->prog.gs);
- if (!v3d->prog.gs) {
- vpm_cfg_bin.As = 1;
- vpm_cfg_bin.Ve = 0;
- vpm_cfg_bin.Vc = v3d->prog.cs->prog_data.vs->vcm_cache_size;
+ v3d_compute_vpm_config(&v3d->screen->devinfo,
+ v3d->prog.cs->prog_data.vs,
+ v3d->prog.vs->prog_data.vs,
+ v3d->prog.gs ? v3d->prog.gs_bin->prog_data.gs : NULL,
+ v3d->prog.gs ? v3d->prog.gs->prog_data.gs : NULL,
+ &vpm_cfg_bin,
+ &vpm_cfg);
- vpm_cfg.As = 1;
- vpm_cfg.Ve = 0;
- vpm_cfg.Vc = v3d->prog.vs->prog_data.vs->vcm_cache_size;
- }
- else {
+ if (v3d->prog.gs) {
#if V3D_VERSION >= 41
v3d_emit_gs_state_record(v3d->job,
v3d->prog.gs_bin, gs_bin_uniforms,
v3d->prog.gs, gs_uniforms);
struct v3d_gs_prog_data *gs = v3d->prog.gs->prog_data.gs;
- struct v3d_gs_prog_data *gs_bin = v3d->prog.gs_bin->prog_data.gs;
-
v3d_emit_tes_gs_common_params(v3d->job,
gs->out_prim_type,
gs->num_invocations);
/* Bin Tes/Gs params */
- struct v3d_vs_prog_data *vs_bin = v3d->prog.cs->prog_data.vs;
- compute_vpm_config_gs(&v3d->screen->devinfo,
- vs_bin, gs_bin, &vpm_cfg_bin);
-
v3d_emit_tes_gs_shader_params(v3d->job,
vpm_cfg_bin.gs_width,
vpm_cfg_bin.Gd,
vpm_cfg_bin.Gv);
/* Render Tes/Gs params */
- struct v3d_vs_prog_data *vs = v3d->prog.vs->prog_data.vs;
- compute_vpm_config_gs(&v3d->screen->devinfo,
- vs, gs, &vpm_cfg);
-
v3d_emit_tes_gs_shader_params(v3d->job,
vpm_cfg.gs_width,
vpm_cfg.Gd,
More information about the mesa-commit
mailing list