fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-23 11:10:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

gallium: remove unbind_trailing_count from set_vertex_buffers

Browse source 
It should implicitly unbind all bound buffers after "count".
This also slightly simplies u_vbuf.

This is a cleanup suggested by:
    https://gitlab.freedesktop.org/mesa/mesa/-/issues/8142

Reviewed-by: Alyssa Rosenzweig <alyssa@rosenzweig.io> (asahi & panfrost)
Reviewed-By: Mike Blumenkrantz <michael.blumenkrantz@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/26309>
This commit is contained in:
Marek Olšák 2023-11-20 13:48:09 -05:00 • committed by Marge Bot
parent 2725b095ea
commit eb20ef9277
79 changed files with 321 additions and 455 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
src/gallium/auxiliary/cso_cache/cso_context.c
View file

@ -1287,25 +1287,19 @@ cso_restore_vertex_elements(struct cso_context_priv *ctx)
void
cso_set_vertex_buffers(struct cso_context *cso,
unsigned count,
unsigned unbind_trailing_count,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
struct cso_context_priv *ctx = (struct cso_context_priv *)cso;
struct u_vbuf *vbuf = ctx->vbuf_current;
if (!count && !unbind_trailing_count)
return;
if (vbuf) {
u_vbuf_set_vertex_buffers(vbuf, count, unbind_trailing_count,
take_ownership, buffers);
u_vbuf_set_vertex_buffers(vbuf, count, take_ownership, buffers);
return;
}
struct pipe_context *pipe = ctx->base.pipe;
pipe->set_vertex_buffers(pipe, count, unbind_trailing_count,
take_ownership, buffers);
pipe->set_vertex_buffers(pipe, count, take_ownership, buffers);
}
@ -1325,7 +1319,6 @@ void
cso_set_vertex_buffers_and_elements(struct cso_context *cso,
const struct cso_velems_state *velems,
unsigned vb_count,
unsigned unbind_trailing_vb_count,
bool take_ownership,
bool uses_user_vertex_buffers,
const struct pipe_vertex_buffer *vbuffers)
@ -1337,45 +1330,32 @@ cso_set_vertex_buffers_and_elements(struct cso_context *cso,
if (vbuf && (ctx->always_use_vbuf || uses_user_vertex_buffers)) {
if (!ctx->vbuf_current) {
/* Unbind all buffers in cso_context, because we'll use u_vbuf. */
unsigned unbind_vb_count = vb_count + unbind_trailing_vb_count;
if (unbind_vb_count)
pipe->set_vertex_buffers(pipe, 0, unbind_vb_count, false, NULL);
pipe->set_vertex_buffers(pipe, 0, false, NULL);
/* Unset this to make sure the CSO is re-bound on the next use. */
ctx->velements = NULL;
ctx->vbuf_current = pipe->vbuf = vbuf;
if (pipe->draw_vbo == tc_draw_vbo)
ctx->base.draw_vbo = u_vbuf_draw_vbo;
unbind_trailing_vb_count = 0;
}
if (vb_count || unbind_trailing_vb_count) {
u_vbuf_set_vertex_buffers(vbuf, vb_count,
unbind_trailing_vb_count,
take_ownership, vbuffers);
}
u_vbuf_set_vertex_buffers(vbuf, vb_count, take_ownership, vbuffers);
u_vbuf_set_vertex_elements(vbuf, velems);
return;
}
if (ctx->vbuf_current) {
/* Unbind all buffers in u_vbuf, because we'll use cso_context. */
unsigned unbind_vb_count = vb_count + unbind_trailing_vb_count;
if (unbind_vb_count)
u_vbuf_set_vertex_buffers(vbuf, 0, unbind_vb_count, false, NULL);
u_vbuf_set_vertex_buffers(vbuf, 0, false, NULL);
/* Unset this to make sure the CSO is re-bound on the next use. */
u_vbuf_unset_vertex_elements(vbuf);
ctx->vbuf_current = pipe->vbuf = NULL;
if (pipe->draw_vbo == tc_draw_vbo)
ctx->base.draw_vbo = pipe->draw_vbo;
unbind_trailing_vb_count = 0;
}
if (vb_count || unbind_trailing_vb_count) {
pipe->set_vertex_buffers(pipe, vb_count, unbind_trailing_vb_count,
take_ownership, vbuffers);
}
pipe->set_vertex_buffers(pipe, vb_count, take_ownership, vbuffers);
cso_set_vertex_elements_direct(ctx, velems);
}
@ -1766,7 +1746,7 @@ cso_restore_state(struct cso_context *ctx, unsigned unbind)
if (state_mask & CSO_BIT_VERTEX_ELEMENTS)
cso_restore_vertex_elements(cso);
if (unbind & CSO_UNBIND_VERTEX_BUFFER0)
cso->base.pipe->set_vertex_buffers(cso->base.pipe, 0, 1, false, NULL);
cso->base.pipe->set_vertex_buffers(cso->base.pipe, 0, false, NULL);
if (state_mask & CSO_BIT_STREAM_OUTPUTS)
cso_restore_stream_outputs(cso);
if (state_mask & CSO_BIT_PAUSE_QUERIES)

2
src/gallium/auxiliary/cso_cache/cso_context.h
View file

