OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v3d: use BITSET for the masks

Browse Source 
So far we were using raw uint32_t for handling masks. But this has the
issue that it only allows to handle up to 32 elements; if we need to
handle more elements, the we need to upgrade to uint64_t.

And this happened inadvertently with commit 370f02bf02 ("gallium: Bump
PIPE_MAX_SHADER_IMAGES to 64"), where the number of elements to handled
were increased from 32 to 64, but we didn't upgrade the mask type.

To fix this, and avoid this happening again in the future, let's use
BITSET, which is designed to handle bitmasks, and can able to handle as
many elements as desired.

Reviewed-by: Alejandro Piñeiro <apinheiro@igalia.com>
Signed-off-by: Juan A. Suarez Romero <jasuarez@igalia.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29299>
This commit is contained in:
Juan A. Suarez Romero
2024-05-21 10:03:24 +02:00
committed by Marge Bot
parent 924c5ad2ac
commit cbcfb34cf7
3 changed files with 51 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/gallium/drivers/v3d/v3d_context.h
View File

@@ -252,15 +252,15 @@ struct v3d_program_stateobj {
struct v3d_constbuf_stateobj {
struct pipe_constant_buffer cb[PIPE_MAX_CONSTANT_BUFFERS];
uint32_t enabled_mask;
uint32_t dirty_mask;
BITSET_DECLARE(enabled_mask, PIPE_MAX_CONSTANT_BUFFERS);
BITSET_DECLARE(dirty_mask, PIPE_MAX_CONSTANT_BUFFERS);
};
struct v3d_vertexbuf_stateobj {
struct pipe_vertex_buffer vb[PIPE_MAX_ATTRIBS];
unsigned count;
uint32_t enabled_mask;
uint32_t dirty_mask;
BITSET_DECLARE(enabled_mask, PIPE_MAX_ATTRIBS);
BITSET_DECLARE(dirty_mask, PIPE_MAX_ATTRIBS);
};
struct v3d_vertex_stateobj {
@@ -288,7 +288,7 @@ struct v3d_streamout_stateobj {
struct v3d_ssbo_stateobj {
struct pipe_shader_buffer sb[PIPE_MAX_SHADER_BUFFERS];
uint32_t enabled_mask;
BITSET_DECLARE(enabled_mask, PIPE_MAX_SHADER_BUFFERS);
};
/* Hash table key for v3d->jobs */
@@ -314,7 +314,7 @@ struct v3d_image_view {
struct v3d_shaderimg_stateobj {
struct v3d_image_view si[PIPE_MAX_SHADER_IMAGES];
uint32_t enabled_mask;
BITSET_DECLARE(enabled_mask, PIPE_MAX_SHADER_IMAGES);
};
struct v3d_perfmon_state {

42
src/gallium/drivers/v3d/v3dx_draw.c
View File

@@ -161,9 +161,10 @@ v3d_predraw_check_stage_inputs(struct pipe_context *pctx,
enum pipe_shader_type s)
{
struct v3d_context *v3d = v3d_context(pctx);
unsigned i;
/* Flush writes to textures we're sampling. */
for (int i = 0; i < v3d->tex[s].num_textures; i++) {
for (i = 0; i < v3d->tex[s].num_textures; i++) {
struct pipe_sampler_view *pview = v3d->tex[s].textures[i];
if (!pview)
continue;
@@ -179,7 +180,8 @@ v3d_predraw_check_stage_inputs(struct pipe_context *pctx,
}
/* Flush writes to UBOs. */
u_foreach_bit(i, v3d->constbuf[s].enabled_mask) {
BITSET_FOREACH_SET(i, v3d->constbuf[s].enabled_mask,
PIPE_MAX_CONSTANT_BUFFERS) {
struct pipe_constant_buffer *cb = &v3d->constbuf[s].cb[i];
if (cb->buffer) {
v3d_flush_jobs_writing_resource(v3d, cb->buffer,
@@ -189,7 +191,8 @@ v3d_predraw_check_stage_inputs(struct pipe_context *pctx,
}
/* Flush reads/writes to our SSBOs */
u_foreach_bit(i, v3d->ssbo[s].enabled_mask) {
BITSET_FOREACH_SET(i, v3d->ssbo[s].enabled_mask,
PIPE_MAX_SHADER_BUFFERS) {
struct pipe_shader_buffer *sb = &v3d->ssbo[s].sb[i];
if (sb->buffer) {
v3d_flush_jobs_reading_resource(v3d, sb->buffer,
@@ -199,7 +202,8 @@ v3d_predraw_check_stage_inputs(struct pipe_context *pctx,
}
/* Flush reads/writes to our image views */
u_foreach_bit(i, v3d->shaderimg[s].enabled_mask) {
BITSET_FOREACH_SET(i, v3d->shaderimg[s].enabled_mask,
PIPE_MAX_SHADER_IMAGES) {
struct v3d_image_view *view = &v3d->shaderimg[s].si[i];
v3d_flush_jobs_reading_resource(v3d, view->base.resource,
@@ -209,7 +213,8 @@ v3d_predraw_check_stage_inputs(struct pipe_context *pctx,
/* Flush writes to our vertex buffers (i.e. from transform feedback) */
if (s == PIPE_SHADER_VERTEX) {
u_foreach_bit(i, v3d->vertexbuf.enabled_mask) {
BITSET_FOREACH_SET(i, v3d->vertexbuf.enabled_mask,
PIPE_MAX_ATTRIBS) {
struct pipe_vertex_buffer *vb = &v3d->vertexbuf.vb[i];
v3d_flush_jobs_writing_resource(v3d, vb->buffer.resource,
@@ -251,10 +256,12 @@ v3d_state_reads_resource(struct v3d_context *v3d,
enum pipe_shader_type s)
{
struct v3d_resource *rsc = v3d_resource(prsc);
unsigned i;
/* Vertex buffers */
if (s == PIPE_SHADER_VERTEX) {
u_foreach_bit(i, v3d->vertexbuf.enabled_mask) {
BITSET_FOREACH_SET(i, v3d->vertexbuf.enabled_mask,
PIPE_MAX_ATTRIBS) {
struct pipe_vertex_buffer *vb = &v3d->vertexbuf.vb[i];
if (!vb->buffer.resource)
continue;
@@ -267,7 +274,8 @@ v3d_state_reads_resource(struct v3d_context *v3d,
}
/* Constant buffers */
u_foreach_bit(i, v3d->constbuf[s].enabled_mask) {
BITSET_FOREACH_SET(i, v3d->constbuf[s].enabled_mask,
PIPE_MAX_CONSTANT_BUFFERS) {
struct pipe_constant_buffer *cb = &v3d->constbuf[s].cb[i];
if (!cb->buffer)
continue;
@@ -278,7 +286,8 @@ v3d_state_reads_resource(struct v3d_context *v3d,
}
/* Shader storage buffers */
u_foreach_bit(i, v3d->ssbo[s].enabled_mask) {
BITSET_FOREACH_SET(i, v3d->ssbo[s].enabled_mask,
PIPE_MAX_SHADER_BUFFERS) {
struct pipe_shader_buffer *sb = &v3d->ssbo[s].sb[i];
if (!sb->buffer)
continue;
@@ -1145,7 +1154,9 @@ v3d_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info,
* which ones are read vs written, so just assume the worst.
*/
for (int s = 0; s < PIPE_SHADER_COMPUTE; s++) {
u_foreach_bit(i, v3d->ssbo[s].enabled_mask) {
unsigned i;
BITSET_FOREACH_SET(i, v3d->ssbo[s].enabled_mask,
PIPE_MAX_SHADER_BUFFERS) {
v3d_job_add_write_resource(job,
v3d->ssbo[s].sb[i].buffer);
struct v3d_resource *rsc= v3d_resource(v3d->ssbo[s].sb[i].buffer);
@@ -1153,7 +1164,8 @@ v3d_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info,
job->tmu_dirty_rcl = true;
}
u_foreach_bit(i, v3d->shaderimg[s].enabled_mask) {
BITSET_FOREACH_SET(i, v3d->shaderimg[s].enabled_mask,
PIPE_MAX_SHADER_IMAGES) {
v3d_job_add_write_resource(job,
v3d->shaderimg[s].si[i].base.resource);
struct v3d_resource *rsc= v3d_resource(v3d->shaderimg[s].si[i].base.resource);
@@ -1399,6 +1411,7 @@ v3d_launch_grid(struct pipe_context *pctx, const struct pipe_grid_info *info)
{
struct v3d_context *v3d = v3d_context(pctx);
struct v3d_screen *screen = v3d->screen;
unsigned i;
v3d_predraw_check_stage_inputs(pctx, PIPE_SHADER_COMPUTE);
@@ -1459,7 +1472,7 @@ v3d_launch_grid(struct pipe_context *pctx, const struct pipe_grid_info *info)
}
uint32_t num_wgs = 1;
for (int i = 0; i < 3; i++) {
for (i = 0; i < 3; i++) {
num_wgs *= v3d->compute_num_workgroups[i];
submit.cfg[i] |= (v3d->compute_num_workgroups[i] <<
V3D_CSD_CFG012_WG_COUNT_SHIFT);
@@ -1562,14 +1575,17 @@ v3d_launch_grid(struct pipe_context *pctx, const struct pipe_grid_info *info)
/* Mark SSBOs as being written.. we don't actually know which ones are
* read vs written, so just assume the worst
*/
u_foreach_bit(i, v3d->ssbo[PIPE_SHADER_COMPUTE].enabled_mask) {
BITSET_FOREACH_SET(i, v3d->ssbo[PIPE_SHADER_COMPUTE].enabled_mask,
PIPE_MAX_SHADER_BUFFERS) {
struct v3d_resource *rsc = v3d_resource(
v3d->ssbo[PIPE_SHADER_COMPUTE].sb[i].buffer);
rsc->writes++;
rsc->compute_written = true;
}
u_foreach_bit(i, v3d->shaderimg[PIPE_SHADER_COMPUTE].enabled_mask) {
BITSET_FOREACH_SET(i,
v3d->shaderimg[PIPE_SHADER_COMPUTE].enabled_mask,
PIPE_MAX_SHADER_IMAGES) {
struct v3d_resource *rsc = v3d_resource(
v3d->shaderimg[PIPE_SHADER_COMPUTE].si[i].base.resource);
rsc->writes++;

36
src/gallium/drivers/v3d/v3dx_state.c
View File

@@ -297,9 +297,13 @@ v3d_set_vertex_buffers(struct pipe_context *pctx,
struct v3d_context *v3d = v3d_context(pctx);
struct v3d_vertexbuf_stateobj *so = &v3d->vertexbuf;
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb,
assert(BITSET_SIZE(so->enabled_mask) <= 32);
uint32_t enabled_mask;
util_set_vertex_buffers_mask(so->vb, &enabled_mask, vb,
count, true);
so->count = util_last_bit(so->enabled_mask);
memcpy(&so->enabled_mask, &enabled_mask, sizeof(enabled_mask));
so->count = BITSET_LAST_BIT(so->enabled_mask);
v3d->dirty |= V3D_DIRTY_VTXBUF;
}
@@ -479,13 +483,13 @@ v3d_set_constant_buffer(struct pipe_context *pctx, enum pipe_shader_type shader,
* passing NULL here.
*/
if (unlikely(!cb)) {
so->enabled_mask &= ~(1 << index);
so->dirty_mask &= ~(1 << index);
BITSET_CLEAR(so->enabled_mask, index);
BITSET_CLEAR(so->dirty_mask, index);
return;
}
so->enabled_mask |= 1 << index;
so->dirty_mask |= 1 << index;
BITSET_SET(so->enabled_mask, index);
BITSET_SET(so->dirty_mask, index);
v3d->dirty |= V3D_DIRTY_CONSTBUF;
}
@@ -1289,7 +1293,6 @@ v3d_set_shader_buffers(struct pipe_context *pctx,
{
struct v3d_context *v3d = v3d_context(pctx);
struct v3d_ssbo_stateobj *so = &v3d->ssbo[shader];
unsigned mask = 0;
if (buffers) {
for (unsigned i = 0; i < count; i++) {
@@ -1301,20 +1304,16 @@ v3d_set_shader_buffers(struct pipe_context *pctx,
(buf->buffer_size == buffers[i].buffer_size))
continue;
mask |= 1 << n;
buf->buffer_offset = buffers[i].buffer_offset;
buf->buffer_size = buffers[i].buffer_size;
pipe_resource_reference(&buf->buffer, buffers[i].buffer);
if (buf->buffer)
so->enabled_mask |= 1 << n;
BITSET_SET(so->enabled_mask, n);
else
so->enabled_mask &= ~(1 << n);
BITSET_CLEAR(so->enabled_mask, n);
}
} else {
mask = ((1 << count) - 1) << start;
for (unsigned i = 0; i < count; i++) {
unsigned n = i + start;
struct pipe_shader_buffer *buf = &so->sb[n];
@@ -1322,7 +1321,7 @@ v3d_set_shader_buffers(struct pipe_context *pctx,
pipe_resource_reference(&buf->buffer, NULL);
}
so->enabled_mask &= ~mask;
BITSET_CLEAR_RANGE(so->enabled_mask, start, start + count);
}
v3d->dirty |= V3D_DIRTY_SSBO;
@@ -1395,12 +1394,12 @@ v3d_set_shader_images(struct pipe_context *pctx,
util_copy_image_view(&iview->base, &images[i]);
if (iview->base.resource) {
so->enabled_mask |= 1 << n;
BITSET_SET(so->enabled_mask, n);
v3d_create_image_view_texture_shader_state(v3d,
so,
n);
} else {
so->enabled_mask &= ~(1 << n);
BITSET_CLEAR(so->enabled_mask, n);
pipe_resource_reference(&iview->tex_state, NULL);
}
}
@@ -1413,10 +1412,7 @@ v3d_set_shader_images(struct pipe_context *pctx,
pipe_resource_reference(&iview->tex_state, NULL);
}
if (count == 32)
so->enabled_mask = 0;
else
so->enabled_mask &= ~(((1 << count) - 1) << start);
BITSET_CLEAR_RANGE(so->enabled_mask, start, start + count);
}
v3d->dirty |= V3D_DIRTY_SHADER_IMAGE;