diff --git a/src/gallium/auxiliary/cso_cache/cso_context.c b/src/gallium/auxiliary/cso_cache/cso_context.c index 7ea76704a6f..98149af8537 100644 --- a/src/gallium/auxiliary/cso_cache/cso_context.c +++ b/src/gallium/auxiliary/cso_cache/cso_context.c @@ -413,7 +413,7 @@ cso_unbind_context(struct cso_context *cso) ctx->base.pipe->set_shader_images(ctx->base.pipe, sh, 0, 0, maximg, NULL); } for (int i = 0; i < maxcb; i++) { - ctx->base.pipe->set_constant_buffer(ctx->base.pipe, sh, i, false, NULL); + ctx->base.pipe->set_constant_buffer(ctx->base.pipe, sh, i, NULL); } } } @@ -422,9 +422,9 @@ cso_unbind_context(struct cso_context *cso) struct pipe_stencil_ref sr = {0}; ctx->base.pipe->set_stencil_ref(ctx->base.pipe, sr); ctx->base.pipe->bind_fs_state(ctx->base.pipe, NULL); - ctx->base.pipe->set_constant_buffer(ctx->base.pipe, MESA_SHADER_FRAGMENT, 0, false, NULL); + ctx->base.pipe->set_constant_buffer(ctx->base.pipe, MESA_SHADER_FRAGMENT, 0, NULL); ctx->base.pipe->bind_vs_state(ctx->base.pipe, NULL); - ctx->base.pipe->set_constant_buffer(ctx->base.pipe, MESA_SHADER_VERTEX, 0, false, NULL); + ctx->base.pipe->set_constant_buffer(ctx->base.pipe, MESA_SHADER_VERTEX, 0, NULL); if (ctx->has_geometry_shader) { ctx->base.pipe->bind_gs_state(ctx->base.pipe, NULL); } @@ -1378,18 +1378,17 @@ cso_restore_vertex_elements(struct cso_context_priv *ctx) void cso_set_vertex_buffers(struct cso_context *cso, unsigned 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 (vbuf) { - u_vbuf_set_vertex_buffers(vbuf, count, take_ownership, buffers); + u_vbuf_set_vertex_buffers(vbuf, count, buffers); return; } - util_set_vertex_buffers(ctx->base.pipe, count, take_ownership, buffers); + ctx->base.pipe->set_vertex_buffers(ctx->base.pipe, count, buffers); } @@ -1426,7 +1425,7 @@ cso_set_vertex_buffers_and_elements(struct cso_context *cso, } u_vbuf_set_vertex_elements(vbuf, velems); - u_vbuf_set_vertex_buffers(vbuf, vb_count, true, vbuffers); + u_vbuf_set_vertex_buffers(vbuf, vb_count, vbuffers); return; } @@ -1832,9 +1831,9 @@ cso_restore_state(struct cso_context *ctx, unsigned unbind) if (state_mask & CSO_BIT_VIEWPORT) cso_restore_viewport(cso); if (unbind & CSO_UNBIND_VS_CONSTANTS) - cso->base.pipe->set_constant_buffer(cso->base.pipe, MESA_SHADER_VERTEX, 0, false, NULL); + cso->base.pipe->set_constant_buffer(cso->base.pipe, MESA_SHADER_VERTEX, 0, NULL); if (unbind & CSO_UNBIND_FS_CONSTANTS) - cso->base.pipe->set_constant_buffer(cso->base.pipe, MESA_SHADER_FRAGMENT, 0, false, NULL); + cso->base.pipe->set_constant_buffer(cso->base.pipe, MESA_SHADER_FRAGMENT, 0, NULL); if (state_mask & CSO_BIT_VERTEX_ELEMENTS) cso_restore_vertex_elements(cso); if (state_mask & CSO_BIT_STREAM_OUTPUTS) diff --git a/src/gallium/auxiliary/cso_cache/cso_context.h b/src/gallium/auxiliary/cso_cache/cso_context.h index 3b493572d0e..718b9f47961 100644 --- a/src/gallium/auxiliary/cso_cache/cso_context.h +++ b/src/gallium/auxiliary/cso_cache/cso_context.h @@ -98,7 +98,6 @@ cso_set_vertex_elements(struct cso_context *ctx, void cso_set_vertex_buffers(struct cso_context *ctx, unsigned count, - bool take_ownership, const struct pipe_vertex_buffer *buffers); void cso_set_stream_outputs(struct cso_context *ctx, diff --git a/src/gallium/auxiliary/draw/draw_context.c b/src/gallium/auxiliary/draw/draw_context.c index deeae8e3de1..0d5351a969d 100644 --- a/src/gallium/auxiliary/draw/draw_context.c +++ b/src/gallium/auxiliary/draw/draw_context.c @@ -417,7 +417,7 @@ draw_set_vertex_buffers(struct draw_context *draw, util_set_vertex_buffers_count(draw->pt.vertex_buffer, &draw->pt.nr_vertex_buffers, - buffers, count, false); + buffers, count); } diff --git a/src/gallium/auxiliary/driver_ddebug/dd_context.c b/src/gallium/auxiliary/driver_ddebug/dd_context.c index c2915d9221f..90bce068182 100644 --- a/src/gallium/auxiliary/driver_ddebug/dd_context.c +++ b/src/gallium/auxiliary/driver_ddebug/dd_context.c @@ -362,7 +362,6 @@ DD_IMM_STATE(polygon_stipple, const struct pipe_poly_stipple, *state, state) static void dd_context_set_constant_buffer(struct pipe_context *_pipe, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *constant_buffer) { struct dd_context *dctx = dd_context(_pipe); @@ -370,7 +369,7 @@ dd_context_set_constant_buffer(struct pipe_context *_pipe, safe_memcpy(&dctx->draw_state.constant_buffers[shader][index], constant_buffer, sizeof(*constant_buffer)); - pipe->set_constant_buffer(pipe, shader, index, take_ownership, constant_buffer); + pipe->set_constant_buffer(pipe, shader, index, constant_buffer); } static void diff --git a/src/gallium/auxiliary/driver_noop/noop_pipe.c b/src/gallium/auxiliary/driver_noop/noop_pipe.c index a8c1c13433d..79691bda13a 100644 --- a/src/gallium/auxiliary/driver_noop/noop_pipe.c +++ b/src/gallium/auxiliary/driver_noop/noop_pipe.c @@ -414,6 +414,12 @@ static bool noop_is_resource_busy(struct pipe_screen *screen, return false; } +static void +noop_resource_release(struct pipe_context *ctx, struct pipe_resource *resource) +{ + pipe_resource_reference(&resource, NULL); +} + static struct pipe_context *noop_create_context(struct pipe_screen *screen, void *priv, unsigned flags) { @@ -458,6 +464,7 @@ static struct pipe_context *noop_create_context(struct pipe_screen *screen, ctx->invalidate_resource = noop_invalidate_resource; ctx->set_context_param = noop_set_context_param; ctx->set_frontend_noop = noop_set_frontend_noop; + ctx->resource_release = noop_resource_release; noop_init_state_functions(ctx); p_atomic_inc(&screen->num_contexts); diff --git a/src/gallium/auxiliary/driver_noop/noop_state.c b/src/gallium/auxiliary/driver_noop/noop_state.c index 93c817766c8..350f1807226 100644 --- a/src/gallium/auxiliary/driver_noop/noop_state.c +++ b/src/gallium/auxiliary/driver_noop/noop_state.c @@ -154,13 +154,8 @@ static void noop_set_framebuffer_state(struct pipe_context *ctx, static void noop_set_constant_buffer(struct pipe_context *ctx, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *cb) { - if (take_ownership && cb) { - struct pipe_resource *buf = cb->buffer; - pipe_resource_reference(&buf, NULL); - } } static void noop_set_inlinable_constants(struct pipe_context *ctx, diff --git a/src/gallium/auxiliary/driver_trace/tr_context.c b/src/gallium/auxiliary/driver_trace/tr_context.c index 1bbd9731474..d8f18ec645f 100644 --- a/src/gallium/auxiliary/driver_trace/tr_context.c +++ b/src/gallium/auxiliary/driver_trace/tr_context.c @@ -942,7 +942,6 @@ trace_context_set_sample_mask(struct pipe_context *_pipe, static void trace_context_set_constant_buffer(struct pipe_context *_pipe, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *constant_buffer) { struct trace_context *tr_ctx = trace_context(_pipe); @@ -953,10 +952,9 @@ trace_context_set_constant_buffer(struct pipe_context *_pipe, trace_dump_arg(ptr, pipe); trace_dump_arg_enum(mesa_shader_stage, shader); trace_dump_arg(uint, index); - trace_dump_arg(bool, take_ownership); trace_dump_arg(constant_buffer, constant_buffer); - pipe->set_constant_buffer(pipe, shader, index, take_ownership, constant_buffer); + pipe->set_constant_buffer(pipe, shader, index, constant_buffer); trace_dump_call_end(); } @@ -2464,6 +2462,21 @@ trace_context_get_device_reset_status(struct pipe_context *_pipe) return status; } +static void +trace_context_resource_release(struct pipe_context *_pipe, struct pipe_resource *resource) +{ + struct trace_context *tr_ctx = trace_context(_pipe); + struct pipe_context *pipe = tr_ctx->pipe; + + trace_dump_call_begin("pipe_context", "resource_release"); + trace_dump_arg(ptr, pipe); + trace_dump_arg(ptr, resource); + + pipe->resource_release(pipe, resource); + + trace_dump_call_end(); +} + struct pipe_context * trace_context_create(struct trace_screen *tr_scr, struct pipe_context *pipe) @@ -2611,6 +2624,7 @@ trace_context_create(struct trace_screen *tr_scr, TR_CTX_INIT(set_global_binding); TR_CTX_INIT(set_hw_atomic_buffers); TR_CTX_INIT(get_device_reset_status); + TR_CTX_INIT(resource_release); #undef TR_CTX_INIT diff --git a/src/gallium/auxiliary/hud/hud_context.c b/src/gallium/auxiliary/hud/hud_context.c index 2af11a4e94b..0cb4b85c4de 100644 --- a/src/gallium/auxiliary/hud/hud_context.c +++ b/src/gallium/auxiliary/hud/hud_context.c @@ -108,14 +108,16 @@ hud_draw_colored_prims(struct hud_context *hud, unsigned prim, hud->constants.scale[1] = yscale * hud_scale; pipe_upload_constant_buffer0(pipe, MESA_SHADER_VERTEX, &hud->constbuf); + struct pipe_resource *releasebuf = NULL; u_upload_data(hud->pipe->stream_uploader, 0, num_vertices * 2 * sizeof(float), 16, buffer, - &vbuffer.buffer_offset, &vbuffer.buffer.resource); + &vbuffer.buffer_offset, &vbuffer.buffer.resource, &releasebuf); u_upload_unmap(hud->pipe->stream_uploader); - cso_set_vertex_buffers(cso, 1, true, &vbuffer); + cso_set_vertex_buffers(cso, 1, &vbuffer); cso_set_fragment_shader_handle(hud->cso, hud->fs_color); cso_draw_arrays(cso, prim, 0, num_vertices); + pipe_resource_release(hud->pipe, releasebuf); } static void @@ -596,7 +598,7 @@ hud_draw_results(struct hud_context *hud, struct pipe_resource *tex) pipe_upload_constant_buffer0(pipe, MESA_SHADER_VERTEX, &hud->constbuf); - cso_set_vertex_buffers(cso, 1, true, &hud->bg.vbuf); + cso_set_vertex_buffers(cso, 1, &hud->bg.vbuf); cso_draw_arrays(cso, MESA_PRIM_QUADS, 0, hud->bg.num_vertices); hud->bg.vbuf.buffer.resource = NULL; } else { @@ -607,7 +609,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, true, &hud->text.vbuf); + cso_set_vertex_buffers(cso, 1, &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); @@ -634,7 +636,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, true, &hud->whitelines.vbuf); + cso_set_vertex_buffers(cso, 1, &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); hud->whitelines.vbuf.buffer.resource = NULL; @@ -694,17 +696,19 @@ hud_stop_queries(struct hud_context *hud, struct pipe_context *pipe) /* Allocate everything once and divide the storage into 3 portions * manually, because u_upload_alloc can unmap memory from previous calls. */ + struct pipe_resource *pres = NULL, *releasebuf = NULL; u_upload_alloc(pipe->stream_uploader, 0, hud->bg.buffer_size + hud->whitelines.buffer_size + hud->text.buffer_size, - 16, &hud->bg.vbuf.buffer_offset, &hud->bg.vbuf.buffer.resource, + 16, &hud->bg.vbuf.buffer_offset, &pres, &releasebuf, (void**)&hud->bg.vertices); if (!hud->bg.vertices) return; - + pipe_resource_reference(&hud->bg.vbuf.buffer.resource, pres); pipe_resource_reference(&hud->whitelines.vbuf.buffer.resource, hud->bg.vbuf.buffer.resource); pipe_resource_reference(&hud->text.vbuf.buffer.resource, hud->bg.vbuf.buffer.resource); + pipe_resource_release(pipe, releasebuf); hud->whitelines.vbuf.buffer_offset = hud->bg.vbuf.buffer_offset + hud->bg.buffer_size; diff --git a/src/gallium/auxiliary/indices/u_primconvert.c b/src/gallium/auxiliary/indices/u_primconvert.c index 876e35631e1..3e6afc92bc1 100644 --- a/src/gallium/auxiliary/indices/u_primconvert.c +++ b/src/gallium/auxiliary/indices/u_primconvert.c @@ -107,7 +107,8 @@ primconvert_init_draw(struct primconvert_context *pc, const struct pipe_draw_info *info, const struct pipe_draw_start_count_bias *draws, struct pipe_draw_info *new_info, - struct pipe_draw_start_count_bias *new_draw) + struct pipe_draw_start_count_bias *new_draw, + struct pipe_resource **releasebuf) { struct pipe_draw_start_count_bias *direct_draws = NULL; unsigned num_direct_draws = 0; @@ -225,7 +226,7 @@ primconvert_init_draw(struct primconvert_context *pc, if (new_size > UINT_MAX) return false; u_upload_alloc(pc->pipe->stream_uploader, 0, new_size, 4, - &ib_offset, &new_info->index.resource, &dst); + &ib_offset, &new_info->index.resource, releasebuf, &dst); if (!dst) return false; new_draw->start = ib_offset / new_info->index_size; @@ -288,13 +289,13 @@ util_primconvert_draw_single_vbo(struct primconvert_context *pc, { struct pipe_draw_info new_info; struct pipe_draw_start_count_bias new_draw; + struct pipe_resource *releasebuf = NULL; - if (!primconvert_init_draw(pc, info, draw, &new_info, &new_draw)) + if (!primconvert_init_draw(pc, info, draw, &new_info, &new_draw, &releasebuf)) return; /* to the translated draw: */ pc->pipe->draw_vbo(pc->pipe, &new_info, drawid_offset, NULL, &new_draw, 1); - - pipe_resource_reference(&new_info.index.resource, NULL); + pipe_resource_release(pc->pipe, releasebuf); } void @@ -312,7 +313,7 @@ util_primconvert_draw_vbo(struct primconvert_context *pc, unsigned draw_count = 0; struct u_indirect_params *new_draws = util_draw_indirect_read(pc->pipe, info, indirect, &draw_count); if (!new_draws) - goto cleanup; + return; for (unsigned i = 0; i < draw_count; i++) util_primconvert_draw_single_vbo(pc, &new_draws[i].info, drawid_offset + i, &new_draws[i].draw); @@ -326,12 +327,6 @@ util_primconvert_draw_vbo(struct primconvert_context *pc, drawid++; } } - -cleanup: - if (info->take_index_buffer_ownership) { - struct pipe_resource *buffer = info->index.resource; - pipe_resource_reference(&buffer, NULL); - } } void @@ -344,6 +339,7 @@ util_primconvert_draw_vertex_state(struct primconvert_context *pc, { struct pipe_draw_info new_info; struct pipe_draw_start_count_bias new_draw; + struct pipe_resource *releasebuf = NULL; if (pc->cfg.primtypes_mask & BITFIELD_BIT(info.mode)) { pc->pipe->draw_vertex_state(pc->pipe, vstate, partial_velem_mask, info, draws, num_draws); @@ -363,7 +359,7 @@ util_primconvert_draw_vertex_state(struct primconvert_context *pc, dinfo.index_size = 4; dinfo.instance_count = 1; dinfo.index.resource = vstate->input.indexbuf; - if (!primconvert_init_draw(pc, &dinfo, draws, &new_info, &new_draw)) + if (!primconvert_init_draw(pc, &dinfo, draws, &new_info, &new_draw, &releasebuf)) return; struct pipe_vertex_state *new_state = pc->pipe->screen->create_vertex_state(pc->pipe->screen, @@ -381,6 +377,5 @@ util_primconvert_draw_vertex_state(struct primconvert_context *pc, } if (info.take_vertex_state_ownership) pipe_vertex_state_reference(&vstate, NULL); - - pipe_resource_reference(&new_info.index.resource, NULL); + pipe_resource_release(pc->pipe, releasebuf); } diff --git a/src/gallium/auxiliary/postprocess/pp_run.c b/src/gallium/auxiliary/postprocess/pp_run.c index e7f6ba19f8b..7e57f02c23f 100644 --- a/src/gallium/auxiliary/postprocess/pp_run.c +++ b/src/gallium/auxiliary/postprocess/pp_run.c @@ -290,7 +290,7 @@ pp_filter_misc_state(struct pp_program *p) void pp_filter_draw(struct pp_program *p) { - util_draw_vertex_buffer(p->pipe, p->cso, p->vbuf, 0, false, + util_draw_vertex_buffer(p->pipe, p->cso, p->vbuf, 0, MESA_PRIM_QUADS, 4, 2); } diff --git a/src/gallium/auxiliary/util/u_blitter.c b/src/gallium/auxiliary/util/u_blitter.c index a8ec1aa9291..819fd8e3b52 100644 --- a/src/gallium/auxiliary/util/u_blitter.c +++ b/src/gallium/auxiliary/util/u_blitter.c @@ -150,6 +150,7 @@ struct blitter_context_priv bool cube_as_2darray; bool has_texrect; bool cached_all_shaders; + bool must_unset_vbuf; /* The Draw module overrides these functions. * Always create the blitter before Draw. */ @@ -580,12 +581,12 @@ void util_blitter_restore_vertex_states(struct blitter_context *blitter) ctx->base.saved_velem_state = INVALID_PTR; } - /* Vertex buffer. */ - if (ctx->base.saved_num_vb) { + /* Vertex buffers: must ensure no internal vbs are left on driver. */ + if (ctx->base.saved_num_vb || ctx->must_unset_vbuf) { pipe->set_vertex_buffers(pipe, ctx->base.saved_num_vb, - 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_vertex_buffers); + for (unsigned i = 0; i < ctx->base.saved_num_vb; i++) + pipe_vertex_buffer_unreference(&ctx->base.saved_vertex_buffers[i]); ctx->base.saved_num_vb = 0; } @@ -774,8 +775,8 @@ void util_blitter_restore_constant_buffer_state(struct blitter_context *blitter) struct pipe_context *pipe = blitter->pipe; pipe->set_constant_buffer(pipe, MESA_SHADER_FRAGMENT, blitter->cb_slot, - true, &blitter->saved_fs_constant_buffer); - blitter->saved_fs_constant_buffer.buffer = NULL; + &blitter->saved_fs_constant_buffer); + pipe_resource_reference(&blitter->saved_fs_constant_buffer.buffer, NULL); } static void blitter_set_rectangle(struct blitter_context_priv *ctx, @@ -1373,11 +1374,12 @@ static void blitter_draw(struct blitter_context_priv *ctx, { struct pipe_context *pipe = ctx->base.pipe; struct pipe_vertex_buffer vb = {0}; + struct pipe_resource *releasebuf = NULL; blitter_set_rectangle(ctx, x1, y1, x2, y2, depth); u_upload_data(pipe->stream_uploader, 0, sizeof(ctx->vertices), 4, ctx->vertices, - &vb.buffer_offset, &vb.buffer.resource); + &vb.buffer_offset, &vb.buffer.resource, &releasebuf); if (!vb.buffer.resource) return; u_upload_unmap(pipe->stream_uploader); @@ -1385,6 +1387,7 @@ static void blitter_draw(struct blitter_context_priv *ctx, pipe->bind_vertex_elements_state(pipe, vertex_elements_cso); pipe->set_vertex_buffers(pipe, 1, &vb); pipe->bind_vs_state(pipe, get_vs(&ctx->base)); + ctx->must_unset_vbuf = true; if (ctx->base.use_index_buffer) { /* Note that for V3D, @@ -1399,6 +1402,7 @@ static void blitter_draw(struct blitter_context_priv *ctx, util_draw_arrays_instanced(pipe, MESA_PRIM_TRIANGLE_FAN, 0, 4, 0, num_instances); } + pipe_resource_release(pipe, releasebuf); } void util_blitter_draw_rectangle(struct blitter_context *blitter, @@ -1542,7 +1546,7 @@ static void util_blitter_clear_custom(struct blitter_context *blitter, .buffer_size = 4 * sizeof(float), }; pipe->set_constant_buffer(pipe, MESA_SHADER_FRAGMENT, blitter->cb_slot, - false, &cb); + &cb); bind_fs_clear_color(ctx, true); } else { bind_fs_empty(ctx); @@ -2402,7 +2406,7 @@ void util_blitter_clear_render_target(struct blitter_context *blitter, .buffer_size = 4 * sizeof(float), }; pipe->set_constant_buffer(pipe, MESA_SHADER_FRAGMENT, blitter->cb_slot, - false, &cb); + &cb); num_layers = dstsurf->last_layer - dstsurf->first_layer + 1; @@ -2852,7 +2856,7 @@ util_blitter_stencil_fallback(struct blitter_context *blitter, .buffer_size = sizeof(mask), }; pipe->set_constant_buffer(pipe, MESA_SHADER_FRAGMENT, blitter->cb_slot, - false, &cb); + &cb); pipe->bind_depth_stencil_alpha_state(pipe, get_stencil_blit_fallback_dsa(ctx, i)); diff --git a/src/gallium/auxiliary/util/u_draw_quad.c b/src/gallium/auxiliary/util/u_draw_quad.c index c332548ce0d..a91cb36f39e 100644 --- a/src/gallium/auxiliary/util/u_draw_quad.c +++ b/src/gallium/auxiliary/util/u_draw_quad.c @@ -43,7 +43,6 @@ util_draw_vertex_buffer(struct pipe_context *pipe, struct cso_context *cso, struct pipe_resource *vbuf, unsigned offset, - bool vb_take_ownership, enum mesa_prim prim_type, unsigned num_verts, unsigned num_attribs) @@ -60,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, vb_take_ownership, &vbuffer); + cso_set_vertex_buffers(cso, 1, &vbuffer); cso_draw_arrays(cso, prim_type, 0, num_verts); } else { - util_set_vertex_buffers(pipe, 1, vb_take_ownership, &vbuffer); + pipe->set_vertex_buffers(pipe, 1, &vbuffer); util_draw_arrays(pipe, prim_type, 0, num_verts); } } @@ -87,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, false, &vbuffer); + cso_set_vertex_buffers(cso, 1, &vbuffer); cso_draw_arrays(cso, prim_type, 0, num_verts); } diff --git a/src/gallium/auxiliary/util/u_draw_quad.h b/src/gallium/auxiliary/util/u_draw_quad.h index af84ef0371c..83164d51fb0 100644 --- a/src/gallium/auxiliary/util/u_draw_quad.h +++ b/src/gallium/auxiliary/util/u_draw_quad.h @@ -45,7 +45,7 @@ struct cso_velems_state; extern void util_draw_vertex_buffer(struct pipe_context *pipe, struct cso_context *cso, struct pipe_resource *vbuf, unsigned offset, - bool vb_take_ownership, enum mesa_prim prim_type, + enum mesa_prim prim_type, unsigned num_attribs, unsigned num_verts); void diff --git a/src/gallium/auxiliary/util/u_helpers.c b/src/gallium/auxiliary/util/u_helpers.c index 799ad1cd6e8..e3014dc6260 100644 --- a/src/gallium/auxiliary/util/u_helpers.c +++ b/src/gallium/auxiliary/util/u_helpers.c @@ -47,8 +47,7 @@ void util_set_vertex_buffers_mask(struct pipe_vertex_buffer *dst, uint32_t *enabled_buffers, const struct pipe_vertex_buffer *src, - unsigned count, - bool take_ownership) + unsigned count) { unsigned last_count = util_last_bit(*enabled_buffers); uint32_t bitmask = 0; @@ -61,10 +60,7 @@ void util_set_vertex_buffers_mask(struct pipe_vertex_buffer *dst, if (src[i].buffer.resource) bitmask |= 1 << i; - pipe_vertex_buffer_unreference(&dst[i]); - - if (!take_ownership && !src[i].is_user_buffer) - pipe_resource_reference(&dst[i].buffer.resource, src[i].buffer.resource); + pipe_vertex_buffer_reference(&dst[i], &src[i]); } /* Copy over the other members of pipe_vertex_buffer. */ @@ -84,8 +80,7 @@ void util_set_vertex_buffers_mask(struct pipe_vertex_buffer *dst, void util_set_vertex_buffers_count(struct pipe_vertex_buffer *dst, unsigned *dst_count, const struct pipe_vertex_buffer *src, - unsigned count, - bool take_ownership) + unsigned count) { uint32_t enabled_buffers = 0; @@ -94,8 +89,7 @@ void util_set_vertex_buffers_count(struct pipe_vertex_buffer *dst, enabled_buffers |= (1ull << i); } - util_set_vertex_buffers_mask(dst, &enabled_buffers, src, count, - take_ownership); + util_set_vertex_buffers_mask(dst, &enabled_buffers, src, count); *dst_count = util_last_bit(enabled_buffers); } @@ -149,7 +143,7 @@ util_upload_index_buffer(struct pipe_context *pipe, { unsigned start_offset = draw->start * info->index_size; - u_upload_data(pipe->stream_uploader, start_offset, + u_upload_data_ref(pipe->stream_uploader, start_offset, draw->count * info->index_size, alignment, (char*)info->index.user + start_offset, out_offset, out_buffer); diff --git a/src/gallium/auxiliary/util/u_helpers.h b/src/gallium/auxiliary/util/u_helpers.h index f377ad4a7d8..a86f24b797a 100644 --- a/src/gallium/auxiliary/util/u_helpers.h +++ b/src/gallium/auxiliary/util/u_helpers.h @@ -40,14 +40,12 @@ extern "C" { void util_set_vertex_buffers_mask(struct pipe_vertex_buffer *dst, uint32_t *enabled_buffers, const struct pipe_vertex_buffer *src, - unsigned count, - bool take_ownership); + unsigned count); void util_set_vertex_buffers_count(struct pipe_vertex_buffer *dst, unsigned *dst_count, const struct pipe_vertex_buffer *src, - unsigned count, - bool take_ownership); + unsigned count); void util_set_shader_buffers_mask(struct pipe_shader_buffer *dst, uint32_t *enabled_buffers, diff --git a/src/gallium/auxiliary/util/u_inlines.h b/src/gallium/auxiliary/util/u_inlines.h index 80dcb58382a..ca14f24a910 100644 --- a/src/gallium/auxiliary/util/u_inlines.h +++ b/src/gallium/auxiliary/util/u_inlines.h @@ -196,6 +196,19 @@ pipe_resource_reference(struct pipe_resource **dst, struct pipe_resource *src) *dst = src; } +static inline void +pipe_resource_release(struct pipe_context *pipe, struct pipe_resource *resource) +{ + if (resource) + pipe->resource_release(pipe, resource); +} + +static inline void +u_default_resource_release(struct pipe_context *pipe, struct pipe_resource *pres) +{ + pipe_resource_reference(&pres, NULL); +} + /** * Subtract the given number of references. */ @@ -686,9 +699,9 @@ pipe_set_constant_buffer(struct pipe_context *pipe, cb.buffer_offset = 0; cb.buffer_size = buf->width0; cb.user_buffer = NULL; - pipe->set_constant_buffer(pipe, shader, index, false, &cb); + pipe->set_constant_buffer(pipe, shader, index, &cb); } else { - pipe->set_constant_buffer(pipe, shader, index, false, NULL); + pipe->set_constant_buffer(pipe, shader, index, NULL); } } @@ -699,17 +712,19 @@ pipe_upload_constant_buffer0(struct pipe_context *pipe, mesa_shader_stage stage, cbuf.buffer = NULL; const unsigned alignment = MAX2(pipe->screen->caps.constant_buffer_offset_alignment, 64); void *ptr; + struct pipe_resource *releasebuf = NULL; if (pipe->screen->caps.prefer_real_buffer_in_constbuf0) { u_upload_alloc(pipe->const_uploader, 0, cbuf.buffer_size, - alignment, &cbuf.buffer_offset, &cbuf.buffer, (void**)&ptr); + alignment, &cbuf.buffer_offset, &cbuf.buffer, &releasebuf, (void**)&ptr); memcpy(ptr, cbuf.user_buffer, cbuf.buffer_size); cbuf.user_buffer = NULL; u_upload_unmap(pipe->const_uploader); - pipe->set_constant_buffer(pipe, stage, 0, true, &cbuf); + pipe->set_constant_buffer(pipe, stage, 0, &cbuf); + pipe_resource_release(pipe, releasebuf); } else { - pipe->set_constant_buffer(pipe, stage, 0, false, cb); + pipe->set_constant_buffer(pipe, stage, 0, cb); } } @@ -778,16 +793,10 @@ util_query_clear_result(union pipe_query_result *result, unsigned type) static inline void util_copy_constant_buffer(struct pipe_constant_buffer *dst, - const struct pipe_constant_buffer *src, - bool take_ownership) + const struct pipe_constant_buffer *src) { if (src) { - if (take_ownership) { - pipe_resource_reference(&dst->buffer, NULL); - dst->buffer = src->buffer; - } else { - pipe_resource_reference(&dst->buffer, src->buffer); - } + pipe_resource_reference(&dst->buffer, src->buffer); dst->buffer_offset = src->buffer_offset; dst->buffer_size = src->buffer_size; dst->user_buffer = src->user_buffer; @@ -985,24 +994,6 @@ static inline unsigned util_res_sample_count(const struct pipe_resource *res) return res->nr_samples > 0 ? res->nr_samples : 1; } -static inline void -util_set_vertex_buffers(struct pipe_context *pipe, - unsigned num_buffers, bool take_ownership, - const struct pipe_vertex_buffer *buffers) -{ - /* set_vertex_buffers requires that reference counts are incremented - * by the caller. - */ - if (!take_ownership) { - for (unsigned i = 0; i < num_buffers; i++) { - if (!buffers[i].is_user_buffer && buffers[i].buffer.resource) - p_atomic_inc(&buffers[i].buffer.resource->reference.count); - } - } - - pipe->set_vertex_buffers(pipe, num_buffers, buffers); -} - #ifdef __cplusplus } #endif diff --git a/src/gallium/auxiliary/util/u_threaded_context.c b/src/gallium/auxiliary/util/u_threaded_context.c index e366570b408..e16f87b268e 100644 --- a/src/gallium/auxiliary/util/u_threaded_context.c +++ b/src/gallium/auxiliary/util/u_threaded_context.c @@ -1664,18 +1664,17 @@ tc_call_set_constant_buffer(struct pipe_context *pipe, void *call) struct tc_constant_buffer *p = (struct tc_constant_buffer *)call; if (unlikely(p->base.is_null)) { - pipe->set_constant_buffer(pipe, p->base.shader, p->base.index, false, NULL); + pipe->set_constant_buffer(pipe, p->base.shader, p->base.index, NULL); return call_size(tc_constant_buffer_base); } - pipe->set_constant_buffer(pipe, p->base.shader, p->base.index, true, &p->cb); + pipe->set_constant_buffer(pipe, p->base.shader, p->base.index, &p->cb); return call_size(tc_constant_buffer); } static void tc_set_constant_buffer(struct pipe_context *_pipe, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *cb) { struct threaded_context *tc = threaded_context(_pipe); @@ -1958,6 +1957,33 @@ tc_sampler_view_release(struct pipe_context *_pipe, struct pipe_sampler_view *vi p->view = view; } +struct tc_resource_release { + struct tc_call_base base; + struct pipe_resource *resource; +}; + +static uint16_t ALWAYS_INLINE +tc_call_resource_release(struct pipe_context *pipe, void *call) +{ + struct tc_resource_release *p = (struct tc_resource_release *)call; + + pipe->resource_release(pipe, p->resource); + return call_size(tc_resource_release); +} + +static void +tc_resource_release(struct pipe_context *_pipe, struct pipe_resource *resource) +{ + if (!resource) + return; + + struct threaded_context *tc = threaded_context(_pipe); + struct tc_resource_release *p = + tc_add_call(tc, TC_CALL_resource_release, tc_resource_release); + + p->resource = resource; +} + struct tc_shader_images { struct tc_call_base base; uint8_t shader, start, count; @@ -2747,7 +2773,7 @@ tc_buffer_map(struct pipe_context *_pipe, struct threaded_transfer *ttrans = slab_zalloc(&tc->pool_transfers); uint8_t *map; - u_upload_alloc(tc->base.stream_uploader, 0, + u_upload_alloc_ref(tc->base.stream_uploader, 0, box->width + (box->x % tc->map_buffer_alignment), tc->map_buffer_alignment, &ttrans->b.offset, &ttrans->staging, (void**)&map); @@ -3699,11 +3725,8 @@ tc_call_draw_single_drawid(struct pipe_context *pipe, void *call) info->info.index_bounds_valid = false; info->info.has_user_indices = false; - info->info.take_index_buffer_ownership = false; pipe->draw_vbo(pipe, &info->info, info_drawid->drawid_offset, NULL, &draw, 1); - if (info->info.index_size) - tc_drop_resource_reference(info->info.index.resource); return call_size(tc_draw_single_drawid); } @@ -3716,7 +3739,6 @@ simplify_draw_info(struct pipe_draw_info *info) */ info->has_user_indices = false; info->index_bounds_valid = false; - info->take_index_buffer_ownership = false; info->index_bias_varies = false; info->_pad = 0; @@ -3788,10 +3810,6 @@ tc_call_draw_single(struct pipe_context *pipe, void *call) first->info.index_bias_varies = index_bias_varies; pipe->draw_vbo(pipe, &first->info, 0, NULL, multi, num_draws); - /* Since all draws use the same index buffer, drop all references at once. */ - if (first->info.index_size) - pipe_drop_resource_references(first->info.index.resource, num_draws); - return call_size(tc_draw_single) * num_draws; } } @@ -3806,11 +3824,8 @@ tc_call_draw_single(struct pipe_context *pipe, void *call) first->info.index_bounds_valid = false; first->info.has_user_indices = false; - first->info.take_index_buffer_ownership = false; pipe->draw_vbo(pipe, &first->info, 0, NULL, &draw, 1); - if (first->info.index_size) - tc_drop_resource_reference(first->info.index.resource); return call_size(tc_draw_single); } @@ -3828,11 +3843,8 @@ tc_call_draw_indirect(struct pipe_context *pipe, void *call) struct tc_draw_indirect *info = to_call(call, tc_draw_indirect); info->info.index_bounds_valid = false; - info->info.take_index_buffer_ownership = false; pipe->draw_vbo(pipe, &info->info, 0, &info->indirect, &info->draw, 1); - if (info->info.index_size) - tc_drop_resource_reference(info->info.index.resource); tc_drop_resource_reference(info->indirect.buffer); tc_drop_resource_reference(info->indirect.indirect_draw_count); @@ -3854,11 +3866,8 @@ tc_call_draw_multi(struct pipe_context *pipe, void *call) info->info.has_user_indices = false; info->info.index_bounds_valid = false; - info->info.take_index_buffer_ownership = false; pipe->draw_vbo(pipe, &info->info, 0, NULL, info->slot, info->num_draws); - if (info->info.index_size) - tc_drop_resource_reference(info->info.index.resource); return info->base.num_slots; } @@ -3879,10 +3888,6 @@ tc_draw_single(struct pipe_context *_pipe, const struct pipe_draw_info *info, tc_add_call(tc, TC_CALL_draw_single, tc_draw_single); if (info->index_size) { - if (!info->take_index_buffer_ownership) { - tc_set_resource_reference(&p->info.index.resource, - info->index.resource); - } tc_add_to_buffer_list(&tc->buffer_lists[tc->next_buf_list], info->index.resource); } memcpy(&p->info, info, DRAW_INFO_SIZE_WITHOUT_MIN_MAX_INDEX); @@ -3907,10 +3912,6 @@ tc_draw_single_draw_id(struct pipe_context *_pipe, &tc_add_call(tc, TC_CALL_draw_single_drawid, tc_draw_single_drawid)->base; if (info->index_size) { - if (!info->take_index_buffer_ownership) { - tc_set_resource_reference(&p->info.index.resource, - info->index.resource); - } tc_add_to_buffer_list(&tc->buffer_lists[tc->next_buf_list], info->index.resource); } ((struct tc_draw_single_drawid*)p)->drawid_offset = drawid_offset; @@ -3935,6 +3936,7 @@ tc_draw_user_indices_single(struct pipe_context *_pipe, unsigned index_size = info->index_size; unsigned size = draws[0].count * index_size; struct pipe_resource *buffer = NULL; + struct pipe_resource *releasebuf = NULL; unsigned offset; if (!size) @@ -3946,7 +3948,7 @@ tc_draw_user_indices_single(struct pipe_context *_pipe, */ u_upload_data(tc->base.stream_uploader, 0, size, 4, (uint8_t*)info->index.user + draws[0].start * index_size, - &offset, &buffer); + &offset, &buffer, &releasebuf); if (unlikely(!buffer)) return; @@ -3959,6 +3961,7 @@ tc_draw_user_indices_single(struct pipe_context *_pipe, p->info.max_index = draws[0].count; p->index_bias = draws[0].index_bias; simplify_draw_info(&p->info); + pipe_resource_release(_pipe, releasebuf); } /* Single draw with user indices and drawid_offset > 0. */ @@ -3974,6 +3977,7 @@ tc_draw_user_indices_single_draw_id(struct pipe_context *_pipe, unsigned index_size = info->index_size; unsigned size = draws[0].count * index_size; struct pipe_resource *buffer = NULL; + struct pipe_resource *releasebuf = NULL; unsigned offset; if (!size) @@ -3985,7 +3989,7 @@ tc_draw_user_indices_single_draw_id(struct pipe_context *_pipe, */ u_upload_data(tc->base.stream_uploader, 0, size, 4, (uint8_t*)info->index.user + draws[0].start * index_size, - &offset, &buffer); + &offset, &buffer, &releasebuf); if (unlikely(!buffer)) return; @@ -3999,6 +4003,7 @@ tc_draw_user_indices_single_draw_id(struct pipe_context *_pipe, p->info.max_index = draws[0].count; p->index_bias = draws[0].index_bias; simplify_draw_info(&p->info); + pipe_resource_release(_pipe, releasebuf); } #define DRAW_OVERHEAD_BYTES sizeof(struct tc_draw_multi) @@ -4017,7 +4022,6 @@ tc_draw_multi(struct pipe_context *_pipe, const struct pipe_draw_info *info, { struct threaded_context *tc = threaded_context(_pipe); int total_offset = 0; - bool take_index_buffer_ownership = info->take_index_buffer_ownership; while (num_draws) { struct tc_batch *next = &tc->batch_slots[tc->next]; @@ -4037,13 +4041,8 @@ tc_draw_multi(struct pipe_context *_pipe, const struct pipe_draw_info *info, tc_add_slot_based_call(tc, TC_CALL_draw_multi, tc_draw_multi, dr); if (info->index_size) { - if (!take_index_buffer_ownership) { - tc_set_resource_reference(&p->info.index.resource, - info->index.resource); - } tc_add_to_buffer_list(&tc->buffer_lists[tc->next_buf_list], info->index.resource); } - take_index_buffer_ownership = false; memcpy(&p->info, info, DRAW_INFO_SIZE_WITHOUT_MIN_MAX_INDEX); p->num_draws = dr; memcpy(p->slot, &draws[total_offset], sizeof(draws[0]) * dr); @@ -4080,7 +4079,7 @@ tc_draw_user_indices_multi(struct pipe_context *_pipe, * e.g. transfer_unmap and flush partially-uninitialized draw_vbo * to the driver if it was done afterwards. */ - u_upload_alloc(tc->base.stream_uploader, 0, + u_upload_alloc_ref(tc->base.stream_uploader, 0, total_count << index_size_shift, 4, &buffer_offset, &buffer, (void**)&ptr); if (unlikely(!buffer)) @@ -4106,12 +4105,7 @@ tc_draw_user_indices_multi(struct pipe_context *_pipe, dr); memcpy(&p->info, info, DRAW_INFO_SIZE_WITHOUT_INDEXBUF_AND_MIN_MAX_INDEX); - if (total_offset == 0) - /* the first slot inherits the reference from u_upload_alloc() */ - p->info.index.resource = buffer; - else - /* all following slots need a new reference */ - tc_set_resource_reference(&p->info.index.resource, buffer); + p->info.index.resource = buffer; p->num_draws = dr; @@ -4157,10 +4151,6 @@ tc_draw_indirect(struct pipe_context *_pipe, const struct pipe_draw_info *info, struct tc_buffer_list *next = &tc->buffer_lists[tc->next_buf_list]; if (info->index_size) { - if (!info->take_index_buffer_ownership) { - tc_set_resource_reference(&p->info.index.resource, - info->index.resource); - } tc_add_to_buffer_list(next, info->index.resource); } memcpy(&p->info, info, DRAW_INFO_SIZE_WITHOUT_MIN_MAX_INDEX); @@ -5676,6 +5666,7 @@ threaded_context_create(struct pipe_context *pipe, CTX_INIT(set_global_binding); CTX_INIT(get_sample_position); CTX_INIT(invalidate_resource); + CTX_INIT(resource_release); CTX_INIT(get_device_reset_status); CTX_INIT(set_device_reset_callback); CTX_INIT(dump_debug_state); diff --git a/src/gallium/auxiliary/util/u_threaded_context_calls.h b/src/gallium/auxiliary/util/u_threaded_context_calls.h index 32355fc0505..2cdbb1cb31f 100644 --- a/src/gallium/auxiliary/util/u_threaded_context_calls.h +++ b/src/gallium/auxiliary/util/u_threaded_context_calls.h @@ -78,6 +78,7 @@ CALL(blit) CALL(resolve) CALL(generate_mipmap) CALL(invalidate_resource) +CALL(resource_release) CALL(clear_render_target) CALL(clear_depth_stencil) CALL(clear_buffer) diff --git a/src/gallium/auxiliary/util/u_upload_mgr.c b/src/gallium/auxiliary/util/u_upload_mgr.c index 4b1ca064332..d2152f1fb36 100644 --- a/src/gallium/auxiliary/util/u_upload_mgr.c +++ b/src/gallium/auxiliary/util/u_upload_mgr.c @@ -54,7 +54,6 @@ struct u_upload_mgr { unsigned buffer_size; /* Same as buffer->width0. */ unsigned offset; /* Aligned offset to the upload buffer, pointing * at the first unused byte. */ - int buffer_private_refcount; }; @@ -151,16 +150,6 @@ u_upload_release_buffer(struct u_upload_mgr *upload) { /* Unmap and unreference the upload buffer. */ upload_unmap_internal(upload, true); - if (upload->buffer_private_refcount) { - /* Subtract the remaining private references before unreferencing - * the buffer. The mega comment below explains it. - */ - assert(upload->buffer_private_refcount > 0); - p_atomic_add(&upload->buffer->reference.count, - -upload->buffer_private_refcount); - upload->buffer_private_refcount = 0; - } - pipe_resource_reference(&upload->buffer, NULL); upload->buffer_size = 0; } @@ -169,12 +158,13 @@ void u_upload_destroy(struct u_upload_mgr *upload) { u_upload_release_buffer(upload); + pipe_resource_release(upload->pipe, upload->buffer); FREE(upload); } /* Return the allocated buffer size or 0 if it failed. */ static unsigned -u_upload_alloc_buffer(struct u_upload_mgr *upload, unsigned min_size) +u_upload_alloc_buffer(struct u_upload_mgr *upload, unsigned min_size, struct pipe_resource **releasebuf) { struct pipe_screen *screen = upload->pipe->screen; struct pipe_resource buffer; @@ -183,6 +173,8 @@ u_upload_alloc_buffer(struct u_upload_mgr *upload, unsigned min_size) /* Release the old buffer, if present: */ u_upload_release_buffer(upload); + *releasebuf = upload->buffer; + upload->buffer = NULL; /* Allocate a new one: */ @@ -208,39 +200,13 @@ u_upload_alloc_buffer(struct u_upload_mgr *upload, unsigned min_size) if (upload->buffer == NULL) return 0; - /* Since atomic operations are very very slow when 2 threads are not - * sharing the same L3 cache (which happens on AMD Zen), eliminate all - * atomics in u_upload_alloc as follows: - * - * u_upload_alloc has to return a buffer reference to the caller. - * Instead of atomic_inc for every call, it does all possible future - * increments in advance here. The maximum number of times u_upload_alloc - * can be called per upload buffer is "size", because the minimum - * allocation size is 1, thus u_upload_alloc can only return "size" number - * of suballocations at most, so we will never need more. This is - * the number that is added to reference.count here. - * - * buffer_private_refcount tracks how many buffer references we can return - * without using atomics. If the buffer is full and there are still - * references left, they are atomically subtracted from reference.count - * before the buffer is unreferenced. - * - * This technique can increase CPU performance by 10%. - * - * The caller of u_upload_alloc_buffer will consume min_size bytes, - * so init the buffer_private_refcount to 1 + size - min_size, instead - * of size to avoid overflowing reference.count when size is huge. - */ - upload->buffer_private_refcount = 1 + (size - min_size); - assert(upload->buffer_private_refcount < INT32_MAX / 2); - p_atomic_add(&upload->buffer->reference.count, upload->buffer_private_refcount); - /* Map the new buffer. */ upload->map = pipe_buffer_map_range(upload->pipe, upload->buffer, 0, size, upload->map_flags, &upload->transfer); if (upload->map == NULL) { u_upload_release_buffer(upload); + pipe_resource_release(upload->pipe, upload->buffer); return 0; } @@ -256,6 +222,7 @@ u_upload_alloc(struct u_upload_mgr *upload, unsigned alignment, unsigned *out_offset, struct pipe_resource **outbuf, + struct pipe_resource **releasebuf, void **ptr) { unsigned buffer_size = upload->buffer_size; @@ -269,14 +236,16 @@ u_upload_alloc(struct u_upload_mgr *upload, if (unlikely(offset + size > buffer_size)) { /* Allocate a new buffer and set the offset to the smallest one. */ offset = align(min_out_offset, alignment); - buffer_size = u_upload_alloc_buffer(upload, offset + size); + buffer_size = u_upload_alloc_buffer(upload, offset + size, releasebuf); if (unlikely(!buffer_size)) { *out_offset = ~0; - pipe_resource_reference(outbuf, NULL); *ptr = NULL; + *releasebuf = NULL; return; } + } else { + *releasebuf = NULL; } if (unlikely(!upload->map)) { @@ -288,8 +257,8 @@ u_upload_alloc(struct u_upload_mgr *upload, if (unlikely(!upload->map)) { upload->transfer = NULL; *out_offset = ~0; - pipe_resource_reference(outbuf, NULL); *ptr = NULL; + *releasebuf = NULL; return; } @@ -305,15 +274,29 @@ u_upload_alloc(struct u_upload_mgr *upload, *out_offset = offset; if (*outbuf != upload->buffer) { - pipe_resource_reference(outbuf, NULL); *outbuf = upload->buffer; - assert (upload->buffer_private_refcount > 0); - upload->buffer_private_refcount--; } upload->offset = offset + size; } +void +u_upload_alloc_ref(struct u_upload_mgr *upload, + unsigned min_out_offset, + unsigned size, + unsigned alignment, + unsigned *out_offset, + struct pipe_resource **outbuf, + void **ptr) +{ + struct pipe_resource *pres = NULL; + struct pipe_resource *releasebuf = NULL; + + u_upload_alloc(upload, min_out_offset, size, alignment, out_offset, &pres, &releasebuf, ptr); + pipe_resource_release(upload->pipe, releasebuf); + pipe_resource_reference(outbuf, pres); +} + void u_upload_data(struct u_upload_mgr *upload, unsigned min_out_offset, @@ -321,13 +304,31 @@ u_upload_data(struct u_upload_mgr *upload, unsigned alignment, const void *data, unsigned *out_offset, - struct pipe_resource **outbuf) + struct pipe_resource **outbuf, + struct pipe_resource **releasebuf) { uint8_t *ptr; u_upload_alloc(upload, min_out_offset, size, alignment, - out_offset, outbuf, + out_offset, outbuf, releasebuf, (void**)&ptr); if (ptr) memcpy(ptr, data, size); } + +void +u_upload_data_ref(struct u_upload_mgr *upload, + unsigned min_out_offset, + unsigned size, + unsigned alignment, + const void *data, + unsigned *out_offset, + struct pipe_resource **outbuf) +{ + struct pipe_resource *pres = NULL; + struct pipe_resource *releasebuf = NULL; + + u_upload_data(upload, min_out_offset, size, alignment, data, out_offset, &pres, &releasebuf); + pipe_resource_release(upload->pipe, releasebuf); + pipe_resource_reference(outbuf, pres); +} diff --git a/src/gallium/auxiliary/util/u_upload_mgr.h b/src/gallium/auxiliary/util/u_upload_mgr.h index 3ea1822ea6e..f4471663da1 100644 --- a/src/gallium/auxiliary/util/u_upload_mgr.h +++ b/src/gallium/auxiliary/util/u_upload_mgr.h @@ -99,6 +99,7 @@ void u_upload_unmap( struct u_upload_mgr *upload ); * \param alignment Alignment of the suballocation within the buffer * \param out_offset Pointer to where the new buffer offset will be returned. * \param outbuf Pointer to where the upload buffer will be returned. + * \param releasebuf If non-null, this buffer must be released by the caller * \param ptr Pointer to the allocated memory that is returned. */ void u_upload_alloc(struct u_upload_mgr *upload, @@ -107,9 +108,20 @@ void u_upload_alloc(struct u_upload_mgr *upload, unsigned alignment, unsigned *out_offset, struct pipe_resource **outbuf, + struct pipe_resource **releasebuf, void **ptr); +/* same as above, but outbuf gains a ref */ +void +u_upload_alloc_ref(struct u_upload_mgr *upload, + unsigned min_out_offset, + unsigned size, + unsigned alignment, + unsigned *out_offset, + struct pipe_resource **outbuf, + void **ptr); + /** * Allocate and write data to the upload buffer. * @@ -122,7 +134,17 @@ void u_upload_data(struct u_upload_mgr *upload, unsigned alignment, const void *data, unsigned *out_offset, - struct pipe_resource **outbuf); + struct pipe_resource **outbuf, + struct pipe_resource **releasebuf); + +/* same as above, but outbuf gains a ref */ +void u_upload_data_ref(struct u_upload_mgr *upload, + unsigned min_out_offset, + unsigned size, + unsigned alignment, + const void *data, + unsigned *out_offset, + struct pipe_resource **outbuf); #ifdef __cplusplus } // extern "C" { diff --git a/src/gallium/auxiliary/util/u_vbuf.c b/src/gallium/auxiliary/util/u_vbuf.c index f023a9f76a0..882f683e2a3 100644 --- a/src/gallium/auxiliary/util/u_vbuf.c +++ b/src/gallium/auxiliary/util/u_vbuf.c @@ -440,15 +440,8 @@ void u_vbuf_unset_vertex_elements(struct u_vbuf *mgr) void u_vbuf_destroy(struct u_vbuf *mgr) { - unsigned i; - mgr->pipe->set_vertex_buffers(mgr->pipe, 0, NULL); - for (i = 0; i < PIPE_MAX_ATTRIBS; i++) - pipe_vertex_buffer_unreference(&mgr->vertex_buffer[i]); - for (i = 0; i < PIPE_MAX_ATTRIBS; i++) - pipe_vertex_buffer_unreference(&mgr->real_vertex_buffer[i]); - if (mgr->pc) util_primconvert_destroy(mgr->pc); @@ -463,7 +456,8 @@ u_vbuf_translate_buffers(struct u_vbuf *mgr, struct translate_key *key, const struct pipe_draw_start_count_bias *draw, unsigned vb_mask, unsigned out_vb, int start_vertex, unsigned num_vertices, - int min_index, bool unroll_indices) + int min_index, bool unroll_indices, + struct pipe_resource **releasebuf) { struct translate *tr; struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS] = {0}; @@ -550,7 +544,7 @@ u_vbuf_translate_buffers(struct u_vbuf *mgr, struct translate_key *key, /* Create and map the output buffer. */ u_upload_alloc(mgr->pipe->stream_uploader, 0, key->output_stride * draw->count, 4, - &out_offset, &out_buffer, + &out_offset, &out_buffer, releasebuf, (void**)&out_map); if (!out_buffer) return PIPE_ERROR_OUT_OF_MEMORY; @@ -584,7 +578,7 @@ u_vbuf_translate_buffers(struct u_vbuf *mgr, struct translate_key *key, mgr->has_signed_vb_offset ? 0 : key->output_stride * start_vertex, key->output_stride * num_vertices, 4, - &out_offset, &out_buffer, + &out_offset, &out_buffer, releasebuf, (void**)&out_map); if (!out_buffer) return PIPE_ERROR_OUT_OF_MEMORY; @@ -608,7 +602,6 @@ u_vbuf_translate_buffers(struct u_vbuf *mgr, struct translate_key *key, mgr->real_vertex_buffer[out_vb].buffer_offset = out_offset; /* Move the buffer reference. */ - pipe_vertex_buffer_unreference(&mgr->real_vertex_buffer[out_vb]); mgr->real_vertex_buffer[out_vb].buffer.resource = out_buffer; mgr->real_vertex_buffer[out_vb].is_user_buffer = false; @@ -627,6 +620,7 @@ u_vbuf_translate_find_free_vb_slots(struct u_vbuf *mgr, ~mgr->enabled_vb_mask; uint32_t unused_vb_mask_orig; bool insufficient_buffers = false; + uint32_t prev_mask = mgr->fallback_vbs_mask; /* No vertex buffers available at all */ if (!unused_vb_mask) @@ -648,6 +642,9 @@ u_vbuf_translate_find_free_vb_slots(struct u_vbuf *mgr, index = ffs(unused_vb_mask) - 1; fallback_vbs[type] = index; + if (prev_mask & BITFIELD_BIT(index)) { + memset(&mgr->real_vertex_buffer[index], 0, sizeof(mgr->real_vertex_buffer[index])); + } mgr->fallback_vbs_mask |= 1 << index; unused_vb_mask &= ~(1 << index); /*printf("found slot=%i for type=%i\n", index, type);*/ @@ -660,6 +657,9 @@ u_vbuf_translate_find_free_vb_slots(struct u_vbuf *mgr, uint32_t index = ffs(unused_vb_mask_orig) - 1; /* When sharing one vertex buffer use per-vertex frequency for everything. */ fallback_vbs[VB_VERTEX] = index; + if (prev_mask & BITFIELD_BIT(index)) { + memset(&mgr->real_vertex_buffer[index], 0, sizeof(mgr->real_vertex_buffer[index])); + } mgr->fallback_vbs_mask = 1 << index; mask[VB_VERTEX] = mask[VB_VERTEX] | mask[VB_CONST] | mask[VB_INSTANCE]; mask[VB_CONST] = 0; @@ -684,7 +684,7 @@ u_vbuf_translate_begin(struct u_vbuf *mgr, const struct pipe_draw_start_count_bias *draw, int start_vertex, unsigned num_vertices, int min_index, bool unroll_indices, - uint32_t misaligned) + uint32_t misaligned, struct pipe_resource **releasebuf) { unsigned mask[VB_NUM] = {0}; struct translate_key key[VB_NUM]; @@ -803,7 +803,7 @@ u_vbuf_translate_begin(struct u_vbuf *mgr, err = u_vbuf_translate_buffers(mgr, &key[type], info, draw, mask[type], mgr->fallback_vbs[type], start[type], num[type], min_index, - unroll_indices && type == VB_VERTEX); + unroll_indices && type == VB_VERTEX, releasebuf); if (err != PIPE_OK) return false; } @@ -853,11 +853,11 @@ static void u_vbuf_translate_end(struct u_vbuf *mgr) mgr->pipe->bind_vertex_elements_state(mgr->pipe, mgr->ve->driver_cso); mgr->using_translate = false; - /* Unreference the now-unused VBOs. */ + /* Release the now-unused VBOs. */ for (i = 0; i < VB_NUM; i++) { unsigned vb = mgr->fallback_vbs[i]; if (vb != ~0u) { - pipe_resource_reference(&mgr->real_vertex_buffer[vb].buffer.resource, NULL); + memset(&mgr->real_vertex_buffer[vb], 0, sizeof(mgr->real_vertex_buffer[vb])); mgr->fallback_vbs[i] = ~0; } } @@ -991,12 +991,10 @@ static void u_vbuf_delete_vertex_elements(void *ctx, void *state, void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr, unsigned count, - 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; @@ -1008,11 +1006,6 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr, 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, NULL); return; } @@ -1036,8 +1029,8 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr, struct pipe_vertex_buffer *real_vb = &mgr->real_vertex_buffer[i]; if (!vb->buffer.resource) { - pipe_vertex_buffer_unreference(orig_vb); - pipe_vertex_buffer_unreference(real_vb); + memset(orig_vb, 0, sizeof(*orig_vb)); + memset(real_vb, 0, sizeof(*real_vb)); continue; } @@ -1047,19 +1040,14 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr, orig_vb->buffer.resource == vb->buffer.resource) num_identical++; - if (take_ownership) { - pipe_vertex_buffer_unreference(orig_vb); - memcpy(orig_vb, vb, sizeof(*vb)); - } else { - pipe_vertex_buffer_reference(orig_vb, vb); - } + *orig_vb = *vb; enabled_vb_mask |= 1 << i; if ((!mgr->caps.attrib_4byte_unaligned && vb->buffer_offset % 4 != 0)) { incompatible_vb_mask |= 1 << i; real_vb->buffer_offset = vb->buffer_offset; - pipe_vertex_buffer_unreference(real_vb); + memset(real_vb, 0, sizeof(*real_vb)); real_vb->is_user_buffer = false; continue; } @@ -1074,12 +1062,12 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr, if (!mgr->caps.user_vertex_buffers && vb->is_user_buffer) { user_vb_mask |= 1 << i; real_vb->buffer_offset = vb->buffer_offset; - pipe_vertex_buffer_unreference(real_vb); + memset(real_vb, 0, sizeof(*real_vb)); real_vb->is_user_buffer = false; continue; } - pipe_vertex_buffer_reference(real_vb, vb); + *real_vb = *vb; } unsigned last_count = mgr->num_vertex_buffers; @@ -1088,8 +1076,8 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr, return; for (; i < last_count; i++) { - pipe_vertex_buffer_unreference(&mgr->vertex_buffer[i]); - pipe_vertex_buffer_unreference(&mgr->real_vertex_buffer[i]); + memset(&mgr->vertex_buffer[i], 0, sizeof(struct pipe_vertex_buffer)); + memset(&mgr->real_vertex_buffer[i], 0, sizeof(struct pipe_vertex_buffer)); } mgr->num_vertex_buffers = count; @@ -1148,13 +1136,15 @@ get_upload_offset_size(struct u_vbuf *mgr, static enum pipe_error u_vbuf_upload_buffers(struct u_vbuf *mgr, int start_vertex, unsigned num_vertices, - int start_instance, unsigned num_instances) + int start_instance, unsigned num_instances, + unsigned *release_count, struct pipe_resource **releasebufs) { unsigned i; struct u_vbuf_elements *ve = mgr->ve; unsigned nr_velems = ve->count; const struct pipe_vertex_element *velems = mgr->using_translate ? mgr->fallback_velems.velems : ve->ve; + unsigned rcount = 0; /* Faster path when no vertex attribs are interleaved. */ if ((ve->interleaved_vb_mask & mgr->user_vb_mask) == 0) { @@ -1175,12 +1165,16 @@ u_vbuf_upload_buffers(struct u_vbuf *mgr, u_upload_data(mgr->pipe->stream_uploader, mgr->has_signed_vb_offset ? 0 : offset, size, 4, ptr + offset, &real_vb->buffer_offset, - &real_vb->buffer.resource); + &real_vb->buffer.resource, &releasebufs[rcount]); if (!real_vb->buffer.resource) return PIPE_ERROR_OUT_OF_MEMORY; + if (releasebufs[rcount]) + rcount++; + real_vb->buffer_offset -= offset; } + *release_count = rcount; return PIPE_OK; } @@ -1235,13 +1229,18 @@ u_vbuf_upload_buffers(struct u_vbuf *mgr, u_upload_data(mgr->pipe->stream_uploader, mgr->has_signed_vb_offset ? 0 : start, end - start, 4, - ptr + start, &real_vb->buffer_offset, &real_vb->buffer.resource); + ptr + start, &real_vb->buffer_offset, &real_vb->buffer.resource, &releasebufs[rcount]); if (!real_vb->buffer.resource) return PIPE_ERROR_OUT_OF_MEMORY; + if (releasebufs[rcount]) + rcount++; + real_vb->buffer_offset -= start; } + *release_count = rcount; + return PIPE_OK; } @@ -1393,10 +1392,6 @@ static void u_vbuf_set_driver_vertex_buffers(struct u_vbuf *mgr) 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, mgr->real_vertex_buffer); /* We don't own the VBO references now. Set them to NULL. */ @@ -1405,8 +1400,7 @@ static void u_vbuf_set_driver_vertex_buffers(struct u_vbuf *mgr) mgr->real_vertex_buffer[i].buffer.resource = NULL; } } else { - /* Slow path where we have to keep VBO references. */ - util_set_vertex_buffers(pipe, count, false, mgr->real_vertex_buffer); + pipe->set_vertex_buffers(pipe, count, mgr->real_vertex_buffer); } mgr->vertex_buffers_dirty = false; } @@ -1417,12 +1411,6 @@ u_vbuf_split_indexed_multidraw(struct u_vbuf *mgr, struct pipe_draw_info *info, unsigned *indirect_data, unsigned stride, unsigned draw_count) { - /* Increase refcount to be able to use take_index_buffer_ownership with - * all draws. - */ - if (draw_count > 1 && info->take_index_buffer_ownership) - p_atomic_add(&info->index.resource->reference.count, draw_count - 1); - assert(info->index_size); for (unsigned i = 0; i < draw_count; i++) { @@ -1453,6 +1441,9 @@ void u_vbuf_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *inf const uint32_t used_vb_mask = mgr->ve->used_vb_mask; uint32_t user_vb_mask = mgr->user_vb_mask & used_vb_mask; unsigned fixed_restart_index = info->index_size ? util_prim_restart_index_from_size(info->index_size) : 0; + struct pipe_resource *releasebuf = NULL; + struct pipe_resource *releasebufs[PIPE_MAX_ATTRIBS]; + unsigned release_count = 0; uint32_t misaligned = 0; if (!mgr->caps.attrib_element_unaligned) { @@ -1483,12 +1474,6 @@ void u_vbuf_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *inf return; } - /* Increase refcount to be able to use take_index_buffer_ownership with - * all draws. - */ - if (num_draws > 1 && info->take_index_buffer_ownership) - p_atomic_add(&info->index.resource->reference.count, num_draws - 1); - for (unsigned d = 0; d < num_draws; d++) { struct pipe_draw_info new_info = *info; struct pipe_draw_start_count_bias new_draw = draws[d]; @@ -1510,13 +1495,13 @@ void u_vbuf_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *inf } if (!draw_count) - goto cleanup; + return; unsigned data_size = (draw_count - 1) * indirect->stride + (new_info.index_size ? 20 : 16); unsigned *data = malloc(data_size); if (!data) - goto cleanup; /* report an error? */ + return; /* report an error? */ /* Read the used buffer range only once, because the read can be * uncached. @@ -1616,7 +1601,7 @@ void u_vbuf_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *inf new_info.instance_count = end_instance - new_info.start_instance; if (new_info.start_instance == ~0u || !new_info.instance_count) - goto cleanup; + return; } else { /* Non-indexed multidraw. * @@ -1653,11 +1638,11 @@ void u_vbuf_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *inf new_info.instance_count = end_instance - new_info.start_instance; if (new_draw.start == ~0u || !new_draw.count || !new_info.instance_count) - goto cleanup; + return; } } else { if ((!indirect && !new_draw.count) || !new_info.instance_count) - goto cleanup; + return; } if (new_info.index_size) { @@ -1708,14 +1693,12 @@ void u_vbuf_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *inf mgr->ve->incompatible_elem_mask) { if (!u_vbuf_translate_begin(mgr, &new_info, &new_draw, start_vertex, num_vertices, - min_index, unroll_indices, misaligned)) { + min_index, unroll_indices, misaligned, &releasebuf)) { debug_warn_once("u_vbuf_translate_begin() failed"); - goto cleanup; + goto out; } if (unroll_indices) { - if (!new_info.has_user_indices && info->take_index_buffer_ownership) - pipe_drop_resource_references(new_info.index.resource, 1); new_info.index_size = 0; new_draw.index_bias = 0; new_info.index_bounds_valid = true; @@ -1733,9 +1716,10 @@ void u_vbuf_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *inf if (user_vb_mask) { if (u_vbuf_upload_buffers(mgr, start_vertex, num_vertices, new_info.start_instance, - new_info.instance_count) != PIPE_OK) { + new_info.instance_count, + &release_count, releasebufs) != PIPE_OK) { debug_warn_once("u_vbuf_upload_buffers() failed"); - goto cleanup; + goto out; } mgr->vertex_buffers_dirty = true; @@ -1782,13 +1766,11 @@ void u_vbuf_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *inf if (mgr->using_translate) { u_vbuf_translate_end(mgr); } - return; -cleanup: - if (info->take_index_buffer_ownership) { - struct pipe_resource *indexbuf = info->index.resource; - pipe_resource_reference(&indexbuf, NULL); - } +out: + pipe_resource_release(pipe, releasebuf); + for (unsigned i = 0; i < release_count; i++) + pipe_resource_release(pipe, releasebufs[i]); } void u_vbuf_save_vertex_elements(struct u_vbuf *mgr) diff --git a/src/gallium/auxiliary/util/u_vbuf.h b/src/gallium/auxiliary/util/u_vbuf.h index 9809ee90b6d..a6aeb3b729e 100644 --- a/src/gallium/auxiliary/util/u_vbuf.h +++ b/src/gallium/auxiliary/util/u_vbuf.h @@ -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, - bool take_ownership, const struct pipe_vertex_buffer *bufs); void u_vbuf_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info, diff --git a/src/gallium/auxiliary/vl/vl_bicubic_filter.c b/src/gallium/auxiliary/vl/vl_bicubic_filter.c index caaee4589c5..12e486598c2 100644 --- a/src/gallium/auxiliary/vl/vl_bicubic_filter.c +++ b/src/gallium/auxiliary/vl/vl_bicubic_filter.c @@ -428,9 +428,10 @@ vl_bicubic_filter_render(struct vl_bicubic_filter *filter, struct pipe_constant_buffer cb = {0}; float *ptr = NULL; + struct pipe_resource *releasebuf = NULL; u_upload_alloc(filter->pipe->const_uploader, 0, 2 * sizeof(float), 256, - &cb.buffer_offset, &cb.buffer, (void**)&ptr); + &cb.buffer_offset, &cb.buffer, &releasebuf, (void**)&ptr); cb.buffer_size = 2 * sizeof(float); if (ptr) { @@ -450,7 +451,7 @@ vl_bicubic_filter_render(struct vl_bicubic_filter *filter, 0, 0, pipe_surface_width(dst), pipe_surface_height(dst), false); filter->pipe->set_constant_buffer(filter->pipe, MESA_SHADER_FRAGMENT, - 0, false, &cb); + 0, &cb); filter->pipe->bind_rasterizer_state(filter->pipe, filter->rs_state); filter->pipe->bind_blend_state(filter->pipe, filter->blend); filter->pipe->bind_sampler_states(filter->pipe, MESA_SHADER_FRAGMENT, @@ -462,7 +463,8 @@ vl_bicubic_filter_render(struct vl_bicubic_filter *filter, filter->pipe->set_framebuffer_state(filter->pipe, &fb_state); filter->pipe->set_viewport_states(filter->pipe, 0, 1, &viewport); filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves); - util_set_vertex_buffers(filter->pipe, 1, false, &filter->quad); + filter->pipe->set_vertex_buffers(filter->pipe, 1, &filter->quad); util_draw_arrays(filter->pipe, MESA_PRIM_QUADS, 0, 4); + pipe_resource_release(filter->pipe, releasebuf); } diff --git a/src/gallium/auxiliary/vl/vl_compositor.c b/src/gallium/auxiliary/vl/vl_compositor.c index 4ca12f923ab..03a42f45792 100644 --- a/src/gallium/auxiliary/vl/vl_compositor.c +++ b/src/gallium/auxiliary/vl/vl_compositor.c @@ -286,7 +286,7 @@ cleanup_buffers(struct vl_compositor *c) if (c->pipe_gfx_supported) { c->pipe->delete_vertex_elements_state(c->pipe, c->vertex_elems_state); } - pipe_resource_reference(&c->vertex_buf.buffer.resource, NULL); + c->vertex_buf.buffer.resource = NULL; } static inline struct u_rect @@ -909,5 +909,5 @@ vl_compositor_cleanup_state(struct vl_compositor_state *s) assert(s); vl_compositor_clear_layers(s); - pipe_resource_reference(&s->shader_params, NULL); + pipe_resource_release(s->pipe, s->shader_params); } diff --git a/src/gallium/auxiliary/vl/vl_compositor_cs.c b/src/gallium/auxiliary/vl/vl_compositor_cs.c index f7ce3874008..2e822cd93c3 100644 --- a/src/gallium/auxiliary/vl/vl_compositor_cs.c +++ b/src/gallium/auxiliary/vl/vl_compositor_cs.c @@ -863,7 +863,7 @@ draw_layers(struct vl_compositor *c, /* Unbind. */ c->pipe->set_shader_images(c->pipe, MESA_SHADER_COMPUTE, 0, 0, 1, NULL); - c->pipe->set_constant_buffer(c->pipe, MESA_SHADER_COMPUTE, 0, false, NULL); + c->pipe->set_constant_buffer(c->pipe, MESA_SHADER_COMPUTE, 0, NULL); c->pipe->set_sampler_views(c->pipe, MESA_SHADER_COMPUTE, 0, 0, num_sampler_views, NULL); c->pipe->bind_compute_state(c->pipe, NULL); diff --git a/src/gallium/auxiliary/vl/vl_compositor_gfx.c b/src/gallium/auxiliary/vl/vl_compositor_gfx.c index 23d0cd87b1c..a81b9371d84 100644 --- a/src/gallium/auxiliary/vl/vl_compositor_gfx.c +++ b/src/gallium/auxiliary/vl/vl_compositor_gfx.c @@ -599,7 +599,7 @@ calc_drawn_area(struct vl_compositor_state *s, struct vl_compositor_layer *layer } static void -gen_vertex_data(struct vl_compositor *c, struct vl_compositor_state *s, struct u_rect *dirty) +gen_vertex_data(struct vl_compositor *c, struct vl_compositor_state *s, struct u_rect *dirty, struct pipe_resource **releasebuf) { struct vertex2f *vb; unsigned i; @@ -611,6 +611,7 @@ gen_vertex_data(struct vl_compositor *c, struct vl_compositor_state *s, struct u VL_COMPOSITOR_VB_STRIDE * VL_COMPOSITOR_MAX_LAYERS * 4, /* size */ 4, /* alignment */ &c->vertex_buf.buffer_offset, &c->vertex_buf.buffer.resource, + releasebuf, (void **)&vb); for (i = 0; i < VL_COMPOSITOR_MAX_LAYERS; i++) { @@ -724,7 +725,8 @@ vl_compositor_gfx_render(struct vl_compositor_state *s, } c->pipe->set_scissor_states(c->pipe, 0, 1, &s->scissor); - gen_vertex_data(c, s, dirty_area); + struct pipe_resource *releasebuf = NULL; + gen_vertex_data(c, s, dirty_area, &releasebuf); set_csc_matrix(s); if (clear_dirty && dirty_area && @@ -739,9 +741,10 @@ 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->bind_vertex_elements_state(c->pipe, c->vertex_elems_state); - util_set_vertex_buffers(c->pipe, 1, false, &c->vertex_buf); + c->pipe->set_vertex_buffers(c->pipe, 1, &c->vertex_buf); pipe_set_constant_buffer(c->pipe, MESA_SHADER_FRAGMENT, 0, s->shader_params); c->pipe->bind_rasterizer_state(c->pipe, c->rast); draw_layers(c, s, dirty_area); + pipe_resource_release(c->pipe, releasebuf); } diff --git a/src/gallium/auxiliary/vl/vl_deint_filter.c b/src/gallium/auxiliary/vl/vl_deint_filter.c index 7160827a7e8..48244435546 100644 --- a/src/gallium/auxiliary/vl/vl_deint_filter.c +++ b/src/gallium/auxiliary/vl/vl_deint_filter.c @@ -494,7 +494,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->bind_vertex_elements_state(filter->pipe, filter->ves); - util_set_vertex_buffers(filter->pipe, 1, false, &filter->quad); + filter->pipe->set_vertex_buffers(filter->pipe, 1, &filter->quad); filter->pipe->bind_vs_state(filter->pipe, filter->vs); filter->pipe->bind_sampler_states(filter->pipe, MESA_SHADER_FRAGMENT, 0, 4, filter->sampler); diff --git a/src/gallium/auxiliary/vl/vl_matrix_filter.c b/src/gallium/auxiliary/vl/vl_matrix_filter.c index 241979f1ac0..776c19ff2ee 100644 --- a/src/gallium/auxiliary/vl/vl_matrix_filter.c +++ b/src/gallium/auxiliary/vl/vl_matrix_filter.c @@ -308,7 +308,7 @@ vl_matrix_filter_render(struct vl_matrix_filter *filter, filter->pipe->set_framebuffer_state(filter->pipe, &fb_state); filter->pipe->set_viewport_states(filter->pipe, 0, 1, &viewport); filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves); - util_set_vertex_buffers(filter->pipe, 1, false, &filter->quad); + filter->pipe->set_vertex_buffers(filter->pipe, 1, &filter->quad); util_draw_arrays(filter->pipe, MESA_PRIM_QUADS, 0, 4); } diff --git a/src/gallium/auxiliary/vl/vl_median_filter.c b/src/gallium/auxiliary/vl/vl_median_filter.c index be56870e9ef..9680b37d355 100644 --- a/src/gallium/auxiliary/vl/vl_median_filter.c +++ b/src/gallium/auxiliary/vl/vl_median_filter.c @@ -426,7 +426,7 @@ vl_median_filter_render(struct vl_median_filter *filter, filter->pipe->set_framebuffer_state(filter->pipe, &fb_state); filter->pipe->set_viewport_states(filter->pipe, 0, 1, &viewport); filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves); - util_set_vertex_buffers(filter->pipe, 1, false, &filter->quad); + filter->pipe->set_vertex_buffers(filter->pipe, 1, &filter->quad); util_draw_arrays(filter->pipe, MESA_PRIM_QUADS, 0, 4); } diff --git a/src/gallium/auxiliary/vl/vl_mpeg12_decoder.c b/src/gallium/auxiliary/vl/vl_mpeg12_decoder.c index c8296be5005..f8bdf251eef 100644 --- a/src/gallium/auxiliary/vl/vl_mpeg12_decoder.c +++ b/src/gallium/auxiliary/vl/vl_mpeg12_decoder.c @@ -786,7 +786,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); - util_set_vertex_buffers(dec->context, 3, false, vb); + dec->context->set_vertex_buffers(dec->context, 3, vb); vl_mc_render_ref(i ? &dec->mc_c : &dec->mc_y, &buf->mc[i], ref_frames[j][i]); } @@ -797,7 +797,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); - util_set_vertex_buffers(dec->context, 2, false, vb); + dec->context->set_vertex_buffers(dec->context, 2, vb); vl_zscan_render(i ? &dec->zscan_c : & dec->zscan_y, &buf->zscan[i] , buf->num_ycbcr_blocks[i]); @@ -816,7 +816,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); - util_set_vertex_buffers(dec->context, 2, false, vb); + dec->context->set_vertex_buffers(dec->context, 2, vb); if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) vl_idct_prepare_stage2(i ? &dec->idct_c : &dec->idct_y, &buf->idct[plane]); diff --git a/src/gallium/drivers/asahi/agx_blit.c b/src/gallium/drivers/asahi/agx_blit.c index 7e11fdae7f7..05d12983ca4 100644 --- a/src/gallium/drivers/asahi/agx_blit.c +++ b/src/gallium/drivers/asahi/agx_blit.c @@ -284,7 +284,7 @@ asahi_compute_restore(struct agx_context *ctx) } /* take_ownership=true so do not unreference */ - pctx->set_constant_buffer(pctx, MESA_SHADER_COMPUTE, 0, true, + pctx->set_constant_buffer(pctx, MESA_SHADER_COMPUTE, 0, &blitter->saved_cb); blitter->saved_cb.buffer = NULL; @@ -366,7 +366,7 @@ asahi_compute_blit(struct pipe_context *ctx, const struct pipe_blit_info *info, .buffer_size = sizeof(data), .user_buffer = data, }; - ctx->set_constant_buffer(ctx, MESA_SHADER_COMPUTE, 0, false, &cb); + ctx->set_constant_buffer(ctx, MESA_SHADER_COMPUTE, 0, &cb); struct pipe_image_view image = { .resource = dst, @@ -448,7 +448,7 @@ asahi_compute_blit(struct pipe_context *ctx, const struct pipe_blit_info *info, }; ctx->launch_grid(ctx, &grid_info); ctx->set_shader_images(ctx, MESA_SHADER_COMPUTE, 0, 0, 1, NULL); - ctx->set_constant_buffer(ctx, MESA_SHADER_COMPUTE, 0, false, NULL); + ctx->set_constant_buffer(ctx, MESA_SHADER_COMPUTE, 0, NULL); ctx->set_sampler_views(ctx, MESA_SHADER_COMPUTE, 0, 0, 1, NULL); asahi_compute_restore(agx_context(ctx)); diff --git a/src/gallium/drivers/asahi/agx_state.c b/src/gallium/drivers/asahi/agx_state.c index 133c0bf424d..19f136e836a 100644 --- a/src/gallium/drivers/asahi/agx_state.c +++ b/src/gallium/drivers/asahi/agx_state.c @@ -1300,18 +1300,18 @@ agx_batch_upload_pbe(struct agx_batch *batch, struct agx_pbe_packed *out, static void agx_set_constant_buffer(struct pipe_context *pctx, mesa_shader_stage shader, - uint index, bool take_ownership, + uint index, const struct pipe_constant_buffer *cb) { struct agx_context *ctx = agx_context(pctx); struct agx_stage *s = &ctx->stage[shader]; struct pipe_constant_buffer *constants = &s->cb[index]; - util_copy_constant_buffer(&s->cb[index], cb, take_ownership); + util_copy_constant_buffer(&s->cb[index], cb); /* Upload user buffer immediately */ if (constants->user_buffer && !constants->buffer) { - u_upload_data(ctx->base.const_uploader, 0, constants->buffer_size, 64, + u_upload_data_ref(ctx->base.const_uploader, 0, constants->buffer_size, 64, constants->user_buffer, &constants->buffer_offset, &constants->buffer); } @@ -1341,7 +1341,7 @@ agx_set_vertex_buffers(struct pipe_context *pctx, unsigned count, struct agx_context *ctx = agx_context(pctx); util_set_vertex_buffers_mask(ctx->vertex_buffers, &ctx->vb_mask, buffers, - count, true); + count); ctx->dirty |= AGX_DIRTY_VERTEX; } @@ -4209,7 +4209,7 @@ agx_draw_without_restart(struct agx_batch *batch, uint32_t desc[5] = {draw->count, info->instance_count, 0, draw->index_bias, info->start_instance}; - u_upload_data(ctx->base.const_uploader, 0, sizeof(desc), 4, &desc, + u_upload_data_ref(ctx->base.const_uploader, 0, sizeof(desc), 4, &desc, &indirect_synthesized.offset, &indirect_synthesized.buffer); indirect = &indirect_synthesized; @@ -4426,7 +4426,7 @@ util_draw_multi_upload_indirect(struct pipe_context *pctx, const struct pipe_draw_start_count_bias *draws) { struct pipe_draw_indirect_info indirect_ = *indirect; - u_upload_data(pctx->const_uploader, 0, 4, 4, &indirect->draw_count, + u_upload_data_ref(pctx->const_uploader, 0, 4, 4, &indirect->draw_count, &indirect_.indirect_draw_count_offset, &indirect_.indirect_draw_count); @@ -5589,6 +5589,7 @@ agx_init_state_functions(struct pipe_context *ctx) ctx->set_viewport_states = agx_set_viewport_states; ctx->sampler_view_destroy = agx_sampler_view_destroy; ctx->sampler_view_release = u_default_sampler_view_release; + ctx->resource_release = u_default_resource_release; ctx->draw_vbo = agx_draw_vbo; ctx->launch_grid = agx_launch_grid; ctx->set_global_binding = agx_set_global_binding; diff --git a/src/gallium/drivers/crocus/crocus_draw.c b/src/gallium/drivers/crocus/crocus_draw.c index f1db66775e6..3b3d73dc7bf 100644 --- a/src/gallium/drivers/crocus/crocus_draw.c +++ b/src/gallium/drivers/crocus/crocus_draw.c @@ -229,7 +229,7 @@ crocus_update_draw_parameters(struct crocus_context *ice, ice->draw.params.baseinstance = info->start_instance; ice->draw.params_valid = true; - u_upload_data(ice->ctx.stream_uploader, 0, + u_upload_data_ref(ice->ctx.stream_uploader, 0, sizeof(ice->draw.params), 4, &ice->draw.params, &draw_params->offset, &draw_params->res); } @@ -247,7 +247,7 @@ crocus_update_draw_parameters(struct crocus_context *ice, ice->draw.derived_params.drawid = drawid_offset; ice->draw.derived_params.is_indexed_draw = is_indexed_draw; - u_upload_data(ice->ctx.stream_uploader, 0, + u_upload_data_ref(ice->ctx.stream_uploader, 0, sizeof(ice->draw.derived_params), 4, &ice->draw.derived_params, &derived_params->offset, &derived_params->res); @@ -463,7 +463,7 @@ crocus_update_grid_size_resource(struct crocus_context *ice, memset(ice->state.last_grid, 0, sizeof(ice->state.last_grid)); } else if (memcmp(ice->state.last_grid, grid->grid, sizeof(grid->grid)) != 0) { memcpy(ice->state.last_grid, grid->grid, sizeof(grid->grid)); - u_upload_data(ice->ctx.const_uploader, 0, sizeof(grid->grid), 4, + u_upload_data_ref(ice->ctx.const_uploader, 0, sizeof(grid->grid), 4, grid->grid, &grid_ref->offset, &grid_ref->res); } diff --git a/src/gallium/drivers/crocus/crocus_fine_fence.c b/src/gallium/drivers/crocus/crocus_fine_fence.c index 9bb8a9673e3..0838585280f 100644 --- a/src/gallium/drivers/crocus/crocus_fine_fence.c +++ b/src/gallium/drivers/crocus/crocus_fine_fence.c @@ -5,7 +5,7 @@ static void crocus_fine_fence_reset(struct crocus_batch *batch) { - u_upload_alloc(batch->fine_fences.uploader, + u_upload_alloc_ref(batch->fine_fences.uploader, 0, sizeof(uint64_t), sizeof(uint64_t), &batch->fine_fences.ref.offset, &batch->fine_fences.ref.res, (void **)&batch->fine_fences.map); diff --git a/src/gallium/drivers/crocus/crocus_query.c b/src/gallium/drivers/crocus/crocus_query.c index 752193a9778..ee7f4d3ea45 100644 --- a/src/gallium/drivers/crocus/crocus_query.c +++ b/src/gallium/drivers/crocus/crocus_query.c @@ -539,7 +539,7 @@ crocus_begin_query(struct pipe_context *ctx, struct pipe_query *query) else size = sizeof(struct crocus_query_snapshots); - u_upload_alloc(ice->query_buffer_uploader, 0, + u_upload_alloc_ref(ice->query_buffer_uploader, 0, size, util_next_power_of_two(size), &q->query_state_ref.offset, &q->query_state_ref.res, &ptr); diff --git a/src/gallium/drivers/crocus/crocus_state.c b/src/gallium/drivers/crocus/crocus_state.c index f31e31eb4bc..17e40455ace 100644 --- a/src/gallium/drivers/crocus/crocus_state.c +++ b/src/gallium/drivers/crocus/crocus_state.c @@ -970,7 +970,7 @@ gen4_upload_curbe(struct crocus_batch *batch) goto emit; uint32_t *map; - u_upload_alloc(ice->ctx.const_uploader, 0, buf_sz, 64, + u_upload_alloc_ref(ice->ctx.const_uploader, 0, buf_sz, 64, &ice->curbe.curbe_offset, (struct pipe_resource **)&ice->curbe.curbe_res, (void **) &map); /* fragment shader constants */ @@ -3505,7 +3505,6 @@ crocus_set_framebuffer_state(struct pipe_context *ctx, static void crocus_set_constant_buffer(struct pipe_context *ctx, mesa_shader_stage p_stage, unsigned index, - bool take_ownership, const struct pipe_constant_buffer *input) { struct crocus_context *ice = (struct crocus_context *) ctx; @@ -3513,7 +3512,7 @@ crocus_set_constant_buffer(struct pipe_context *ctx, struct crocus_shader_state *shs = &ice->state.shaders[stage]; struct pipe_constant_buffer *cbuf = &shs->constbufs[index]; - util_copy_constant_buffer(&shs->constbufs[index], input, take_ownership); + util_copy_constant_buffer(&shs->constbufs[index], input); if (input && input->buffer_size && (input->buffer || input->user_buffer)) { shs->bound_cbufs |= 1u << index; @@ -3521,12 +3520,12 @@ crocus_set_constant_buffer(struct pipe_context *ctx, if (input->user_buffer) { void *map = NULL; pipe_resource_reference(&cbuf->buffer, NULL); - u_upload_alloc(ice->ctx.const_uploader, 0, input->buffer_size, 64, + u_upload_alloc_ref(ice->ctx.const_uploader, 0, input->buffer_size, 64, &cbuf->buffer_offset, &cbuf->buffer, (void **) &map); if (!cbuf->buffer) { /* Allocation was unsuccessful - just unbind */ - crocus_set_constant_buffer(ctx, p_stage, index, false, NULL); + crocus_set_constant_buffer(ctx, p_stage, index, NULL); return; } @@ -3566,7 +3565,7 @@ upload_sysvals(struct crocus_context *ice, uint32_t *map = NULL; assert(sysval_cbuf_index < PIPE_MAX_CONSTANT_BUFFERS); - u_upload_alloc(ice->ctx.const_uploader, 0, upload_size, 64, + u_upload_alloc_ref(ice->ctx.const_uploader, 0, upload_size, 64, &cbuf->buffer_offset, &cbuf->buffer, (void **) &map); for (int i = 0; i < shader->num_system_values; i++) { @@ -3693,7 +3692,7 @@ crocus_set_vertex_buffers(struct pipe_context *ctx, (GFX_VERx10 < 75 && screen->devinfo.platform != INTEL_PLATFORM_BYT) * 2; util_set_vertex_buffers_mask(ice->state.vertex_buffers, &ice->state.bound_vertex_buffers, - buffers, count, true); + buffers, count); for (unsigned i = 0; i < count; i++) { struct pipe_vertex_buffer *state = @@ -4056,7 +4055,7 @@ crocus_create_stream_output_target(struct pipe_context *ctx, #if GFX_VER >= 7 struct crocus_context *ice = (struct crocus_context *) ctx; void *temp; - u_upload_alloc(ice->ctx.stream_uploader, 0, sizeof(uint32_t), 4, + u_upload_alloc_ref(ice->ctx.stream_uploader, 0, sizeof(uint32_t), 4, &cso->offset_offset, (struct pipe_resource **)&cso->offset_res, &temp); @@ -4105,7 +4104,7 @@ crocus_stream_store_prims_written(struct crocus_batch *batch, struct crocus_stream_output_target *tgt) { if (!tgt->offset_res) { - u_upload_alloc(batch->ice->ctx.stream_uploader, 0, 4096, 4, + u_upload_alloc_ref(batch->ice->ctx.stream_uploader, 0, 4096, 4, &tgt->offset_offset, (struct pipe_resource **)&tgt->offset_res, &tgt->prim_map); @@ -7829,7 +7828,7 @@ crocus_upload_render_state(struct crocus_context *ice, if (draw->has_user_indices) { unsigned start_offset = draw->index_size * sc->start; - u_upload_data(ice->ctx.stream_uploader, 0, + u_upload_data_ref(ice->ctx.stream_uploader, 0, sc->count * draw->index_size, 4, (char *)draw->index.user + start_offset, &offset, &ice->state.index_buffer.res); @@ -9298,6 +9297,7 @@ genX(crocus_init_state)(struct crocus_context *ice) ctx->set_viewport_states = crocus_set_viewport_states; ctx->sampler_view_destroy = crocus_sampler_view_destroy; ctx->sampler_view_release = u_default_sampler_view_release; + ctx->resource_release = u_default_resource_release; ctx->surface_destroy = crocus_surface_destroy; ctx->draw_vbo = crocus_draw_vbo; ctx->launch_grid = crocus_launch_grid; diff --git a/src/gallium/drivers/d3d12/d3d12_compute_transforms.cpp b/src/gallium/drivers/d3d12/d3d12_compute_transforms.cpp index 7ce86dba08f..4eaad480f1b 100644 --- a/src/gallium/drivers/d3d12/d3d12_compute_transforms.cpp +++ b/src/gallium/drivers/d3d12/d3d12_compute_transforms.cpp @@ -505,7 +505,7 @@ d3d12_restore_compute_transform_state(struct d3d12_context *ctx, d3d12_compute_t ctx->base.bind_compute_state(&ctx->base, save->cs); - ctx->base.set_constant_buffer(&ctx->base, MESA_SHADER_COMPUTE, 1, true, &save->cbuf0); + ctx->base.set_constant_buffer(&ctx->base, MESA_SHADER_COMPUTE, 1, &save->cbuf0); ctx->base.set_shader_buffers(&ctx->base, MESA_SHADER_COMPUTE, 0, ARRAY_SIZE(save->ssbos), save->ssbos, (1u << ARRAY_SIZE(save->ssbos)) - 1); if (ctx->current_predication) diff --git a/src/gallium/drivers/d3d12/d3d12_context_graphics.cpp b/src/gallium/drivers/d3d12/d3d12_context_graphics.cpp index 64ee89f9383..ba6cc63eb1d 100644 --- a/src/gallium/drivers/d3d12/d3d12_context_graphics.cpp +++ b/src/gallium/drivers/d3d12/d3d12_context_graphics.cpp @@ -1264,7 +1264,7 @@ d3d12_set_vertex_buffers(struct pipe_context *pctx, 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, true); + util_set_vertex_buffers_count(ctx->vbs, &ctx->num_vbs, buffers, num_buffers); for (unsigned i = 0; i < ctx->num_vbs; ++i) { const struct pipe_vertex_buffer* buf = ctx->vbs + i; @@ -1367,7 +1367,6 @@ d3d12_increment_constant_buffer_bind_count(struct d3d12_context *ctx, static void d3d12_set_constant_buffer(struct pipe_context *pctx, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *buf) { struct d3d12_context *ctx = d3d12_context(pctx); @@ -1378,7 +1377,7 @@ d3d12_set_constant_buffer(struct pipe_context *pctx, if (buf) { unsigned offset = buf->buffer_offset; if (buf->user_buffer) { - u_upload_data(pctx->const_uploader, 0, buf->buffer_size, + u_upload_data_ref(pctx->const_uploader, 0, buf->buffer_size, D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT, buf->user_buffer, &offset, &ctx->cbufs[shader][index].buffer); d3d12_increment_constant_buffer_bind_count(ctx, shader, @@ -1388,12 +1387,7 @@ d3d12_set_constant_buffer(struct pipe_context *pctx, if (buffer) d3d12_increment_constant_buffer_bind_count(ctx, shader, d3d12_resource(buffer)); - if (take_ownership) { - pipe_resource_reference(&ctx->cbufs[shader][index].buffer, NULL); - ctx->cbufs[shader][index].buffer = buffer; - } else { - pipe_resource_reference(&ctx->cbufs[shader][index].buffer, buffer); - } + pipe_resource_reference(&ctx->cbufs[shader][index].buffer, buffer); } ctx->cbufs[shader][index].buffer_offset = offset; @@ -1922,7 +1916,7 @@ d3d12_disable_fake_so_buffers(struct d3d12_context *ctx) cbuf.buffer = fake_target->fill_buffer; cbuf.buffer_offset = fake_target->fill_buffer_offset; cbuf.buffer_size = fake_target->fill_buffer->width0 - cbuf.buffer_offset; - ctx->base.set_constant_buffer(&ctx->base, MESA_SHADER_COMPUTE, 1, false, &cbuf); + ctx->base.set_constant_buffer(&ctx->base, MESA_SHADER_COMPUTE, 1, &cbuf); grid.indirect = fake_target->fill_buffer; grid.indirect_offset = fake_target->fill_buffer_offset + 4; @@ -2277,6 +2271,7 @@ d3d12_init_graphics_context_functions(struct d3d12_context *ctx) ctx->base.create_sampler_view = d3d12_create_sampler_view; ctx->base.sampler_view_destroy = d3d12_destroy_sampler_view; ctx->base.sampler_view_release = u_default_sampler_view_release; + ctx->base.resource_release = u_default_resource_release; ctx->base.create_vertex_elements_state = d3d12_create_vertex_elements_state; ctx->base.bind_vertex_elements_state = d3d12_bind_vertex_elements_state; diff --git a/src/gallium/drivers/d3d12/d3d12_draw.cpp b/src/gallium/drivers/d3d12/d3d12_draw.cpp index 11fa9c66907..d9388c71ef1 100644 --- a/src/gallium/drivers/d3d12/d3d12_draw.cpp +++ b/src/gallium/drivers/d3d12/d3d12_draw.cpp @@ -795,7 +795,7 @@ update_draw_indirect_with_sysvals(struct d3d12_context *ctx, draw_count_cbuf.buffer_offset = indirect_in->indirect_draw_count_offset; draw_count_cbuf.buffer_size = 4; draw_count_cbuf.user_buffer = nullptr; - ctx->base.set_constant_buffer(&ctx->base, MESA_SHADER_COMPUTE, 1, false, &draw_count_cbuf); + ctx->base.set_constant_buffer(&ctx->base, MESA_SHADER_COMPUTE, 1, &draw_count_cbuf); } pipe_shader_buffer new_cs_ssbos[2]; diff --git a/src/gallium/drivers/etnaviv/etnaviv_state.c b/src/gallium/drivers/etnaviv/etnaviv_state.c index 40da56bd825..e16c22b76f3 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_state.c +++ b/src/gallium/drivers/etnaviv/etnaviv_state.c @@ -78,7 +78,7 @@ etna_set_sample_mask(struct pipe_context *pctx, unsigned sample_mask) static void etna_set_constant_buffer(struct pipe_context *pctx, - mesa_shader_stage shader, uint index, bool take_ownership, + mesa_shader_stage shader, uint index, const struct pipe_constant_buffer *cb) { struct etna_context *ctx = etna_context(pctx); @@ -86,7 +86,7 @@ etna_set_constant_buffer(struct pipe_context *pctx, assert(index < ETNA_MAX_CONST_BUF); - util_copy_constant_buffer(&so->cb[index], cb, take_ownership); + util_copy_constant_buffer(&so->cb[index], cb); /* Note that the gallium frontends can unbind constant buffers by * passing NULL here. */ @@ -99,7 +99,7 @@ etna_set_constant_buffer(struct pipe_context *pctx, if (!cb->buffer) { struct pipe_constant_buffer *cb = &so->cb[index]; - u_upload_data(pctx->const_uploader, 0, cb->buffer_size, 16, cb->user_buffer, &cb->buffer_offset, &cb->buffer); + u_upload_data_ref(pctx->const_uploader, 0, cb->buffer_size, 16, cb->user_buffer, &cb->buffer_offset, &cb->buffer); ctx->dirty |= ETNA_DIRTY_SHADER_CACHES; } @@ -518,8 +518,7 @@ etna_set_vertex_buffers(struct pipe_context *pctx, unsigned num_buffers, 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, - true); + util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb, num_buffers); so->count = util_last_bit(so->enabled_mask); if (!num_buffers) { diff --git a/src/gallium/drivers/etnaviv/etnaviv_texture_desc.c b/src/gallium/drivers/etnaviv/etnaviv_texture_desc.c index 26432ffa7da..bad85e52992 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_texture_desc.c +++ b/src/gallium/drivers/etnaviv/etnaviv_texture_desc.c @@ -388,6 +388,7 @@ etna_texture_desc_init(struct pipe_context *pctx) ctx->base.create_sampler_view = etna_create_sampler_view_desc; ctx->base.sampler_view_destroy = etna_sampler_view_desc_destroy; ctx->base.sampler_view_release = u_default_sampler_view_release; + ctx->base.resource_release = u_default_resource_release; ctx->emit_texture_state = etna_emit_texture_desc; ctx->ts_for_sampler_view = etna_ts_for_sampler_view_state; } diff --git a/src/gallium/drivers/etnaviv/etnaviv_texture_state.c b/src/gallium/drivers/etnaviv/etnaviv_texture_state.c index 90f2b803f33..a3dbbd65d6c 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_texture_state.c +++ b/src/gallium/drivers/etnaviv/etnaviv_texture_state.c @@ -617,6 +617,7 @@ etna_texture_state_init(struct pipe_context *pctx) ctx->base.create_sampler_view = etna_create_sampler_view_state; ctx->base.sampler_view_destroy = etna_sampler_view_state_destroy; ctx->base.sampler_view_release = u_default_sampler_view_release; + ctx->base.resource_release = u_default_resource_release; ctx->ts_for_sampler_view = etna_ts_for_sampler_view_state; STATIC_ASSERT(VIVS_TE_SAMPLER_LOD_ADDR__LEN == VIVS_NTE_SAMPLER_ADDR_LOD__LEN); diff --git a/src/gallium/drivers/freedreno/a3xx/fd3_emit.c b/src/gallium/drivers/freedreno/a3xx/fd3_emit.c index 56bfbf42035..55b0765da5a 100644 --- a/src/gallium/drivers/freedreno/a3xx/fd3_emit.c +++ b/src/gallium/drivers/freedreno/a3xx/fd3_emit.c @@ -235,7 +235,7 @@ emit_textures(struct fd_context *ctx, struct fd_ringbuffer *ring, unsigned off; void *ptr; - u_upload_alloc(fd3_ctx->border_color_uploader, 0, + u_upload_alloc_ref(fd3_ctx->border_color_uploader, 0, BORDER_COLOR_UPLOAD_SIZE, BORDER_COLOR_UPLOAD_SIZE, &off, &fd3_ctx->border_color_buf, &ptr); diff --git a/src/gallium/drivers/freedreno/a4xx/fd4_emit.c b/src/gallium/drivers/freedreno/a4xx/fd4_emit.c index e3d6186026d..007e6531e9f 100644 --- a/src/gallium/drivers/freedreno/a4xx/fd4_emit.c +++ b/src/gallium/drivers/freedreno/a4xx/fd4_emit.c @@ -333,7 +333,7 @@ emit_textures(struct fd_context *ctx, struct fd_ringbuffer *ring, unsigned off; void *ptr; - u_upload_alloc(fd4_ctx->border_color_uploader, 0, + u_upload_alloc_ref(fd4_ctx->border_color_uploader, 0, BORDER_COLOR_UPLOAD_SIZE, BORDER_COLOR_UPLOAD_SIZE, &off, &fd4_ctx->border_color_buf, &ptr); diff --git a/src/gallium/drivers/freedreno/a5xx/fd5_emit.c b/src/gallium/drivers/freedreno/a5xx/fd5_emit.c index 49729806d49..c3131e40902 100644 --- a/src/gallium/drivers/freedreno/a5xx/fd5_emit.c +++ b/src/gallium/drivers/freedreno/a5xx/fd5_emit.c @@ -294,7 +294,7 @@ emit_border_color(struct fd_context *ctx, struct fd_ringbuffer *ring) assert_dt const unsigned int alignment = util_next_power_of_two(FD5_BORDER_COLOR_UPLOAD_SIZE); - u_upload_alloc(fd5_ctx->border_color_uploader, 0, + u_upload_alloc_ref(fd5_ctx->border_color_uploader, 0, FD5_BORDER_COLOR_UPLOAD_SIZE, alignment, &off, &fd5_ctx->border_color_buf, &ptr); diff --git a/src/gallium/drivers/freedreno/a6xx/fd6_const.cc b/src/gallium/drivers/freedreno/a6xx/fd6_const.cc index 2c4614a9be6..4ae4efa3287 100644 --- a/src/gallium/drivers/freedreno/a6xx/fd6_const.cc +++ b/src/gallium/drivers/freedreno/a6xx/fd6_const.cc @@ -51,7 +51,7 @@ fd6_upload_emit_driver_ubo(struct fd_context *ctx, fd_cs &cs, unsigned buffer_offset; struct pipe_resource *buffer = NULL; - u_upload_data(pctx->const_uploader, 0, sizedwords * sizeof(uint32_t), + u_upload_data_ref(pctx->const_uploader, 0, sizedwords * sizeof(uint32_t), 16, dwords, &buffer_offset, &buffer); if (!buffer) return; /* nothing good will come of this.. */ @@ -490,7 +490,7 @@ fd6_emit_cs_driver_params(struct fd_context *ctx, fd_cs &cs, struct pipe_resource *buffer = NULL; unsigned buffer_offset; - u_upload_data(ctx->base.const_uploader, 0, sizeof(compute_params), + u_upload_data_ref(ctx->base.const_uploader, 0, sizeof(compute_params), 16, &compute_params, &buffer_offset, &buffer); if (info->indirect) { diff --git a/src/gallium/drivers/freedreno/freedreno_blitter.c b/src/gallium/drivers/freedreno/freedreno_blitter.c index 098f8ab964a..d6bb57045a3 100644 --- a/src/gallium/drivers/freedreno/freedreno_blitter.c +++ b/src/gallium/drivers/freedreno/freedreno_blitter.c @@ -292,7 +292,7 @@ fd_blitter_clear(struct pipe_context *pctx, unsigned buffers, .buffer_size = 16, .user_buffer = &color->ui, }; - pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 0, false, &cb); + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 0, &cb); unsigned rs_idx = pfb->samples > 1 ? 1 : 0; if (!ctx->clear_rs_state[rs_idx]) { diff --git a/src/gallium/drivers/freedreno/freedreno_state.c b/src/gallium/drivers/freedreno/freedreno_state.c index dd71de03c2a..23f982c03b2 100644 --- a/src/gallium/drivers/freedreno/freedreno_state.c +++ b/src/gallium/drivers/freedreno/freedreno_state.c @@ -110,7 +110,7 @@ fd_set_min_samples(struct pipe_context *pctx, unsigned min_samples) in_dt static void upload_user_buffer(struct pipe_context *pctx, struct pipe_constant_buffer *cb) { - u_upload_data(pctx->stream_uploader, 0, cb->buffer_size, 64, + u_upload_data_ref(pctx->stream_uploader, 0, cb->buffer_size, 64, cb->user_buffer, &cb->buffer_offset, &cb->buffer); cb->user_buffer = NULL; } @@ -125,13 +125,13 @@ upload_user_buffer(struct pipe_context *pctx, struct pipe_constant_buffer *cb) */ static void fd_set_constant_buffer(struct pipe_context *pctx, mesa_shader_stage shader, - uint index, bool take_ownership, + uint index, const struct pipe_constant_buffer *cb) in_dt { struct fd_context *ctx = fd_context(pctx); struct fd_constbuf_stateobj *so = &ctx->constbuf[shader]; - util_copy_constant_buffer(&so->cb[index], cb, take_ownership); + util_copy_constant_buffer(&so->cb[index], cb); /* Note that gallium frontends can unbind constant buffers by * passing a NULL cb, or a cb with no buffer: @@ -472,8 +472,7 @@ fd_set_vertex_buffers(struct pipe_context *pctx, unsigned count, } } - util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb, count, - true); + util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb, count); so->count = util_last_bit(so->enabled_mask); if (!vb) diff --git a/src/gallium/drivers/freedreno/freedreno_texture.c b/src/gallium/drivers/freedreno/freedreno_texture.c index 87ec5ba4944..307195ffd35 100644 --- a/src/gallium/drivers/freedreno/freedreno_texture.c +++ b/src/gallium/drivers/freedreno/freedreno_texture.c @@ -95,6 +95,7 @@ fd_texture_init(struct pipe_context *pctx) if (!pctx->sampler_view_destroy) pctx->sampler_view_destroy = fd_sampler_view_destroy; pctx->sampler_view_release = u_default_sampler_view_release; + pctx->resource_release = u_default_resource_release; } /* helper for setting up border-color buffer for a3xx/a4xx: */ diff --git a/src/gallium/drivers/freedreno/ir3/ir3_const.h b/src/gallium/drivers/freedreno/ir3/ir3_const.h index 90d7115b812..c310c2c907d 100644 --- a/src/gallium/drivers/freedreno/ir3/ir3_const.h +++ b/src/gallium/drivers/freedreno/ir3/ir3_const.h @@ -220,7 +220,7 @@ ir3_emit_ubos(struct fd_context *ctx, const struct ir3_shader_variant *v, */ if (cb->user_buffer) { struct pipe_context *pctx = &ctx->base; - u_upload_data(pctx->stream_uploader, 0, cb->buffer_size, 64, + u_upload_data_ref(pctx->stream_uploader, 0, cb->buffer_size, 64, cb->user_buffer, &cb->buffer_offset, &cb->buffer); cb->user_buffer = NULL; } @@ -640,7 +640,7 @@ ir3_emit_cs_driver_params(const struct ir3_shader_variant *v, struct pipe_resource *buffer = NULL; unsigned buffer_offset; - u_upload_data(ctx->base.const_uploader, 0, sizeof(compute_params), + u_upload_data_ref(ctx->base.const_uploader, 0, sizeof(compute_params), 16, &compute_params, &buffer_offset, &buffer); /* Copy the indirect params into the driver param buffer. The layout diff --git a/src/gallium/drivers/i915/i915_state.c b/src/gallium/drivers/i915/i915_state.c index 3d51f885cad..8d786c02e41 100644 --- a/src/gallium/drivers/i915/i915_state.c +++ b/src/gallium/drivers/i915/i915_state.c @@ -719,7 +719,6 @@ i915_delete_vs_state(struct pipe_context *pipe, void *shader) static void i915_set_constant_buffer(struct pipe_context *pipe, mesa_shader_stage shader, uint32_t index, - bool take_ownership, const struct pipe_constant_buffer *cb) { struct i915_context *i915 = i915_context(pipe); @@ -761,12 +760,7 @@ i915_set_constant_buffer(struct pipe_context *pipe, diff = i915->current.num_user_constants[shader] != 0; } - if (take_ownership) { - pipe_resource_reference(&i915->constants[shader], NULL); - i915->constants[shader] = buf; - } else { - pipe_resource_reference(&i915->constants[shader], buf); - } + pipe_resource_reference(&i915->constants[shader], buf); i915->current.num_user_constants[shader] = new_num; if (diff) @@ -1057,8 +1051,7 @@ i915_set_vertex_buffers(struct pipe_context *pipe, unsigned count, assert(count <= PIPE_MAX_ATTRIBS); util_set_vertex_buffers_count(draw->pt.vertex_buffer, - &draw->pt.nr_vertex_buffers, buffers, count, - true); + &draw->pt.nr_vertex_buffers, buffers, count); } static void * @@ -1148,6 +1141,7 @@ i915_init_state_functions(struct i915_context *i915) i915->base.create_sampler_view = i915_create_sampler_view; i915->base.sampler_view_destroy = i915_sampler_view_destroy; i915->base.sampler_view_release = u_default_sampler_view_release; + i915->base.resource_release = u_default_resource_release; i915->base.set_viewport_states = i915_set_viewport_states; i915->base.set_vertex_buffers = i915_set_vertex_buffers; } diff --git a/src/gallium/drivers/iris/iris_blorp.c b/src/gallium/drivers/iris/iris_blorp.c index a3b22dfaf33..73764281994 100644 --- a/src/gallium/drivers/iris/iris_blorp.c +++ b/src/gallium/drivers/iris/iris_blorp.c @@ -63,7 +63,7 @@ stream_state(struct iris_batch *batch, struct pipe_resource *res = NULL; void *ptr = NULL; - u_upload_alloc(uploader, 0, size, alignment, out_offset, &res, &ptr); + u_upload_alloc_ref(uploader, 0, size, alignment, out_offset, &res, &ptr); struct iris_bo *bo = iris_resource_bo(res); iris_use_pinned_bo(batch, bo, false, IRIS_DOMAIN_NONE); diff --git a/src/gallium/drivers/iris/iris_draw.c b/src/gallium/drivers/iris/iris_draw.c index 97f08f254e3..0b586c0236f 100644 --- a/src/gallium/drivers/iris/iris_draw.c +++ b/src/gallium/drivers/iris/iris_draw.c @@ -146,7 +146,7 @@ iris_update_draw_parameters(struct iris_context *ice, ice->draw.params.baseinstance = info->start_instance; ice->draw.params_valid = true; - u_upload_data(ice->ctx.const_uploader, 0, + u_upload_data_ref(ice->ctx.const_uploader, 0, sizeof(ice->draw.params), 4, &ice->draw.params, &draw_params->offset, &draw_params->res); } @@ -164,7 +164,7 @@ iris_update_draw_parameters(struct iris_context *ice, ice->draw.derived_params.drawid = drawid_offset; ice->draw.derived_params.is_indexed_draw = is_indexed_draw; - u_upload_data(ice->ctx.const_uploader, 0, + u_upload_data_ref(ice->ctx.const_uploader, 0, sizeof(ice->draw.derived_params), 4, &ice->draw.derived_params, &derived_params->offset, &derived_params->res); @@ -376,7 +376,7 @@ iris_update_grid_size_resource(struct iris_context *ice, grid_updated = true; } else if (memcmp(ice->state.last_grid, grid->grid, sizeof(grid->grid)) != 0) { memcpy(ice->state.last_grid, grid->grid, sizeof(grid->grid)); - u_upload_data(ice->state.dynamic_uploader, 0, sizeof(grid->grid), 4, + u_upload_data_ref(ice->state.dynamic_uploader, 0, sizeof(grid->grid), 4, grid->grid, &grid_ref->offset, &grid_ref->res); grid_updated = true; } @@ -392,7 +392,7 @@ iris_update_grid_size_resource(struct iris_context *ice, struct iris_bo *grid_bo = iris_resource_bo(grid_ref->res); void *surf_map = NULL; - u_upload_alloc(ice->state.surface_uploader, 0, isl_dev->ss.size, + u_upload_alloc_ref(ice->state.surface_uploader, 0, isl_dev->ss.size, isl_dev->ss.align, &state_ref->offset, &state_ref->res, &surf_map); state_ref->offset += diff --git a/src/gallium/drivers/iris/iris_fine_fence.c b/src/gallium/drivers/iris/iris_fine_fence.c index bdeffdd2053..9e9e954a4ed 100644 --- a/src/gallium/drivers/iris/iris_fine_fence.c +++ b/src/gallium/drivers/iris/iris_fine_fence.c @@ -5,7 +5,7 @@ static void iris_fine_fence_reset(struct iris_batch *batch) { - u_upload_alloc(batch->fine_fences.uploader, + u_upload_alloc_ref(batch->fine_fences.uploader, 0, sizeof(uint64_t), sizeof(uint64_t), &batch->fine_fences.ref.offset, &batch->fine_fences.ref.res, (void **)&batch->fine_fences.map); diff --git a/src/gallium/drivers/iris/iris_indirect_gen.c b/src/gallium/drivers/iris/iris_indirect_gen.c index e05339e2cec..9fe2d1c775b 100644 --- a/src/gallium/drivers/iris/iris_indirect_gen.c +++ b/src/gallium/drivers/iris/iris_indirect_gen.c @@ -116,7 +116,7 @@ upload_state(struct iris_batch *batch, unsigned alignment) { void *p = NULL; - u_upload_alloc(uploader, 0, size, alignment, &ref->offset, &ref->res, &p); + u_upload_alloc_ref(uploader, 0, size, alignment, &ref->offset, &ref->res, &p); iris_use_pinned_bo(batch, iris_resource_bo(ref->res), false, IRIS_DOMAIN_NONE); return p; } @@ -131,7 +131,7 @@ stream_state(struct iris_batch *batch, { void *ptr = NULL; - u_upload_alloc(uploader, 0, size, alignment, out_offset, out_res, &ptr); + u_upload_alloc_ref(uploader, 0, size, alignment, out_offset, out_res, &ptr); struct iris_bo *bo = iris_resource_bo(*out_res); iris_use_pinned_bo(batch, bo, false, IRIS_DOMAIN_NONE); diff --git a/src/gallium/drivers/iris/iris_program.c b/src/gallium/drivers/iris/iris_program.c index 3822c56fd9f..27e765f80f3 100644 --- a/src/gallium/drivers/iris/iris_program.c +++ b/src/gallium/drivers/iris/iris_program.c @@ -696,7 +696,7 @@ upload_state(struct u_upload_mgr *uploader, unsigned alignment) { void *p = NULL; - u_upload_alloc(uploader, 0, size, alignment, &ref->offset, &ref->res, &p); + u_upload_alloc_ref(uploader, 0, size, alignment, &ref->offset, &ref->res, &p); return p; } diff --git a/src/gallium/drivers/iris/iris_program_cache.c b/src/gallium/drivers/iris/iris_program_cache.c index 451368e7e40..1007ea9dd6a 100644 --- a/src/gallium/drivers/iris/iris_program_cache.c +++ b/src/gallium/drivers/iris/iris_program_cache.c @@ -165,7 +165,7 @@ iris_upload_shader(struct iris_screen *screen, { const struct intel_device_info *devinfo = screen->devinfo; - u_upload_alloc(uploader, 0, shader->program_size, 64, + u_upload_alloc_ref(uploader, 0, shader->program_size, 64, &shader->assembly.offset, &shader->assembly.res, &shader->map); memcpy(shader->map, assembly, shader->program_size); diff --git a/src/gallium/drivers/iris/iris_query.c b/src/gallium/drivers/iris/iris_query.c index 29a5161cbb3..6810342c14f 100644 --- a/src/gallium/drivers/iris/iris_query.c +++ b/src/gallium/drivers/iris/iris_query.c @@ -518,7 +518,7 @@ iris_begin_query(struct pipe_context *ctx, struct pipe_query *query) else size = sizeof(struct iris_query_snapshots); - u_upload_alloc(ice->query_buffer_uploader, 0, + u_upload_alloc_ref(ice->query_buffer_uploader, 0, size, util_next_power_of_two(size), &q->query_state_ref.offset, &q->query_state_ref.res, &ptr); diff --git a/src/gallium/drivers/iris/iris_state.c b/src/gallium/drivers/iris/iris_state.c index 137fcd99073..92885754499 100644 --- a/src/gallium/drivers/iris/iris_state.c +++ b/src/gallium/drivers/iris/iris_state.c @@ -326,7 +326,7 @@ upload_state(struct u_upload_mgr *uploader, unsigned alignment) { void *p = NULL; - u_upload_alloc(uploader, 0, size, alignment, &ref->offset, &ref->res, &p); + u_upload_alloc_ref(uploader, 0, size, alignment, &ref->offset, &ref->res, &p); return p; } @@ -347,7 +347,7 @@ stream_state(struct iris_batch *batch, { void *ptr = NULL; - u_upload_alloc(uploader, 0, size, alignment, out_offset, out_res, &ptr); + u_upload_alloc_ref(uploader, 0, size, alignment, out_offset, out_res, &ptr); struct iris_bo *bo = iris_resource_bo(*out_res); iris_use_pinned_bo(batch, bo, false, IRIS_DOMAIN_NONE); @@ -3963,7 +3963,6 @@ iris_set_framebuffer_state(struct pipe_context *ctx, static void iris_set_constant_buffer(struct pipe_context *ctx, mesa_shader_stage stage, unsigned index, - bool take_ownership, const struct pipe_constant_buffer *input) { struct iris_context *ice = (struct iris_context *) ctx; @@ -3979,12 +3978,12 @@ iris_set_constant_buffer(struct pipe_context *ctx, if (input->user_buffer) { void *map = NULL; pipe_resource_reference(&cbuf->buffer, NULL); - u_upload_alloc(ice->ctx.const_uploader, 0, input->buffer_size, 64, + u_upload_alloc_ref(ice->ctx.const_uploader, 0, input->buffer_size, 64, &cbuf->buffer_offset, &cbuf->buffer, (void **) &map); if (!cbuf->buffer) { /* Allocation was unsuccessful - just unbind */ - iris_set_constant_buffer(ctx, stage, index, false, NULL); + iris_set_constant_buffer(ctx, stage, index, NULL); return; } @@ -3997,12 +3996,7 @@ iris_set_constant_buffer(struct pipe_context *ctx, shs->dirty_cbufs |= 1u << index; } - if (take_ownership) { - pipe_resource_reference(&cbuf->buffer, NULL); - cbuf->buffer = input->buffer; - } else { - pipe_resource_reference(&cbuf->buffer, input->buffer); - } + pipe_resource_reference(&cbuf->buffer, input->buffer); cbuf->buffer_offset = input->buffer_offset; } @@ -4042,7 +4036,7 @@ upload_sysvals(struct iris_context *ice, void *map = NULL; assert(sysval_cbuf_index < PIPE_MAX_CONSTANT_BUFFERS); - u_upload_alloc(ice->ctx.const_uploader, 0, upload_size, 64, + u_upload_alloc_ref(ice->ctx.const_uploader, 0, upload_size, 64, &cbuf->buffer_offset, &cbuf->buffer, &map); uint32_t *sysval_map = map; @@ -4209,8 +4203,7 @@ iris_set_vertex_buffers(struct pipe_context *ctx, state->resource != buffer->buffer.resource) ice->state.dirty |= IRIS_DIRTY_VERTEX_BUFFER_FLUSHES; - pipe_resource_reference(&state->resource, NULL); - state->resource = buffer->buffer.resource; + pipe_resource_reference(&state->resource, buffer->buffer.resource); struct iris_resource *res = (void *) state->resource; @@ -8492,7 +8485,7 @@ iris_emit_index_buffer(struct iris_context *ice, if (draw->has_user_indices) { unsigned start_offset = draw->index_size * sc->start; - u_upload_data(ice->ctx.const_uploader, start_offset, + u_upload_data_ref(ice->ctx.const_uploader, start_offset, sc->count * draw->index_size, 4, (char*)draw->index.user + start_offset, &offset, &ice->state.last_res.index_buffer); @@ -10671,6 +10664,7 @@ genX(init_state)(struct iris_context *ice) ctx->set_viewport_states = iris_set_viewport_states; ctx->sampler_view_destroy = iris_sampler_view_destroy; ctx->sampler_view_release = u_default_sampler_view_release; + ctx->resource_release = u_default_resource_release; ctx->surface_destroy = iris_surface_destroy; ctx->draw_vbo = iris_draw_vbo; ctx->launch_grid = iris_launch_grid; diff --git a/src/gallium/drivers/lima/lima_context.c b/src/gallium/drivers/lima/lima_context.c index ad966bd90ec..7ee961e2674 100644 --- a/src/gallium/drivers/lima/lima_context.c +++ b/src/gallium/drivers/lima/lima_context.c @@ -76,7 +76,7 @@ lima_ctx_buff_alloc(struct lima_context *ctx, enum lima_ctx_buff buff, cbs->size = align(size, 0x40); - u_upload_alloc(ctx->uploader, 0, cbs->size, 0x40, &cbs->offset, + u_upload_alloc_ref(ctx->uploader, 0, cbs->size, 0x40, &cbs->offset, &cbs->res, &ret); return ret; diff --git a/src/gallium/drivers/lima/lima_job.c b/src/gallium/drivers/lima/lima_job.c index fc72bbbdb3b..da2d4f125ad 100644 --- a/src/gallium/drivers/lima/lima_job.c +++ b/src/gallium/drivers/lima/lima_job.c @@ -310,7 +310,7 @@ lima_job_create_stream_bo(struct lima_job *job, int pipe, void *cpu; unsigned offset; struct pipe_resource *pres = NULL; - u_upload_alloc(ctx->uploader, 0, size, 0x40, &offset, &pres, &cpu); + u_upload_alloc_ref(ctx->uploader, 0, size, 0x40, &offset, &pres, &cpu); struct lima_resource *res = lima_resource(pres); *va = res->bo->va + offset; diff --git a/src/gallium/drivers/lima/lima_state.c b/src/gallium/drivers/lima/lima_state.c index 2283472761f..9936557db07 100644 --- a/src/gallium/drivers/lima/lima_state.c +++ b/src/gallium/drivers/lima/lima_state.c @@ -193,7 +193,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, true); + vb, count); so->count = util_last_bit(so->enabled_mask); ctx->dirty |= LIMA_CONTEXT_DIRTY_VERTEX_BUFF; @@ -264,7 +264,6 @@ lima_set_stencil_ref(struct pipe_context *pctx, static void lima_set_constant_buffer(struct pipe_context *pctx, mesa_shader_stage shader, uint index, - bool pass_reference, const struct pipe_constant_buffer *cb) { struct lima_context *ctx = lima_context(pctx); @@ -441,6 +440,7 @@ lima_state_init(struct lima_context *ctx) ctx->base.create_sampler_view = lima_create_sampler_view; ctx->base.sampler_view_destroy = lima_sampler_view_destroy; ctx->base.sampler_view_release = u_default_sampler_view_release; + ctx->base.resource_release = u_default_resource_release; ctx->base.set_sampler_views = lima_set_sampler_views; ctx->base.set_sample_mask = lima_set_sample_mask; @@ -452,5 +452,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, false); + 0); } diff --git a/src/gallium/drivers/llvmpipe/lp_setup.c b/src/gallium/drivers/llvmpipe/lp_setup.c index 87842a64605..9052aa455b7 100644 --- a/src/gallium/drivers/llvmpipe/lp_setup.c +++ b/src/gallium/drivers/llvmpipe/lp_setup.c @@ -639,10 +639,10 @@ lp_setup_set_fs_constants(struct lp_setup_context *setup, unsigned i; for (i = 0; i < num; ++i) { util_copy_constant_buffer(&setup->constants[i].current, - &buffers[i], false); + &buffers[i]); } for (; i < ARRAY_SIZE(setup->constants); i++) { - util_copy_constant_buffer(&setup->constants[i].current, NULL, false); + util_copy_constant_buffer(&setup->constants[i].current, NULL); } setup->dirty |= LP_SETUP_NEW_CONSTANTS; } diff --git a/src/gallium/drivers/llvmpipe/lp_state_cs.c b/src/gallium/drivers/llvmpipe/lp_state_cs.c index cbe32d7622f..916cf362c2e 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_cs.c +++ b/src/gallium/drivers/llvmpipe/lp_state_cs.c @@ -1545,10 +1545,10 @@ lp_csctx_set_cs_constants(struct lp_cs_context *csctx, assert(num <= ARRAY_SIZE(csctx->constants)); for (i = 0; i < num; ++i) { - util_copy_constant_buffer(&csctx->constants[i].current, &buffers[i], false); + util_copy_constant_buffer(&csctx->constants[i].current, &buffers[i]); } for (; i < ARRAY_SIZE(csctx->constants); i++) { - util_copy_constant_buffer(&csctx->constants[i].current, NULL, false); + util_copy_constant_buffer(&csctx->constants[i].current, NULL); } } diff --git a/src/gallium/drivers/llvmpipe/lp_state_fs.c b/src/gallium/drivers/llvmpipe/lp_state_fs.c index 1328d112cb8..c3dba775369 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_fs.c +++ b/src/gallium/drivers/llvmpipe/lp_state_fs.c @@ -4229,7 +4229,6 @@ llvmpipe_delete_fs_state(struct pipe_context *pipe, void *fs) static void llvmpipe_set_constant_buffer(struct pipe_context *pipe, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *cb) { struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe); @@ -4239,15 +4238,14 @@ llvmpipe_set_constant_buffer(struct pipe_context *pipe, assert(index < ARRAY_SIZE(llvmpipe->constants[shader])); /* note: reference counting */ - util_copy_constant_buffer(&llvmpipe->constants[shader][index], cb, - take_ownership); + util_copy_constant_buffer(&llvmpipe->constants[shader][index], cb); /* user_buffer is only valid until the next set_constant_buffer (at most, * possibly until shader deletion), so we need to upload it now to make * sure it doesn't get updated/freed out from under us. */ if (constants->user_buffer) { - u_upload_data(llvmpipe->pipe.const_uploader, 0, constants->buffer_size, + u_upload_data_ref(llvmpipe->pipe.const_uploader, 0, constants->buffer_size, 16, constants->user_buffer, &constants->buffer_offset, &constants->buffer); } diff --git a/src/gallium/drivers/llvmpipe/lp_state_sampler.c b/src/gallium/drivers/llvmpipe/lp_state_sampler.c index 3a86223a676..8c7be29b2f1 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_sampler.c +++ b/src/gallium/drivers/llvmpipe/lp_state_sampler.c @@ -622,5 +622,6 @@ llvmpipe_init_sampler_funcs(struct llvmpipe_context *llvmpipe) llvmpipe->pipe.set_sampler_views = llvmpipe_set_sampler_views; llvmpipe->pipe.sampler_view_destroy = llvmpipe_sampler_view_destroy; llvmpipe->pipe.sampler_view_release = u_default_sampler_view_release; + llvmpipe->pipe.resource_release = u_default_resource_release; llvmpipe->pipe.delete_sampler_state = llvmpipe_delete_sampler_state; } diff --git a/src/gallium/drivers/llvmpipe/lp_state_vertex.c b/src/gallium/drivers/llvmpipe/lp_state_vertex.c index dba5311aa40..119aec090c0 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_vertex.c +++ b/src/gallium/drivers/llvmpipe/lp_state_vertex.c @@ -89,7 +89,7 @@ llvmpipe_set_vertex_buffers(struct pipe_context *pipe, util_set_vertex_buffers_count(llvmpipe->vertex_buffer, &llvmpipe->num_vertex_buffers, - buffers, count, true); + buffers, count); llvmpipe->dirty |= LP_NEW_VERTEX; diff --git a/src/gallium/drivers/nouveau/nv30/nv30_state.c b/src/gallium/drivers/nouveau/nv30/nv30_state.c index 50318a94ce7..5db7436a5b1 100644 --- a/src/gallium/drivers/nouveau/nv30/nv30_state.c +++ b/src/gallium/drivers/nouveau/nv30/nv30_state.c @@ -328,7 +328,6 @@ nv30_set_sample_mask(struct pipe_context *pipe, unsigned sample_mask) static void nv30_set_constant_buffer(struct pipe_context *pipe, mesa_shader_stage shader, uint index, - bool pass_reference, const struct pipe_constant_buffer *cb) { struct nv30_context *nv30 = nv30_context(pipe); @@ -346,22 +345,12 @@ nv30_set_constant_buffer(struct pipe_context *pipe, size = buf->width0 / (4 * sizeof(float)); if (shader == MESA_SHADER_VERTEX) { - if (pass_reference) { - pipe_resource_reference(&nv30->vertprog.constbuf, NULL); - nv30->vertprog.constbuf = buf; - } else { - pipe_resource_reference(&nv30->vertprog.constbuf, buf); - } + pipe_resource_reference(&nv30->vertprog.constbuf, buf); nv30->vertprog.constbuf_nr = size; nv30->dirty |= NV30_NEW_VERTCONST; } else if (shader == MESA_SHADER_FRAGMENT) { - if (pass_reference) { - pipe_resource_reference(&nv30->fragprog.constbuf, NULL); - nv30->fragprog.constbuf = buf; - } else { - pipe_resource_reference(&nv30->fragprog.constbuf, buf); - } + pipe_resource_reference(&nv30->fragprog.constbuf, buf); nv30->fragprog.constbuf_nr = size; nv30->dirty |= NV30_NEW_FRAGCONST; } @@ -446,7 +435,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, true); + vb, count); nv30->dirty |= NV30_NEW_ARRAYS; } diff --git a/src/gallium/drivers/nouveau/nv30/nv30_texture.c b/src/gallium/drivers/nouveau/nv30/nv30_texture.c index c4e26065904..92dcd8d5a0a 100644 --- a/src/gallium/drivers/nouveau/nv30/nv30_texture.c +++ b/src/gallium/drivers/nouveau/nv30/nv30_texture.c @@ -325,4 +325,5 @@ nv30_texture_init(struct pipe_context *pipe) pipe->create_sampler_view = nv30_sampler_view_create; pipe->sampler_view_destroy = nv30_sampler_view_destroy; pipe->sampler_view_release = u_default_sampler_view_release; + pipe->resource_release = u_default_resource_release; } diff --git a/src/gallium/drivers/nouveau/nv50/nv50_state.c b/src/gallium/drivers/nouveau/nv50/nv50_state.c index 17e01d8044d..16bf48a1d1c 100644 --- a/src/gallium/drivers/nouveau/nv50/nv50_state.c +++ b/src/gallium/drivers/nouveau/nv50/nv50_state.c @@ -885,7 +885,6 @@ nv50_get_compute_state_info(struct pipe_context *pipe, void *hwcso, static void nv50_set_constant_buffer(struct pipe_context *pipe, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *cb) { struct nv50_context *nv50 = nv50_context(pipe); @@ -915,12 +914,7 @@ nv50_set_constant_buffer(struct pipe_context *pipe, if (nv50->constbuf[s][i].u.buf) nv04_resource(nv50->constbuf[s][i].u.buf)->cb_bindings[s] &= ~(1 << i); - if (take_ownership) { - pipe_resource_reference(&nv50->constbuf[s][i].u.buf, NULL); - nv50->constbuf[s][i].u.buf = res; - } else { - pipe_resource_reference(&nv50->constbuf[s][i].u.buf, res); - } + pipe_resource_reference(&nv50->constbuf[s][i].u.buf, res); nv50->constbuf[s][i].user = (cb && cb->user_buffer) ? true : false; if (nv50->constbuf[s][i].user) { @@ -1089,7 +1083,7 @@ nv50_set_vertex_buffers(struct pipe_context *pipe, unsigned last_count = nv50->num_vtxbufs; util_set_vertex_buffers_count(nv50->vtxbuf, &nv50->num_vtxbufs, vb, - count, true); + count); unsigned clear_mask = last_count > count ? BITFIELD_RANGE(count, last_count - count) : 0; @@ -1475,6 +1469,7 @@ nv50_init_state_functions(struct nv50_context *nv50) pipe->create_sampler_view = nv50_create_sampler_view; pipe->sampler_view_destroy = nv50_sampler_view_destroy; pipe->sampler_view_release = u_default_sampler_view_release; + pipe->resource_release = u_default_resource_release; pipe->set_sampler_views = nv50_set_sampler_views; pipe->create_vs_state = nv50_vp_state_create; diff --git a/src/gallium/drivers/nouveau/nvc0/nvc0_state.c b/src/gallium/drivers/nouveau/nvc0/nvc0_state.c index b235b8a908d..f6a86b96553 100644 --- a/src/gallium/drivers/nouveau/nvc0/nvc0_state.c +++ b/src/gallium/drivers/nouveau/nvc0/nvc0_state.c @@ -789,7 +789,6 @@ nvc0_get_compute_state_info(struct pipe_context *pipe, void *hwcso, static void nvc0_set_constant_buffer(struct pipe_context *pipe, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *cb) { struct nvc0_context *nvc0 = nvc0_context(pipe); @@ -819,12 +818,7 @@ nvc0_set_constant_buffer(struct pipe_context *pipe, if (nvc0->constbuf[s][i].u.buf) nv04_resource(nvc0->constbuf[s][i].u.buf)->cb_bindings[s] &= ~(1 << i); - if (take_ownership) { - pipe_resource_reference(&nvc0->constbuf[s][i].u.buf, NULL); - nvc0->constbuf[s][i].u.buf = res; - } else { - pipe_resource_reference(&nvc0->constbuf[s][i].u.buf, res); - } + pipe_resource_reference(&nvc0->constbuf[s][i].u.buf, res); nvc0->constbuf[s][i].user = (cb && cb->user_buffer) ? true : false; if (nvc0->constbuf[s][i].user) { @@ -1030,7 +1024,7 @@ nvc0_set_vertex_buffers(struct pipe_context *pipe, unsigned last_count = nvc0->num_vtxbufs; util_set_vertex_buffers_count(nvc0->vtxbuf, &nvc0->num_vtxbufs, vb, - count, true); + count); unsigned clear_mask = last_count > count ? BITFIELD_RANGE(count, last_count - count) : 0; @@ -1432,6 +1426,7 @@ nvc0_init_state_functions(struct nvc0_context *nvc0) pipe->create_sampler_view = nvc0_create_sampler_view; pipe->sampler_view_destroy = nvc0_sampler_view_destroy; pipe->sampler_view_release = u_default_sampler_view_release; + pipe->resource_release = u_default_resource_release; pipe->set_sampler_views = nvc0_set_sampler_views; pipe->create_vs_state = nvc0_vp_state_create; diff --git a/src/gallium/drivers/panfrost/pan_cmdstream.c b/src/gallium/drivers/panfrost/pan_cmdstream.c index 96f9722e75a..db49219aa11 100644 --- a/src/gallium/drivers/panfrost/pan_cmdstream.c +++ b/src/gallium/drivers/panfrost/pan_cmdstream.c @@ -3585,15 +3585,15 @@ panfrost_launch_afbc_conv_shader(struct panfrost_batch *batch, void *cso, struct panfrost_constant_buffer *pbuf = &batch->ctx->constant_buffer[MESA_SHADER_COMPUTE]; saved_cso = batch->ctx->uncompiled[MESA_SHADER_COMPUTE]; - util_copy_constant_buffer(&pbuf->cb[0], &saved_const, true); + util_copy_constant_buffer(&pbuf->cb[0], &saved_const); pctx->bind_compute_state(pctx, cso); - pctx->set_constant_buffer(pctx, MESA_SHADER_COMPUTE, 0, false, cbuf); + pctx->set_constant_buffer(pctx, MESA_SHADER_COMPUTE, 0, cbuf); panfrost_launch_grid_on_batch(pctx, batch, &grid); pctx->bind_compute_state(pctx, saved_cso); - pctx->set_constant_buffer(pctx, MESA_SHADER_COMPUTE, 0, true, &saved_const); + pctx->set_constant_buffer(pctx, MESA_SHADER_COMPUTE, 0, &saved_const); } #define LAUNCH_AFBC_CONV_SHADER(name, batch, rsrc, consts, nr_blocks) \ @@ -3792,15 +3792,15 @@ panfrost_mtk_detile_compute(struct panfrost_context *ctx, struct pipe_blit_info &batch->ctx->constant_buffer[MESA_SHADER_COMPUTE]; void *saved_cso = batch->ctx->uncompiled[MESA_SHADER_COMPUTE]; void *cso = shader->mtk_tiled.detile_cso; - util_copy_constant_buffer(&pbuf->cb[0], &saved_const, true); + util_copy_constant_buffer(&pbuf->cb[0], &saved_const); pipe->bind_compute_state(pipe, cso); - pipe->set_constant_buffer(pipe, MESA_SHADER_COMPUTE, 0, false, &cbuf); + pipe->set_constant_buffer(pipe, MESA_SHADER_COMPUTE, 0, &cbuf); panfrost_launch_grid_on_batch(pipe, batch, &grid_info); pipe->bind_compute_state(pipe, saved_cso); - pipe->set_constant_buffer(pipe, MESA_SHADER_COMPUTE, 0, true, &saved_const); + pipe->set_constant_buffer(pipe, MESA_SHADER_COMPUTE, 0, &saved_const); panfrost_resource_restore_format(pan_resource(y_src), &y_src_save); panfrost_resource_restore_format(pan_resource(uv_src), &uv_src_save); @@ -4327,6 +4327,7 @@ context_populate_vtbl(struct pipe_context *pipe) pipe->create_sampler_view = panfrost_create_sampler_view; pipe->sampler_view_destroy = panfrost_sampler_view_destroy; pipe->sampler_view_release = u_default_sampler_view_release; + pipe->resource_release = u_default_resource_release; pipe->create_sampler_state = panfrost_create_sampler_state; pipe->create_blend_state = panfrost_create_blend_state; diff --git a/src/gallium/drivers/panfrost/pan_context.c b/src/gallium/drivers/panfrost/pan_context.c index ece422a7c3d..e9d472db759 100644 --- a/src/gallium/drivers/panfrost/pan_context.c +++ b/src/gallium/drivers/panfrost/pan_context.c @@ -338,7 +338,7 @@ panfrost_set_vertex_buffers(struct pipe_context *pctx, unsigned num_buffers, struct panfrost_context *ctx = pan_context(pctx); util_set_vertex_buffers_mask(ctx->vertex_buffers, &ctx->vb_mask, buffers, - num_buffers, true); + num_buffers); ctx->dirty |= PAN_DIRTY_VERTEX; } @@ -346,13 +346,12 @@ panfrost_set_vertex_buffers(struct pipe_context *pctx, unsigned num_buffers, static void panfrost_set_constant_buffer(struct pipe_context *pctx, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *buf) { struct panfrost_context *ctx = pan_context(pctx); struct panfrost_constant_buffer *pbuf = &ctx->constant_buffer[shader]; - util_copy_constant_buffer(&pbuf->cb[index], buf, take_ownership); + util_copy_constant_buffer(&pbuf->cb[index], buf); unsigned mask = (1 << index); diff --git a/src/gallium/drivers/r300/r300_render.c b/src/gallium/drivers/r300/r300_render.c index c5e6d984730..f835ca01a1a 100644 --- a/src/gallium/drivers/r300/r300_render.c +++ b/src/gallium/drivers/r300/r300_render.c @@ -1050,7 +1050,7 @@ static void r300_render_draw_elements(struct vbuf_render* render, CS_LOCALS(r300); DBG(r300, DBG_DRAW, "r300: render_draw_elements (count: %d)\n", count); - u_upload_data(r300->uploader, 0, count * 2, 4, indices, + u_upload_data_ref(r300->uploader, 0, count * 2, 4, indices, &index_buffer_offset, &index_buffer); if (!index_buffer) { return; diff --git a/src/gallium/drivers/r300/r300_render_translate.c b/src/gallium/drivers/r300/r300_render_translate.c index b579960c49a..cea5200cab3 100644 --- a/src/gallium/drivers/r300/r300_render_translate.c +++ b/src/gallium/drivers/r300/r300_render_translate.c @@ -21,7 +21,7 @@ void r300_translate_index_buffer(struct r300_context *r300, switch (*index_size) { case 1: *out_buffer = NULL; - u_upload_alloc(r300->uploader, 0, count * 2, 4, + u_upload_alloc_ref(r300->uploader, 0, count * 2, 4, &out_offset, out_buffer, ptr); util_shorten_ubyte_elts_to_userptr( @@ -35,7 +35,7 @@ void r300_translate_index_buffer(struct r300_context *r300, case 2: if (index_offset) { *out_buffer = NULL; - u_upload_alloc(r300->uploader, 0, count * 2, 4, + u_upload_alloc_ref(r300->uploader, 0, count * 2, 4, &out_offset, out_buffer, ptr); util_rebuild_ushort_elts_to_userptr(&r300->context, info, @@ -50,7 +50,7 @@ void r300_translate_index_buffer(struct r300_context *r300, case 4: if (index_offset) { *out_buffer = NULL; - u_upload_alloc(r300->uploader, 0, count * 4, 4, + u_upload_alloc_ref(r300->uploader, 0, count * 4, 4, &out_offset, out_buffer, ptr); util_rebuild_uint_elts_to_userptr(&r300->context, info, diff --git a/src/gallium/drivers/r300/r300_screen_buffer.c b/src/gallium/drivers/r300/r300_screen_buffer.c index 37b6befdb09..490f1361e50 100644 --- a/src/gallium/drivers/r300/r300_screen_buffer.c +++ b/src/gallium/drivers/r300/r300_screen_buffer.c @@ -22,7 +22,7 @@ void r300_upload_index_buffer(struct r300_context *r300, *index_buffer = NULL; - u_upload_data(r300->uploader, + u_upload_data_ref(r300->uploader, 0, count * index_size, 4, ptr + (*start * index_size), &index_offset, diff --git a/src/gallium/drivers/r300/r300_state.c b/src/gallium/drivers/r300/r300_state.c index 0438f14a68d..094ee293ecd 100644 --- a/src/gallium/drivers/r300/r300_state.c +++ b/src/gallium/drivers/r300/r300_state.c @@ -1792,14 +1792,13 @@ static void r300_set_vertex_buffers_hwtcl(struct pipe_context* pipe, struct r300_context* r300 = r300_context(pipe); util_set_vertex_buffers_count(r300->vertex_buffer, - &r300->nr_vertex_buffers, buffers, count, - true); + &r300->nr_vertex_buffers, buffers, count); /* 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, false); + &r300->dummy_vb, 1); } r300->vertex_arrays_dirty = true; @@ -1813,8 +1812,7 @@ 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, - true); + &r300->nr_vertex_buffers, buffers, count); draw_set_vertex_buffers(r300->draw, count, buffers); if (!buffers) @@ -2063,7 +2061,6 @@ static void r300_delete_vs_state(struct pipe_context* pipe, void* shader) static void r300_set_constant_buffer(struct pipe_context *pipe, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *cb) { struct r300_context* r300 = r300_context(pipe); @@ -2178,6 +2175,7 @@ void r300_init_state_functions(struct r300_context* r300) r300->context.create_sampler_view = r300_create_sampler_view; r300->context.sampler_view_destroy = r300_sampler_view_destroy; r300->context.sampler_view_release = u_default_sampler_view_release; + r300->context.resource_release = u_default_resource_release; r300->context.set_scissor_states = r300_set_scissor_states; diff --git a/src/gallium/drivers/r600/evergreen_compute.c b/src/gallium/drivers/r600/evergreen_compute.c index de1f9121d8c..00e3896847a 100644 --- a/src/gallium/drivers/r600/evergreen_compute.c +++ b/src/gallium/drivers/r600/evergreen_compute.c @@ -146,7 +146,7 @@ static void evergreen_cs_set_constant_buffer(struct r600_context *rctx, cb.buffer = buffer; cb.user_buffer = NULL; - rctx->b.b.set_constant_buffer(&rctx->b.b, MESA_SHADER_COMPUTE, cb_index, false, &cb); + rctx->b.b.set_constant_buffer(&rctx->b.b, MESA_SHADER_COMPUTE, cb_index, &cb); } /* We need to define these R600 registers here, because we can't include diff --git a/src/gallium/drivers/r600/evergreen_state.c b/src/gallium/drivers/r600/evergreen_state.c index e897cc8c598..5379bbe7ef8 100644 --- a/src/gallium/drivers/r600/evergreen_state.c +++ b/src/gallium/drivers/r600/evergreen_state.c @@ -1760,7 +1760,7 @@ evergreen_emit_arb_shader_image_load_store_incomplete(struct r600_context *rctx, assert(ARRAY_SIZE(immed_resource_words) == 8); assert(ARRAY_SIZE(resource_words) == 8); - u_upload_alloc(rctx->b.b.stream_uploader, 0, + u_upload_alloc_ref(rctx->b.b.stream_uploader, 0, 4, 256, &dummy_offset, @@ -4942,17 +4942,17 @@ void evergreen_setup_tess_constants(struct r600_context *rctx, if (unlikely(vertexid)) rctx->b.b.set_constant_buffer(&rctx->b.b, MESA_SHADER_VERTEX, - R600_LDS_INFO_CONST_BUFFER, false, + R600_LDS_INFO_CONST_BUFFER, &rctx->lds_constbuf_pipe); else rctx->b.b.set_constant_buffer(&rctx->b.b, MESA_SHADER_VERTEX, - R600_LDS_INFO_CONST_BUFFER, false, + R600_LDS_INFO_CONST_BUFFER, NULL); rctx->b.b.set_constant_buffer(&rctx->b.b, MESA_SHADER_TESS_CTRL, - R600_LDS_INFO_CONST_BUFFER, false, NULL); + R600_LDS_INFO_CONST_BUFFER, NULL); rctx->b.b.set_constant_buffer(&rctx->b.b, MESA_SHADER_TESS_EVAL, - R600_LDS_INFO_CONST_BUFFER, false, NULL); + R600_LDS_INFO_CONST_BUFFER, NULL); return; } @@ -5009,13 +5009,13 @@ void evergreen_setup_tess_constants(struct r600_context *rctx, rctx->last_num_tcs_input_cp = num_tcs_input_cp; rctx->b.b.set_constant_buffer(&rctx->b.b, MESA_SHADER_VERTEX, - R600_LDS_INFO_CONST_BUFFER, false, + R600_LDS_INFO_CONST_BUFFER, &rctx->lds_constbuf_pipe); rctx->b.b.set_constant_buffer(&rctx->b.b, MESA_SHADER_TESS_CTRL, - R600_LDS_INFO_CONST_BUFFER, false, + R600_LDS_INFO_CONST_BUFFER, &rctx->lds_constbuf_pipe); rctx->b.b.set_constant_buffer(&rctx->b.b, MESA_SHADER_TESS_EVAL, - R600_LDS_INFO_CONST_BUFFER, true, + R600_LDS_INFO_CONST_BUFFER, &rctx->lds_constbuf_pipe); } diff --git a/src/gallium/drivers/r600/r600_blit.c b/src/gallium/drivers/r600/r600_blit.c index cb0dec40328..ba7edf65902 100644 --- a/src/gallium/drivers/r600/r600_blit.c +++ b/src/gallium/drivers/r600/r600_blit.c @@ -807,7 +807,7 @@ static void r600_blitter_clear_buffer(struct r600_context *rctx, return; } - u_upload_data(pipe->stream_uploader, 0, num_channels*4, 4, clear_value, + u_upload_data_ref(pipe->stream_uploader, 0, num_channels*4, 4, clear_value, &vb.buffer_offset, &vb.buffer.resource); if (!vb.buffer.resource) goto out; diff --git a/src/gallium/drivers/r600/r600_buffer_common.c b/src/gallium/drivers/r600/r600_buffer_common.c index 849093eacad..3b247b4b52c 100644 --- a/src/gallium/drivers/r600/r600_buffer_common.c +++ b/src/gallium/drivers/r600/r600_buffer_common.c @@ -374,7 +374,7 @@ void *r600_buffer_transfer_map(struct pipe_context *ctx, unsigned offset; struct r600_resource *staging = NULL; - u_upload_alloc(ctx->stream_uploader, 0, + u_upload_alloc_ref(ctx->stream_uploader, 0, box->width + (box->x % R600_MAP_BUFFER_ALIGNMENT), rctx->screen->info.tcc_cache_line_size, &offset, (struct pipe_resource**)&staging, diff --git a/src/gallium/drivers/r600/r600_pipe.c b/src/gallium/drivers/r600/r600_pipe.c index d7f085ca742..ca817723279 100644 --- a/src/gallium/drivers/r600/r600_pipe.c +++ b/src/gallium/drivers/r600/r600_pipe.c @@ -53,7 +53,7 @@ static void r600_destroy_context(struct pipe_context *context) if (rctx->append_fence) pipe_resource_reference((struct pipe_resource**)&rctx->append_fence, NULL); for (sh = 0; sh < MESA_SHADER_STAGES; sh++) { - rctx->b.b.set_constant_buffer(&rctx->b.b, sh, R600_BUFFER_INFO_CONST_BUFFER, false, NULL); + rctx->b.b.set_constant_buffer(&rctx->b.b, sh, R600_BUFFER_INFO_CONST_BUFFER, NULL); free(rctx->driver_consts[sh].constants); } @@ -85,7 +85,7 @@ static void r600_destroy_context(struct pipe_context *context) for (sh = 0; sh < MESA_SHADER_STAGES; ++sh) for (i = 0; i < PIPE_MAX_CONSTANT_BUFFERS; ++i) - rctx->b.b.set_constant_buffer(context, sh, i, false, NULL); + rctx->b.b.set_constant_buffer(context, sh, i, NULL); if (rctx->blitter) { util_blitter_destroy(rctx->blitter); diff --git a/src/gallium/drivers/r600/r600_pipe_common.c b/src/gallium/drivers/r600/r600_pipe_common.c index 4903a9e2006..a398cacac3e 100644 --- a/src/gallium/drivers/r600/r600_pipe_common.c +++ b/src/gallium/drivers/r600/r600_pipe_common.c @@ -158,7 +158,7 @@ void r600_draw_rectangle(struct blitter_context *blitter, /* Upload vertices. The hw rectangle has only 3 vertices, * The 4th one is derived from the first 3. * The vertex specification should match u_blitter's vertex element state. */ - u_upload_alloc(rctx->b.stream_uploader, 0, sizeof(float) * 24, + u_upload_alloc_ref(rctx->b.stream_uploader, 0, sizeof(float) * 24, rctx->screen->info.tcc_cache_line_size, &offset, &buf, (void**)&vb); if (!buf) diff --git a/src/gallium/drivers/r600/r600_query.c b/src/gallium/drivers/r600/r600_query.c index 079e95cb8dd..758050caade 100644 --- a/src/gallium/drivers/r600/r600_query.c +++ b/src/gallium/drivers/r600/r600_query.c @@ -1579,7 +1579,7 @@ static void r600_restore_qbo_state(struct r600_common_context *rctx, struct r600_qbo_state *st) { rctx->b.bind_compute_state(&rctx->b, st->saved_compute); - rctx->b.set_constant_buffer(&rctx->b, MESA_SHADER_COMPUTE, 0, true, &st->saved_const0); + rctx->b.set_constant_buffer(&rctx->b, MESA_SHADER_COMPUTE, 0, &st->saved_const0); rctx->b.set_shader_buffers(&rctx->b, MESA_SHADER_COMPUTE, 0, 3, st->saved_ssbo, ~0); for (unsigned i = 0; i < 3; ++i) pipe_resource_reference(&st->saved_ssbo[i].buffer, NULL); @@ -1712,7 +1712,7 @@ static void r600_query_hw_get_result_resource(struct r600_common_context *rctx, } else consts.buffer_offset = 0; - rctx->b.set_constant_buffer(&rctx->b, MESA_SHADER_COMPUTE, 0, false, &constant_buffer); + rctx->b.set_constant_buffer(&rctx->b, MESA_SHADER_COMPUTE, 0, &constant_buffer); rctx->b.set_shader_buffers(&rctx->b, MESA_SHADER_COMPUTE, 0, 3, ssbo, ~0); diff --git a/src/gallium/drivers/r600/r600_state_common.c b/src/gallium/drivers/r600/r600_state_common.c index 22ecfc7edad..708c777c3e7 100644 --- a/src/gallium/drivers/r600/r600_state_common.c +++ b/src/gallium/drivers/r600/r600_state_common.c @@ -589,8 +589,7 @@ static void r600_set_vertex_buffers(struct pipe_context *ctx, (vb[i].is_user_buffer != input[i].is_user_buffer))) { if (input[i].buffer.resource) { vb[i].buffer_offset = input[i].buffer_offset; - pipe_resource_reference(&vb[i].buffer.resource, NULL); - vb[i].buffer.resource = input[i].buffer.resource; + pipe_resource_reference(&vb[i].buffer.resource, input[i].buffer.resource); new_buffer_mask |= 1 << i; r600_context_add_resource_size(ctx, input[i].buffer.resource); } else { @@ -598,8 +597,7 @@ static void r600_set_vertex_buffers(struct pipe_context *ctx, disable_mask |= 1 << i; } } else if (input[i].buffer.resource) { - pipe_resource_reference(&vb[i].buffer.resource, NULL); - vb[i].buffer.resource = input[i].buffer.resource; + pipe_resource_reference(&vb[i].buffer.resource, input[i].buffer.resource); } } @@ -1240,7 +1238,6 @@ void r600_constant_buffers_dirty(struct r600_context *rctx, struct r600_constbuf static void r600_set_constant_buffer(struct pipe_context *ctx, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *input) { struct r600_context *rctx = (struct r600_context *)ctx; @@ -1278,11 +1275,11 @@ static void r600_set_constant_buffer(struct pipe_context *ctx, tmpPtr[i] = util_cpu_to_le32(((uint32_t *)ptr)[i]); } - u_upload_data(ctx->stream_uploader, 0, size, 256, + u_upload_data_ref(ctx->stream_uploader, 0, size, 256, tmpPtr, &cb->buffer_offset, &cb->buffer); free(tmpPtr); } else { - u_upload_data(ctx->stream_uploader, 0, + u_upload_data_ref(ctx->stream_uploader, 0, input->buffer_size, 256, ptr, &cb->buffer_offset, &cb->buffer); } @@ -1291,12 +1288,7 @@ static void r600_set_constant_buffer(struct pipe_context *ctx, } else { /* Setup the hw buffer. */ cb->buffer_offset = input->buffer_offset; - if (take_ownership) { - pipe_resource_reference(&cb->buffer, NULL); - cb->buffer = input->buffer; - } else { - pipe_resource_reference(&cb->buffer, input->buffer); - } + pipe_resource_reference(&cb->buffer, input->buffer); r600_context_add_resource_size(ctx, input->buffer); } @@ -1410,7 +1402,7 @@ void r600_update_driver_const_buffers(struct r600_context *rctx, bool compute_on cb.user_buffer = ptr; cb.buffer_offset = 0; cb.buffer_size = size; - rctx->b.b.set_constant_buffer(&rctx->b.b, sh, R600_BUFFER_INFO_CONST_BUFFER, false, &cb); + rctx->b.b.set_constant_buffer(&rctx->b.b, sh, R600_BUFFER_INFO_CONST_BUFFER, &cb); pipe_resource_reference(&cb.buffer, NULL); } } @@ -1599,21 +1591,21 @@ static void update_gs_block_state(struct r600_context *rctx, unsigned enable) if (enable) { r600_set_constant_buffer(&rctx->b.b, MESA_SHADER_GEOMETRY, - R600_GS_RING_CONST_BUFFER, false, &rctx->gs_rings.esgs_ring); + R600_GS_RING_CONST_BUFFER, &rctx->gs_rings.esgs_ring); if (rctx->tes_shader) { r600_set_constant_buffer(&rctx->b.b, MESA_SHADER_TESS_EVAL, - R600_GS_RING_CONST_BUFFER, false, &rctx->gs_rings.gsvs_ring); + R600_GS_RING_CONST_BUFFER, &rctx->gs_rings.gsvs_ring); } else { r600_set_constant_buffer(&rctx->b.b, MESA_SHADER_VERTEX, - R600_GS_RING_CONST_BUFFER, false, &rctx->gs_rings.gsvs_ring); + R600_GS_RING_CONST_BUFFER, &rctx->gs_rings.gsvs_ring); } } else { r600_set_constant_buffer(&rctx->b.b, MESA_SHADER_GEOMETRY, - R600_GS_RING_CONST_BUFFER, false, NULL); + R600_GS_RING_CONST_BUFFER, NULL); r600_set_constant_buffer(&rctx->b.b, MESA_SHADER_VERTEX, - R600_GS_RING_CONST_BUFFER, false, NULL); + R600_GS_RING_CONST_BUFFER, NULL); r600_set_constant_buffer(&rctx->b.b, MESA_SHADER_TESS_EVAL, - R600_GS_RING_CONST_BUFFER, false, NULL); + R600_GS_RING_CONST_BUFFER, NULL); } } } @@ -2298,7 +2290,7 @@ r600_indirect_parameters_init(struct r600_context *rctx, indirect_parameters->counter = 0; indirect_parameters->internal = NULL; - u_upload_alloc(rctx->b.b.stream_uploader, 0, + u_upload_alloc_ref(rctx->b.b.stream_uploader, 0, sizeof(struct r600_indirect_gpu_internal), 256, &indirect_parameters->internal_offset, @@ -2630,7 +2622,7 @@ static void r600_draw_vbo(struct pipe_context *ctx, const struct pipe_draw_info indexbuf->width0 - index_offset; const unsigned out_width = count * out_size; - u_upload_alloc(ctx->stream_uploader, start, out_width, + u_upload_alloc_ref(ctx->stream_uploader, start, out_width, 256, &out_offset, &out_buffer, &ptr); if (unlikely(!ptr)) @@ -2655,7 +2647,7 @@ static void r600_draw_vbo(struct pipe_context *ctx, const struct pipe_draw_info draws[0].count*index_size > 20)) { unsigned start_offset = draws[0].start * index_size; indexbuf = NULL; - u_upload_data(ctx->stream_uploader, 0, + u_upload_data_ref(ctx->stream_uploader, 0, draws[0].count * index_size, 256, (char*)info->index.user + start_offset, &index_offset, &indexbuf); @@ -3966,6 +3958,7 @@ void r600_init_common_state_functions(struct r600_context *rctx) rctx->b.b.set_sampler_views = r600_set_sampler_views; rctx->b.b.sampler_view_destroy = r600_sampler_view_destroy; rctx->b.b.sampler_view_release = u_default_sampler_view_release; + rctx->b.b.resource_release = u_default_resource_release; rctx->b.b.memory_barrier = r600_memory_barrier; rctx->b.b.texture_barrier = r600_texture_barrier; rctx->b.b.set_stream_output_targets = r600_set_streamout_targets; diff --git a/src/gallium/drivers/radeonsi/gfx11_query.c b/src/gallium/drivers/radeonsi/gfx11_query.c index 790da31bb87..ecade746fe7 100644 --- a/src/gallium/drivers/radeonsi/gfx11_query.c +++ b/src/gallium/drivers/radeonsi/gfx11_query.c @@ -374,7 +374,7 @@ static void gfx11_sh_query_get_result_resource(struct si_context *sctx, struct s ssbo[2].buffer_size = is_result_64bit ? 8 : 4; } - sctx->b.set_constant_buffer(&sctx->b, MESA_SHADER_COMPUTE, 0, false, &constant_buffer); + sctx->b.set_constant_buffer(&sctx->b, MESA_SHADER_COMPUTE, 0, &constant_buffer); if (flags & PIPE_QUERY_WAIT) { uint64_t va; diff --git a/src/gallium/drivers/radeonsi/si_buffer.c b/src/gallium/drivers/radeonsi/si_buffer.c index 2694506527b..8e6ecc2f612 100644 --- a/src/gallium/drivers/radeonsi/si_buffer.c +++ b/src/gallium/drivers/radeonsi/si_buffer.c @@ -448,7 +448,7 @@ static void *si_buffer_transfer_map(struct pipe_context *ctx, struct pipe_resour else uploader = sctx->b.stream_uploader; - u_upload_alloc(uploader, 0, box->width + (box->x % SI_MAP_BUFFER_ALIGNMENT), + u_upload_alloc_ref(uploader, 0, box->width + (box->x % SI_MAP_BUFFER_ALIGNMENT), sctx->screen->info.tcc_cache_line_size, &offset, (struct pipe_resource **)&staging, (void **)&data); diff --git a/src/gallium/drivers/radeonsi/si_descriptors.c b/src/gallium/drivers/radeonsi/si_descriptors.c index b64a31516df..2e3ed05d93b 100644 --- a/src/gallium/drivers/radeonsi/si_descriptors.c +++ b/src/gallium/drivers/radeonsi/si_descriptors.c @@ -125,7 +125,7 @@ static void si_upload_descriptors(struct si_context *sctx, struct si_descriptors uint32_t *ptr; unsigned buffer_offset; - u_upload_alloc(sctx->b.const_uploader, first_slot_offset, upload_size, + u_upload_alloc_ref(sctx->b.const_uploader, first_slot_offset, upload_size, si_optimal_tcc_alignment(sctx, upload_size), &buffer_offset, (struct pipe_resource **)&desc->buffer, (void **)&ptr); if (!desc->buffer) { @@ -1117,14 +1117,14 @@ static void si_upload_const_buffer(struct si_context *sctx, struct si_resource * { void *tmp; - u_upload_alloc(sctx->b.const_uploader, 0, size, si_optimal_tcc_alignment(sctx, size), + u_upload_alloc_ref(sctx->b.const_uploader, 0, size, si_optimal_tcc_alignment(sctx, size), const_offset, (struct pipe_resource **)buf, &tmp); if (*buf) util_memcpy_cpu_to_le32(tmp, ptr, size); } static void si_set_constant_buffer(struct si_context *sctx, struct si_buffer_resources *buffers, - unsigned descriptors_idx, uint slot, bool take_ownership, + unsigned descriptors_idx, uint slot, const struct pipe_constant_buffer *input) { struct si_descriptors *descs = &sctx->descriptors[descriptors_idx]; @@ -1146,15 +1146,11 @@ static void si_set_constant_buffer(struct si_context *sctx, struct si_buffer_res input->buffer_size, &buffer_offset); if (!buffer) { /* Just unbind on failure. */ - si_set_constant_buffer(sctx, buffers, descriptors_idx, slot, false, NULL); + si_set_constant_buffer(sctx, buffers, descriptors_idx, slot, NULL); return; } } else { - if (take_ownership) { - buffer = input->buffer; - } else { - pipe_resource_reference(&buffer, input->buffer); - } + pipe_resource_reference(&buffer, input->buffer); buffer_offset = input->buffer_offset; } @@ -1212,7 +1208,7 @@ void si_invalidate_inlinable_uniforms(struct si_context *sctx, mesa_shader_stage } static void si_pipe_set_constant_buffer(struct pipe_context *ctx, mesa_shader_stage shader, - uint slot, bool take_ownership, + uint slot, const struct pipe_constant_buffer *input) { struct si_context *sctx = (struct si_context *)ctx; @@ -1237,7 +1233,7 @@ static void si_pipe_set_constant_buffer(struct pipe_context *ctx, mesa_shader_st slot = si_get_constbuf_slot(slot); si_set_constant_buffer(sctx, &sctx->const_and_shader_buffers[shader], si_const_and_shader_buffer_descriptors_idx(shader), slot, - take_ownership, input); + input); } static void si_set_inlinable_constants(struct pipe_context *ctx, @@ -1390,7 +1386,7 @@ void si_get_shader_buffers(struct si_context *sctx, mesa_shader_stage shader, ui void si_set_internal_const_buffer(struct si_context *sctx, uint slot, const struct pipe_constant_buffer *input) { - si_set_constant_buffer(sctx, &sctx->internal_bindings, SI_DESCS_INTERNAL, slot, false, input); + si_set_constant_buffer(sctx, &sctx->internal_bindings, SI_DESCS_INTERNAL, slot, input); } void si_set_internal_shader_buffer(struct si_context *sctx, uint slot, diff --git a/src/gallium/drivers/radeonsi/si_fence.c b/src/gallium/drivers/radeonsi/si_fence.c index f1fa9a33360..14eae33994f 100644 --- a/src/gallium/drivers/radeonsi/si_fence.c +++ b/src/gallium/drivers/radeonsi/si_fence.c @@ -248,7 +248,7 @@ static void si_fine_fence_set(struct si_context *ctx, struct si_fine_fence *fine assert(util_bitcount(flags & (PIPE_FLUSH_TOP_OF_PIPE | PIPE_FLUSH_BOTTOM_OF_PIPE)) == 1); /* Use cached system memory for the fence. */ - u_upload_alloc(ctx->cached_gtt_allocator, 0, 4, 4, &fine->offset, + u_upload_alloc_ref(ctx->cached_gtt_allocator, 0, 4, 4, &fine->offset, (struct pipe_resource **)&fine->buf, (void **)&fence_ptr); if (!fine->buf) return; diff --git a/src/gallium/drivers/radeonsi/si_pipe.c b/src/gallium/drivers/radeonsi/si_pipe.c index 59a2f346401..1f17c597789 100644 --- a/src/gallium/drivers/radeonsi/si_pipe.c +++ b/src/gallium/drivers/radeonsi/si_pipe.c @@ -773,7 +773,7 @@ static struct pipe_context *si_create_context(struct pipe_screen *screen, unsign unsigned start_shader = sctx->is_gfx_queue ? 0 : MESA_SHADER_COMPUTE; for (shader = start_shader; shader < SI_NUM_SHADERS; shader++) { for (i = 0; i < SI_NUM_CONST_BUFFERS; i++) { - sctx->b.set_constant_buffer(&sctx->b, shader, i, false, &sctx->null_const_buf); + sctx->b.set_constant_buffer(&sctx->b, shader, i, &sctx->null_const_buf); } } diff --git a/src/gallium/drivers/radeonsi/si_pipe.h b/src/gallium/drivers/radeonsi/si_pipe.h index 15ce24aff1a..5f83e4ed188 100644 --- a/src/gallium/drivers/radeonsi/si_pipe.h +++ b/src/gallium/drivers/radeonsi/si_pipe.h @@ -1152,9 +1152,9 @@ struct si_context { uint16_t vertex_buffer_unaligned; /* bitmask of not dword-aligned buffers */ struct pipe_vertex_buffer vertex_buffer[SI_NUM_VERTEX_BUFFERS]; - /* Even though we don't need this variable, u_upload_alloc has an optimization that skips + /* Even though we don't need this variable, u_upload_alloc_ref has an optimization that skips * reference counting when the new upload buffer is the same as the last one. So keep - * the last upload buffer here and always pass &last_const_upload_buffer to u_upload_alloc. + * the last upload buffer here and always pass &last_const_upload_buffer to u_upload_alloc_ref. */ struct si_resource *last_const_upload_buffer; diff --git a/src/gallium/drivers/radeonsi/si_query.c b/src/gallium/drivers/radeonsi/si_query.c index 8c1cc5a44d8..2e002ddecbc 100644 --- a/src/gallium/drivers/radeonsi/si_query.c +++ b/src/gallium/drivers/radeonsi/si_query.c @@ -1619,7 +1619,7 @@ static void si_query_hw_get_result_resource(struct si_context *sctx, struct si_q params.start_offset += qbuf->results_end - query->result_size; } - sctx->b.set_constant_buffer(&sctx->b, MESA_SHADER_COMPUTE, 0, false, &constant_buffer); + sctx->b.set_constant_buffer(&sctx->b, MESA_SHADER_COMPUTE, 0, &constant_buffer); ssbo[0].buffer = &qbuf->buf->b.b; ssbo[0].buffer_offset = params.start_offset; diff --git a/src/gallium/drivers/radeonsi/si_shader.c b/src/gallium/drivers/radeonsi/si_shader.c index 5ee2f90c28a..82ee5f6ed53 100644 --- a/src/gallium/drivers/radeonsi/si_shader.c +++ b/src/gallium/drivers/radeonsi/si_shader.c @@ -323,7 +323,7 @@ static void *pre_upload_binary(struct si_screen *sscreen, struct si_shader *shad *upload_ctx = si_get_aux_context(&sscreen->aux_context.shader_upload); void *ret; - u_upload_alloc((*upload_ctx)->b.stream_uploader, 0, binary_size, 256, + u_upload_alloc_ref((*upload_ctx)->b.stream_uploader, 0, binary_size, 256, staging_offset, staging, &ret); if (!ret) si_put_aux_context_flush(&sscreen->aux_context.shader_upload); diff --git a/src/gallium/drivers/radeonsi/si_state.c b/src/gallium/drivers/radeonsi/si_state.c index 4f053f2ba3d..f39f3169c34 100644 --- a/src/gallium/drivers/radeonsi/si_state.c +++ b/src/gallium/drivers/radeonsi/si_state.c @@ -1841,7 +1841,7 @@ void si_save_qbo_state(struct si_context *sctx, struct si_qbo_state *st) void si_restore_qbo_state(struct si_context *sctx, struct si_qbo_state *st) { - sctx->b.set_constant_buffer(&sctx->b, MESA_SHADER_COMPUTE, 0, true, &st->saved_const0); + sctx->b.set_constant_buffer(&sctx->b, MESA_SHADER_COMPUTE, 0, &st->saved_const0); } static void si_emit_db_render_state(struct si_context *sctx, unsigned index) @@ -4738,8 +4738,7 @@ static void si_set_vertex_buffers(struct pipe_context *ctx, unsigned count, dst->buffer_offset = src->buffer_offset; /* Only unreference bound vertex buffers. */ - pipe_resource_reference(&dst->buffer.resource, NULL); - dst->buffer.resource = src->buffer.resource; + pipe_resource_reference(&dst->buffer.resource, src->buffer.resource); if (src->buffer_offset & 3) unaligned |= BITFIELD_BIT(i); @@ -4891,6 +4890,7 @@ void si_init_state_compute_functions(struct si_context *sctx) sctx->b.create_sampler_view = si_create_sampler_view; sctx->b.sampler_view_destroy = si_sampler_view_destroy; sctx->b.sampler_view_release = u_default_sampler_view_release; + sctx->b.resource_release = u_default_resource_release; } void si_init_state_functions(struct si_context *sctx) diff --git a/src/gallium/drivers/radeonsi/si_state_draw.cpp b/src/gallium/drivers/radeonsi/si_state_draw.cpp index 82e2787973b..e293a428dfe 100644 --- a/src/gallium/drivers/radeonsi/si_state_draw.cpp +++ b/src/gallium/drivers/radeonsi/si_state_draw.cpp @@ -1868,7 +1868,7 @@ static bool si_upload_and_prefetch_VB_descriptors(struct si_context *sctx, /* Vertex buffer descriptors are the only ones which are uploaded directly * and don't go through si_upload_graphics_shader_descriptors. */ - u_upload_alloc(sctx->b.const_uploader, 0, alloc_size, + u_upload_alloc_ref(sctx->b.const_uploader, 0, alloc_size, si_optimal_tcc_alignment(sctx, alloc_size), &offset, (struct pipe_resource **)&sctx->last_const_upload_buffer, (void **)&ptr); if (!sctx->last_const_upload_buffer) @@ -2184,7 +2184,7 @@ static void si_draw(struct pipe_context *ctx, start_offset = start * 2; size = count * 2; - /* Don't use u_upload_alloc because we don't need to map the buffer for CPU access. */ + /* Don't use u_upload_alloc_ref because we don't need to map the buffer for CPU access. */ indexbuf = pipe_buffer_create(&sctx->screen->b, 0, PIPE_USAGE_IMMUTABLE, start_offset + size); if (unlikely(!indexbuf)) return; @@ -2208,7 +2208,7 @@ static void si_draw(struct pipe_context *ctx, start_offset = draws[0].start * index_size; indexbuf = NULL; - u_upload_data(ctx->stream_uploader, start_offset, draws[0].count * index_size, + u_upload_data_ref(ctx->stream_uploader, start_offset, draws[0].count * index_size, sctx->screen->info.tcc_cache_line_size, (char *)info->index.user + start_offset, &index_offset, &indexbuf); if (unlikely(!indexbuf)) diff --git a/src/gallium/drivers/radeonsi/si_state_viewport.c b/src/gallium/drivers/radeonsi/si_state_viewport.c index b72122eec58..7f8d8b188f2 100644 --- a/src/gallium/drivers/radeonsi/si_state_viewport.c +++ b/src/gallium/drivers/radeonsi/si_state_viewport.c @@ -86,7 +86,7 @@ static void si_emit_cull_state(struct si_context *sctx, unsigned index) memcmp(&info, &sctx->last_small_prim_cull_info, sizeof(info))) { unsigned offset = 0; - u_upload_data(sctx->b.const_uploader, 0, sizeof(info), + u_upload_data_ref(sctx->b.const_uploader, 0, sizeof(info), si_optimal_tcc_alignment(sctx, sizeof(info)), &info, &offset, (struct pipe_resource **)&sctx->small_prim_cull_info_buf); diff --git a/src/gallium/drivers/softpipe/sp_state_sampler.c b/src/gallium/drivers/softpipe/sp_state_sampler.c index fee36cd38a3..028d39a83aa 100644 --- a/src/gallium/drivers/softpipe/sp_state_sampler.c +++ b/src/gallium/drivers/softpipe/sp_state_sampler.c @@ -350,4 +350,5 @@ softpipe_init_sampler_funcs(struct pipe_context *pipe) pipe->set_sampler_views = softpipe_set_sampler_views; pipe->sampler_view_destroy = softpipe_sampler_view_destroy; pipe->sampler_view_release = u_default_sampler_view_release; + pipe->resource_release = u_default_resource_release; } diff --git a/src/gallium/drivers/softpipe/sp_state_shader.c b/src/gallium/drivers/softpipe/sp_state_shader.c index fa2f60f1096..47ef0a4f3c3 100644 --- a/src/gallium/drivers/softpipe/sp_state_shader.c +++ b/src/gallium/drivers/softpipe/sp_state_shader.c @@ -357,7 +357,6 @@ softpipe_delete_gs_state(struct pipe_context *pipe, void *gs) static void softpipe_set_constant_buffer(struct pipe_context *pipe, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *cb) { struct softpipe_context *softpipe = softpipe_context(pipe); @@ -381,13 +380,7 @@ softpipe_set_constant_buffer(struct pipe_context *pipe, draw_flush(softpipe->draw); - /* note: reference counting */ - if (take_ownership) { - pipe_resource_reference(&softpipe->constants[shader][index], NULL); - softpipe->constants[shader][index] = constants; - } else { - pipe_resource_reference(&softpipe->constants[shader][index], constants); - } + pipe_resource_reference(&softpipe->constants[shader][index], constants); if (shader == MESA_SHADER_VERTEX || shader == MESA_SHADER_GEOMETRY) { draw_set_mapped_constant_buffer(softpipe->draw, shader, index, data, size); diff --git a/src/gallium/drivers/softpipe/sp_state_vertex.c b/src/gallium/drivers/softpipe/sp_state_vertex.c index 49d0492e30a..e3469a5341f 100644 --- a/src/gallium/drivers/softpipe/sp_state_vertex.c +++ b/src/gallium/drivers/softpipe/sp_state_vertex.c @@ -89,7 +89,7 @@ softpipe_set_vertex_buffers(struct pipe_context *pipe, util_set_vertex_buffers_count(softpipe->vertex_buffer, &softpipe->num_vertex_buffers, - buffers, count, true); + buffers, count); softpipe->dirty |= SP_NEW_VERTEX; diff --git a/src/gallium/drivers/svga/svga_draw_elements.c b/src/gallium/drivers/svga/svga_draw_elements.c index 59415fbe24e..2efe297ed28 100644 --- a/src/gallium/drivers/svga/svga_draw_elements.c +++ b/src/gallium/drivers/svga/svga_draw_elements.c @@ -111,7 +111,7 @@ translate_indices(struct svga_hwtnl *hwtnl, goto fail; } else { /* Allocate upload buffer space. Align to the index size. */ - u_upload_alloc(pipe->stream_uploader, 0, size, gen_size, + u_upload_alloc_ref(pipe->stream_uploader, 0, size, gen_size, out_offset, &dst, &dst_map); if (!dst) goto fail; @@ -246,7 +246,7 @@ svga_hwtnl_draw_range_elements(struct svga_hwtnl *hwtnl, unsigned index_offset; if (info->has_user_indices) { - u_upload_data(pipe->stream_uploader, 0, count * info->index_size, + u_upload_data_ref(pipe->stream_uploader, 0, count * info->index_size, info->index_size, (char *) info->index.user + start_offset, &index_offset, &index_buffer); u_upload_unmap(pipe->stream_uploader); diff --git a/src/gallium/drivers/svga/svga_pipe_constants.c b/src/gallium/drivers/svga/svga_pipe_constants.c index 5cb4f057ee3..55c11554801 100644 --- a/src/gallium/drivers/svga/svga_pipe_constants.c +++ b/src/gallium/drivers/svga/svga_pipe_constants.c @@ -25,7 +25,6 @@ struct svga_constbuf static void svga_set_constant_buffer(struct pipe_context *pipe, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *cb) { struct svga_screen *svgascreen = svga_screen(pipe->screen); @@ -49,12 +48,7 @@ svga_set_constant_buffer(struct pipe_context *pipe, assert(index < svgascreen->max_const_buffers); (void) svgascreen; - if (take_ownership) { - pipe_resource_reference(&svga->curr.constbufs[shader][index].buffer, NULL); - svga->curr.constbufs[shader][index].buffer = buf; - } else { - pipe_resource_reference(&svga->curr.constbufs[shader][index].buffer, buf); - } + pipe_resource_reference(&svga->curr.constbufs[shader][index].buffer, buf); /* Make sure the constant buffer size to be updated is within the * limit supported by the device. @@ -110,4 +104,3 @@ svga_init_constbuffer_functions(struct svga_context *svga) { svga->pipe.set_constant_buffer = svga_set_constant_buffer; } - diff --git a/src/gallium/drivers/svga/svga_pipe_sampler.c b/src/gallium/drivers/svga/svga_pipe_sampler.c index c098b4987e9..2a8957d451a 100644 --- a/src/gallium/drivers/svga/svga_pipe_sampler.c +++ b/src/gallium/drivers/svga/svga_pipe_sampler.c @@ -543,4 +543,5 @@ svga_init_sampler_functions(struct svga_context *svga) svga->pipe.create_sampler_view = svga_create_sampler_view; svga->pipe.sampler_view_destroy = svga_sampler_view_destroy; svga->pipe.sampler_view_release = u_default_sampler_view_release; + svga->pipe.resource_release = u_default_resource_release; } diff --git a/src/gallium/drivers/svga/svga_pipe_vertex.c b/src/gallium/drivers/svga/svga_pipe_vertex.c index 9a2910d28b7..a8e24d0fe33 100644 --- a/src/gallium/drivers/svga/svga_pipe_vertex.c +++ b/src/gallium/drivers/svga/svga_pipe_vertex.c @@ -30,7 +30,7 @@ svga_set_vertex_buffers(struct pipe_context *pipe, util_set_vertex_buffers_count(svga->curr.vb, &svga->curr.num_vertex_buffers, - buffers, count, true); + buffers, count); svga->dirty |= SVGA_NEW_VBUFFER; } diff --git a/src/gallium/drivers/svga/svga_resource_texture.c b/src/gallium/drivers/svga/svga_resource_texture.c index 0764c27d397..44775527c9a 100644 --- a/src/gallium/drivers/svga/svga_resource_texture.c +++ b/src/gallium/drivers/svga/svga_resource_texture.c @@ -1459,7 +1459,7 @@ svga_texture_transfer_map_upload(struct svga_context *svga, * upload buffer manager code will try to allocate a new buffer * with the new buffer size. */ - u_upload_alloc(svga->tex_upload, 0, upload_size, 16, + u_upload_alloc_ref(svga->tex_upload, 0, upload_size, 16, &offset, &tex_buffer, &tex_map); if (!tex_map) { diff --git a/src/gallium/drivers/svga/svga_state_constants.c b/src/gallium/drivers/svga/svga_state_constants.c index 6ebdf88160d..4d938896b9c 100644 --- a/src/gallium/drivers/svga/svga_state_constants.c +++ b/src/gallium/drivers/svga/svga_state_constants.c @@ -771,7 +771,7 @@ emit_constbuf(struct svga_context *svga, */ alloc_buf_size = align(new_buf_size, CONST0_UPLOAD_ALIGNMENT); - u_upload_alloc(svga->const0_upload, 0, alloc_buf_size, + u_upload_alloc_ref(svga->const0_upload, 0, alloc_buf_size, CONST0_UPLOAD_ALIGNMENT, &offset, &dst_buffer, &dst_map); diff --git a/src/gallium/drivers/svga/svga_state_ts.c b/src/gallium/drivers/svga/svga_state_ts.c index 2150c573986..32911590aa1 100644 --- a/src/gallium/drivers/svga/svga_state_ts.c +++ b/src/gallium/drivers/svga/svga_state_ts.c @@ -211,7 +211,7 @@ get_passthrough_tcs(struct svga_context *svga) cb.user_buffer = (void *) svga->curr.default_tesslevels; cb.buffer_offset = 0; cb.buffer_size = 2 * 4 * sizeof(float); - svga->pipe.set_constant_buffer(&svga->pipe, MESA_SHADER_TESS_CTRL, 0, false, &cb); + svga->pipe.set_constant_buffer(&svga->pipe, MESA_SHADER_TESS_CTRL, 0, &cb); } diff --git a/src/gallium/drivers/tegra/tegra_context.c b/src/gallium/drivers/tegra/tegra_context.c index 7f5e6294be4..46e3651c99c 100644 --- a/src/gallium/drivers/tegra/tegra_context.c +++ b/src/gallium/drivers/tegra/tegra_context.c @@ -476,7 +476,7 @@ tegra_set_clip_state(struct pipe_context *pcontext, static void tegra_set_constant_buffer(struct pipe_context *pcontext, mesa_shader_stage shader, - unsigned int index, bool take_ownership, + unsigned int index, const struct pipe_constant_buffer *buf) { struct tegra_context *context = to_tegra_context(pcontext); @@ -488,7 +488,7 @@ tegra_set_constant_buffer(struct pipe_context *pcontext, mesa_shader_stage shade buf = &buffer; } - context->gpu->set_constant_buffer(context->gpu, shader, index, take_ownership, buf); + context->gpu->set_constant_buffer(context->gpu, shader, index, buf); } static void @@ -1355,6 +1355,7 @@ tegra_screen_context_create(struct pipe_screen *pscreen, void *priv, context->base.create_sampler_view = tegra_create_sampler_view; context->base.sampler_view_destroy = tegra_sampler_view_destroy; context->base.sampler_view_release = u_default_sampler_view_release; + context->base.resource_release = u_default_resource_release; context->base.create_surface = tegra_create_surface; context->base.surface_destroy = tegra_surface_destroy; diff --git a/src/gallium/drivers/v3d/v3d_blit.c b/src/gallium/drivers/v3d/v3d_blit.c index dc057d77670..bc9d21731e0 100644 --- a/src/gallium/drivers/v3d/v3d_blit.c +++ b/src/gallium/drivers/v3d/v3d_blit.c @@ -837,7 +837,7 @@ v3d_sand8_blit(struct pipe_context *pctx, struct pipe_blit_info *info) .buffer_size = sizeof(sand8_stride), }; - pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 0, false, + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 0, &cb_uniforms); struct pipe_constant_buffer saved_fs_cb1 = { 0 }; pipe_resource_reference(&saved_fs_cb1.buffer, @@ -850,7 +850,7 @@ v3d_sand8_blit(struct pipe_context *pctx, struct pipe_blit_info *info) .buffer_size = (src->bo->size - src->slices[info->src.level].offset), }; - pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, false, + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, &cb_src); /* Unbind the textures, to make sure we don't try to recurse into the * shadow blit. @@ -866,7 +866,7 @@ v3d_sand8_blit(struct pipe_context *pctx, struct pipe_blit_info *info) util_blitter_restore_constant_buffer_state(v3d->blitter); /* Restore cb1 (util_blitter doesn't handle this one). */ - pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, true, + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, &saved_fs_cb1); pipe_resource_reference(&dst_surf.texture, NULL); @@ -1144,7 +1144,7 @@ v3d_sand30_blit(struct pipe_context *pctx, struct pipe_blit_info *info) .buffer_size = sizeof(sand30_stride), }; - pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 0, false, + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 0, &cb_uniforms); struct pipe_constant_buffer saved_fs_cb1 = { 0 }; @@ -1158,7 +1158,7 @@ v3d_sand30_blit(struct pipe_context *pctx, struct pipe_blit_info *info) .buffer_size = (src->bo->size - src->slices[info->src.level].offset), }; - pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, false, + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, &cb_src); /* Unbind the textures, to make sure we don't try to recurse into the * shadow blit. @@ -1175,7 +1175,7 @@ v3d_sand30_blit(struct pipe_context *pctx, struct pipe_blit_info *info) util_blitter_restore_constant_buffer_state(v3d->blitter); /* Restore cb1 (util_blitter doesn't handle this one). */ - pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, true, + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, &saved_fs_cb1); pipe_resource_reference(&dst_surf.texture, NULL); diff --git a/src/gallium/drivers/v3d/v3d_context.c b/src/gallium/drivers/v3d/v3d_context.c index 5ab43581f49..369a9d8afd6 100644 --- a/src/gallium/drivers/v3d/v3d_context.c +++ b/src/gallium/drivers/v3d/v3d_context.c @@ -228,7 +228,7 @@ v3d_ensure_prim_counts_allocated(struct v3d_context *ctx) /* Init all 7 counters and 1 padding to 0 */ uint32_t zeroes[8] = { 0 }; - u_upload_data(ctx->uploader, + u_upload_data_ref(ctx->uploader, 0, sizeof(zeroes), 32, zeroes, &ctx->prim_counts_offset, &ctx->prim_counts); diff --git a/src/gallium/drivers/v3d/v3d_disk_cache.c b/src/gallium/drivers/v3d/v3d_disk_cache.c index b7eb1b7ab1e..705d94cd964 100644 --- a/src/gallium/drivers/v3d/v3d_disk_cache.c +++ b/src/gallium/drivers/v3d/v3d_disk_cache.c @@ -166,7 +166,7 @@ v3d_disk_cache_retrieve(struct v3d_context *v3d, ralloc_array(shader->prog_data.base, uint32_t, ulist_count); memcpy(shader->prog_data.base->uniforms.data, ulist_data, ulist_data_size); - u_upload_data(v3d->state_uploader, 0, qpu_size, 8, + u_upload_data_ref(v3d->state_uploader, 0, qpu_size, 8, qpu_insts, &shader->offset, &shader->resource); shader->qpu_size = qpu_size; diff --git a/src/gallium/drivers/v3d/v3d_program.c b/src/gallium/drivers/v3d/v3d_program.c index 4f747840976..e9f1ec4f6d5 100644 --- a/src/gallium/drivers/v3d/v3d_program.c +++ b/src/gallium/drivers/v3d/v3d_program.c @@ -510,7 +510,7 @@ v3d_get_compiled_shader(struct v3d_context *v3d, ralloc_steal(shader, shader->prog_data.base); if (shader->qpu_size) { - u_upload_data(v3d->state_uploader, 0, shader->qpu_size, 8, + u_upload_data_ref(v3d->state_uploader, 0, shader->qpu_size, 8, qpu_insts, &shader->offset, &shader->resource); } diff --git a/src/gallium/drivers/v3d/v3d_uniforms.c b/src/gallium/drivers/v3d/v3d_uniforms.c index eb8c1c58923..0609a55a7d5 100644 --- a/src/gallium/drivers/v3d/v3d_uniforms.c +++ b/src/gallium/drivers/v3d/v3d_uniforms.c @@ -322,7 +322,7 @@ v3d_write_uniforms(struct v3d_context *v3d, struct v3d_job *job, * the GPU. */ if (!cb->cb[unit].buffer) { - u_upload_data(v3d->uploader, 0, + u_upload_data_ref(v3d->uploader, 0, cb->cb[unit].buffer_size, 16, cb->cb[unit].user_buffer, &cb->cb[unit].buffer_offset, diff --git a/src/gallium/drivers/v3d/v3dx_draw.c b/src/gallium/drivers/v3d/v3dx_draw.c index dfb30359864..3dac278c0dc 100644 --- a/src/gallium/drivers/v3d/v3dx_draw.c +++ b/src/gallium/drivers/v3d/v3dx_draw.c @@ -1290,7 +1290,7 @@ v3d_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info, if (info->has_user_indices) { unsigned start_offset = draws[0].start * info->index_size; prsc = NULL; - u_upload_data(v3d->uploader, start_offset, + u_upload_data_ref(v3d->uploader, start_offset, draws[0].count * info->index_size, 4, (char*)info->index.user + start_offset, &offset, &prsc); diff --git a/src/gallium/drivers/v3d/v3dx_state.c b/src/gallium/drivers/v3d/v3dx_state.c index e8b0034c57a..fb27f8cb626 100644 --- a/src/gallium/drivers/v3d/v3dx_state.c +++ b/src/gallium/drivers/v3d/v3dx_state.c @@ -309,7 +309,7 @@ v3d_set_vertex_buffers(struct pipe_context *pctx, assert(BITSET_SIZE(so->enabled_mask) <= 32); util_set_vertex_buffers_mask(so->vb, &so->enabled_mask[0], vb, - count, true); + count); so->count = BITSET_LAST_BIT(so->enabled_mask); @@ -441,7 +441,7 @@ v3d_vertex_state_create(struct pipe_context *pctx, unsigned num_elements, * elements use them. */ uint32_t *attrs; - u_upload_alloc(v3d->state_uploader, 0, + u_upload_alloc_ref(v3d->state_uploader, 0, V3D_MAX_VS_INPUTS * sizeof(float), 16, &so->defaults_offset, &so->defaults, (void **)&attrs); @@ -484,13 +484,12 @@ v3d_vertex_state_bind(struct pipe_context *pctx, void *hwcso) static void v3d_set_constant_buffer(struct pipe_context *pctx, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *cb) { struct v3d_context *v3d = v3d_context(pctx); struct v3d_constbuf_stateobj *so = &v3d->constbuf[shader]; - util_copy_constant_buffer(&so->cb[index], cb, take_ownership); + util_copy_constant_buffer(&so->cb[index], cb); /* Note that the gallium frontend can unbind constant buffers by * passing NULL here. @@ -789,7 +788,7 @@ v3d_create_sampler_state(struct pipe_context *pctx, int sampler_align = so->border_color_variants ? 32 : 8; int sampler_size = align(cl_packet_length(SAMPLER_STATE), sampler_align); int num_variants = (so->border_color_variants ? ARRAY_SIZE(so->sampler_state_offset) : 1); - u_upload_alloc(v3d->state_uploader, 0, + u_upload_alloc_ref(v3d->state_uploader, 0, sampler_size * num_variants, sampler_align, &so->sampler_state_offset[0], @@ -1345,7 +1344,7 @@ v3d_create_image_view_texture_shader_state(struct v3d_context *v3d, struct v3d_image_view *iview = &so->si[img]; void *map; - u_upload_alloc(v3d->uploader, 0, cl_packet_length(TEXTURE_SHADER_STATE), + u_upload_alloc_ref(v3d->uploader, 0, cl_packet_length(TEXTURE_SHADER_STATE), 32, &iview->tex_state_offset, &iview->tex_state, @@ -1470,6 +1469,7 @@ v3dX(state_init)(struct pipe_context *pctx) pctx->create_sampler_view = v3d_create_sampler_view; pctx->sampler_view_destroy = v3d_sampler_view_destroy; pctx->sampler_view_release = u_default_sampler_view_release; + pctx->resource_release = u_default_resource_release; pctx->set_sampler_views = v3d_set_sampler_views; pctx->set_shader_buffers = v3d_set_shader_buffers; diff --git a/src/gallium/drivers/vc4/vc4_blit.c b/src/gallium/drivers/vc4/vc4_blit.c index 9f9d621c8dd..505a16e8be2 100644 --- a/src/gallium/drivers/vc4/vc4_blit.c +++ b/src/gallium/drivers/vc4/vc4_blit.c @@ -385,14 +385,14 @@ vc4_yuv_blit(struct pipe_context *pctx, struct pipe_blit_info *info) .user_buffer = &stride, .buffer_size = sizeof(stride), }; - pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 0, false, &cb_uniforms); + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 0, &cb_uniforms); struct pipe_constant_buffer cb_src = { .buffer = info->src.resource, .buffer_offset = src->slices[info->src.level].offset, .buffer_size = (src->bo->size - src->slices[info->src.level].offset), }; - pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, false, &cb_src); + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, &cb_src); /* Unbind the textures, to make sure we don't try to recurse into the * shadow blit. @@ -408,7 +408,7 @@ vc4_yuv_blit(struct pipe_context *pctx, struct pipe_blit_info *info) util_blitter_restore_constant_buffer_state(vc4->blitter); /* Restore cb1 (util_blitter doesn't handle this one). */ struct pipe_constant_buffer cb_disabled = { 0 }; - pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, false, &cb_disabled); + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, &cb_disabled); pipe_resource_reference(&dst_surf.texture, NULL); diff --git a/src/gallium/drivers/vc4/vc4_draw.c b/src/gallium/drivers/vc4/vc4_draw.c index 07d178ceb6a..84566b80938 100644 --- a/src/gallium/drivers/vc4/vc4_draw.c +++ b/src/gallium/drivers/vc4/vc4_draw.c @@ -403,7 +403,7 @@ vc4_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info, if (info->has_user_indices) { unsigned start_offset = draws[0].start * info->index_size; prsc = NULL; - u_upload_data(vc4->uploader, start_offset, + u_upload_data_ref(vc4->uploader, start_offset, draws[0].count * index_size, 4, (char*)info->index.user + start_offset, &offset, &prsc); diff --git a/src/gallium/drivers/vc4/vc4_resource.c b/src/gallium/drivers/vc4/vc4_resource.c index 2fa66f78115..c69224d57ec 100644 --- a/src/gallium/drivers/vc4/vc4_resource.c +++ b/src/gallium/drivers/vc4/vc4_resource.c @@ -1130,7 +1130,7 @@ vc4_get_shadow_index_buffer(struct pipe_context *pctx, void *data; struct pipe_resource *shadow_rsc = NULL; - u_upload_alloc(vc4->uploader, 0, count * 2, 4, + u_upload_alloc_ref(vc4->uploader, 0, count * 2, 4, shadow_offset, &shadow_rsc, &data); uint16_t *dst = data; diff --git a/src/gallium/drivers/vc4/vc4_state.c b/src/gallium/drivers/vc4/vc4_state.c index e677969c87e..583d68f8fb7 100644 --- a/src/gallium/drivers/vc4/vc4_state.c +++ b/src/gallium/drivers/vc4/vc4_state.c @@ -310,7 +310,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, true); + count); so->count = util_last_bit(so->enabled_mask); vc4->dirty |= VC4_DIRTY_VTXBUF; @@ -373,7 +373,6 @@ vc4_vertex_state_bind(struct pipe_context *pctx, void *hwcso) static void vc4_set_constant_buffer(struct pipe_context *pctx, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *cb) { struct vc4_context *vc4 = vc4_context(pctx); @@ -391,7 +390,7 @@ vc4_set_constant_buffer(struct pipe_context *pctx, if (index == 1 && so->cb[index].buffer_size != cb->buffer_size) vc4->dirty |= VC4_DIRTY_UBO_1_SIZE; - util_copy_constant_buffer(&so->cb[index], cb, take_ownership); + util_copy_constant_buffer(&so->cb[index], cb); so->enabled_mask |= 1 << index; so->dirty_mask |= 1 << index; @@ -698,5 +697,6 @@ vc4_state_init(struct pipe_context *pctx) pctx->create_sampler_view = vc4_create_sampler_view; pctx->sampler_view_destroy = vc4_sampler_view_destroy; pctx->sampler_view_release = u_default_sampler_view_release; + pctx->resource_release = u_default_resource_release; pctx->set_sampler_views = vc4_set_sampler_views; } diff --git a/src/gallium/drivers/vc4/vc4_uniforms.c b/src/gallium/drivers/vc4/vc4_uniforms.c index 6a7d1c90a01..5f06f7071a4 100644 --- a/src/gallium/drivers/vc4/vc4_uniforms.c +++ b/src/gallium/drivers/vc4/vc4_uniforms.c @@ -252,7 +252,7 @@ vc4_write_uniforms(struct vc4_context *vc4, struct vc4_compiled_shader *shader, * the GPU. */ if (!cb->cb[0].buffer) { - u_upload_data(vc4->uploader, 0, + u_upload_data_ref(vc4->uploader, 0, cb->cb[0].buffer_size, 16, cb->cb[0].user_buffer, &cb->cb[0].buffer_offset, diff --git a/src/gallium/drivers/virgl/virgl_context.c b/src/gallium/drivers/virgl/virgl_context.c index 498bd000e63..fb636486d3e 100644 --- a/src/gallium/drivers/virgl/virgl_context.c +++ b/src/gallium/drivers/virgl/virgl_context.c @@ -580,8 +580,7 @@ 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, - true); + buffers, num_buffers); if (buffers) { for (unsigned i = 0; i < num_buffers; i++) { @@ -638,7 +637,6 @@ static void virgl_hw_set_index_buffer(struct virgl_context *vctx, static void virgl_set_constant_buffer(struct pipe_context *ctx, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *buf) { struct virgl_context *vctx = virgl_context(ctx); @@ -653,12 +651,7 @@ static void virgl_set_constant_buffer(struct pipe_context *ctx, buf->buffer_offset, buf->buffer_size, res); - if (take_ownership) { - pipe_resource_reference(&binding->ubos[index].buffer, NULL); - binding->ubos[index].buffer = buf->buffer; - } else { - pipe_resource_reference(&binding->ubos[index].buffer, buf->buffer); - } + pipe_resource_reference(&binding->ubos[index].buffer, buf->buffer); binding->ubos[index] = *buf; binding->ubo_enabled_mask |= 1 << index; } else { @@ -1051,7 +1044,7 @@ static void virgl_draw_vbo(struct pipe_context *ctx, if (ib.user_buffer) { unsigned start_offset = draws[0].start * ib.index_size; - u_upload_data(vctx->uploader, 0, + u_upload_data_ref(vctx->uploader, 0, draws[0].count * ib.index_size, 4, (char*)ib.user_buffer + start_offset, &ib.offset, &ib.buffer); @@ -1785,6 +1778,7 @@ struct pipe_context *virgl_context_create(struct pipe_screen *pscreen, vctx->base.create_sampler_view = virgl_create_sampler_view; vctx->base.sampler_view_destroy = virgl_destroy_sampler_view; vctx->base.sampler_view_release = u_default_sampler_view_release; + vctx->base.resource_release = u_default_resource_release; vctx->base.set_sampler_views = virgl_set_sampler_views; vctx->base.texture_barrier = virgl_texture_barrier; diff --git a/src/gallium/drivers/zink/zink_context.c b/src/gallium/drivers/zink/zink_context.c index 46e2335efe6..25e3d0e27bc 100644 --- a/src/gallium/drivers/zink/zink_context.c +++ b/src/gallium/drivers/zink/zink_context.c @@ -1379,8 +1379,7 @@ zink_set_vertex_buffers_internal(struct pipe_context *pctx, const struct pipe_vertex_buffer *vb = buffers + i; struct pipe_vertex_buffer *ctx_vb = &ctx->vertex_buffers[i]; update_existing_vbo(ctx, i); - pipe_resource_reference(&ctx_vb->buffer.resource, NULL); - ctx_vb->buffer.resource = vb->buffer.resource; + pipe_resource_reference(&ctx_vb->buffer.resource, vb->buffer.resource); if (vb->buffer.resource) { struct zink_resource *res = zink_resource(vb->buffer.resource); @@ -1538,7 +1537,6 @@ invalidate_inlined_uniforms(struct zink_context *ctx, mesa_shader_stage pstage) ALWAYS_INLINE static void zink_set_constant_buffer_internal(struct pipe_context *pctx, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *cb, bool use_db) { @@ -1551,7 +1549,7 @@ zink_set_constant_buffer_internal(struct pipe_context *pctx, unsigned offset = cb->buffer_offset; struct zink_screen *screen = zink_screen(pctx->screen); if (cb->user_buffer) { - u_upload_data(ctx->base.const_uploader, 0, cb->buffer_size, + u_upload_data_ref(ctx->base.const_uploader, 0, cb->buffer_size, screen->info.props.limits.minUniformBufferOffsetAlignment, cb->user_buffer, &offset, &buffer); } @@ -1575,12 +1573,7 @@ zink_set_constant_buffer_internal(struct pipe_context *pctx, !!res != !!buffer || (res && res->obj->buffer != new_res->obj->buffer) || ctx->ubos[shader][index].buffer_size != cb->buffer_size; - if (take_ownership) { - pipe_resource_reference(&ctx->ubos[shader][index].buffer, NULL); - ctx->ubos[shader][index].buffer = buffer; - } else { - pipe_resource_reference(&ctx->ubos[shader][index].buffer, buffer); - } + pipe_resource_reference(&ctx->ubos[shader][index].buffer, buffer); ctx->ubos[shader][index].buffer_offset = offset; ctx->ubos[shader][index].buffer_size = cb->buffer_size; ctx->ubos[shader][index].user_buffer = NULL; @@ -1626,19 +1619,17 @@ zink_set_constant_buffer_internal(struct pipe_context *pctx, static void zink_set_constant_buffer_db(struct pipe_context *pctx, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *cb) { - zink_set_constant_buffer_internal(pctx, shader, index, take_ownership, cb, true); + zink_set_constant_buffer_internal(pctx, shader, index, cb, true); } static void zink_set_constant_buffer_lazy(struct pipe_context *pctx, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *cb) { - zink_set_constant_buffer_internal(pctx, shader, index, take_ownership, cb, false); + zink_set_constant_buffer_internal(pctx, shader, index, cb, false); } ALWAYS_INLINE static void @@ -5447,6 +5438,7 @@ zink_context_create(struct pipe_screen *pscreen, void *priv, unsigned flags) ctx->base.set_sampler_views = zink_set_sampler_views; ctx->base.sampler_view_destroy = zink_sampler_view_destroy; ctx->base.sampler_view_release = u_default_sampler_view_release; + ctx->base.resource_release = u_default_resource_release; ctx->base.get_sample_position = zink_get_sample_position; ctx->base.set_sample_locations = zink_set_sample_locations; diff --git a/src/gallium/drivers/zink/zink_draw.cpp b/src/gallium/drivers/zink/zink_draw.cpp index 7ee772e64e4..50583e758a3 100644 --- a/src/gallium/drivers/zink/zink_draw.cpp +++ b/src/gallium/drivers/zink/zink_draw.cpp @@ -389,7 +389,7 @@ zink_draw(struct pipe_context *pctx, zink_batch_reference_resource(ctx, zink_resource(index_buffer)); } else { index_buffer = dinfo->index.resource; - zink_batch_reference_resource_rw(ctx, zink_resource(index_buffer), false); + zink_batch_resource_usage_set(ctx->bs, zink_resource(index_buffer), false, true); } assert(index_size <= 4 && index_size != 3); assert(index_size != 1 || screen->info.have_EXT_index_type_uint8); diff --git a/src/gallium/drivers/zink/zink_resource.c b/src/gallium/drivers/zink/zink_resource.c index 8b09f8dd68a..e10a1005cd5 100644 --- a/src/gallium/drivers/zink/zink_resource.c +++ b/src/gallium/drivers/zink/zink_resource.c @@ -2413,7 +2413,7 @@ zink_buffer_map(struct pipe_context *pctx, mgr = ctx->tc->base.stream_uploader; else mgr = ctx->base.stream_uploader; - u_upload_alloc(mgr, 0, box->width, + u_upload_alloc_ref(mgr, 0, box->width, screen->info.props.limits.minMemoryMapAlignment, &offset, (struct pipe_resource **)&trans->staging_res, (void **)&ptr); trans->offset = offset; diff --git a/src/gallium/frontends/d3d10umd/Draw.cpp b/src/gallium/frontends/d3d10umd/Draw.cpp index 6f651f8faf8..3bf231ea486 100644 --- a/src/gallium/frontends/d3d10umd/Draw.cpp +++ b/src/gallium/frontends/d3d10umd/Draw.cpp @@ -105,7 +105,7 @@ ResolveState(Device *pDevice) update_velems(pDevice); if (pDevice->vbuffers_changed) { - cso_set_vertex_buffers(pDevice->cso, PIPE_MAX_ATTRIBS, false, pDevice->vertex_buffers); + cso_set_vertex_buffers(pDevice->cso, PIPE_MAX_ATTRIBS, pDevice->vertex_buffers); pDevice->vbuffers_changed = false; } } diff --git a/src/gallium/frontends/d3d10umd/Shader.cpp b/src/gallium/frontends/d3d10umd/Shader.cpp index 5f9171af156..df6ffa19dfa 100644 --- a/src/gallium/frontends/d3d10umd/Shader.cpp +++ b/src/gallium/frontends/d3d10umd/Shader.cpp @@ -174,7 +174,6 @@ SetConstantBuffers(mesa_shader_stage shader_type, // IN pipe->set_constant_buffer(pipe, shader_type, StartBuffer + i, - false, &cb); } } diff --git a/src/gallium/frontends/lavapipe/lvp_execute.c b/src/gallium/frontends/lavapipe/lvp_execute.c index 5aabebbb72d..ce01df69e34 100644 --- a/src/gallium/frontends/lavapipe/lvp_execute.c +++ b/src/gallium/frontends/lavapipe/lvp_execute.c @@ -93,6 +93,8 @@ struct rendering_state { struct u_upload_mgr *uploader; struct cso_context *cso; + struct util_dynarray releasebufs; + bool blend_dirty; bool rs_dirty; bool dsa_dirty; @@ -208,7 +210,6 @@ struct rendering_state { void *tess_states[2]; struct util_dynarray push_desc_sets; - struct util_dynarray internal_buffers; struct lvp_pipeline *exec_graph; @@ -302,9 +303,12 @@ update_pcbuf(struct rendering_state *state, mesa_shader_stage pstage, cbuf.buffer_size = size; cbuf.buffer = NULL; cbuf.user_buffer = NULL; - u_upload_alloc(state->uploader, 0, size, 64, &cbuf.buffer_offset, &cbuf.buffer, (void**)&mem); + struct pipe_resource *releasebuf = NULL; + u_upload_alloc(state->uploader, 0, size, 64, &cbuf.buffer_offset, &cbuf.buffer, &releasebuf, (void**)&mem); + if (releasebuf) + util_dynarray_append(&state->releasebufs, struct pipe_resource*, releasebuf); memcpy(mem, state->push_constants, size); - state->pctx->set_constant_buffer(state->pctx, pstage, 0, true, &cbuf); + state->pctx->set_constant_buffer(state->pctx, pstage, 0, &cbuf); } state->pcbuf_dirty[api_stage] = false; } @@ -317,7 +321,7 @@ static void emit_compute_state(struct rendering_state *state) if (state->constbuf_dirty[MESA_SHADER_COMPUTE]) { for (unsigned i = 0; i < state->num_const_bufs[MESA_SHADER_COMPUTE]; i++) state->pctx->set_constant_buffer(state->pctx, MESA_SHADER_COMPUTE, - i + 1, false, &state->const_buffer[MESA_SHADER_COMPUTE][i]); + i + 1, &state->const_buffer[MESA_SHADER_COMPUTE][i]); state->constbuf_dirty[MESA_SHADER_COMPUTE] = false; } @@ -494,7 +498,7 @@ static void emit_state(struct rendering_state *state) } if (state->vb_dirty) { - cso_set_vertex_buffers(state->cso, state->num_vb, false, state->vb); + cso_set_vertex_buffers(state->cso, state->num_vb, state->vb); state->vb_dirty = false; } @@ -502,7 +506,7 @@ static void emit_state(struct rendering_state *state) if (state->constbuf_dirty[sh]) { for (unsigned idx = 0; idx < state->num_const_bufs[sh]; idx++) state->pctx->set_constant_buffer(state->pctx, sh, - idx + 1, false, &state->const_buffer[sh][idx]); + idx + 1, &state->const_buffer[sh][idx]); } state->constbuf_dirty[sh] = false; } @@ -4365,12 +4369,13 @@ lvp_push_internal_buffer(struct rendering_state *state, mesa_shader_stage stage, }; uint8_t *mem; - u_upload_alloc(state->uploader, 0, size, 64, &buffer.buffer_offset, &buffer.buffer, (void**)&mem); + struct pipe_resource *releasebuf = NULL; + u_upload_alloc(state->uploader, 0, size, 64, &buffer.buffer_offset, &buffer.buffer, &releasebuf, (void**)&mem); + if (releasebuf) + util_dynarray_append(&state->releasebufs, struct pipe_resource*, releasebuf); state->pctx->set_shader_buffers(state->pctx, stage, 0, 1, &buffer, 0x1); - util_dynarray_append(&state->internal_buffers, struct pipe_resource *, buffer.buffer); - return mem; } @@ -4581,7 +4586,7 @@ lvp_trace_rays(struct rendering_state *state, VkTraceRaysIndirectCommand2KHR *co if (state->constbuf_dirty[MESA_SHADER_RAYGEN]) { for (unsigned i = 0; i < state->num_const_bufs[MESA_SHADER_RAYGEN]; i++) state->pctx->set_constant_buffer(state->pctx, MESA_SHADER_COMPUTE, - i + 1, false, &state->const_buffer[MESA_SHADER_RAYGEN][i]); + i + 1, &state->const_buffer[MESA_SHADER_RAYGEN][i]); state->constbuf_dirty[MESA_SHADER_RAYGEN] = false; } @@ -5380,7 +5385,7 @@ VkResult lvp_execute_cmds(struct lvp_device *device, state->sample_mask = UINT32_MAX; state->poison_mem = device->poison_mem; util_dynarray_init(&state->push_desc_sets, NULL); - util_dynarray_init(&state->internal_buffers, NULL); + util_dynarray_init(&state->releasebufs, NULL); /* default values */ state->min_sample_shading = 1; @@ -5418,12 +5423,13 @@ VkResult lvp_execute_cmds(struct lvp_device *device, util_dynarray_foreach (&state->push_desc_sets, struct lvp_descriptor_set *, set) lvp_descriptor_set_destroy(device, *set); + struct pipe_resource **pres = state->releasebufs.data; + unsigned count = util_dynarray_num_elements(&state->releasebufs, struct pipe_resource*); + for (unsigned j = 0; j < count; j++) + pipe_resource_release(state->pctx, pres[j]); + util_dynarray_fini(&state->push_desc_sets); - - util_dynarray_foreach (&state->internal_buffers, struct pipe_resource *, buffer) - pipe_resource_reference(buffer, NULL); - - util_dynarray_fini(&state->internal_buffers); + util_dynarray_fini(&state->releasebufs); for (unsigned i = 0; i < ARRAY_SIZE(state->desc_buffers); i++) pipe_resource_reference(&state->desc_buffers[i], NULL); diff --git a/src/gallium/frontends/rusticl/mesa/pipe/context.rs b/src/gallium/frontends/rusticl/mesa/pipe/context.rs index 7b8d80ec9bd..3450d27ef5d 100644 --- a/src/gallium/frontends/rusticl/mesa/pipe/context.rs +++ b/src/gallium/frontends/rusticl/mesa/pipe/context.rs @@ -433,7 +433,6 @@ impl PipeContext { self.pipe.as_ptr(), mesa_shader_stage::MESA_SHADER_COMPUTE, idx, - false, &cb, ) } @@ -451,7 +450,6 @@ impl PipeContext { self.pipe.as_ptr(), mesa_shader_stage::MESA_SHADER_COMPUTE, idx, - false, if data.is_empty() { ptr::null() } else { &cb }, ) } @@ -469,6 +467,7 @@ impl PipeContext { unsafe { let stream = self.pipe.as_ref().stream_uploader; + let mut releasebuf = ptr::null_mut(); u_upload_data( stream, 0, @@ -477,6 +476,7 @@ impl PipeContext { data.as_ptr().cast(), &mut cb.buffer_offset, &mut cb.buffer, + &mut releasebuf, ); u_upload_unmap(stream); @@ -488,9 +488,9 @@ impl PipeContext { self.pipe.as_ptr(), mesa_shader_stage::MESA_SHADER_COMPUTE, idx, - true, &cb, ); + self.pipe.as_ref().resource_release.unwrap()(self.pipe.as_ptr(), releasebuf); true } diff --git a/src/gallium/include/pipe/p_context.h b/src/gallium/include/pipe/p_context.h index 79a9d5124c3..e70a1d4c903 100644 --- a/src/gallium/include/pipe/p_context.h +++ b/src/gallium/include/pipe/p_context.h @@ -460,13 +460,10 @@ struct pipe_context { * * \param shader Shader stage * \param index Buffer binding slot index within a shader stage - * \param take_ownership The callee takes ownership of the buffer reference. - * (the callee shouldn't increment the ref count) * \param buf Constant buffer parameters */ void (*set_constant_buffer)(struct pipe_context *, mesa_shader_stage shader, uint index, - bool take_ownership, const struct pipe_constant_buffer *buf); /** @@ -620,11 +617,6 @@ struct pipe_context { /** * Bind an array of vertex buffers to the specified slots. * - * Unlike other set functions, the caller should always increment - * the buffer reference counts because the driver should only copy - * the pipe_resource pointers. This is the same behavior as setting - * take_ownership = true in other functions. - * * count must be equal to the maximum used vertex buffer index + 1 * in vertex elements or 0. * @@ -964,6 +956,13 @@ struct pipe_context { bool (*resource_commit)(struct pipe_context *, struct pipe_resource *, unsigned level, struct pipe_box *box, bool commit); + /** + * Signal the driver that the frontend has released a resource. + * + * Following this call, the driver has full ownership of the resource. + */ + void (*resource_release)(struct pipe_context *, struct pipe_resource *); + /** * Creates a video codec for a specific video format/profile */ diff --git a/src/gallium/include/pipe/p_state.h b/src/gallium/include/pipe/p_state.h index 6cb73977612..733d21ac6db 100644 --- a/src/gallium/include/pipe/p_state.h +++ b/src/gallium/include/pipe/p_state.h @@ -848,11 +848,9 @@ struct pipe_draw_info bool index_bounds_valid:1; /**< whether min_index and max_index are valid; they're always invalid if index_size == 0 */ bool increment_draw_id:1; /**< whether drawid increments for direct draws */ - bool take_index_buffer_ownership:1; /**< callee inherits caller's refcount - (no need to reference indexbuf, but still needs to unreference it) */ bool index_bias_varies:1; /**< true if index_bias varies between draws */ bool was_line_loop:1; /**< true if mesa_prim was LINE_LOOP before translation */ - uint8_t _pad:1; + uint8_t _pad:2; unsigned start_instance; /**< first instance id */ unsigned instance_count; /**< number of instances */ diff --git a/src/gallium/tools/trace/dump_state.py b/src/gallium/tools/trace/dump_state.py index bce4fcda110..cc0b0a2961c 100755 --- a/src/gallium/tools/trace/dump_state.py +++ b/src/gallium/tools/trace/dump_state.py @@ -422,7 +422,7 @@ class Context(Dispatcher): return self._state.fs assert False - def set_constant_buffer(self, shader, index, take_ownership, constant_buffer): + def set_constant_buffer(self, shader, index, constant_buffer): self._update(self._get_stage_state(shader).constant_buffer, index, 1, [constant_buffer]) def set_framebuffer_state(self, state): diff --git a/src/mesa/main/bufferobj.c b/src/mesa/main/bufferobj.c index 992587357a7..6b598a5b48b 100644 --- a/src/mesa/main/bufferobj.c +++ b/src/mesa/main/bufferobj.c @@ -40,6 +40,7 @@ #include "bufferobj.h" #include "externalobjects.h" #include "mtypes.h" +#include "shared.h" #include "teximage.h" #include "glformats.h" #include "texstore.h" @@ -258,21 +259,9 @@ buffer_usage(GLenum target, GLboolean immutable, static void _mesa_bufferobj_release_buffer(struct gl_context *ctx, struct gl_buffer_object *obj) { - if (!obj->buffer) - return; - - /* Subtract the remaining private references before unreferencing - * the buffer. See the header file for explanation. - */ - if (obj->private_refcount) { - assert(obj->private_refcount > 0); - p_atomic_add(&obj->buffer->reference.count, - -obj->private_refcount); - obj->private_refcount = 0; - } - obj->private_refcount_ctx = NULL; - - pipe_resource_reference(&obj->buffer, NULL); + if (obj->buffer) + _mesa_release_pending_resource(ctx, obj->buffer, true); + obj->buffer = NULL; } static ALWAYS_INLINE GLboolean @@ -379,8 +368,6 @@ bufferobj_data(struct gl_context *ctx, obj->Size = 0; return GL_FALSE; } - - obj->private_refcount_ctx = ctx; } /* The current buffer may be bound, so we have to revalidate all atoms that @@ -1163,6 +1150,13 @@ unreference_zombie_buffers_for_ctx(struct gl_context *ctx) detach_ctx_from_buffer(ctx, buf); } } + + set_foreach(&ctx->Shared->ReleaseResources, entry) { + struct pipe_resource *releasebuf = (void*)entry->key; + if (_mesa_release_pending_resource(ctx, releasebuf, false)) + _mesa_set_remove(&ctx->Shared->ReleaseResources, entry); + } + _mesa_clear_releasebufs(ctx); } /** diff --git a/src/mesa/main/bufferobj.h b/src/mesa/main/bufferobj.h index e67bd4eb9f9..01833da8d6f 100644 --- a/src/mesa/main/bufferobj.h +++ b/src/mesa/main/bufferobj.h @@ -36,42 +36,6 @@ * Internal functions */ -static ALWAYS_INLINE struct pipe_resource * -_mesa_get_bufferobj_reference(struct gl_context *ctx, struct gl_buffer_object *obj) -{ - assert(obj); - struct pipe_resource *buffer = obj->buffer; - - /* Only one context is using the fast path. All other contexts must use - * the slow path. - */ - if (unlikely(obj->private_refcount_ctx != ctx || - obj->private_refcount <= 0)) { - if (buffer) { - if (obj->private_refcount_ctx != ctx) { - p_atomic_inc(&buffer->reference.count); - } else { - /* This is the number of atomic increments we will skip. */ - const unsigned count = 100000000; - p_atomic_add(&buffer->reference.count, count); - - /* Remove the reference that we return. */ - assert(obj->private_refcount == 0); - obj->private_refcount = count - 1; - } - } - return buffer; - } - - /* Return a buffer reference while decrementing the private refcount. - * The buffer must be non-NULL, which is implied by private_refcount_ctx - * being non-NULL. - */ - assert(buffer); - obj->private_refcount--; - return buffer; -} - void _mesa_bufferobj_subdata(struct gl_context *ctx, GLintptrARB offset, GLsizeiptrARB size, diff --git a/src/mesa/main/context.c b/src/mesa/main/context.c index e759d639597..81167a380f5 100644 --- a/src/mesa/main/context.c +++ b/src/mesa/main/context.c @@ -1040,6 +1040,11 @@ _mesa_initialize_context(struct gl_context *ctx, ctx->FirstTimeCurrent = GL_TRUE; + simple_mtx_lock(&ctx->Shared->Mutex); + list_addtail(&ctx->SharedLink, &ctx->Shared->Contexts); + simple_mtx_unlock(&ctx->Shared->Mutex); + util_dynarray_init(&ctx->ReleaseResources, NULL); + return GL_TRUE; fail: @@ -1122,6 +1127,14 @@ _mesa_free_context_data(struct gl_context *ctx, bool destroy_debug_output) free(ctx->MarshalExec); /* Shared context state (display lists, textures, etc) */ + simple_mtx_lock(&ctx->Shared->Mutex); + list_del(&ctx->SharedLink); + + _mesa_clear_releasebufs(ctx); + util_dynarray_fini(&ctx->ReleaseResources); + + simple_mtx_unlock(&ctx->Shared->Mutex); + _mesa_reference_shared_state(ctx, &ctx->Shared, NULL); if (destroy_debug_output) @@ -1148,6 +1161,15 @@ _mesa_free_context_data(struct gl_context *ctx, bool destroy_debug_output) free(ctx->tmp_draws); } +void +_mesa_clear_releasebufs(struct gl_context *ctx) +{ + struct pipe_resource **pres = ctx->ReleaseResources.data; + unsigned count = util_dynarray_num_elements(&ctx->ReleaseResources, struct pipe_resource*); + for (unsigned j = 0; j < count; j++) + pipe_resource_release(ctx->pipe, pres[j]); + util_dynarray_clear(&ctx->ReleaseResources); +} /** * Copy attribute groups from one context to another. diff --git a/src/mesa/main/context.h b/src/mesa/main/context.h index eec823ce83b..06bfe91b003 100644 --- a/src/mesa/main/context.h +++ b/src/mesa/main/context.h @@ -541,6 +541,8 @@ _mesa_has_internalformat_query(const struct gl_context *ctx) _mesa_is_gles3(ctx); } +void +_mesa_clear_releasebufs(struct gl_context *ctx); #ifdef __cplusplus } #endif diff --git a/src/mesa/main/draw.c b/src/mesa/main/draw.c index be1c704efdf..15cbe17064f 100644 --- a/src/mesa/main/draw.c +++ b/src/mesa/main/draw.c @@ -1162,7 +1162,6 @@ _mesa_draw_arrays(struct gl_context *ctx, GLenum mode, GLint start, info.index_bounds_valid = true; info.increment_draw_id = false; info.was_line_loop = false; - info.take_index_buffer_ownership = false; info.index_bias_varies = false; /* Packed section end. */ info.start_instance = baseInstance; @@ -1469,7 +1468,6 @@ _mesa_MultiDrawArrays(GLenum mode, const GLint *first, info.index_bounds_valid = false; info.increment_draw_id = primcount > 1; info.was_line_loop = false; - info.take_index_buffer_ownership = false; info.index_bias_varies = false; /* Packed section end. */ info.start_instance = 0; @@ -1630,8 +1628,7 @@ _mesa_validated_drawrangeelements(struct gl_context *ctx, if (index_bo && ctx->Driver.DrawGallium == st_draw_gallium && st->cso_context->draw_vbo == tc_draw_vbo && ctx->DrawID == 0) { assert(!st->draw_needs_minmax_index); - struct pipe_resource *index_buffer = - _mesa_get_bufferobj_reference(ctx, index_bo); + struct pipe_resource *index_buffer = index_bo->buffer; struct tc_draw_single *draw = tc_add_draw_single_call(st->pipe, index_buffer); bool primitive_restart = ctx->Array._PrimitiveRestart[index_size_shift]; @@ -1646,7 +1643,6 @@ _mesa_validated_drawrangeelements(struct gl_context *ctx, draw->info.has_user_indices = false; draw->info.index_bounds_valid = false; draw->info.increment_draw_id = false; - draw->info.take_index_buffer_ownership = false; draw->info.index_bias_varies = false; draw->info.was_line_loop = false; draw->info._pad = 0; @@ -1675,7 +1671,6 @@ _mesa_validated_drawrangeelements(struct gl_context *ctx, info.index_bounds_valid = index_bounds_valid; info.increment_draw_id = false; info.was_line_loop = false; - info.take_index_buffer_ownership = false; info.index_bias_varies = false; /* Packed section end. */ info.start_instance = baseInstance; @@ -1687,14 +1682,7 @@ _mesa_validated_drawrangeelements(struct gl_context *ctx, draw.start = 0; } else { draw.start = (uintptr_t)indices >> index_size_shift; - - if (ctx->pipe->draw_vbo == tc_draw_vbo) { - /* Fast path for u_threaded_context to eliminate atomics. */ - info.index.resource = _mesa_get_bufferobj_reference(ctx, index_bo); - info.take_index_buffer_ownership = true; - } else { - info.index.resource = index_bo->buffer; - } + info.index.resource = index_bo->buffer; } draw.index_bias = basevertex; @@ -2065,7 +2053,6 @@ _mesa_validated_multidrawelements(struct gl_context *ctx, info.index_bounds_valid = false; info.increment_draw_id = primcount > 1; info.was_line_loop = false; - info.take_index_buffer_ownership = false; info.index_bias_varies = !!basevertex; /* Packed section end. */ info.start_instance = 0; @@ -2075,13 +2062,7 @@ _mesa_validated_multidrawelements(struct gl_context *ctx, if (info.has_user_indices) { info.index.user = (void*)min_index_ptr; } else { - if (ctx->pipe->draw_vbo == tc_draw_vbo) { - /* Fast path for u_threaded_context to eliminate atomics. */ - info.index.resource = _mesa_get_bufferobj_reference(ctx, index_bo); - info.take_index_buffer_ownership = true; - } else { - info.index.resource = index_bo->buffer; - } + info.index.resource = index_bo->buffer; /* No index buffer storage allocated - nothing to do. */ if (!info.index.resource) @@ -2457,7 +2438,6 @@ _mesa_MultiDrawArraysIndirect(GLenum mode, const GLvoid *indirect, info.index_bounds_valid = false; info.increment_draw_id = primcount > 1; info.was_line_loop = false; - info.take_index_buffer_ownership = false; info.index_bias_varies = false; /* Packed section end. */ @@ -2552,25 +2532,13 @@ _mesa_MultiDrawElementsIndirect(GLenum mode, GLenum type, info.index_bounds_valid = false; info.increment_draw_id = primcount > 1; info.was_line_loop = false; - info.take_index_buffer_ownership = false; info.index_bias_varies = false; /* Packed section end. */ info.restart_index = ctx->Array._RestartIndex[index_size_shift]; struct gl_buffer_object *index_bo = ctx->Array.VAO->IndexBufferObj; - if (ctx->pipe->draw_vbo == tc_draw_vbo) { - /* Fast path for u_threaded_context to eliminate atomics. */ - info.index.resource = _mesa_get_bufferobj_reference(ctx, index_bo); - info.take_index_buffer_ownership = true; - /* Increase refcount so be able to use take_index_buffer_ownership with - * multiple draws. - */ - if (primcount > 1 && info.index.resource) - p_atomic_add(&info.index.resource->reference.count, primcount - 1); - } else { - info.index.resource = index_bo->buffer; - } + info.index.resource = index_bo->buffer; /* No index buffer storage allocated - nothing to do. */ if (!info.index.resource) diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h index 9e647c157b6..cf9c8cfd4b3 100644 --- a/src/mesa/main/mtypes.h +++ b/src/mesa/main/mtypes.h @@ -52,6 +52,7 @@ #include "main/formats.h" /* MESA_FORMAT_COUNT */ #include "util/u_idalloc.h" #include "util/simple_mtx.h" +#include "util/set.h" #include "util/u_dynarray.h" #include "vbo/vbo.h" #include "state_tracker/st_atom.h" @@ -1443,22 +1444,6 @@ struct gl_buffer_object gl_buffer_usage UsageHistory; /**< How has this buffer been used so far? */ struct pipe_resource *buffer; - struct gl_context *private_refcount_ctx; - /* This mechanism allows passing buffer references to the driver without - * using atomics to increase the reference count. - * - * This private refcount can be decremented without atomics but only one - * context (ctx above) can use this counter to be thread-safe. - * - * This number is atomically added to buffer->reference.count at - * initialization. If it's never used, the same number is atomically - * subtracted from buffer->reference.count before destruction. If this - * number is decremented, we can pass that reference to the driver without - * touching reference.count. At buffer destruction we only subtract - * the number of references we did not return. This can possibly turn - * a million atomic increments into 1 add and 1 subtract atomic op. - */ - int private_refcount; GLbitfield StorageFlags; /**< GL_MAP_PERSISTENT_BIT, etc. */ @@ -2426,6 +2411,9 @@ struct gl_shared_state GLint RefCount; /**< Reference count */ bool DisplayListsAffectGLThread; + struct list_head Contexts; /**< gl_context objects */ + struct set ReleaseResources; /**< in use by some context */ + struct _mesa_HashTable DisplayList; /**< Display lists hash table */ struct _mesa_HashTable TexObjects; /**< Texture objects hash table */ @@ -3273,6 +3261,10 @@ struct gl_context { /** State possibly shared with other contexts in the address space */ struct gl_shared_state *Shared; + struct list_head SharedLink; + + /** Only accessible while Shared->Mutex is held */ + struct util_dynarray ReleaseResources; /** Whether Shared->BufferObjects has already been locked for this context. */ bool BufferObjectsLocked; diff --git a/src/mesa/main/shared.c b/src/mesa/main/shared.c index 6d423fcd0d6..3d2e92bffe5 100644 --- a/src/mesa/main/shared.c +++ b/src/mesa/main/shared.c @@ -48,6 +48,8 @@ #include "util/set.h" #include "util/u_memory.h" #include "util/u_process.h" +#include "util/u_threaded_context.h" +#include "state_tracker/st_context.h" static void free_shared_state(struct gl_context *ctx, struct gl_shared_state *shared); @@ -77,6 +79,8 @@ _mesa_alloc_shared_state(struct gl_context *ctx, _mesa_InitHashTable(&shared->DisplayList); _mesa_InitHashTable(&shared->TexObjects); _mesa_InitHashTable(&shared->Programs); + list_inithead(&shared->Contexts); + _mesa_set_init(&shared->ReleaseResources, NULL, _mesa_hash_pointer, _mesa_key_pointer_equal); shared->DefaultVertexProgram = ctx->Driver.NewProgram(ctx, MESA_SHADER_VERTEX, 0, true); @@ -414,6 +418,10 @@ free_shared_state(struct gl_context *ctx, struct gl_shared_state *shared) _mesa_DeinitHashTable(&shared->SemaphoreObjects, delete_semaphore_object_cb, ctx); + /* these should all be deleted by now */ + assert(!shared->ReleaseResources.entries); + _mesa_set_fini(&shared->ReleaseResources, NULL); + simple_mtx_destroy(&shared->Mutex); simple_mtx_destroy(&shared->TexMutex); @@ -459,3 +467,64 @@ _mesa_reference_shared_state(struct gl_context *ctx, simple_mtx_unlock(&state->Mutex); } } + +static bool +_mesa_check_shared_resource_usage(struct gl_context *ctx, struct pipe_resource *resource, struct gl_context **only_user) +{ + unsigned busy_count = 0; + /* iterate over all the shared contexts and check tc for resource usage */ + list_for_each_entry(struct gl_context, shared_ctx, &ctx->Shared->Contexts, SharedLink) { + bool is_busy = threaded_context_is_buffer_on_busy_list(shared_ctx->st->pipe, resource); + if (!is_busy) + continue; + *only_user = shared_ctx; + busy_count++; + } + /* if there is only one active user, return it */ + if (busy_count != 1) + *only_user = NULL; + return busy_count > 0; +} + +/* Pending resources cannot be released immediately in the case where there are multiple contexts and TC is used. + * Instead: + * - if there is only one context, it gets released to the driver + * - if there are multiple shared contexts, mesa iterates over all of them and checks the tc bufferlist to see whether the buffer is in use: + * - if the buffer is in use by multiple contexts, mesa will store the buffer to the shared data and check back later with normal zombie buffer prunes + * - if the buffer is in use by a single context, mesa will store the buffer onto that context, where it will be pruned naturally with zombie buffer prunes + * - if the buffer is not in use, it will be released to the driver + */ +bool +_mesa_release_pending_resource(struct gl_context *ctx, struct pipe_resource *resource, bool frontend_released) +{ + assert(resource); + assert(resource->target == PIPE_BUFFER); + + /* if tc is not in use or no contexts are shared with this one, just release */ + if (ctx->st->is_threaded_context && ctx->Shared->RefCount > 1) { + simple_mtx_lock(&ctx->Shared->Mutex); + + struct gl_context *only_user = NULL; + bool is_busy = _mesa_check_shared_resource_usage(ctx, resource, &only_user); + if (is_busy) { + if (only_user) { + if (only_user == ctx) + pipe_resource_release(ctx->pipe, resource); + else + /* this is an array of resources that the user context can immediately release next time it prunes */ + util_dynarray_append(&only_user->ReleaseResources, struct pipe_resource*, resource); + } else if (frontend_released) { + /* this is reached when the frontend object is destroyed and the pipe_resource is released */ + _mesa_set_add(&ctx->Shared->ReleaseResources, resource); + } + } + simple_mtx_unlock(&ctx->Shared->Mutex); + + /* returning true here indicates that the caller should remove the entry from Shared->ReleaseResources */ + if (is_busy) + return !!only_user; + } + + pipe_resource_release(ctx->pipe, resource); + return true; +} diff --git a/src/mesa/main/shared.h b/src/mesa/main/shared.h index e942567f0c7..aa91028b219 100644 --- a/src/mesa/main/shared.h +++ b/src/mesa/main/shared.h @@ -37,5 +37,6 @@ struct gl_shared_state * _mesa_alloc_shared_state(struct gl_context *ctx, const struct st_config_options *options); - +bool +_mesa_release_pending_resource(struct gl_context *ctx, struct pipe_resource *resource, bool frontend_released); #endif diff --git a/src/mesa/state_tracker/st_atom_array.cpp b/src/mesa/state_tracker/st_atom_array.cpp index 817d49b2554..ac48f859347 100644 --- a/src/mesa/state_tracker/st_atom_array.cpp +++ b/src/mesa/state_tracker/st_atom_array.cpp @@ -149,8 +149,7 @@ setup_arrays(struct gl_context *ctx, /* Set the vertex buffer. */ if (!ALLOW_USER_BUFFERS || binding->BufferObj) { assert(binding->BufferObj); - struct pipe_resource *buf = - _mesa_get_bufferobj_reference(ctx, binding->BufferObj); + struct pipe_resource *buf = binding->BufferObj->buffer; vbuffer[bufidx].buffer.resource = buf; vbuffer[bufidx].is_user_buffer = false; vbuffer[bufidx].buffer_offset = binding->Offset + @@ -215,8 +214,7 @@ setup_arrays(struct gl_context *ctx, if (binding->BufferObj) { /* Set the binding */ - vbuffer[bufidx].buffer.resource = - _mesa_get_bufferobj_reference(ctx, binding->BufferObj); + vbuffer[bufidx].buffer.resource = binding->BufferObj->buffer; vbuffer[bufidx].is_user_buffer = false; vbuffer[bufidx].buffer_offset = _mesa_draw_binding_offset(binding); } else { @@ -315,10 +313,11 @@ st_setup_current(struct st_context *st, st->pipe->const_uploader : st->pipe->stream_uploader; uint8_t *ptr = NULL; + struct pipe_resource *releasebuf = NULL; u_upload_alloc(uploader, 0, max_size, 16, &vbuffer[bufidx].buffer_offset, - &vbuffer[bufidx].buffer.resource, (void**)&ptr); + &vbuffer[bufidx].buffer.resource, &releasebuf, (void**)&ptr); uint8_t *cursor = ptr; if (FILL_TC_SET_VB) { @@ -355,6 +354,7 @@ st_setup_current(struct st_context *st, /* Always unmap. The uploader might use explicit flushes. */ u_upload_unmap(uploader); + st_add_releasebuf(st, releasebuf); } } @@ -479,7 +479,7 @@ st_update_array_templ(struct st_context *st, } else { /* Only vertex buffers. */ if (!FILL_TC_SET_VB) - cso_set_vertex_buffers(st->cso_context, num_vbuffers, true, vbuffer); + cso_set_vertex_buffers(st->cso_context, num_vbuffers, vbuffer); /* This can change only when we update vertex elements. */ assert(st->uses_user_vertex_buffers == uses_user_vertex_buffers); @@ -704,7 +704,5 @@ st_create_gallium_vertex_state(struct gl_context *ctx, indexbuf->buffer : NULL, enabled_arrays); - for (unsigned i = 0; i < num_vbuffers; i++) - pipe_vertex_buffer_unreference(&vbuffer[i]); return state; } diff --git a/src/mesa/state_tracker/st_atom_constbuf.c b/src/mesa/state_tracker/st_atom_constbuf.c index 115ed521fb3..737372e0034 100644 --- a/src/mesa/state_tracker/st_atom_constbuf.c +++ b/src/mesa/state_tracker/st_atom_constbuf.c @@ -57,7 +57,7 @@ st_unbind_unused_cb0(struct st_context *st, mesa_shader_stage shader_type) if (st->state.constbuf0_enabled_shader_mask & (1 << shader_type)) { struct pipe_context *pipe = st->pipe; - pipe->set_constant_buffer(pipe, shader_type, 0, false, NULL); + pipe->set_constant_buffer(pipe, shader_type, 0, NULL); st->state.constbuf0_enabled_shader_mask &= ~(1 << shader_type); } } @@ -123,6 +123,7 @@ st_upload_constants(struct st_context *st, struct gl_program *prog, mesa_shader_ /* this path cannot be used with select/feedback draws */ if (st->prefer_real_buffer_in_constbuf0) { struct pipe_context *pipe = st->pipe; + struct pipe_resource *releasebuf = NULL; uint32_t *ptr; const unsigned alignment = MAX2( @@ -133,7 +134,7 @@ st_upload_constants(struct st_context *st, struct gl_program *prog, mesa_shader_ * to compensate for the fetch_state defect. */ u_upload_alloc(pipe->const_uploader, 0, paramBytes + 12, - alignment, &cb.buffer_offset, &cb.buffer, (void**)&ptr); + alignment, &cb.buffer_offset, &cb.buffer, &releasebuf, (void**)&ptr); int uniform_bytes = params->UniformBytes; if (uniform_bytes) @@ -146,7 +147,7 @@ st_upload_constants(struct st_context *st, struct gl_program *prog, mesa_shader_ _mesa_upload_state_parameters(st->ctx, params, ptr); u_upload_unmap(pipe->const_uploader); - pipe->set_constant_buffer(pipe, stage, 0, true, &cb); + pipe->set_constant_buffer(pipe, stage, 0, &cb); /* Set inlinable constants. This is more involved because state * parameters are uploaded directly above instead of being loaded @@ -174,6 +175,7 @@ st_upload_constants(struct st_context *st, struct gl_program *prog, mesa_shader_ prog->info.num_inlinable_uniforms, values); } + st_add_releasebuf(st, releasebuf); } else { struct pipe_context *pipe = st->pipe; @@ -185,7 +187,7 @@ st_upload_constants(struct st_context *st, struct gl_program *prog, mesa_shader_ if (params->StateFlags) _mesa_load_state_parameters(st->ctx, params); - pipe->set_constant_buffer(pipe, stage, 0, false, &cb); + pipe->set_constant_buffer(pipe, stage, 0, &cb); /* Set inlinable constants. */ unsigned num_inlinable_uniforms = prog->info.num_inlinable_uniforms; @@ -303,8 +305,7 @@ st_bind_ubos(struct st_context *st, struct gl_program *prog, &st->ctx->UniformBufferBindings[prog->sh.UniformBlocks[i]->Binding]; if (binding->BufferObject) { - cb.buffer = _mesa_get_bufferobj_reference(st->ctx, - binding->BufferObject); + cb.buffer = binding->BufferObject->buffer; } else { cb.buffer = NULL; } @@ -324,7 +325,7 @@ st_bind_ubos(struct st_context *st, struct gl_program *prog, cb.buffer_size = 0; } - pipe->set_constant_buffer(pipe, shader_type, 1 + i, true, &cb); + pipe->set_constant_buffer(pipe, shader_type, 1 + i, &cb); } } diff --git a/src/mesa/state_tracker/st_atom_constbuf.h b/src/mesa/state_tracker/st_atom_constbuf.h index 6b338d96d8c..6a3ce5c1539 100644 --- a/src/mesa/state_tracker/st_atom_constbuf.h +++ b/src/mesa/state_tracker/st_atom_constbuf.h @@ -34,7 +34,6 @@ struct gl_program_parameter_list; struct st_context; - void st_upload_constants(struct st_context *st, struct gl_program *prog, mesa_shader_stage stage); diff --git a/src/mesa/state_tracker/st_cb_drawpixels.c b/src/mesa/state_tracker/st_cb_drawpixels.c index 05662dfc008..2f81bcdd6c7 100644 --- a/src/mesa/state_tracker/st_cb_drawpixels.c +++ b/src/mesa/state_tracker/st_cb_drawpixels.c @@ -1387,7 +1387,7 @@ st_DrawPixels(struct gl_context *ctx, GLint x, GLint y, for (unsigned i = 0; i < num_sampler_view; i++) st->pipe->sampler_view_release(st->pipe, sv[i]); - + /* free the texture (but may persist in the cache) */ pipe_resource_reference(&pt, NULL); } @@ -1919,7 +1919,7 @@ st_CopyPixels(struct gl_context *ctx, GLint srcx, GLint srcy, st->pipe->sampler_view_release(st->pipe, sv[0]); if (frontend_owns_sv1) st->pipe->sampler_view_release(st->pipe, sv[1]); - + pipe_resource_reference(&pt, NULL); } diff --git a/src/mesa/state_tracker/st_cb_drawtex.c b/src/mesa/state_tracker/st_cb_drawtex.c index fade6f004aa..518b9fc2a48 100644 --- a/src/mesa/state_tracker/st_cb_drawtex.c +++ b/src/mesa/state_tracker/st_cb_drawtex.c @@ -157,6 +157,7 @@ st_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z, numAttribs = 1 + emitColor + numTexCoords; /* load vertex buffer */ + struct pipe_resource *releasebuf = NULL; { #define SET_ATTRIB(VERT, ATTR, X, Y, Z, W) \ do { \ @@ -174,7 +175,7 @@ st_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z, u_upload_alloc(pipe->stream_uploader, 0, numAttribs * 4 * 4 * sizeof(GLfloat), 4, - &offset, &vbuffer, (void **) &vbuf); + &offset, &vbuffer, &releasebuf, (void **) &vbuf); if (!vbuffer) { return; } @@ -299,11 +300,13 @@ st_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z, } util_draw_vertex_buffer(pipe, cso, vbuffer, - offset, true, + offset, MESA_PRIM_TRIANGLE_FAN, 4, /* verts */ numAttribs); /* attribs/vert */ + pipe_resource_release(pipe, releasebuf); + /* restore state */ cso_restore_state(cso, 0); ctx->Array.NewVertexElements = true; diff --git a/src/mesa/state_tracker/st_context.c b/src/mesa/state_tracker/st_context.c index d02ed904558..31d298825f3 100644 --- a/src/mesa/state_tracker/st_context.c +++ b/src/mesa/state_tracker/st_context.c @@ -769,6 +769,8 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe, list_inithead(&st->zombie_shaders.list.node); simple_mtx_init(&st->zombie_shaders.mutex, mtx_plain); + util_dynarray_init(&st->release_resources, NULL); + ctx->Const.DriverSupportedPrimMask = screen->caps.supported_prim_modes | /* patches is always supported */ BITFIELD_BIT(MESA_PRIM_PATCHES); @@ -888,6 +890,28 @@ destroy_framebuffer_attachment_sampler_cb(void *data, void *userData) } } +void +st_prune_releasebufs(struct st_context *st) +{ + struct pipe_resource **pres = st->release_resources.data; + unsigned count = util_dynarray_num_elements(&st->release_resources, struct pipe_resource*); + for (unsigned j = 0; j < count; j++) + pipe_resource_release(st->pipe, pres[j]); + util_dynarray_clear(&st->release_resources); + st->release_counter = 0; +} + +void +st_add_releasebuf(struct st_context *st, struct pipe_resource *releasebuf) +{ + if (!releasebuf) + return; + if (st->release_counter != st->work_counter) + st_prune_releasebufs(st); + util_dynarray_append(&st->release_resources, struct pipe_resource*, releasebuf); + st->release_counter = st->work_counter; +} + void st_destroy_context(struct st_context *st) { @@ -935,6 +959,9 @@ st_destroy_context(struct st_context *st) } } + st_prune_releasebufs(st); + util_dynarray_fini(&st->release_resources); + st_release_program(st, &st->fp); st_release_program(st, &st->gp); st_release_program(st, &st->vp); diff --git a/src/mesa/state_tracker/st_context.h b/src/mesa/state_tracker/st_context.h index e2dba2da6ea..c06832831b0 100644 --- a/src/mesa/state_tracker/st_context.h +++ b/src/mesa/state_tracker/st_context.h @@ -279,6 +279,9 @@ struct st_context struct gl_program *current_program[MESA_SHADER_MESH_STAGES]; }; + struct util_dynarray release_resources; + unsigned release_counter; + struct st_common_variant *vp_variant; struct { @@ -548,6 +551,11 @@ st_context_add_work(struct st_context *st) } } +void +st_prune_releasebufs(struct st_context *st); + +void +st_add_releasebuf(struct st_context *st, struct pipe_resource *releasebuf); #ifdef __cplusplus } diff --git a/src/mesa/state_tracker/st_draw.c b/src/mesa/state_tracker/st_draw.c index b310e34a5f2..0f8fb6d7bbb 100644 --- a/src/mesa/state_tracker/st_draw.c +++ b/src/mesa/state_tracker/st_draw.c @@ -122,11 +122,6 @@ st_draw_gallium_multimode(struct gl_context *ctx, info->mode = mode[first]; cso_draw_vbo(cso, info, 0, NULL, &draws[first], i - first); first = i; - - /* We can pass the reference only once. st_buffer_object keeps - * the reference alive for later draws. - */ - info->take_index_buffer_ownership = false; } } } @@ -192,14 +187,7 @@ st_indirect_draw_vbo(struct gl_context *ctx, /* indices are always in a real VBO */ assert(bufobj); - if (st->pipe->draw_vbo == tc_draw_vbo && - (draw_count == 1 || st->has_multi_draw_indirect)) { - /* Fast path for u_threaded_context to eliminate atomics. */ - info.index.resource = _mesa_get_bufferobj_reference(ctx, bufobj); - info.take_index_buffer_ownership = true; - } else { - info.index.resource = bufobj->buffer; - } + info.index.resource = bufobj->buffer; /* No index buffer storage allocated - nothing to do. */ if (!info.index.resource) @@ -306,10 +294,11 @@ st_draw_quad(struct st_context *st, { struct pipe_vertex_buffer vb = {0}; struct st_util_vertex *verts; + struct pipe_resource *releasebuf = NULL; u_upload_alloc(st->pipe->stream_uploader, 0, 4 * sizeof(struct st_util_vertex), 4, - &vb.buffer_offset, &vb.buffer.resource, (void **) &verts); + &vb.buffer_offset, &vb.buffer.resource, &releasebuf, (void **) &verts); if (!vb.buffer.resource) { return false; } @@ -360,7 +349,7 @@ st_draw_quad(struct st_context *st, u_upload_unmap(st->pipe->stream_uploader); - cso_set_vertex_buffers(st->cso_context, 1, true, &vb); + cso_set_vertex_buffers(st->cso_context, 1, &vb); if (num_instances > 1) { cso_draw_arrays_instanced(st->cso_context, MESA_PRIM_TRIANGLE_FAN, 0, 4, @@ -368,6 +357,7 @@ st_draw_quad(struct st_context *st, } else { cso_draw_arrays(st->cso_context, MESA_PRIM_TRIANGLE_FAN, 0, 4); } + pipe_resource_release(st->pipe, releasebuf); return true; } @@ -418,11 +408,6 @@ st_hw_select_draw_gallium_multimode(struct gl_context *ctx, cso_draw_vbo(cso, info, 0, NULL, &draws[first], i - first); first = i; - - /* We can pass the reference only once. st_buffer_object keeps - * the reference alive for later draws. - */ - info->take_index_buffer_ownership = false; } } } diff --git a/src/mesa/state_tracker/st_draw_feedback.c b/src/mesa/state_tracker/st_draw_feedback.c index 1cd70f7730b..27bd452def0 100644 --- a/src/mesa/state_tracker/st_draw_feedback.c +++ b/src/mesa/state_tracker/st_draw_feedback.c @@ -457,8 +457,6 @@ st_feedback_draw_vbo(struct gl_context *ctx, if (vb_transfer[buf]) pipe_buffer_unmap(pipe, vb_transfer[buf]); draw_set_mapped_vertex_buffer(draw, buf, NULL, 0); - if (!vbuffers[buf].is_user_buffer) - pipe_resource_reference(&vbuffers[buf].buffer.resource, NULL); } draw_set_vertex_buffers(draw, 0, NULL); diff --git a/src/mesa/state_tracker/st_pbo.c b/src/mesa/state_tracker/st_pbo.c index 1f8156d6ab8..a7f71f78b53 100644 --- a/src/mesa/state_tracker/st_pbo.c +++ b/src/mesa/state_tracker/st_pbo.c @@ -214,6 +214,7 @@ st_pbo_draw(struct st_context *st, const struct st_pbo_addresses *addr, cso_set_mesh_shader_handle(cso, NULL); /* Upload vertices */ + struct pipe_resource *releasebuf = NULL; { struct pipe_vertex_buffer vbo = {0}; struct cso_velems_state velem; @@ -226,7 +227,7 @@ st_pbo_draw(struct st_context *st, const struct st_pbo_addresses *addr, float *verts = NULL; u_upload_alloc(st->pipe->stream_uploader, 0, 8 * sizeof(float), 4, - &vbo.buffer_offset, &vbo.buffer.resource, (void **) &verts); + &vbo.buffer_offset, &vbo.buffer.resource, &releasebuf, (void **) &verts); if (!verts) return false; @@ -250,7 +251,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, true, &vbo); + cso_set_vertex_buffers(cso, 1, &vbo); } /* Upload constants */ @@ -277,6 +278,7 @@ st_pbo_draw(struct st_context *st, const struct st_pbo_addresses *addr, cso_draw_arrays_instanced(cso, MESA_PRIM_TRIANGLE_STRIP, 0, 4, 0, addr->depth); } + pipe_resource_release(st->pipe, releasebuf); return true; }