@ -95,7 +95,6 @@ cso_set_vertex_elements(struct cso_context *ctx,
void cso_set_vertex_buffers(struct cso_context *ctx,
unsigned count,
unsigned unbind_trailing_count,
bool take_ownership,
const struct pipe_vertex_buffer *buffers);
@ -205,7 +204,6 @@ void
cso_set_vertex_buffers_and_elements(struct cso_context *ctx,
const struct cso_velems_state *velems,
unsigned vb_count,
unsigned unbind_trailing_vb_count,
bool take_ownership,
bool uses_user_vertex_buffers,
const struct pipe_vertex_buffer *vbuffers);

4
src/gallium/auxiliary/draw/draw_context.c
View file

@ -405,15 +405,13 @@ draw_set_viewport_states(struct draw_context *draw,
void
draw_set_vertex_buffers(struct draw_context *draw,
unsigned count,
unsigned unbind_num_trailing_slots,
const struct pipe_vertex_buffer *buffers)
{
assert(count <= PIPE_MAX_ATTRIBS);
util_set_vertex_buffers_count(draw->pt.vertex_buffer,
&draw->pt.nr_vertex_buffers,
buffers, count,
unbind_num_trailing_slots, false);
buffers, count, false);
}

1
src/gallium/auxiliary/draw/draw_context.h
View file

@ -321,7 +321,6 @@ void draw_delete_mesh_shader(struct draw_context *draw,
void draw_set_vertex_buffers(struct draw_context *draw,
unsigned count,
unsigned unbind_num_trailing_slots,
const struct pipe_vertex_buffer *buffers);
void draw_set_vertex_elements(struct draw_context *draw,

10
src/gallium/auxiliary/driver_ddebug/dd_context.c
View file

@ -571,7 +571,6 @@ dd_context_set_shader_buffers(struct pipe_context *_pipe,
static void
dd_context_set_vertex_buffers(struct pipe_context *_pipe,
unsigned num_buffers,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
@ -580,11 +579,12 @@ dd_context_set_vertex_buffers(struct pipe_context *_pipe,
safe_memcpy(&dctx->draw_state.vertex_buffers[0], buffers,
sizeof(buffers[0]) * num_buffers);
if (dctx->num_vertex_buffers > num_buffers) {
safe_memcpy(&dctx->draw_state.vertex_buffers[num_buffers], NULL,
sizeof(buffers[0]) * unbind_num_trailing_slots);
pipe->set_vertex_buffers(pipe, num_buffers,
unbind_num_trailing_slots, take_ownership,
buffers);
sizeof(buffers[0]) * (dctx->num_vertex_buffers - num_buffers));
}
pipe->set_vertex_buffers(pipe, num_buffers, take_ownership, buffers);
dctx->num_vertex_buffers = num_buffers;
}
static void

1
src/gallium/auxiliary/driver_ddebug/dd_pipe.h
View file

@ -302,6 +302,7 @@ struct dd_context
struct dd_draw_state draw_state;
unsigned num_draw_calls;
unsigned num_vertex_buffers;
struct u_log_context log;

1
src/gallium/auxiliary/driver_noop/noop_state.c
View file

@ -215,7 +215,6 @@ static void noop_delete_state(struct pipe_context *ctx, void *state)
static void noop_set_vertex_buffers(struct pipe_context *ctx,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{

6
src/gallium/auxiliary/driver_trace/tr_context.c
View file

@ -1238,7 +1238,6 @@ trace_context_set_sampler_views(struct pipe_context *_pipe,
static void
trace_context_set_vertex_buffers(struct pipe_context *_pipe,
unsigned num_buffers,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
@ -1249,16 +1248,13 @@ trace_context_set_vertex_buffers(struct pipe_context *_pipe,
trace_dump_arg(ptr, pipe);
trace_dump_arg(uint, num_buffers);
trace_dump_arg(uint, unbind_num_trailing_slots);
trace_dump_arg(bool, take_ownership);
trace_dump_arg_begin("buffers");
trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
trace_dump_arg_end();
pipe->set_vertex_buffers(pipe, num_buffers,
unbind_num_trailing_slots, take_ownership,
buffers);
pipe->set_vertex_buffers(pipe, num_buffers, take_ownership, buffers);
trace_dump_call_end();
}

8
src/gallium/auxiliary/hud/hud_context.c
View file

@ -112,7 +112,7 @@ hud_draw_colored_prims(struct hud_context *hud, unsigned prim,
&vbuffer.buffer_offset, &vbuffer.buffer.resource);
u_upload_unmap(hud->pipe->stream_uploader);
cso_set_vertex_buffers(cso, 1, 0, false, &vbuffer);
cso_set_vertex_buffers(cso, 1, false, &vbuffer);
pipe_resource_reference(&vbuffer.buffer.resource, NULL);
cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
cso_draw_arrays(cso, prim, 0, num_vertices);
@ -601,7 +601,7 @@ hud_draw_results(struct hud_context *hud, struct pipe_resource *tex)
pipe->set_constant_buffer(pipe, PIPE_SHADER_VERTEX, 0, false, &hud->constbuf);
cso_set_vertex_buffers(cso, 1, 0, false, &hud->bg.vbuf);
cso_set_vertex_buffers(cso, 1, false, &hud->bg.vbuf);
cso_draw_arrays(cso, MESA_PRIM_QUADS, 0, hud->bg.num_vertices);
}
pipe_resource_reference(&hud->bg.vbuf.buffer.resource, NULL);
@ -610,7 +610,7 @@ hud_draw_results(struct hud_context *hud, struct pipe_resource *tex)
if (hud->text.num_vertices) {
cso_set_vertex_shader_handle(cso, hud->vs_text);
cso_set_vertex_elements(cso, &hud->text_velems);
cso_set_vertex_buffers(cso, 1, 0, false, &hud->text.vbuf);
cso_set_vertex_buffers(cso, 1, false, &hud->text.vbuf);
cso_set_fragment_shader_handle(hud->cso, hud->fs_text);
cso_draw_arrays(cso, MESA_PRIM_QUADS, 0, hud->text.num_vertices);
cso_set_vertex_elements(cso, &hud->velems);
@ -635,7 +635,7 @@ hud_draw_results(struct hud_context *hud, struct pipe_resource *tex)
if (hud->whitelines.num_vertices) {
cso_set_vertex_shader_handle(cso, hud->vs_color);
cso_set_vertex_buffers(cso, 1, 0, false, &hud->whitelines.vbuf);
cso_set_vertex_buffers(cso, 1, false, &hud->whitelines.vbuf);
cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
cso_draw_arrays(cso, MESA_PRIM_LINES, 0, hud->whitelines.num_vertices);
}

14
src/gallium/auxiliary/util/u_blitter.c
View file

@ -643,10 +643,12 @@ void util_blitter_restore_vertex_states(struct blitter_context *blitter)
unsigned i;
/* Vertex buffer. */
if (ctx->base.saved_vertex_buffer.buffer.resource) {
pipe->set_vertex_buffers(pipe, 1, 0, true,
&ctx->base.saved_vertex_buffer);
ctx->base.saved_vertex_buffer.buffer.resource = NULL;
if (ctx->base.saved_num_vb) {
pipe->set_vertex_buffers(pipe, ctx->base.saved_num_vb, true,
ctx->base.saved_vertex_buffers);
memset(ctx->base.saved_vertex_buffers, 0,
sizeof(ctx->base.saved_vertex_buffers[0]) * ctx->base.saved_num_vb);
ctx->base.saved_num_vb = 0;
}
/* Vertex elements. */
@ -1409,7 +1411,7 @@ static void blitter_draw(struct blitter_context_priv *ctx,
return;
u_upload_unmap(pipe->stream_uploader);
pipe->set_vertex_buffers(pipe, 1, 0, false, &vb);
pipe->set_vertex_buffers(pipe, 1, false, &vb);
pipe->bind_vertex_elements_state(pipe, vertex_elements_cso);
pipe->bind_vs_state(pipe, get_vs(&ctx->base));
@ -2631,7 +2633,7 @@ void util_blitter_clear_buffer(struct blitter_context *blitter,
blitter_check_saved_vertex_states(ctx);
blitter_disable_render_cond(ctx);
pipe->set_vertex_buffers(pipe, 1, 0, false, &vb);
pipe->set_vertex_buffers(pipe, 1, false, &vb);
pipe->bind_vertex_elements_state(pipe,
ctx->velem_state_readbuf[num_channels-1]);
bind_vs_pos_only(ctx, num_channels);

15
src/gallium/auxiliary/util/u_blitter.h
View file

@ -129,7 +129,8 @@ struct blitter_context
unsigned cb_slot;
struct pipe_constant_buffer saved_fs_constant_buffer;
struct pipe_vertex_buffer saved_vertex_buffer;
unsigned saved_num_vb;
struct pipe_vertex_buffer saved_vertex_buffers[PIPE_MAX_ATTRIBS];
unsigned saved_num_so_targets;
struct pipe_stream_output_target *saved_so_targets[PIPE_MAX_SO_BUFFERS];
@ -532,11 +533,15 @@ util_blitter_save_fragment_constant_buffer_slot(
}
static inline void
util_blitter_save_vertex_buffer_slot(struct blitter_context *blitter,
struct pipe_vertex_buffer *vertex_buffers)
util_blitter_save_vertex_buffers(struct blitter_context *blitter,
struct pipe_vertex_buffer *vertex_buffers,
unsigned count)
{
pipe_vertex_buffer_reference(&blitter->saved_vertex_buffer,
&vertex_buffers[0]);
for (unsigned i = 0; i < count; i++) {
pipe_vertex_buffer_reference(&blitter->saved_vertex_buffers[i],
&vertex_buffers[i]);
}
blitter->saved_num_vb = count;
}
static inline void

8
src/gallium/auxiliary/util/u_draw_quad.c
View file

@ -59,10 +59,10 @@ util_draw_vertex_buffer(struct pipe_context *pipe,
/* note: vertex elements already set by caller */
if (cso) {
cso_set_vertex_buffers(cso, 1, 0, false, &vbuffer);
cso_set_vertex_buffers(cso, 1, false, &vbuffer);
cso_draw_arrays(cso, prim_type, 0, num_verts);
} else {
pipe->set_vertex_buffers(pipe, 1, 0, false, &vbuffer);
pipe->set_vertex_buffers(pipe, 1, false, &vbuffer);
util_draw_arrays(pipe, prim_type, 0, num_verts);
}
}
@ -86,7 +86,7 @@ util_draw_user_vertex_buffer(struct cso_context *cso, void *buffer,
/* note: vertex elements already set by caller */
cso_set_vertex_buffers(cso, 1, 0, false, &vbuffer);
cso_set_vertex_buffers(cso, 1, false, &vbuffer);
cso_draw_arrays(cso, prim_type, 0, num_verts);
}
@ -104,6 +104,6 @@ util_draw_user_vertices(struct cso_context *cso, struct cso_velems_state *ve,
vbuffer.is_user_buffer = true;
vbuffer.buffer.user = buffer;
cso_set_vertex_buffers_and_elements(cso, ve, 1, 0, false, true, &vbuffer);
cso_set_vertex_buffers_and_elements(cso, ve, 1, false, true, &vbuffer);
cso_draw_arrays(cso, prim_type, 0, num_verts);
}

28
src/gallium/auxiliary/util/u_helpers.c
View file

@ -48,16 +48,16 @@ void util_set_vertex_buffers_mask(struct pipe_vertex_buffer *dst,
uint32_t *enabled_buffers,
const struct pipe_vertex_buffer *src,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership)
{
unsigned i;
unsigned last_count = util_last_bit(*enabled_buffers);
uint32_t bitmask = 0;
unsigned i = 0;
*enabled_buffers &= ~BITFIELD_MASK(count);
assert(!count || src);
if (src) {
for (i = 0; i < count; i++) {
for (; i < count; i++) {
if (src[i].buffer.resource)
bitmask |= 1 << i;
@ -69,17 +69,12 @@ void util_set_vertex_buffers_mask(struct pipe_vertex_buffer *dst,
/* Copy over the other members of pipe_vertex_buffer. */
memcpy(dst, src, count * sizeof(struct pipe_vertex_buffer));
*enabled_buffers |= bitmask;
}
else {
/* Unreference the buffers. */
for (i = 0; i < count; i++)
*enabled_buffers = bitmask;
for (; i < last_count; i++)
pipe_vertex_buffer_unreference(&dst[i]);
}
for (i = 0; i < unbind_num_trailing_slots; i++)
pipe_vertex_buffer_unreference(&dst[count + i]);
}
/**
@ -90,19 +85,16 @@ void util_set_vertex_buffers_count(struct pipe_vertex_buffer *dst,
unsigned *dst_count,
const struct pipe_vertex_buffer *src,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership)
{
unsigned i;
uint32_t enabled_buffers = 0;
for (i = 0; i < *dst_count; i++) {
for (unsigned i = 0; i < *dst_count; i++) {
if (dst[i].buffer.resource)
enabled_buffers |= (1ull << i);
}
util_set_vertex_buffers_mask(dst, &enabled_buffers, src,
count, unbind_num_trailing_slots,
util_set_vertex_buffers_mask(dst, &enabled_buffers, src, count,
take_ownership);
*dst_count = util_last_bit(enabled_buffers);

2
src/gallium/auxiliary/util/u_helpers.h
View file

@ -41,14 +41,12 @@ void util_set_vertex_buffers_mask(struct pipe_vertex_buffer *dst,
uint32_t *enabled_buffers,
const struct pipe_vertex_buffer *src,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership);
void util_set_vertex_buffers_count(struct pipe_vertex_buffer *dst,
unsigned *dst_count,
const struct pipe_vertex_buffer *src,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership);
void util_set_shader_buffers_mask(struct pipe_shader_buffer *dst,

30
src/gallium/auxiliary/util/u_threaded_context.c
View file

@ -945,7 +945,7 @@ tc_add_all_gfx_bindings_to_buffer_list(struct threaded_context *tc)
{
BITSET_WORD *buffer_list = tc->buffer_lists[tc->next_buf_list].buffer_list;
tc_add_bindings_to_buffer_list(buffer_list, tc->vertex_buffers, tc->max_vertex_buffers);
tc_add_bindings_to_buffer_list(buffer_list, tc->vertex_buffers, tc->num_vertex_buffers);
if (tc->seen_streamout_buffers)
tc_add_bindings_to_buffer_list(buffer_list, tc->streamout_buffers, PIPE_MAX_SO_BUFFERS);
@ -981,7 +981,7 @@ tc_rebind_buffer(struct threaded_context *tc, uint32_t old_id, uint32_t new_id,
unsigned vbo = 0, so = 0;
vbo = tc_rebind_bindings(old_id, new_id, tc->vertex_buffers,
tc->max_vertex_buffers);
tc->num_vertex_buffers);
if (vbo)
*rebind_mask |= BITFIELD_BIT(TC_BINDING_VERTEX_BUFFER);
@ -2153,7 +2153,6 @@ tc_set_shader_buffers(struct pipe_context *_pipe,
struct tc_vertex_buffers {
struct tc_call_base base;
uint8_t count;
uint8_t unbind_num_trailing_slots;
struct pipe_vertex_buffer slot[0]; /* more will be allocated if needed */
};
@ -2164,34 +2163,31 @@ tc_call_set_vertex_buffers(struct pipe_context *pipe, void *call)
unsigned count = p->count;
if (!count) {
pipe->set_vertex_buffers(pipe, 0, p->unbind_num_trailing_slots, false, NULL);
pipe->set_vertex_buffers(pipe, 0, false, NULL);
return call_size(tc_vertex_buffers);
}
for (unsigned i = 0; i < count; i++)
tc_assert(!p->slot[i].is_user_buffer);
pipe->set_vertex_buffers(pipe, count, p->unbind_num_trailing_slots, true, p->slot);
pipe->set_vertex_buffers(pipe, count, true, p->slot);
return p->base.num_slots;
}
static void
tc_set_vertex_buffers(struct pipe_context *_pipe,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
struct threaded_context *tc = threaded_context(_pipe);
if (!count && !unbind_num_trailing_slots)
return;
assert(!count || buffers);
if (count && buffers) {
if (count) {
struct tc_vertex_buffers *p =
tc_add_slot_based_call(tc, TC_CALL_set_vertex_buffers, tc_vertex_buffers, count);
p->count = count;
p->unbind_num_trailing_slots = unbind_num_trailing_slots;
struct tc_buffer_list *next = &tc->buffer_lists[tc->next_buf_list];
@ -2225,18 +2221,16 @@ tc_set_vertex_buffers(struct pipe_context *_pipe,
}
}
}
tc_unbind_buffers(&tc->vertex_buffers[count],
unbind_num_trailing_slots);
} else {
struct tc_vertex_buffers *p =
tc_add_slot_based_call(tc, TC_CALL_set_vertex_buffers, tc_vertex_buffers, 0);
p->count = 0;
p->unbind_num_trailing_slots = count + unbind_num_trailing_slots;
tc_unbind_buffers(&tc->vertex_buffers[0],
count + unbind_num_trailing_slots);
}
/* We don't need to unbind trailing buffers because we never touch bindings
* after num_vertex_buffers.
*/
tc->num_vertex_buffers = count;
}
struct tc_stream_outputs {
@ -5285,8 +5279,6 @@ threaded_context_create(struct pipe_context *pipe,
/* If you have different limits in each shader stage, set the maximum. */
struct pipe_screen *screen = pipe->screen;;
tc->max_vertex_buffers =
screen->get_param(screen, PIPE_CAP_MAX_VERTEX_BUFFERS);
tc->max_const_buffers =
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
PIPE_SHADER_CAP_MAX_CONST_BUFFERS);

2
src/gallium/auxiliary/util/u_threaded_context.h
View file

@ -616,7 +616,7 @@ struct threaded_context {
int8_t last_completed;
unsigned max_vertex_buffers;
uint8_t num_vertex_buffers;
unsigned max_const_buffers;
unsigned max_shader_buffers;
unsigned max_images;

146
src/gallium/auxiliary/util/u_vbuf.c
View file

@ -171,6 +171,9 @@ struct u_vbuf {
/* This is what was set in set_vertex_buffers.
* May contain user buffers. */
struct pipe_vertex_buffer vertex_buffer[PIPE_MAX_ATTRIBS];
uint8_t num_vertex_buffers;
uint8_t num_real_vertex_buffers;
bool vertex_buffers_dirty;
uint32_t enabled_vb_mask;
uint32_t unaligned_vb_mask[2]; //16/32bit
@ -178,8 +181,6 @@ struct u_vbuf {
/* Vertex buffers for the driver.
* There are usually no user buffers. */
struct pipe_vertex_buffer real_vertex_buffer[PIPE_MAX_ATTRIBS];
uint32_t dirty_real_vb_mask; /* which buffers are dirty since the last
call of set_vertex_buffers */
/* Vertex elements. */
struct u_vbuf_elements *ve, *ve_saved;
@ -441,12 +442,9 @@ void u_vbuf_unset_vertex_elements(struct u_vbuf *mgr)
void u_vbuf_destroy(struct u_vbuf *mgr)
{
struct pipe_screen *screen = mgr->pipe->screen;
unsigned i;
const unsigned num_vb = screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
PIPE_SHADER_CAP_MAX_INPUTS);
mgr->pipe->set_vertex_buffers(mgr->pipe, 0, num_vb, false, NULL);
mgr->pipe->set_vertex_buffers(mgr->pipe, 0, false, NULL);
for (i = 0; i < PIPE_MAX_ATTRIBS; i++)
pipe_vertex_buffer_unreference(&mgr->vertex_buffer[i]);
@ -672,7 +670,9 @@ u_vbuf_translate_find_free_vb_slots(struct u_vbuf *mgr,
for (type = 0; type < VB_NUM; type++) {
if (mask[type]) {
mgr->dirty_real_vb_mask |= 1 << fallback_vbs[type];
mgr->num_real_vertex_buffers =
MAX2(mgr->num_real_vertex_buffers, fallback_vbs[type] + 1);
mgr->vertex_buffers_dirty = true;
}
}
@ -863,8 +863,11 @@ static void u_vbuf_translate_end(struct u_vbuf *mgr)
mgr->fallback_vbs[i] = ~0;
}
}
/* This will cause the buffer to be unbound in the driver later. */
mgr->dirty_real_vb_mask |= mgr->fallback_vbs_mask;
/* This will cause the fallback buffers above num_vertex_buffers to be
* unbound.
*/
mgr->num_real_vertex_buffers = mgr->num_vertex_buffers;
mgr->vertex_buffers_dirty = true;
mgr->fallback_vbs_mask = 0;
}
@ -993,10 +996,34 @@ static void u_vbuf_delete_vertex_elements(void *ctx, void *state,
void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *bufs)
{
if (!count) {
struct pipe_context *pipe = mgr->pipe;
unsigned last_count = mgr->num_vertex_buffers;
/* Unbind. */
mgr->num_vertex_buffers = 0;
mgr->num_real_vertex_buffers = 0;
mgr->user_vb_mask = 0;
mgr->incompatible_vb_mask = 0;
mgr->enabled_vb_mask = 0;
mgr->unaligned_vb_mask[0] = 0;
mgr->unaligned_vb_mask[1] = 0;
mgr->vertex_buffers_dirty = false;
for (unsigned i = 0; i < last_count; i++) {
pipe_vertex_buffer_unreference(&mgr->vertex_buffer[i]);
pipe_vertex_buffer_unreference(&mgr->real_vertex_buffer[i]);
}
pipe->set_vertex_buffers(pipe, 0, false, NULL);
return;
}
assert(bufs);
unsigned i;
/* which buffers are enabled */
uint32_t enabled_vb_mask = 0;
@ -1006,29 +1033,7 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr,
uint32_t incompatible_vb_mask = 0;
/* which buffers are unaligned to 2/4 bytes */
uint32_t unaligned_vb_mask[2] = {0};
uint32_t mask = ~BITFIELD64_MASK(count + unbind_num_trailing_slots);
if (!bufs) {
struct pipe_context *pipe = mgr->pipe;
/* Unbind. */
unsigned total_count = count + unbind_num_trailing_slots;
mgr->dirty_real_vb_mask &= mask;
/* Zero out the bits we are going to rewrite completely. */
mgr->user_vb_mask &= mask;
mgr->incompatible_vb_mask &= mask;
mgr->enabled_vb_mask &= mask;
mgr->unaligned_vb_mask[0] &= mask;
mgr->unaligned_vb_mask[1] &= mask;
for (i = 0; i < total_count; i++) {
pipe_vertex_buffer_unreference(&mgr->vertex_buffer[i]);
pipe_vertex_buffer_unreference(&mgr->real_vertex_buffer[i]);
}
pipe->set_vertex_buffers(pipe, count, unbind_num_trailing_slots, false, NULL);
return;
}
unsigned num_identical = 0;
for (i = 0; i < count; i++) {
const struct pipe_vertex_buffer *vb = &bufs[i];
@ -1041,20 +1046,11 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr,
continue;
}
bool not_user = !vb->is_user_buffer && vb->is_user_buffer == orig_vb->is_user_buffer;
/* struct isn't tightly packed: do not use memcmp */
if (not_user &&
orig_vb->buffer_offset == vb->buffer_offset && orig_vb->buffer.resource == vb->buffer.resource) {
mask |= BITFIELD_BIT(i);
if (take_ownership) {
pipe_vertex_buffer_unreference(orig_vb);
/* the pointer was unset in the line above, so copy it back */
orig_vb->buffer.resource = vb->buffer.resource;
}
if (mask == UINT32_MAX)
return;
continue;
}
/* The structure has holes: do not use memcmp. */
if (orig_vb->is_user_buffer == vb->is_user_buffer &&
orig_vb->buffer_offset == vb->buffer_offset &&
orig_vb->buffer.resource == vb->buffer.resource)
num_identical++;
if (take_ownership) {
pipe_vertex_buffer_unreference(orig_vb);
@ -1091,30 +1087,24 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr,
pipe_vertex_buffer_reference(real_vb, vb);
}
for (i = 0; i < unbind_num_trailing_slots; i++) {
unsigned dst_index = count + i;
unsigned last_count = mgr->num_vertex_buffers;
pipe_vertex_buffer_unreference(&mgr->vertex_buffer[dst_index]);
pipe_vertex_buffer_unreference(&mgr->real_vertex_buffer[dst_index]);
if (num_identical == count && count == last_count)
return;
for (; i < last_count; i++) {
pipe_vertex_buffer_unreference(&mgr->vertex_buffer[i]);
pipe_vertex_buffer_unreference(&mgr->real_vertex_buffer[i]);
}
/* Zero out the bits we are going to rewrite completely. */
mgr->user_vb_mask &= mask;
mgr->incompatible_vb_mask &= mask;
mgr->enabled_vb_mask &= mask;
mgr->unaligned_vb_mask[0] &= mask;
mgr->unaligned_vb_mask[1] &= mask;
mgr->user_vb_mask |= user_vb_mask;
mgr->incompatible_vb_mask |= incompatible_vb_mask;
mgr->enabled_vb_mask |= enabled_vb_mask;
mgr->unaligned_vb_mask[0] |= unaligned_vb_mask[0];
mgr->unaligned_vb_mask[1] |= unaligned_vb_mask[1];
/* All changed buffers are marked as dirty, even the NULL ones,
* which will cause the NULL buffers to be unbound in the driver later. */
mgr->dirty_real_vb_mask |= ~mask;
mgr->num_vertex_buffers = count;
mgr->num_real_vertex_buffers = count;
mgr->user_vb_mask = user_vb_mask;
mgr->incompatible_vb_mask = incompatible_vb_mask;
mgr->enabled_vb_mask = enabled_vb_mask;
mgr->unaligned_vb_mask[0] = unaligned_vb_mask[0];
mgr->unaligned_vb_mask[1] = unaligned_vb_mask[1];
mgr->vertex_buffers_dirty = true;
}
static ALWAYS_INLINE bool
@ -1403,15 +1393,16 @@ void u_vbuf_get_minmax_index(struct pipe_context *pipe,
static void u_vbuf_set_driver_vertex_buffers(struct u_vbuf *mgr)
{
struct pipe_context *pipe = mgr->pipe;
unsigned count = util_last_bit(mgr->dirty_real_vb_mask);
unsigned count = mgr->num_real_vertex_buffers;
if (mgr->dirty_real_vb_mask == mgr->enabled_vb_mask &&
mgr->dirty_real_vb_mask == mgr->user_vb_mask) {
assert(mgr->vertex_buffers_dirty);
if (mgr->user_vb_mask == BITFIELD_MASK(count)) {
/* Fast path that allows us to transfer the VBO references to the driver
* to skip atomic reference counting there. These are freshly uploaded
* user buffers that can be discarded after this call.
*/
pipe->set_vertex_buffers(pipe, count, 0, true, mgr->real_vertex_buffer);
pipe->set_vertex_buffers(pipe, count, true, mgr->real_vertex_buffer);
/* We don't own the VBO references now. Set them to NULL. */
for (unsigned i = 0; i < count; i++) {
@ -1420,9 +1411,9 @@ static void u_vbuf_set_driver_vertex_buffers(struct u_vbuf *mgr)
}
} else {
/* Slow path where we have to keep VBO references. */
pipe->set_vertex_buffers(pipe, count, 0, false, mgr->real_vertex_buffer);
pipe->set_vertex_buffers(pipe, count, false, mgr->real_vertex_buffer);
}
mgr->dirty_real_vb_mask = 0;
mgr->vertex_buffers_dirty = false;
}
static void
@ -1489,7 +1480,7 @@ void u_vbuf_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *inf
mgr->caps.supported_prim_modes & BITFIELD_BIT(info->mode)) {
/* Set vertex buffers if needed. */
if (mgr->dirty_real_vb_mask & used_vb_mask) {
if (mgr->vertex_buffers_dirty) {
u_vbuf_set_driver_vertex_buffers(mgr);
}
@ -1740,6 +1731,7 @@ void u_vbuf_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *inf
user_vb_mask &= ~(incompatible_vb_mask |
mgr->ve->incompatible_vb_mask_all);
mgr->vertex_buffers_dirty = true;
}
/* Upload user buffers. */
@ -1751,7 +1743,7 @@ void u_vbuf_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *inf
goto cleanup;
}
mgr->dirty_real_vb_mask |= user_vb_mask;
mgr->vertex_buffers_dirty = true;
}
/*
@ -1776,7 +1768,7 @@ void u_vbuf_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *inf
*/
u_upload_unmap(pipe->stream_uploader);
if (mgr->dirty_real_vb_mask)
if (mgr->vertex_buffers_dirty)
u_vbuf_set_driver_vertex_buffers(mgr);
if ((new_info.index_size == 1 && mgr->caps.rewrite_ubyte_ibs) ||

1
src/gallium/auxiliary/util/u_vbuf.h
View file

@ -82,7 +82,6 @@ void u_vbuf_set_vertex_elements(struct u_vbuf *mgr,
void u_vbuf_unset_vertex_elements(struct u_vbuf *mgr);
void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *bufs);
void u_vbuf_draw_vbo(struct pipe_context *pipe,

2
src/gallium/auxiliary/vl/vl_bicubic_filter.c
View file

@ -461,7 +461,7 @@ vl_bicubic_filter_render(struct vl_bicubic_filter *filter,
filter->pipe->bind_fs_state(filter->pipe, filter->fs);
filter->pipe->set_framebuffer_state(filter->pipe, &fb_state);
filter->pipe->set_viewport_states(filter->pipe, 0, 1, &viewport);
filter->pipe->set_vertex_buffers(filter->pipe, 1, 0, false, &filter->quad);
filter->pipe->set_vertex_buffers(filter->pipe, 1, false, &filter->quad);
filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves);
util_draw_arrays(filter->pipe, MESA_PRIM_QUADS, 0, 4);

2
src/gallium/auxiliary/vl/vl_compositor_gfx.c
View file

@ -739,7 +739,7 @@ vl_compositor_gfx_render(struct vl_compositor_state *s,
c->pipe->set_framebuffer_state(c->pipe, &c->fb_state);
c->pipe->bind_vs_state(c->pipe, c->vs);
c->pipe->set_vertex_buffers(c->pipe, 1, 0, false, &c->vertex_buf);
c->pipe->set_vertex_buffers(c->pipe, 1, false, &c->vertex_buf);
c->pipe->bind_vertex_elements_state(c->pipe, c->vertex_elems_state);
pipe_set_constant_buffer(c->pipe, PIPE_SHADER_FRAGMENT, 0, s->shader_params);
c->pipe->bind_rasterizer_state(c->pipe, c->rast);

2
src/gallium/auxiliary/vl/vl_deint_filter.c
View file

@ -479,7 +479,7 @@ vl_deint_filter_render(struct vl_deint_filter *filter,
/* set up pipe state */
filter->pipe->bind_rasterizer_state(filter->pipe, filter->rs_state);
filter->pipe->set_vertex_buffers(filter->pipe, 1, 0, false, &filter->quad);
filter->pipe->set_vertex_buffers(filter->pipe, 1, false, &filter->quad);
filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves);
filter->pipe->bind_vs_state(filter->pipe, filter->vs);
filter->pipe->bind_sampler_states(filter->pipe, PIPE_SHADER_FRAGMENT,

2
src/gallium/auxiliary/vl/vl_matrix_filter.c
View file

@ -307,7 +307,7 @@ vl_matrix_filter_render(struct vl_matrix_filter *filter,
filter->pipe->bind_fs_state(filter->pipe, filter->fs);
filter->pipe->set_framebuffer_state(filter->pipe, &fb_state);
filter->pipe->set_viewport_states(filter->pipe, 0, 1, &viewport);
filter->pipe->set_vertex_buffers(filter->pipe, 1, 0, false, &filter->quad);
filter->pipe->set_vertex_buffers(filter->pipe, 1, false, &filter->quad);
filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves);
util_draw_arrays(filter->pipe, MESA_PRIM_QUADS, 0, 4);

2
src/gallium/auxiliary/vl/vl_median_filter.c
View file

@ -426,7 +426,7 @@ vl_median_filter_render(struct vl_median_filter *filter,
filter->pipe->bind_fs_state(filter->pipe, filter->fs);
filter->pipe->set_framebuffer_state(filter->pipe, &fb_state);
filter->pipe->set_viewport_states(filter->pipe, 0, 1, &viewport);
filter->pipe->set_vertex_buffers(filter->pipe, 1, 0, false, &filter->quad);
filter->pipe->set_vertex_buffers(filter->pipe, 1, false, &filter->quad);
filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves);
util_draw_arrays(filter->pipe, MESA_PRIM_QUADS, 0, 4);

6
src/gallium/auxiliary/vl/vl_mpeg12_decoder.c
View file

@ -794,7 +794,7 @@ vl_mpeg12_end_frame(struct pipe_video_codec *decoder,
if (!ref_frames[j] || !ref_frames[j][i]) continue;
vb[2] = vl_vb_get_mv(&buf->vertex_stream, j);
dec->context->set_vertex_buffers(dec->context, 3, 0, false, vb);
dec->context->set_vertex_buffers(dec->context, 3, false, vb);
vl_mc_render_ref(i ? &dec->mc_c : &dec->mc_y, &buf->mc[i], ref_frames[j][i]);
}
@ -805,7 +805,7 @@ vl_mpeg12_end_frame(struct pipe_video_codec *decoder,
if (!buf->num_ycbcr_blocks[i]) continue;
vb[1] = vl_vb_get_ycbcr(&buf->vertex_stream, i);
dec->context->set_vertex_buffers(dec->context, 2, 0, false, vb);
dec->context->set_vertex_buffers(dec->context, 2, false, vb);
vl_zscan_render(i ? &dec->zscan_c : & dec->zscan_y, &buf->zscan[i] , buf->num_ycbcr_blocks[i]);
@ -824,7 +824,7 @@ vl_mpeg12_end_frame(struct pipe_video_codec *decoder,
if (!buf->num_ycbcr_blocks[plane]) continue;
vb[1] = vl_vb_get_ycbcr(&buf->vertex_stream, plane);
dec->context->set_vertex_buffers(dec->context, 2, 0, false, vb);
dec->context->set_vertex_buffers(dec->context, 2, false, vb);
if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT)
vl_idct_prepare_stage2(i ? &dec->idct_c : &dec->idct_y, &buf->idct[plane]);

3
src/gallium/drivers/asahi/agx_blit.c
View file

@ -318,7 +318,8 @@ void
agx_blitter_save(struct agx_context *ctx, struct blitter_context *blitter,
bool render_cond)
{
util_blitter_save_vertex_buffer_slot(blitter, ctx->vertex_buffers);
util_blitter_save_vertex_buffers(blitter, ctx->vertex_buffers,
util_last_bit(ctx->vb_mask));
util_blitter_save_vertex_elements(blitter, ctx->attributes);
util_blitter_save_vertex_shader(blitter,
ctx->stage[PIPE_SHADER_VERTEX].shader);

5
src/gallium/drivers/asahi/agx_state.c
View file

@ -1419,14 +1419,13 @@ agx_delete_state(struct pipe_context *ctx, void *state)
static void
agx_set_vertex_buffers(struct pipe_context *pctx, unsigned count,
unsigned unbind_num_trailing_slots, bool take_ownership,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
struct agx_context *ctx = agx_context(pctx);
util_set_vertex_buffers_mask(ctx->vertex_buffers, &ctx->vb_mask, buffers,
count, unbind_num_trailing_slots,
take_ownership);
count, take_ownership);
ctx->dirty |= AGX_DIRTY_VERTEX;
}

3
src/gallium/drivers/crocus/crocus_blit.c
View file

@ -42,7 +42,8 @@ void crocus_blitter_begin(struct crocus_context *ice, enum crocus_blitter_op op,
util_blitter_save_geometry_shader(ice->blitter, ice->shaders.uncompiled[MESA_SHADER_GEOMETRY]);
util_blitter_save_so_targets(ice->blitter, ice->state.so_targets,
(struct pipe_stream_output_target**)ice->state.so_target);
util_blitter_save_vertex_buffer_slot(ice->blitter, ice->state.vertex_buffers);
util_blitter_save_vertex_buffers(ice->blitter, ice->state.vertex_buffers,
util_last_bit(ice->state.bound_vertex_buffers));
util_blitter_save_vertex_elements(ice->blitter, (void *)ice->state.cso_vertex_elements);
if (op & CROCUS_SAVE_FRAGMENT_STATE) {
util_blitter_save_blend(ice->blitter, ice->state.cso_blend);

6
src/gallium/drivers/crocus/crocus_state.c
View file

@ -3659,7 +3659,6 @@ crocus_delete_state(struct pipe_context *ctx, void *state)
static void
crocus_set_vertex_buffers(struct pipe_context *ctx,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
@ -3667,12 +3666,9 @@ crocus_set_vertex_buffers(struct pipe_context *ctx,
struct crocus_screen *screen = (struct crocus_screen *) ctx->screen;
const unsigned padding =
(GFX_VERx10 < 75 && screen->devinfo.platform != INTEL_PLATFORM_BYT) * 2;
ice->state.bound_vertex_buffers &=
~u_bit_consecutive64(0, count + unbind_num_trailing_slots);
util_set_vertex_buffers_mask(ice->state.vertex_buffers, &ice->state.bound_vertex_buffers,
buffers, count, unbind_num_trailing_slots,
take_ownership);
buffers, count, take_ownership);
for (unsigned i = 0; i < count; i++) {
struct pipe_vertex_buffer *state =

2
src/gallium/drivers/d3d12/d3d12_blit.cpp
View file

@ -557,7 +557,7 @@ util_blit_save_state(struct d3d12_context *ctx)
ctx->num_sampler_views[PIPE_SHADER_FRAGMENT],
ctx->sampler_views[PIPE_SHADER_FRAGMENT]);
util_blitter_save_fragment_constant_buffer_slot(ctx->blitter, ctx->cbufs[PIPE_SHADER_FRAGMENT]);
util_blitter_save_vertex_buffer_slot(ctx->blitter, ctx->vbs);
util_blitter_save_vertex_buffers(ctx->blitter, ctx->vbs, ctx->num_vbs);
util_blitter_save_sample_mask(ctx->blitter, ctx->gfx_pipeline_state.sample_mask, 0);
util_blitter_save_so_targets(ctx->blitter, ctx->gfx_pipeline_state.num_so_targets, ctx->so_targets);
}

8
src/gallium/drivers/d3d12/d3d12_context.cpp
View file

@ -1334,15 +1334,11 @@ d3d12_set_polygon_stipple(struct pipe_context *pctx,
static void
d3d12_set_vertex_buffers(struct pipe_context *pctx,
unsigned num_buffers,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
struct d3d12_context *ctx = d3d12_context(pctx);
util_set_vertex_buffers_count(ctx->vbs, &ctx->num_vbs,
buffers, num_buffers,
unbind_num_trailing_slots,
take_ownership);
util_set_vertex_buffers_count(ctx->vbs, &ctx->num_vbs, buffers, num_buffers, take_ownership);
for (unsigned i = 0; i < ctx->num_vbs; ++i) {
const struct pipe_vertex_buffer* buf = ctx->vbs + i;
@ -2097,7 +2093,7 @@ d3d12_clear_render_target(struct pipe_context *pctx,
ctx->num_sampler_views[PIPE_SHADER_FRAGMENT],
ctx->sampler_views[PIPE_SHADER_FRAGMENT]);
util_blitter_save_fragment_constant_buffer_slot(ctx->blitter, ctx->cbufs[PIPE_SHADER_FRAGMENT]);
util_blitter_save_vertex_buffer_slot(ctx->blitter, ctx->vbs);
util_blitter_save_vertex_buffers(ctx->blitter, ctx->vbs, ctx->num_vbs);
util_blitter_save_sample_mask(ctx->blitter, ctx->gfx_pipeline_state.sample_mask, 0);
util_blitter_save_so_targets(ctx->blitter, ctx->gfx_pipeline_state.num_so_targets, ctx->so_targets);

3
src/gallium/drivers/etnaviv/etnaviv_clear_blit.c
View file

@ -51,7 +51,8 @@ etna_blit_save_state(struct etna_context *ctx, bool render_cond)
{
util_blitter_save_fragment_constant_buffer_slot(ctx->blitter,
ctx->constant_buffer[PIPE_SHADER_FRAGMENT].cb);
util_blitter_save_vertex_buffer_slot(ctx->blitter, ctx->vertex_buffer.vb);
util_blitter_save_vertex_buffers(ctx->blitter, ctx->vertex_buffer.vb,
ctx->vertex_buffer.count);
util_blitter_save_vertex_elements(ctx->blitter, ctx->vertex_elements);
util_blitter_save_vertex_shader(ctx->blitter, ctx->shader.bind_vs);
util_blitter_save_rasterizer(ctx->blitter, ctx->rasterizer);

6
src/gallium/drivers/etnaviv/etnaviv_state.c
View file

@ -451,14 +451,12 @@ etna_set_viewport_states(struct pipe_context *pctx, unsigned start_slot,
static void
etna_set_vertex_buffers(struct pipe_context *pctx, unsigned num_buffers,
unsigned unbind_num_trailing_slots, bool take_ownership,
const struct pipe_vertex_buffer *vb)
bool take_ownership, const struct pipe_vertex_buffer *vb)
{
struct etna_context *ctx = etna_context(pctx);
struct etna_vertexbuf_state *so = &ctx->vertex_buffer;
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb,
num_buffers, unbind_num_trailing_slots,
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb, num_buffers,
take_ownership);
so->count = util_last_bit(so->enabled_mask);

6
src/gallium/drivers/freedreno/freedreno_blitter.c
View file

@ -79,7 +79,9 @@ default_src_texture(struct pipe_sampler_view *src_templ,
static void
fd_blitter_pipe_begin(struct fd_context *ctx, bool render_cond) assert_dt
{
util_blitter_save_vertex_buffer_slot(ctx->blitter, ctx->vtx.vertexbuf.vb);
util_blitter_save_vertex_buffers(
ctx->blitter, ctx->vtx.vertexbuf.vb,
util_last_bit(ctx->vtx.vertexbuf.enabled_mask));
util_blitter_save_vertex_elements(ctx->blitter, ctx->vtx.vtx);
util_blitter_save_vertex_shader(ctx->blitter, ctx->prog.vs);
util_blitter_save_tessctrl_shader(ctx->blitter, ctx->prog.hs);
@ -235,7 +237,7 @@ fd_blitter_clear(struct pipe_context *pctx, unsigned buffers,
pctx->set_viewport_states(pctx, 0, 1, &vp);
pctx->bind_vertex_elements_state(pctx, ctx->solid_vbuf_state.vtx);
pctx->set_vertex_buffers(pctx, 1, 0, false,
pctx->set_vertex_buffers(pctx, 1, false,
&ctx->solid_vbuf_state.vertexbuf.vb[0]);
pctx->set_stream_output_targets(pctx, 0, NULL, NULL);

6
src/gallium/drivers/freedreno/freedreno_state.c
View file

@ -468,8 +468,7 @@ fd_set_viewport_states(struct pipe_context *pctx, unsigned start_slot,
}
static void
fd_set_vertex_buffers(struct pipe_context *pctx,
unsigned count, unsigned unbind_num_trailing_slots,
fd_set_vertex_buffers(struct pipe_context *pctx, unsigned count,
bool take_ownership,
const struct pipe_vertex_buffer *vb) in_dt
{
@ -492,8 +491,7 @@ fd_set_vertex_buffers(struct pipe_context *pctx,
}
}
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb,
count, unbind_num_trailing_slots,
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb, count,
take_ownership);
so->count = util_last_bit(so->enabled_mask);

7
src/gallium/drivers/i915/i915_state.c
View file

@ -992,18 +992,17 @@ i915_delete_rasterizer_state(struct pipe_context *pipe, void *raster)
static void
i915_set_vertex_buffers(struct pipe_context *pipe, unsigned count,
unsigned unbind_num_trailing_slots, bool take_ownership,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
struct i915_context *i915 = i915_context(pipe);
struct draw_context *draw = i915->draw;
util_set_vertex_buffers_count(i915->vertex_buffers, &i915->nr_vertex_buffers,
buffers, count, unbind_num_trailing_slots,
take_ownership);
buffers, count, take_ownership);
/* pass-through to draw module */
draw_set_vertex_buffers(draw, count, unbind_num_trailing_slots, buffers);
draw_set_vertex_buffers(draw, count, buffers);
}
static void *

3
src/gallium/drivers/i915/i915_surface.c
View file

@ -60,7 +60,8 @@ i915_util_blitter_save_states(struct i915_context *i915)
util_blitter_save_viewport(i915->blitter, &i915->viewport);
util_blitter_save_scissor(i915->blitter, &i915->scissor);
util_blitter_save_vertex_elements(i915->blitter, i915->velems);
util_blitter_save_vertex_buffer_slot(i915->blitter, i915->vertex_buffers);
util_blitter_save_vertex_buffers(i915->blitter, i915->vertex_buffers,
i915->nr_vertex_buffers);
util_blitter_save_framebuffer(i915->blitter, &i915->framebuffer);

9
src/gallium/drivers/iris/iris_state.c
View file

@ -4008,7 +4008,6 @@ iris_delete_state(struct pipe_context *ctx, void *state)
static void
iris_set_vertex_buffers(struct pipe_context *ctx,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
@ -4016,8 +4015,8 @@ iris_set_vertex_buffers(struct pipe_context *ctx,
struct iris_screen *screen = (struct iris_screen *)ctx->screen;
struct iris_genx_state *genx = ice->state.genx;
ice->state.bound_vertex_buffers &=
~u_bit_consecutive64(0, count + unbind_num_trailing_slots);
unsigned last_count = util_last_bit64(ice->state.bound_vertex_buffers);
ice->state.bound_vertex_buffers = 0;
for (unsigned i = 0; i < count; i++) {
const struct pipe_vertex_buffer *buffer = buffers ? &buffers[i] : NULL;
@ -4072,9 +4071,9 @@ iris_set_vertex_buffers(struct pipe_context *ctx,
}
}
for (unsigned i = 0; i < unbind_num_trailing_slots; i++) {
for (unsigned i = count; i < last_count; i++) {
struct iris_vertex_buffer_state *state =
&genx->vertex_buffers[count + i];
&genx->vertex_buffers[i];
pipe_resource_reference(&state->resource, NULL);
}

4
src/gallium/drivers/lima/lima_resource.c
View file

@ -837,8 +837,8 @@ lima_util_blitter_save_states(struct lima_context *ctx)
util_blitter_save_scissor(ctx->blitter, &ctx->scissor);
util_blitter_save_vertex_elements(ctx->blitter,
ctx->vertex_elements);
util_blitter_save_vertex_buffer_slot(ctx->blitter,
ctx->vertex_buffers.vb);
util_blitter_save_vertex_buffers(ctx->blitter,
ctx->vertex_buffers.vb, ctx->vertex_buffers.count);
util_blitter_save_framebuffer(ctx->blitter, &ctx->framebuffer.base);

7
src/gallium/drivers/lima/lima_state.c
View file

@ -187,7 +187,6 @@ lima_delete_vertex_elements_state(struct pipe_context *pctx, void *hwcso)
static void
lima_set_vertex_buffers(struct pipe_context *pctx,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *vb)
{
@ -195,9 +194,7 @@ lima_set_vertex_buffers(struct pipe_context *pctx,
struct lima_context_vertex_buffer *so = &ctx->vertex_buffers;
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask,
vb, count,
unbind_num_trailing_slots,
take_ownership);
vb, count, take_ownership);
so->count = util_last_bit(so->enabled_mask);
ctx->dirty |= LIMA_CONTEXT_DIRTY_VERTEX_BUFF;
@ -472,5 +469,5 @@ lima_state_fini(struct lima_context *ctx)
struct lima_context_vertex_buffer *so = &ctx->vertex_buffers;
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, NULL,
0, ARRAY_SIZE(so->vb), false);
0, false);
}

5
src/gallium/drivers/llvmpipe/lp_state_vertex.c
View file

@ -81,7 +81,6 @@ llvmpipe_delete_vertex_elements_state(struct pipe_context *pipe, void *velems)
static void
llvmpipe_set_vertex_buffers(struct pipe_context *pipe,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
@ -92,13 +91,11 @@ llvmpipe_set_vertex_buffers(struct pipe_context *pipe,
util_set_vertex_buffers_count(llvmpipe->vertex_buffer,
&llvmpipe->num_vertex_buffers,
buffers, count,
unbind_num_trailing_slots,
take_ownership);
llvmpipe->dirty |= LP_NEW_VERTEX;
draw_set_vertex_buffers(llvmpipe->draw, count,
unbind_num_trailing_slots, buffers);
draw_set_vertex_buffers(llvmpipe->draw, count, buffers);
}

3
src/gallium/drivers/llvmpipe/lp_surface.c
View file

@ -162,7 +162,8 @@ lp_blit(struct pipe_context *pipe,
info.mask = PIPE_MASK_R;
}
util_blitter_save_vertex_buffer_slot(lp->blitter, lp->vertex_buffer);
util_blitter_save_vertex_buffers(lp->blitter, lp->vertex_buffer,
lp->num_vertex_buffers);
util_blitter_save_vertex_elements(lp->blitter, (void*)lp->velems);
util_blitter_save_vertex_shader(lp->blitter, (void*)lp->vs);
util_blitter_save_geometry_shader(lp->blitter, (void*)lp->gs);

2
src/gallium/drivers/nouveau/nv30/nv30_draw.c
View file

@ -396,7 +396,7 @@ nv30_render_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info,
if (nv30->draw_dirty & NV30_NEW_CLIP)
draw_set_clip_state(draw, &nv30->clip);
if (nv30->draw_dirty & NV30_NEW_ARRAYS) {
draw_set_vertex_buffers(draw, nv30->num_vtxbufs, 0, nv30->vtxbuf);
draw_set_vertex_buffers(draw, nv30->num_vtxbufs, nv30->vtxbuf);
draw_set_vertex_elements(draw, nv30->vertex->num_elements, nv30->vertex->pipe);
}
if (nv30->draw_dirty & NV30_NEW_FRAGPROG) {

2
src/gallium/drivers/nouveau/nv30/nv30_miptree.c
View file

@ -248,7 +248,7 @@ nv30_blit(struct pipe_context *pipe,
/* XXX turn off occlusion queries */
util_blitter_save_vertex_buffer_slot(nv30->blitter, nv30->vtxbuf);
util_blitter_save_vertex_buffers(nv30->blitter, nv30->vtxbuf, nv30->num_vtxbufs);
util_blitter_save_vertex_elements(nv30->blitter, nv30->vertex);
util_blitter_save_vertex_shader(nv30->blitter, nv30->vertprog.program);
util_blitter_save_rasterizer(nv30->blitter, nv30->rast);

5
src/gallium/drivers/nouveau/nv30/nv30_state.c
View file

@ -437,7 +437,6 @@ nv30_set_viewport_states(struct pipe_context *pipe,
static void
nv30_set_vertex_buffers(struct pipe_context *pipe,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *vb)
{
@ -446,9 +445,7 @@ nv30_set_vertex_buffers(struct pipe_context *pipe,
nouveau_bufctx_reset(nv30->bufctx, BUFCTX_VTXBUF);
util_set_vertex_buffers_count(nv30->vtxbuf, &nv30->num_vtxbufs,
vb, count,
unbind_num_trailing_slots,
take_ownership);
vb, count, take_ownership);
nv30->dirty |= NV30_NEW_ARRAYS;
}

8
src/gallium/drivers/nouveau/nv50/nv50_state.c
View file

@ -1085,7 +1085,6 @@ nv50_set_window_rectangles(struct pipe_context *pipe,
static void
nv50_set_vertex_buffers(struct pipe_context *pipe,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *vb)
{
@ -1095,11 +1094,12 @@ nv50_set_vertex_buffers(struct pipe_context *pipe,
nouveau_bufctx_reset(nv50->bufctx_3d, NV50_BIND_3D_VERTEX);
nv50->dirty_3d |= NV50_NEW_3D_ARRAYS;
unsigned last_count = nv50->num_vtxbufs;
util_set_vertex_buffers_count(nv50->vtxbuf, &nv50->num_vtxbufs, vb,
count, unbind_num_trailing_slots,
take_ownership);
count, take_ownership);
unsigned clear_mask = ~u_bit_consecutive(count, unbind_num_trailing_slots);
unsigned clear_mask =
last_count > count ? BITFIELD_RANGE(count, last_count - count) : 0;
nv50->vbo_user &= clear_mask;
nv50->vbo_constant &= clear_mask;
nv50->vtxbufs_coherent &= clear_mask;

8
src/gallium/drivers/nouveau/nvc0/nvc0_state.c
View file

@ -1038,7 +1038,6 @@ nvc0_set_patch_vertices(struct pipe_context *pipe, uint8_t patch_vertices)
static void
nvc0_set_vertex_buffers(struct pipe_context *pipe,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *vb)
{
@ -1048,11 +1047,12 @@ nvc0_set_vertex_buffers(struct pipe_context *pipe,
nouveau_bufctx_reset(nvc0->bufctx_3d, NVC0_BIND_3D_VTX);
nvc0->dirty_3d |= NVC0_NEW_3D_ARRAYS;
unsigned last_count = nvc0->num_vtxbufs;
util_set_vertex_buffers_count(nvc0->vtxbuf, &nvc0->num_vtxbufs, vb,
count, unbind_num_trailing_slots,
take_ownership);
count, take_ownership);
unsigned clear_mask = ~u_bit_consecutive(count, unbind_num_trailing_slots);
unsigned clear_mask =
last_count > count ? BITFIELD_RANGE(count, last_count - count) : 0;
nvc0->vbo_user &= clear_mask;
nvc0->constant_vbos &= clear_mask;
nvc0->vtxbufs_coherent &= clear_mask;

3
src/gallium/drivers/panfrost/pan_blit.c
View file

@ -38,7 +38,8 @@ panfrost_blitter_save(struct panfrost_context *ctx,
{
struct blitter_context *blitter = ctx->blitter;
util_blitter_save_vertex_buffer_slot(blitter, ctx->vertex_buffers);
util_blitter_save_vertex_buffers(blitter, ctx->vertex_buffers,
util_last_bit(ctx->vb_mask));
util_blitter_save_vertex_elements(blitter, ctx->vertex);
util_blitter_save_vertex_shader(blitter,
ctx->uncompiled[PIPE_SHADER_VERTEX]);

4
src/gallium/drivers/panfrost/pan_context.c
View file

@ -327,15 +327,13 @@ panfrost_bind_sampler_states(struct pipe_context *pctx,
static void
panfrost_set_vertex_buffers(struct pipe_context *pctx, unsigned num_buffers,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
struct panfrost_context *ctx = pan_context(pctx);
util_set_vertex_buffers_mask(ctx->vertex_buffers, &ctx->vb_mask, buffers,
num_buffers, unbind_num_trailing_slots,
take_ownership);
num_buffers, take_ownership);
ctx->dirty |= PAN_DIRTY_VERTEX;
}

3
src/gallium/drivers/r300/r300_blit.c
View file

@ -69,7 +69,8 @@ static void r300_blitter_begin(struct r300_context* r300, enum r300_blitter_op o
util_blitter_save_viewport(r300->blitter, &r300->viewport);
util_blitter_save_scissor(r300->blitter, r300->scissor_state.state);
util_blitter_save_sample_mask(r300->blitter, *(unsigned*)r300->sample_mask.state, 0);
util_blitter_save_vertex_buffer_slot(r300->blitter, r300->vertex_buffer);
util_blitter_save_vertex_buffers(r300->blitter, r300->vertex_buffer,
r300->nr_vertex_buffers);
util_blitter_save_vertex_elements(r300->blitter, r300->velems);
struct pipe_constant_buffer cb = {

2
src/gallium/drivers/r300/r300_context.c
View file

@ -474,7 +474,7 @@ struct pipe_context* r300_create_context(struct pipe_screen* screen,
vb.depth0 = 1;
r300->dummy_vb.buffer.resource = screen->resource_create(screen, &vb);
r300->context.set_vertex_buffers(&r300->context, 1, 0, false, &r300->dummy_vb);
r300->context.set_vertex_buffers(&r300->context, 1, false, &r300->dummy_vb);
}
{

20
src/gallium/drivers/r300/r300_state.c
View file

@ -1771,23 +1771,20 @@ static void r300_set_viewport_states(struct pipe_context* pipe,
}
static void r300_set_vertex_buffers_hwtcl(struct pipe_context* pipe,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
unsigned count, bool take_ownership,
const struct pipe_vertex_buffer* buffers)
{
struct r300_context* r300 = r300_context(pipe);
util_set_vertex_buffers_count(r300->vertex_buffer,
&r300->nr_vertex_buffers,
buffers, count,
unbind_num_trailing_slots, take_ownership);
&r300->nr_vertex_buffers, buffers, count,
take_ownership);
/* There must be at least one vertex buffer set, otherwise it locks up. */
if (!r300->nr_vertex_buffers) {
util_set_vertex_buffers_count(r300->vertex_buffer,
&r300->nr_vertex_buffers,
&r300->dummy_vb, 1, 0, false);
&r300->dummy_vb, 1, false);
}
r300->vertex_arrays_dirty = true;
@ -1795,7 +1792,6 @@ static void r300_set_vertex_buffers_hwtcl(struct pipe_context* pipe,
static void r300_set_vertex_buffers_swtcl(struct pipe_context* pipe,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer* buffers)
{
@ -1803,11 +1799,9 @@ static void r300_set_vertex_buffers_swtcl(struct pipe_context* pipe,
unsigned i;
util_set_vertex_buffers_count(r300->vertex_buffer,
&r300->nr_vertex_buffers,
buffers, count,
unbind_num_trailing_slots, take_ownership);
draw_set_vertex_buffers(r300->draw, count,
unbind_num_trailing_slots, buffers);
&r300->nr_vertex_buffers, buffers, count,
take_ownership);
draw_set_vertex_buffers(r300->draw, count, buffers);
if (!buffers)
return;

3
src/gallium/drivers/r600/r600_blit.c
View file

@ -59,7 +59,8 @@ static void r600_blitter_begin(struct pipe_context *ctx, enum r600_blitter_op op
rctx->cmd_buf_is_compute = false;
}
util_blitter_save_vertex_buffer_slot(rctx->blitter, rctx->vertex_buffer_state.vb);
util_blitter_save_vertex_buffers(rctx->blitter, rctx->vertex_buffer_state.vb,
util_last_bit(rctx->vertex_buffer_state.enabled_mask));
util_blitter_save_vertex_elements(rctx->blitter, rctx->vertex_fetch_shader.cso);
util_blitter_save_vertex_shader(rctx->blitter, rctx->vs_shader);
util_blitter_save_geometry_shader(rctx->blitter, rctx->gs_shader);

2
src/gallium/drivers/r600/r600_pipe_common.c
View file

@ -208,7 +208,7 @@ void r600_draw_rectangle(struct blitter_context *blitter,
vbuffer.buffer.resource = buf;
vbuffer.buffer_offset = offset;
rctx->b.set_vertex_buffers(&rctx->b, 1, 0, false, &vbuffer);
rctx->b.set_vertex_buffers(&rctx->b, 1, false, &vbuffer);
util_draw_arrays_instanced(&rctx->b, R600_PRIM_RECTANGLE_LIST, 0, 3,
0, num_instances);
pipe_resource_reference(&buf, NULL);

21
src/gallium/drivers/r600/r600_state_common.c
View file

@ -577,9 +577,7 @@ static void r600_bind_vertex_elements(struct pipe_context *ctx, void *state)
}
static void r600_set_vertex_buffers(struct pipe_context *ctx,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
unsigned count, bool take_ownership,
const struct pipe_vertex_buffer *input)
{
struct r600_context *rctx = (struct r600_context *)ctx;
@ -591,7 +589,6 @@ static void r600_set_vertex_buffers(struct pipe_context *ctx,
uint32_t new_buffer_mask = 0;
/* Set vertex buffers. */
if (input) {
for (i = 0; i < count; i++) {
if (likely((input[i].buffer.resource != vb[i].buffer.resource) ||
(vb[i].buffer_offset != input[i].buffer_offset) ||
@ -621,17 +618,13 @@ static void r600_set_vertex_buffers(struct pipe_context *ctx,
}
}
}
} else {
for (i = 0; i < count; i++) {
pipe_resource_reference(&vb[i].buffer.resource, NULL);
}
disable_mask = ((1ull << count) - 1);
}
for (i = 0; i < unbind_num_trailing_slots; i++) {
pipe_resource_reference(&vb[count + i].buffer.resource, NULL);
}
disable_mask |= ((1ull << unbind_num_trailing_slots) - 1) << count;
unsigned last_count = util_last_bit(rctx->vertex_buffer_state.enabled_mask);
for (; i < last_count; i++)
pipe_resource_reference(&vb[i].buffer.resource, NULL);
if (last_count > count)
disable_mask |= BITFIELD_RANGE(count, last_count - count);
rctx->vertex_buffer_state.enabled_mask &= ~disable_mask;
rctx->vertex_buffer_state.dirty_mask &= rctx->vertex_buffer_state.enabled_mask;

1
src/gallium/drivers/radeonsi/si_pipe.h
View file

@ -1160,6 +1160,7 @@ struct si_context {
/* Vertex buffers. */
bool vertex_buffers_dirty;
uint8_t num_vertex_buffers;
uint16_t vertex_buffer_unaligned; /* bitmask of not dword-aligned buffers */
struct pipe_vertex_buffer vertex_buffer[SI_NUM_VERTEX_BUFFERS];

63
src/gallium/drivers/radeonsi/si_state.c
View file

@ -5546,52 +5546,33 @@ static void si_delete_vertex_element(struct pipe_context *ctx, void *state)
FREE(state);
}
static void si_set_vertex_buffers(struct pipe_context *ctx, unsigned count,
unsigned unbind_num_trailing_slots, bool take_ownership,
static void si_set_vertex_buffers(struct pipe_context *ctx, unsigned count, bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
struct si_context *sctx = (struct si_context *)ctx;
unsigned updated_mask = u_bit_consecutive(0, count + unbind_num_trailing_slots);
uint32_t orig_unaligned = sctx->vertex_buffer_unaligned;
uint32_t unaligned = 0;
int i;
unsigned i;
assert(count + unbind_num_trailing_slots <= ARRAY_SIZE(sctx->vertex_buffer));
assert(count <= ARRAY_SIZE(sctx->vertex_buffer));
assert(!count || buffers);
if (buffers) {
if (take_ownership) {
for (i = 0; i < count; i++) {
const struct pipe_vertex_buffer *src = buffers + i;
struct pipe_vertex_buffer *dst = sctx->vertex_buffer + i;
struct pipe_resource *buf = src->buffer.resource;
unsigned slot_bit = 1 << i;
/* Only unreference bound vertex buffers. (take_ownership) */
pipe_resource_reference(&dst->buffer.resource, NULL);
if (src->buffer_offset & 3)
unaligned |= slot_bit;
if (buf) {
si_resource(buf)->bind_history |= SI_BIND_VERTEX_BUFFER;
radeon_add_to_buffer_list(sctx, &sctx->gfx_cs, si_resource(buf),
RADEON_USAGE_READ | RADEON_PRIO_VERTEX_BUFFER);
}
}
/* take_ownership allows us to copy pipe_resource pointers without refcounting. */
memcpy(sctx->vertex_buffer, buffers, count * sizeof(struct pipe_vertex_buffer));
} else {
for (i = 0; i < count; i++) {
const struct pipe_vertex_buffer *src = buffers + i;
struct pipe_vertex_buffer *dst = sctx->vertex_buffer + i;
struct pipe_resource *buf = src->buffer.resource;
unsigned slot_bit = 1 << i;
pipe_resource_reference(&dst->buffer.resource, buf);
dst->buffer_offset = src->buffer_offset;
if (dst->buffer_offset & 3)
unaligned |= slot_bit;
/* Only unreference bound vertex buffers. (take_ownership) */
if (take_ownership) {
pipe_resource_reference(&dst->buffer.resource, NULL);
dst->buffer.resource = src->buffer.resource;
} else {
pipe_resource_reference(&dst->buffer.resource, src->buffer.resource);
}
if (src->buffer_offset & 3)
unaligned |= BITFIELD_BIT(i);
if (buf) {
si_resource(buf)->bind_history |= SI_BIND_VERTEX_BUFFER;
@ -5599,17 +5580,14 @@ static void si_set_vertex_buffers(struct pipe_context *ctx, unsigned count,
RADEON_USAGE_READ | RADEON_PRIO_VERTEX_BUFFER);
}
}
}
} else {
for (i = 0; i < count; i++)
unsigned last_count = sctx->num_vertex_buffers;
for (; i < last_count; i++)
pipe_resource_reference(&sctx->vertex_buffer[i].buffer.resource, NULL);
}
for (i = 0; i < unbind_num_trailing_slots; i++)
pipe_resource_reference(&sctx->vertex_buffer[count + i].buffer.resource, NULL);
sctx->num_vertex_buffers = count;
sctx->vertex_buffers_dirty = sctx->num_vertex_elements > 0;
sctx->vertex_buffer_unaligned = (orig_unaligned & ~updated_mask) | unaligned;
sctx->vertex_buffer_unaligned = unaligned;
/* Check whether alignment may have changed in a way that requires
* shader changes. This check is conservative: a vertex buffer can only
@ -5618,8 +5596,7 @@ static void si_set_vertex_buffers(struct pipe_context *ctx, unsigned count,
* whether buffers are at least dword-aligned, since that should always
* be the case in well-behaved applications anyway.
*/
if ((sctx->vertex_elements->vb_alignment_check_mask &
(unaligned | orig_unaligned) & updated_mask)) {
if (sctx->vertex_elements->vb_alignment_check_mask & unaligned) {
si_vs_key_update_inputs(sctx);
sctx->do_update_shaders = true;
}

4
src/gallium/drivers/softpipe/sp_state_vertex.c
View file

@ -81,7 +81,6 @@ softpipe_delete_vertex_elements_state(struct pipe_context *pipe, void *velems)
static void
softpipe_set_vertex_buffers(struct pipe_context *pipe,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
@ -92,12 +91,11 @@ softpipe_set_vertex_buffers(struct pipe_context *pipe,
util_set_vertex_buffers_count(softpipe->vertex_buffer,
&softpipe->num_vertex_buffers,
buffers, count,
unbind_num_trailing_slots,
take_ownership);
softpipe->dirty |= SP_NEW_VERTEX;
draw_set_vertex_buffers(softpipe->draw, count, unbind_num_trailing_slots, buffers);
draw_set_vertex_buffers(softpipe->draw, count, buffers);
}

3
src/gallium/drivers/softpipe/sp_surface.c
View file

@ -60,7 +60,8 @@ static void sp_blit(struct pipe_context *pipe,
/* XXX turn off occlusion and streamout queries */
util_blitter_save_vertex_buffer_slot(sp->blitter, sp->vertex_buffer);
util_blitter_save_vertex_buffers(sp->blitter, sp->vertex_buffer,
sp->num_vertex_buffers);
util_blitter_save_vertex_elements(sp->blitter, sp->velems);
util_blitter_save_vertex_shader(sp->blitter, sp->vs);
util_blitter_save_geometry_shader(sp->blitter, sp->gs);

3
src/gallium/drivers/svga/svga_pipe_blit.c
View file

@ -619,7 +619,8 @@ try_blit(struct svga_context *svga, const struct pipe_blit_info *blit_info)
/* XXX turn off occlusion and streamout queries */
util_blitter_save_vertex_buffer_slot(svga->blitter, svga->curr.vb);
util_blitter_save_vertex_buffers(svga->blitter, svga->curr.vb,
svga->curr.num_vertex_buffers);
util_blitter_save_vertex_elements(svga->blitter, (void*)svga->curr.velems);
util_blitter_save_vertex_shader(svga->blitter, svga->curr.vs);
util_blitter_save_geometry_shader(svga->blitter, svga->curr.user_gs);

3
src/gallium/drivers/svga/svga_pipe_clear.c
View file

@ -41,7 +41,8 @@
static void
begin_blit(struct svga_context *svga)
{
util_blitter_save_vertex_buffer_slot(svga->blitter, svga->curr.vb);
util_blitter_save_vertex_buffers(svga->blitter, svga->curr.vb,
svga->curr.num_vertex_buffers);
util_blitter_save_vertex_elements(svga->blitter, (void*)svga->curr.velems);
util_blitter_save_vertex_shader(svga->blitter, svga->curr.vs);
util_blitter_save_geometry_shader(svga->blitter, svga->curr.gs);

5
src/gallium/drivers/svga/svga_pipe_vertex.c
View file

@ -42,7 +42,6 @@
static void
svga_set_vertex_buffers(struct pipe_context *pipe,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
@ -50,9 +49,7 @@ svga_set_vertex_buffers(struct pipe_context *pipe,
util_set_vertex_buffers_count(svga->curr.vb,
&svga->curr.num_vertex_buffers,
buffers, count,
unbind_num_trailing_slots,
take_ownership);
buffers, count, take_ownership);
svga->dirty |= SVGA_NEW_VBUFFER;
}

2
src/gallium/drivers/svga/svga_swtnl_state.c
View file

@ -114,7 +114,7 @@ update_swtnl_draw(struct svga_context *svga, uint64_t dirty)
if (dirty & SVGA_NEW_VBUFFER)
draw_set_vertex_buffers(svga->swtnl.draw,
svga->curr.num_vertex_buffers, 0,
svga->curr.num_vertex_buffers,
svga->curr.vb);
if (dirty & SVGA_NEW_VELEMENT)

3
src/gallium/drivers/tegra/tegra_context.c
View file

@ -635,7 +635,7 @@ tegra_set_shader_images(struct pipe_context *pcontext, enum pipe_shader_type sha
static void
tegra_set_vertex_buffers(struct pipe_context *pcontext,
unsigned num_buffers, unsigned unbind_num_trailing_slots,
unsigned num_buffers,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
@ -655,7 +655,6 @@ tegra_set_vertex_buffers(struct pipe_context *pcontext,
}
context->gpu->set_vertex_buffers(context->gpu, num_buffers,
unbind_num_trailing_slots,
take_ownership, buffers);
}

2
src/gallium/drivers/v3d/v3d_blit.c
View file

@ -42,7 +42,7 @@ v3d_blitter_save(struct v3d_context *v3d, bool op_blit, bool render_cond)
{
util_blitter_save_fragment_constant_buffer_slot(v3d->blitter,
v3d->constbuf[PIPE_SHADER_FRAGMENT].cb);
util_blitter_save_vertex_buffer_slot(v3d->blitter, v3d->vertexbuf.vb);
util_blitter_save_vertex_buffers(v3d->blitter, v3d->vertexbuf.vb, v3d->vertexbuf.count);
util_blitter_save_vertex_elements(v3d->blitter, v3d->vtx);
util_blitter_save_vertex_shader(v3d->blitter, v3d->prog.bind_vs);
util_blitter_save_geometry_shader(v3d->blitter, v3d->prog.bind_gs);

4
src/gallium/drivers/v3d/v3dx_state.c
View file

@ -292,7 +292,6 @@ v3d_set_viewport_states(struct pipe_context *pctx,
static void
v3d_set_vertex_buffers(struct pipe_context *pctx,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *vb)
{
@ -300,8 +299,7 @@ v3d_set_vertex_buffers(struct pipe_context *pctx,
struct v3d_vertexbuf_stateobj *so = &v3d->vertexbuf;
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb,
count, unbind_num_trailing_slots,
take_ownership);
count, take_ownership);
so->count = util_last_bit(so->enabled_mask);
v3d->dirty |= V3D_DIRTY_VTXBUF;

3
src/gallium/drivers/vc4/vc4_blit.c
View file

@ -195,7 +195,8 @@ vc4_blitter_save(struct vc4_context *vc4)
{
util_blitter_save_fragment_constant_buffer_slot(vc4->blitter,
vc4->constbuf[PIPE_SHADER_FRAGMENT].cb);
util_blitter_save_vertex_buffer_slot(vc4->blitter, vc4->vertexbuf.vb);
util_blitter_save_vertex_buffers(vc4->blitter, vc4->vertexbuf.vb,
vc4->vertexbuf.count);
util_blitter_save_vertex_elements(vc4->blitter, vc4->vtx);
util_blitter_save_vertex_shader(vc4->blitter, vc4->prog.bind_vs);
util_blitter_save_rasterizer(vc4->blitter, vc4->rasterizer);

4
src/gallium/drivers/vc4/vc4_state.c
View file

@ -313,7 +313,6 @@ vc4_set_viewport_states(struct pipe_context *pctx,
static void
vc4_set_vertex_buffers(struct pipe_context *pctx,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *vb)
{
@ -321,8 +320,7 @@ vc4_set_vertex_buffers(struct pipe_context *pctx,
struct vc4_vertexbuf_stateobj *so = &vc4->vertexbuf;
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb,
count, unbind_num_trailing_slots,
take_ownership);
count, take_ownership);
so->count = util_last_bit(so->enabled_mask);
vc4->dirty |= VC4_DIRTY_VTXBUF;

2
src/gallium/drivers/virgl/virgl_context.c
View file

@ -565,7 +565,6 @@ static void virgl_bind_vertex_elements_state(struct pipe_context *ctx,
static void virgl_set_vertex_buffers(struct pipe_context *ctx,
unsigned num_buffers,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
@ -574,7 +573,6 @@ static void virgl_set_vertex_buffers(struct pipe_context *ctx,
util_set_vertex_buffers_count(vctx->vertex_buffer,
&vctx->num_vertex_buffers,
buffers, num_buffers,
unbind_num_trailing_slots,
take_ownership);
if (buffers) {

3
src/gallium/drivers/zink/zink_blit.c
View file

@ -501,7 +501,8 @@ zink_blit_begin(struct zink_context *ctx, enum zink_blit_flags flags)
util_blitter_save_vertex_elements(ctx->blitter, ctx->element_state);
util_blitter_save_viewport(ctx->blitter, ctx->vp_state.viewport_states);
util_blitter_save_vertex_buffer_slot(ctx->blitter, ctx->vertex_buffers);
util_blitter_save_vertex_buffers(ctx->blitter, ctx->vertex_buffers,
util_last_bit(ctx->gfx_pipeline_state.vertex_buffers_enabled_mask));
util_blitter_save_vertex_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_VERTEX]);
util_blitter_save_tessctrl_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_TESS_CTRL]);
util_blitter_save_tesseval_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_TESS_EVAL]);

16
src/gallium/drivers/zink/zink_context.c
View file

@ -1339,7 +1339,6 @@ update_existing_vbo(struct zink_context *ctx, unsigned slot)
static void
zink_set_vertex_buffers(struct pipe_context *pctx,
unsigned num_buffers,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
@ -1348,10 +1347,11 @@ zink_set_vertex_buffers(struct pipe_context *pctx,
const bool need_state_change = !zink_screen(pctx->screen)->info.have_EXT_extended_dynamic_state &&
!have_input_state;
uint32_t enabled_buffers = ctx->gfx_pipeline_state.vertex_buffers_enabled_mask;
enabled_buffers |= u_bit_consecutive(0, num_buffers);
enabled_buffers &= ~u_bit_consecutive(num_buffers, unbind_num_trailing_slots);
unsigned last_count = util_last_bit(enabled_buffers);
enabled_buffers = u_bit_consecutive(0, num_buffers);
assert(!num_buffers || buffers);
if (buffers) {
for (unsigned i = 0; i < num_buffers; ++i) {
const struct pipe_vertex_buffer *vb = buffers + i;
struct pipe_vertex_buffer *ctx_vb = &ctx->vertex_buffers[i];
@ -1379,13 +1379,7 @@ zink_set_vertex_buffers(struct pipe_context *pctx,
enabled_buffers &= ~BITFIELD_BIT(i);
}
}
} else {
for (unsigned i = 0; i < num_buffers; ++i) {
update_existing_vbo(ctx, i);
pipe_resource_reference(&ctx->vertex_buffers[i].buffer.resource, NULL);
}
}
for (unsigned i = 0; i < unbind_num_trailing_slots; i++) {
for (unsigned i = num_buffers; i < last_count; i++) {
update_existing_vbo(ctx, i);
pipe_resource_reference(&ctx->vertex_buffers[i].buffer.resource, NULL);
}

2
src/gallium/frontends/lavapipe/lvp_execute.c
View file

@ -504,7 +504,7 @@ static void emit_state(struct rendering_state *state)
}
if (state->vb_dirty) {
cso_set_vertex_buffers(state->cso, state->num_vb, 0, false, state->vb);
cso_set_vertex_buffers(state->cso, state->num_vb, false, state->vb);
state->vb_dirty = false;
}

15
src/gallium/frontends/nine/nine_state.c
View file

@ -959,7 +959,6 @@ update_vertex_buffers(struct NineDevice9 *device)
struct pipe_context *pipe = context->pipe;
struct pipe_vertex_buffer vbuffer[PIPE_MAX_ATTRIBS];
unsigned vtxbuf_count;
unsigned trailing_count;
unsigned mask, i, vtxbuf_i;
mask = context->vtxbuf_mask |
@ -978,12 +977,10 @@ update_vertex_buffers(struct NineDevice9 *device)
}
}
trailing_count = (context->last_vtxbuf_count <= vtxbuf_count) ? 0 :
context->last_vtxbuf_count - vtxbuf_count;
if (vtxbuf_count)
pipe->set_vertex_buffers(pipe, vtxbuf_count, trailing_count, false, vbuffer);
pipe->set_vertex_buffers(pipe, vtxbuf_count, false, vbuffer);
else
pipe->set_vertex_buffers(pipe, 0, trailing_count, false, NULL);
pipe->set_vertex_buffers(pipe, 0, false, NULL);
context->last_vtxbuf_count = vtxbuf_count;
context->changed.vtxbuf = 0;
@ -2546,7 +2543,7 @@ CSMT_ITEM_NO_WAIT(nine_context_draw_indexed_primitive_from_vtxbuf_idxbuf,
else
info.index.user = user_ibuf;
context->pipe->set_vertex_buffers(context->pipe, 1, 0, false, vbuf);
context->pipe->set_vertex_buffers(context->pipe, 1, false, vbuf);
context->changed.vtxbuf |= 1;
context->pipe->draw_vbo(context->pipe, &info, 0, NULL, &draw, 1);
@ -3067,7 +3064,7 @@ nine_context_clear(struct NineDevice9 *device)
pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 0,
NINE_MAX_SAMPLERS_PS, false, NULL);
pipe->set_vertex_buffers(pipe, 0, device->caps.MaxStreams, false, NULL);
pipe->set_vertex_buffers(pipe, 0, false, NULL);
for (i = 0; i < ARRAY_SIZE(context->rt); ++i)
nine_bind(&context->rt[i], NULL);
@ -3273,7 +3270,7 @@ update_vertex_buffers_sw(struct NineDevice9 *device, int dummy_vbo_stream,
}
vtxbuf_count = j;
pipe_sw->set_vertex_buffers(pipe_sw, vtxbuf_count, device->caps.MaxStreams-vtxbuf_count, true, vbuffer);
pipe_sw->set_vertex_buffers(pipe_sw, vtxbuf_count, true, vbuffer);
nine_context_get_pipe_release(device);
}
@ -3412,7 +3409,7 @@ nine_state_after_draw_sw(struct NineDevice9 *device)
struct pipe_context *pipe_sw = device->pipe_sw;
int i;
pipe_sw->set_vertex_buffers(pipe_sw, 0, device->caps.MaxStreams, false, NULL);
pipe_sw->set_vertex_buffers(pipe_sw, 0, false, NULL);
for (i = 0; i < 4; i++) {
if (sw_internal->transfers_so[i])
pipe->buffer_unmap(pipe, sw_internal->transfers_so[i]);

2
src/gallium/include/pipe/p_context.h
View file

@ -608,7 +608,6 @@ struct pipe_context {
* Bind an array of vertex buffers to the specified slots.
*
* \param count number of consecutive vertex buffers to bind.
* \param unbind_num_trailing_slots unbind slots after the bound slots
* \param take_ownership the caller holds buffer references and they
* should be taken over by the callee. This means
* that drivers shouldn't increment reference counts.
@ -616,7 +615,6 @@ struct pipe_context {
*/
void (*set_vertex_buffers)(struct pipe_context *,
unsigned num_buffers,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *);

16
src/mesa/state_tracker/st_atom_array.cpp
View file

@ -334,30 +334,20 @@ st_update_array_templ(struct st_context *st,
enabled_attribs,
&velements, vbuffer, &num_vbuffers);
unsigned unbind_trailing_vbuffers =
st->last_num_vbuffers > num_vbuffers ?
st->last_num_vbuffers - num_vbuffers : 0;
st->last_num_vbuffers = num_vbuffers;
struct cso_context *cso = st->cso_context;
if (UPDATE == UPDATE_ALL) {
velements.count = vp->num_inputs + vp_variant->key.passthrough_edgeflags;
/* Set vertex buffers and elements. */
cso_set_vertex_buffers_and_elements(cso, &velements,
num_vbuffers,
unbind_trailing_vbuffers,
true,
uses_user_vertex_buffers,
vbuffer);
cso_set_vertex_buffers_and_elements(cso, &velements, num_vbuffers, true,
uses_user_vertex_buffers, vbuffer);
/* The driver should clear this after it has processed the update. */
ctx->Array.NewVertexElements = false;
st->uses_user_vertex_buffers = uses_user_vertex_buffers;
} else {
/* Only vertex buffers. */
cso_set_vertex_buffers(cso, num_vbuffers, unbind_trailing_vbuffers,
true, vbuffer);
cso_set_vertex_buffers(cso, num_vbuffers, true, vbuffer);
/* This can change only when we update vertex elements. */
assert(st->uses_user_vertex_buffers == uses_user_vertex_buffers);
}

1
src/mesa/state_tracker/st_cb_drawtex.c
View file

@ -301,7 +301,6 @@ st_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z,
MESA_PRIM_TRIANGLE_FAN,
4, /* verts */
numAttribs); /* attribs/vert */
st->last_num_vbuffers = MAX2(st->last_num_vbuffers, 1);
pipe_resource_reference(&vbuffer, NULL);

2
src/mesa/state_tracker/st_context.h
View file

@ -357,8 +357,6 @@ struct st_context
void *winsys_drawable_handle;
/* The number of vertex buffers from the last call of validate_arrays. */
unsigned last_num_vbuffers;
bool uses_user_vertex_buffers;
unsigned last_used_atomic_bindings[PIPE_SHADER_TYPES];

3
src/mesa/state_tracker/st_draw.c
View file

@ -421,8 +421,7 @@ st_draw_quad(struct st_context *st,
u_upload_unmap(st->pipe->stream_uploader);
cso_set_vertex_buffers(st->cso_context, 1, 0, false, &vb);
st->last_num_vbuffers = MAX2(st->last_num_vbuffers, 1);
cso_set_vertex_buffers(st->cso_context, 1, false, &vb);
if (num_instances > 1) {
cso_draw_arrays_instanced(st->cso_context, MESA_PRIM_TRIANGLE_FAN, 0, 4,

4
src/mesa/state_tracker/st_draw_feedback.c
View file

@ -157,7 +157,7 @@ st_feedback_draw_vbo(struct gl_context *ctx,
}
}
draw_set_vertex_buffers(draw, num_vbuffers, 0, vbuffers);
draw_set_vertex_buffers(draw, num_vbuffers, vbuffers);
draw_set_vertex_elements(draw, vp->num_inputs, velements.velems);
if (info->index_size) {
@ -455,7 +455,7 @@ st_feedback_draw_vbo(struct gl_context *ctx,
if (!vbuffers[buf].is_user_buffer)
pipe_resource_reference(&vbuffers[buf].buffer.resource, NULL);
}
draw_set_vertex_buffers(draw, 0, num_vbuffers, NULL);
draw_set_vertex_buffers(draw, 0, NULL);
draw_bind_vertex_shader(draw, NULL);
}

4
src/mesa/state_tracker/st_pbo.c
View file

@ -244,9 +244,7 @@ st_pbo_draw(struct st_context *st, const struct st_pbo_addresses *addr,
velem.velems[0].dual_slot = false;
cso_set_vertex_elements(cso, &velem);
cso_set_vertex_buffers(cso, 1, 0, false, &vbo);
st->last_num_vbuffers = MAX2(st->last_num_vbuffers, 1);
cso_set_vertex_buffers(cso, 1, false, &vbo);
pipe_resource_reference(&vbo.buffer.resource, NULL);
}