Mesa (master): turnip: add tu_device pointer to tu_cs
GitLab Mirror
gitlab-mirror at kemper.freedesktop.org
Mon Feb 24 22:17:09 UTC 2020
Module: Mesa
Branch: master
Commit: 4b2a7dcd93f285ea88a110afa75cbac5d147e5cb
URL: http://cgit.freedesktop.org/mesa/mesa/commit/?id=4b2a7dcd93f285ea88a110afa75cbac5d147e5cb
Author: Jonathan Marek <jonathan at marek.ca>
Date: Mon Feb 24 08:57:00 2020 -0500
turnip: add tu_device pointer to tu_cs
Signed-off-by: Jonathan Marek <jonathan at marek.ca>
Reviewed-by: Eric Anholt <eric at anholt.net>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/merge_requests/3925>
---
src/freedreno/vulkan/tu_blit.c | 6 +--
src/freedreno/vulkan/tu_cmd_buffer.c | 96 +++++++++++++++++------------------
src/freedreno/vulkan/tu_cs.c | 43 ++++++++--------
src/freedreno/vulkan/tu_cs.h | 23 ++++-----
src/freedreno/vulkan/tu_meta_buffer.c | 2 +-
src/freedreno/vulkan/tu_pipeline.c | 25 +++++----
src/freedreno/vulkan/tu_private.h | 1 +
src/freedreno/vulkan/tu_query.c | 16 +++---
8 files changed, 103 insertions(+), 109 deletions(-)
diff --git a/src/freedreno/vulkan/tu_blit.c b/src/freedreno/vulkan/tu_blit.c
index b71effb62ed..73b04b4b0a0 100644
--- a/src/freedreno/vulkan/tu_blit.c
+++ b/src/freedreno/vulkan/tu_blit.c
@@ -84,7 +84,7 @@ emit_blit_step(struct tu_cmd_buffer *cmdbuf, struct tu_cs *cs,
{
struct tu_physical_device *phys_dev = cmdbuf->device->physical_device;
- tu_cs_reserve_space(cmdbuf->device, cs, 66);
+ tu_cs_reserve_space(cs, 66);
enum a6xx_format fmt = tu6_get_native_format(blt->dst.fmt)->rb;
if (fmt == FMT6_Z24_UNORM_S8_UINT)
@@ -280,7 +280,7 @@ void tu_blit(struct tu_cmd_buffer *cmdbuf, struct tu_cs *cs,
assert(blt->dst.samples == 1);
}
- tu_cs_reserve_space(cmdbuf->device, cs, 18);
+ tu_cs_reserve_space(cs, 18);
tu6_emit_event_write(cmdbuf, cs, LRZ_FLUSH, false);
tu6_emit_event_write(cmdbuf, cs, PC_CCU_FLUSH_COLOR_TS, true);
@@ -365,7 +365,7 @@ void tu_blit(struct tu_cmd_buffer *cmdbuf, struct tu_cs *cs,
blt->src.ubwc_va += blt->src.ubwc_size;
}
- tu_cs_reserve_space(cmdbuf->device, cs, 17);
+ tu_cs_reserve_space(cs, 17);
tu6_emit_event_write(cmdbuf, cs, PC_CCU_FLUSH_COLOR_TS, true);
tu6_emit_event_write(cmdbuf, cs, PC_CCU_FLUSH_DEPTH_TS, true);
diff --git a/src/freedreno/vulkan/tu_cmd_buffer.c b/src/freedreno/vulkan/tu_cmd_buffer.c
index 1528bab0035..9403f37b12d 100644
--- a/src/freedreno/vulkan/tu_cmd_buffer.c
+++ b/src/freedreno/vulkan/tu_cmd_buffer.c
@@ -1061,7 +1061,7 @@ tu6_emit_restart_index(struct tu_cs *cs, uint32_t restart_index)
static void
tu6_init_hw(struct tu_cmd_buffer *cmd, struct tu_cs *cs)
{
- VkResult result = tu_cs_reserve_space(cmd->device, cs, 256);
+ VkResult result = tu_cs_reserve_space(cs, 256);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -1486,12 +1486,12 @@ tu_cmd_prepare_sysmem_clear_ib(struct tu_cmd_buffer *cmd,
const struct tu_framebuffer *fb = cmd->state.framebuffer;
const uint32_t blit_cmd_space = 25 + 66 * fb->layers + 17;
const uint32_t clear_space =
- blit_cmd_space * cmd->state.pass->attachment_count + 5;
+ blit_cmd_space * cmd->state.pass->attachment_count + 5;
struct tu_cs sub_cs;
- VkResult result = tu_cs_begin_sub_stream(cmd->device, &cmd->sub_cs,
- clear_space, &sub_cs);
+ VkResult result =
+ tu_cs_begin_sub_stream(&cmd->sub_cs, clear_space, &sub_cs);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -1503,7 +1503,7 @@ tu_cmd_prepare_sysmem_clear_ib(struct tu_cmd_buffer *cmd,
/* TODO: We shouldn't need this flush, but without it we'd have an empty IB
* when nothing clears which we currently can't handle.
*/
- tu_cs_reserve_space(cmd->device, &sub_cs, 5);
+ tu_cs_reserve_space(&sub_cs, 5);
tu6_emit_event_write(cmd, &sub_cs, PC_CCU_FLUSH_COLOR_TS, true);
cmd->state.sysmem_clear_ib = tu_cs_end_sub_stream(&cmd->sub_cs, &sub_cs);
@@ -1513,7 +1513,7 @@ static void
tu6_sysmem_render_begin(struct tu_cmd_buffer *cmd, struct tu_cs *cs,
const struct VkRect2D *renderArea)
{
- VkResult result = tu_cs_reserve_space(cmd->device, cs, 1024);
+ VkResult result = tu_cs_reserve_space(cs, 1024);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -1582,7 +1582,7 @@ tu6_sysmem_render_end(struct tu_cmd_buffer *cmd, struct tu_cs *cs)
}
const uint32_t space = 14 + tu_cs_get_call_size(&cmd->draw_epilogue_cs);
- VkResult result = tu_cs_reserve_space(cmd->device, cs, space);
+ VkResult result = tu_cs_reserve_space(cs, space);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -1607,7 +1607,7 @@ tu6_tile_render_begin(struct tu_cmd_buffer *cmd, struct tu_cs *cs)
{
struct tu_physical_device *phys_dev = cmd->device->physical_device;
- VkResult result = tu_cs_reserve_space(cmd->device, cs, 1024);
+ VkResult result = tu_cs_reserve_space(cs, 1024);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -1668,7 +1668,7 @@ tu6_render_tile(struct tu_cmd_buffer *cmd,
const struct tu_tile *tile)
{
const uint32_t render_tile_space = 256 + tu_cs_get_call_size(&cmd->draw_cs);
- VkResult result = tu_cs_reserve_space(cmd->device, cs, render_tile_space);
+ VkResult result = tu_cs_reserve_space(cs, render_tile_space);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -1705,7 +1705,7 @@ static void
tu6_tile_render_end(struct tu_cmd_buffer *cmd, struct tu_cs *cs)
{
const uint32_t space = 16 + tu_cs_get_call_size(&cmd->draw_epilogue_cs);
- VkResult result = tu_cs_reserve_space(cmd->device, cs, space);
+ VkResult result = tu_cs_reserve_space(cs, space);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -1749,7 +1749,7 @@ tu_cmd_render_sysmem(struct tu_cmd_buffer *cmd)
tu6_sysmem_render_begin(cmd, &cmd->cs, &tiling->render_area);
const uint32_t space = tu_cs_get_call_size(&cmd->draw_cs);
- VkResult result = tu_cs_reserve_space(cmd->device, &cmd->cs, space);
+ VkResult result = tu_cs_reserve_space(&cmd->cs, space);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -1772,8 +1772,8 @@ tu_cmd_prepare_tile_load_ib(struct tu_cmd_buffer *cmd,
struct tu_cs sub_cs;
- VkResult result = tu_cs_begin_sub_stream(cmd->device, &cmd->sub_cs,
- tile_load_space, &sub_cs);
+ VkResult result =
+ tu_cs_begin_sub_stream(&cmd->sub_cs, tile_load_space, &sub_cs);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -1805,8 +1805,8 @@ tu_cmd_prepare_tile_store_ib(struct tu_cmd_buffer *cmd)
const uint32_t tile_store_space = 32 + 23 * cmd->state.pass->attachment_count;
struct tu_cs sub_cs;
- VkResult result = tu_cs_begin_sub_stream(cmd->device, &cmd->sub_cs,
- tile_store_space, &sub_cs);
+ VkResult result =
+ tu_cs_begin_sub_stream(&cmd->sub_cs, tile_store_space, &sub_cs);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -2004,10 +2004,10 @@ tu_create_cmd_buffer(struct tu_device *device,
}
tu_bo_list_init(&cmd_buffer->bo_list);
- tu_cs_init(&cmd_buffer->cs, TU_CS_MODE_GROW, 4096);
- tu_cs_init(&cmd_buffer->draw_cs, TU_CS_MODE_GROW, 4096);
- tu_cs_init(&cmd_buffer->draw_epilogue_cs, TU_CS_MODE_GROW, 4096);
- tu_cs_init(&cmd_buffer->sub_cs, TU_CS_MODE_SUB_STREAM, 2048);
+ tu_cs_init(&cmd_buffer->cs, device, TU_CS_MODE_GROW, 4096);
+ tu_cs_init(&cmd_buffer->draw_cs, device, TU_CS_MODE_GROW, 4096);
+ tu_cs_init(&cmd_buffer->draw_epilogue_cs, device, TU_CS_MODE_GROW, 4096);
+ tu_cs_init(&cmd_buffer->sub_cs, device, TU_CS_MODE_SUB_STREAM, 2048);
*pCommandBuffer = tu_cmd_buffer_to_handle(cmd_buffer);
@@ -2043,10 +2043,10 @@ tu_cmd_buffer_destroy(struct tu_cmd_buffer *cmd_buffer)
for (unsigned i = 0; i < VK_PIPELINE_BIND_POINT_RANGE_SIZE; i++)
free(cmd_buffer->descriptors[i].push_set.set.mapped_ptr);
- tu_cs_finish(cmd_buffer->device, &cmd_buffer->cs);
- tu_cs_finish(cmd_buffer->device, &cmd_buffer->draw_cs);
- tu_cs_finish(cmd_buffer->device, &cmd_buffer->draw_epilogue_cs);
- tu_cs_finish(cmd_buffer->device, &cmd_buffer->sub_cs);
+ tu_cs_finish(&cmd_buffer->cs);
+ tu_cs_finish(&cmd_buffer->draw_cs);
+ tu_cs_finish(&cmd_buffer->draw_epilogue_cs);
+ tu_cs_finish(&cmd_buffer->sub_cs);
tu_bo_list_destroy(&cmd_buffer->bo_list);
vk_free(&cmd_buffer->pool->alloc, cmd_buffer);
@@ -2060,10 +2060,10 @@ tu_reset_cmd_buffer(struct tu_cmd_buffer *cmd_buffer)
cmd_buffer->record_result = VK_SUCCESS;
tu_bo_list_reset(&cmd_buffer->bo_list);
- tu_cs_reset(cmd_buffer->device, &cmd_buffer->cs);
- tu_cs_reset(cmd_buffer->device, &cmd_buffer->draw_cs);
- tu_cs_reset(cmd_buffer->device, &cmd_buffer->draw_epilogue_cs);
- tu_cs_reset(cmd_buffer->device, &cmd_buffer->sub_cs);
+ tu_cs_reset(&cmd_buffer->cs);
+ tu_cs_reset(&cmd_buffer->draw_cs);
+ tu_cs_reset(&cmd_buffer->draw_epilogue_cs);
+ tu_cs_reset(&cmd_buffer->sub_cs);
for (unsigned i = 0; i < VK_PIPELINE_BIND_POINT_RANGE_SIZE; i++) {
cmd_buffer->descriptors[i].valid = 0;
@@ -2236,7 +2236,7 @@ tu_CmdBindIndexBuffer(VkCommandBuffer commandBuffer,
/* initialize/update the restart index */
if (!cmd->state.index_buffer || cmd->state.index_type != indexType) {
struct tu_cs *draw_cs = &cmd->draw_cs;
- VkResult result = tu_cs_reserve_space(cmd->device, draw_cs, 2);
+ VkResult result = tu_cs_reserve_space(draw_cs, 2);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -2386,7 +2386,7 @@ tu_CmdSetViewport(VkCommandBuffer commandBuffer,
TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
struct tu_cs *draw_cs = &cmd->draw_cs;
- VkResult result = tu_cs_reserve_space(cmd->device, draw_cs, 12);
+ VkResult result = tu_cs_reserve_space(draw_cs, 12);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -2407,7 +2407,7 @@ tu_CmdSetScissor(VkCommandBuffer commandBuffer,
TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
struct tu_cs *draw_cs = &cmd->draw_cs;
- VkResult result = tu_cs_reserve_space(cmd->device, draw_cs, 3);
+ VkResult result = tu_cs_reserve_space(draw_cs, 3);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -2439,7 +2439,7 @@ tu_CmdSetDepthBias(VkCommandBuffer commandBuffer,
TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
struct tu_cs *draw_cs = &cmd->draw_cs;
- VkResult result = tu_cs_reserve_space(cmd->device, draw_cs, 4);
+ VkResult result = tu_cs_reserve_space(draw_cs, 4);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -2458,7 +2458,7 @@ tu_CmdSetBlendConstants(VkCommandBuffer commandBuffer,
TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
struct tu_cs *draw_cs = &cmd->draw_cs;
- VkResult result = tu_cs_reserve_space(cmd->device, draw_cs, 5);
+ VkResult result = tu_cs_reserve_space(draw_cs, 5);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -2668,7 +2668,7 @@ tu_CmdBeginRenderPass(VkCommandBuffer commandBuffer,
tu_cmd_prepare_tile_load_ib(cmd, pRenderPassBegin);
tu_cmd_prepare_tile_store_ib(cmd);
- VkResult result = tu_cs_reserve_space(cmd->device, &cmd->draw_cs, 1024);
+ VkResult result = tu_cs_reserve_space(&cmd->draw_cs, 1024);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -2722,7 +2722,7 @@ tu_CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
}
}
- VkResult result = tu_cs_reserve_space(cmd->device, &cmd->draw_cs, 1024);
+ VkResult result = tu_cs_reserve_space(&cmd->draw_cs, 1024);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -3142,7 +3142,7 @@ tu6_emit_consts(struct tu_cmd_buffer *cmd,
gl_shader_stage type)
{
struct tu_cs cs;
- tu_cs_begin_sub_stream(cmd->device, &cmd->sub_cs, 512, &cs); /* TODO: maximum size? */
+ tu_cs_begin_sub_stream(&cmd->sub_cs, 512, &cs); /* TODO: maximum size? */
tu6_emit_user_consts(&cs, pipeline, descriptors_state, type, cmd->push_constants);
tu6_emit_ubos(&cs, pipeline, descriptors_state, type);
@@ -3166,7 +3166,7 @@ tu6_emit_vs_params(struct tu_cmd_buffer *cmd,
return VK_SUCCESS;
}
- VkResult result = tu_cs_begin_sub_stream(cmd->device, &cmd->sub_cs, 8, &cs);
+ VkResult result = tu_cs_begin_sub_stream(&cmd->sub_cs, 8, &cs);
if (result != VK_SUCCESS)
return result;
@@ -3199,7 +3199,6 @@ tu6_emit_textures(struct tu_cmd_buffer *cmd,
bool *needs_border,
bool is_sysmem)
{
- struct tu_device *device = cmd->device;
struct tu_cs *draw_state = &cmd->sub_cs;
const struct tu_program_descriptor_linkage *link =
&pipeline->program.link[type];
@@ -3212,7 +3211,7 @@ tu6_emit_textures(struct tu_cmd_buffer *cmd,
/* allocate and fill texture state */
struct ts_cs_memory tex_const;
- result = tu_cs_alloc(device, draw_state, link->texture_map.num_desc,
+ result = tu_cs_alloc(draw_state, link->texture_map.num_desc,
A6XX_TEX_CONST_DWORDS, &tex_const);
if (result != VK_SUCCESS)
return result;
@@ -3230,7 +3229,7 @@ tu6_emit_textures(struct tu_cmd_buffer *cmd,
/* allocate and fill sampler state */
struct ts_cs_memory tex_samp = { 0 };
if (link->sampler_map.num_desc) {
- result = tu_cs_alloc(device, draw_state, link->sampler_map.num_desc,
+ result = tu_cs_alloc(draw_state, link->sampler_map.num_desc,
A6XX_TEX_SAMP_DWORDS, &tex_samp);
if (result != VK_SUCCESS)
return result;
@@ -3275,7 +3274,7 @@ tu6_emit_textures(struct tu_cmd_buffer *cmd,
}
struct tu_cs cs;
- result = tu_cs_begin_sub_stream(device, draw_state, 16, &cs);
+ result = tu_cs_begin_sub_stream(draw_state, 16, &cs);
if (result != VK_SUCCESS)
return result;
@@ -3319,7 +3318,6 @@ tu6_emit_ibo(struct tu_cmd_buffer *cmd,
gl_shader_stage type,
struct tu_cs_entry *entry)
{
- struct tu_device *device = cmd->device;
struct tu_cs *draw_state = &cmd->sub_cs;
const struct tu_program_descriptor_linkage *link =
&pipeline->program.link[type];
@@ -3333,7 +3331,7 @@ tu6_emit_ibo(struct tu_cmd_buffer *cmd,
}
struct ts_cs_memory ibo_const;
- result = tu_cs_alloc(device, draw_state, num_desc,
+ result = tu_cs_alloc(draw_state, num_desc,
A6XX_TEX_CONST_DWORDS, &ibo_const);
if (result != VK_SUCCESS)
return result;
@@ -3377,7 +3375,7 @@ tu6_emit_ibo(struct tu_cmd_buffer *cmd,
assert(ssbo_index == num_desc);
struct tu_cs cs;
- result = tu_cs_begin_sub_stream(device, draw_state, 7, &cs);
+ result = tu_cs_begin_sub_stream(draw_state, 7, &cs);
if (result != VK_SUCCESS)
return result;
@@ -3487,7 +3485,7 @@ tu6_emit_border_color(struct tu_cmd_buffer *cmd,
&pipeline->program.link[MESA_SHADER_FRAGMENT].sampler_map;
struct ts_cs_memory ptr;
- VkResult result = tu_cs_alloc(cmd->device, &cmd->sub_cs,
+ VkResult result = tu_cs_alloc(&cmd->sub_cs,
vs_sampler->num_desc + fs_sampler->num_desc,
128 / 4,
&ptr);
@@ -3530,7 +3528,7 @@ tu6_bind_draw_states(struct tu_cmd_buffer *cmd,
struct tu_descriptor_state *descriptors_state =
&cmd->descriptors[VK_PIPELINE_BIND_POINT_GRAPHICS];
- VkResult result = tu_cs_reserve_space(cmd->device, cs, 256);
+ VkResult result = tu_cs_reserve_space(cs, 256);
if (result != VK_SUCCESS)
return result;
@@ -3842,7 +3840,7 @@ tu_draw(struct tu_cmd_buffer *cmd, const struct tu_draw_info *draw)
return;
}
- result = tu_cs_reserve_space(cmd->device, cs, 32);
+ result = tu_cs_reserve_space(cs, 32);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -4017,7 +4015,7 @@ tu_dispatch(struct tu_cmd_buffer *cmd,
struct tu_descriptor_state *descriptors_state =
&cmd->descriptors[VK_PIPELINE_BIND_POINT_COMPUTE];
- VkResult result = tu_cs_reserve_space(cmd->device, cs, 256);
+ VkResult result = tu_cs_reserve_space(cs, 256);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -4249,7 +4247,7 @@ write_event(struct tu_cmd_buffer *cmd, struct tu_event *event, unsigned value)
{
struct tu_cs *cs = &cmd->cs;
- VkResult result = tu_cs_reserve_space(cmd->device, cs, 4);
+ VkResult result = tu_cs_reserve_space(cs, 4);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
@@ -4302,7 +4300,7 @@ tu_CmdWaitEvents(VkCommandBuffer commandBuffer,
TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
struct tu_cs *cs = &cmd->cs;
- VkResult result = tu_cs_reserve_space(cmd->device, cs, eventCount * 7);
+ VkResult result = tu_cs_reserve_space(cs, eventCount * 7);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
diff --git a/src/freedreno/vulkan/tu_cs.c b/src/freedreno/vulkan/tu_cs.c
index 4e7ea2b5022..6cb96b0926d 100644
--- a/src/freedreno/vulkan/tu_cs.c
+++ b/src/freedreno/vulkan/tu_cs.c
@@ -27,12 +27,16 @@
* Initialize a command stream.
*/
void
-tu_cs_init(struct tu_cs *cs, enum tu_cs_mode mode, uint32_t initial_size)
+tu_cs_init(struct tu_cs *cs,
+ struct tu_device *device,
+ enum tu_cs_mode mode,
+ uint32_t initial_size)
{
assert(mode != TU_CS_MODE_EXTERNAL);
memset(cs, 0, sizeof(*cs));
+ cs->device = device;
cs->mode = mode;
cs->next_bo_size = initial_size;
}
@@ -54,10 +58,10 @@ tu_cs_init_external(struct tu_cs *cs, uint32_t *start, uint32_t *end)
* Finish and release all resources owned by a command stream.
*/
void
-tu_cs_finish(struct tu_device *dev, struct tu_cs *cs)
+tu_cs_finish(struct tu_cs *cs)
{
for (uint32_t i = 0; i < cs->bo_count; ++i) {
- tu_bo_finish(dev, cs->bos[i]);
+ tu_bo_finish(cs->device, cs->bos[i]);
free(cs->bos[i]);
}
@@ -110,7 +114,7 @@ tu_cs_is_empty(const struct tu_cs *cs)
* be emitted to the new BO.
*/
static VkResult
-tu_cs_add_bo(struct tu_device *dev, struct tu_cs *cs, uint32_t size)
+tu_cs_add_bo(struct tu_cs *cs, uint32_t size)
{
/* no BO for TU_CS_MODE_EXTERNAL */
assert(cs->mode != TU_CS_MODE_EXTERNAL);
@@ -134,15 +138,16 @@ tu_cs_add_bo(struct tu_device *dev, struct tu_cs *cs, uint32_t size)
if (!new_bo)
return VK_ERROR_OUT_OF_HOST_MEMORY;
- VkResult result = tu_bo_init_new(dev, new_bo, size * sizeof(uint32_t));
+ VkResult result =
+ tu_bo_init_new(cs->device, new_bo, size * sizeof(uint32_t));
if (result != VK_SUCCESS) {
free(new_bo);
return result;
}
- result = tu_bo_map(dev, new_bo);
+ result = tu_bo_map(cs->device, new_bo);
if (result != VK_SUCCESS) {
- tu_bo_finish(dev, new_bo);
+ tu_bo_finish(cs->device, new_bo);
free(new_bo);
return result;
}
@@ -266,21 +271,18 @@ tu_cs_end(struct tu_cs *cs)
* emission.
*/
VkResult
-tu_cs_begin_sub_stream(struct tu_device *dev,
- struct tu_cs *cs,
- uint32_t size,
- struct tu_cs *sub_cs)
+tu_cs_begin_sub_stream(struct tu_cs *cs, uint32_t size, struct tu_cs *sub_cs)
{
assert(cs->mode == TU_CS_MODE_SUB_STREAM);
assert(size);
- VkResult result = tu_cs_reserve_space(dev, cs, size);
+ VkResult result = tu_cs_reserve_space(cs, size);
if (result != VK_SUCCESS)
return result;
tu_cs_init_external(sub_cs, cs->cur, cs->reserved_end);
tu_cs_begin(sub_cs);
- result = tu_cs_reserve_space(dev, sub_cs, size);
+ result = tu_cs_reserve_space(sub_cs, size);
assert(result == VK_SUCCESS);
return VK_SUCCESS;
@@ -292,8 +294,7 @@ tu_cs_begin_sub_stream(struct tu_device *dev,
*
*/
VkResult
-tu_cs_alloc(struct tu_device *dev,
- struct tu_cs *cs,
+tu_cs_alloc(struct tu_cs *cs,
uint32_t count,
uint32_t size,
struct ts_cs_memory *memory)
@@ -306,7 +307,7 @@ tu_cs_alloc(struct tu_device *dev,
/* TODO: smarter way to deal with alignment? */
- VkResult result = tu_cs_reserve_space(dev, cs, count * size + (size-1));
+ VkResult result = tu_cs_reserve_space(cs, count * size + (size-1));
if (result != VK_SUCCESS)
return result;
@@ -356,9 +357,7 @@ tu_cs_end_sub_stream(struct tu_cs *cs, struct tu_cs *sub_cs)
* This never fails when \a cs has mode TU_CS_MODE_EXTERNAL.
*/
VkResult
-tu_cs_reserve_space(struct tu_device *dev,
- struct tu_cs *cs,
- uint32_t reserved_size)
+tu_cs_reserve_space(struct tu_cs *cs, uint32_t reserved_size)
{
if (tu_cs_get_space(cs) < reserved_size) {
if (cs->mode == TU_CS_MODE_EXTERNAL) {
@@ -376,7 +375,7 @@ tu_cs_reserve_space(struct tu_device *dev,
/* switch to a new BO */
uint32_t new_size = MAX2(cs->next_bo_size, reserved_size);
- VkResult result = tu_cs_add_bo(dev, cs, new_size);
+ VkResult result = tu_cs_add_bo(cs, new_size);
if (result != VK_SUCCESS)
return result;
@@ -402,7 +401,7 @@ tu_cs_reserve_space(struct tu_device *dev,
* packets in \a cs, but does not necessarily release all resources.
*/
void
-tu_cs_reset(struct tu_device *dev, struct tu_cs *cs)
+tu_cs_reset(struct tu_cs *cs)
{
if (cs->mode == TU_CS_MODE_EXTERNAL) {
assert(!cs->bo_count && !cs->entry_count);
@@ -411,7 +410,7 @@ tu_cs_reset(struct tu_device *dev, struct tu_cs *cs)
}
for (uint32_t i = 0; i + 1 < cs->bo_count; ++i) {
- tu_bo_finish(dev, cs->bos[i]);
+ tu_bo_finish(cs->device, cs->bos[i]);
free(cs->bos[i]);
}
diff --git a/src/freedreno/vulkan/tu_cs.h b/src/freedreno/vulkan/tu_cs.h
index e7fd0c42eb8..45e774c581a 100644
--- a/src/freedreno/vulkan/tu_cs.h
+++ b/src/freedreno/vulkan/tu_cs.h
@@ -28,13 +28,16 @@
#include "registers/adreno_pm4.xml.h"
void
-tu_cs_init(struct tu_cs *cs, enum tu_cs_mode mode, uint32_t initial_size);
+tu_cs_init(struct tu_cs *cs,
+ struct tu_device *device,
+ enum tu_cs_mode mode,
+ uint32_t initial_size);
void
tu_cs_init_external(struct tu_cs *cs, uint32_t *start, uint32_t *end);
void
-tu_cs_finish(struct tu_device *dev, struct tu_cs *cs);
+tu_cs_finish(struct tu_cs *cs);
void
tu_cs_begin(struct tu_cs *cs);
@@ -43,14 +46,10 @@ void
tu_cs_end(struct tu_cs *cs);
VkResult
-tu_cs_begin_sub_stream(struct tu_device *dev,
- struct tu_cs *cs,
- uint32_t size,
- struct tu_cs *sub_cs);
+tu_cs_begin_sub_stream(struct tu_cs *cs, uint32_t size, struct tu_cs *sub_cs);
VkResult
-tu_cs_alloc(struct tu_device *dev,
- struct tu_cs *cs,
+tu_cs_alloc(struct tu_cs *cs,
uint32_t count,
uint32_t size,
struct ts_cs_memory *memory);
@@ -59,12 +58,10 @@ struct tu_cs_entry
tu_cs_end_sub_stream(struct tu_cs *cs, struct tu_cs *sub_cs);
VkResult
-tu_cs_reserve_space(struct tu_device *dev,
- struct tu_cs *cs,
- uint32_t reserved_size);
+tu_cs_reserve_space(struct tu_cs *cs, uint32_t reserved_size);
void
-tu_cs_reset(struct tu_device *dev, struct tu_cs *cs);
+tu_cs_reset(struct tu_cs *cs);
VkResult
tu_cs_add_entries(struct tu_cs *cs, struct tu_cs *target);
@@ -224,7 +221,7 @@ tu_cond_exec_start(struct tu_device *dev, struct tu_cs *cs,
/* Reserve enough space so that both the condition packet and the actual
* condition will fit in the same IB.
*/
- VkResult result = tu_cs_reserve_space(dev, cs, max_dwords + 3);
+ VkResult result = tu_cs_reserve_space(cs, max_dwords + 3);
if (result != VK_SUCCESS)
return result;
diff --git a/src/freedreno/vulkan/tu_meta_buffer.c b/src/freedreno/vulkan/tu_meta_buffer.c
index c7fcbd5e672..fd82b9cdf8d 100644
--- a/src/freedreno/vulkan/tu_meta_buffer.c
+++ b/src/freedreno/vulkan/tu_meta_buffer.c
@@ -45,7 +45,7 @@ tu_CmdUpdateBuffer(VkCommandBuffer commandBuffer,
tu_bo_list_add(&cmd->bo_list, buffer->bo, MSM_SUBMIT_BO_WRITE);
struct ts_cs_memory tmp;
- VkResult result = tu_cs_alloc(cmd->device, &cmd->sub_cs, DIV_ROUND_UP(dataSize, 64), 64, &tmp);
+ VkResult result = tu_cs_alloc(&cmd->sub_cs, DIV_ROUND_UP(dataSize, 64), 64, &tmp);
if (result != VK_SUCCESS) {
cmd->record_result = result;
return;
diff --git a/src/freedreno/vulkan/tu_pipeline.c b/src/freedreno/vulkan/tu_pipeline.c
index 3d7278a4c89..75ce56dc673 100644
--- a/src/freedreno/vulkan/tu_pipeline.c
+++ b/src/freedreno/vulkan/tu_pipeline.c
@@ -1524,10 +1524,10 @@ tu_pipeline_create(struct tu_device *dev,
if (!pipeline)
return VK_ERROR_OUT_OF_HOST_MEMORY;
- tu_cs_init(&pipeline->cs, TU_CS_MODE_SUB_STREAM, 2048);
+ tu_cs_init(&pipeline->cs, dev, TU_CS_MODE_SUB_STREAM, 2048);
/* reserve the space now such that tu_cs_begin_sub_stream never fails */
- VkResult result = tu_cs_reserve_space(dev, &pipeline->cs, 2048);
+ VkResult result = tu_cs_reserve_space(&pipeline->cs, 2048);
if (result != VK_SUCCESS) {
vk_free2(&dev->alloc, pAllocator, pipeline);
return result;
@@ -1660,11 +1660,11 @@ tu_pipeline_builder_parse_shader_stages(struct tu_pipeline_builder *builder,
struct tu_pipeline *pipeline)
{
struct tu_cs prog_cs;
- tu_cs_begin_sub_stream(builder->device, &pipeline->cs, 512, &prog_cs);
+ tu_cs_begin_sub_stream(&pipeline->cs, 512, &prog_cs);
tu6_emit_program(&prog_cs, builder, &pipeline->program.binary_bo, false);
pipeline->program.state_ib = tu_cs_end_sub_stream(&pipeline->cs, &prog_cs);
- tu_cs_begin_sub_stream(builder->device, &pipeline->cs, 512, &prog_cs);
+ tu_cs_begin_sub_stream(&pipeline->cs, 512, &prog_cs);
tu6_emit_program(&prog_cs, builder, &pipeline->program.binary_bo, true);
pipeline->program.binning_state_ib =
tu_cs_end_sub_stream(&pipeline->cs, &prog_cs);
@@ -1688,7 +1688,7 @@ tu_pipeline_builder_parse_vertex_input(struct tu_pipeline_builder *builder,
const struct tu_shader *vs = builder->shaders[MESA_SHADER_VERTEX];
struct tu_cs vi_cs;
- tu_cs_begin_sub_stream(builder->device, &pipeline->cs,
+ tu_cs_begin_sub_stream(&pipeline->cs,
MAX_VERTEX_ATTRIBS * 5 + 2, &vi_cs);
tu6_emit_vertex_input(&vi_cs, &vs->variants[0], vi_info,
pipeline->vi.bindings, pipeline->vi.strides,
@@ -1696,7 +1696,7 @@ tu_pipeline_builder_parse_vertex_input(struct tu_pipeline_builder *builder,
pipeline->vi.state_ib = tu_cs_end_sub_stream(&pipeline->cs, &vi_cs);
if (vs->has_binning_pass) {
- tu_cs_begin_sub_stream(builder->device, &pipeline->cs,
+ tu_cs_begin_sub_stream(&pipeline->cs,
MAX_VERTEX_ATTRIBS * 5 + 2, &vi_cs);
tu6_emit_vertex_input(
&vi_cs, &vs->variants[1], vi_info, pipeline->vi.binning_bindings,
@@ -1737,7 +1737,7 @@ tu_pipeline_builder_parse_viewport(struct tu_pipeline_builder *builder,
builder->create_info->pViewportState;
struct tu_cs vp_cs;
- tu_cs_begin_sub_stream(builder->device, &pipeline->cs, 15, &vp_cs);
+ tu_cs_begin_sub_stream(&pipeline->cs, 15, &vp_cs);
if (!(pipeline->dynamic_state.mask & TU_DYNAMIC_VIEWPORT)) {
assert(vp_info->viewportCount == 1);
@@ -1763,7 +1763,7 @@ tu_pipeline_builder_parse_rasterization(struct tu_pipeline_builder *builder,
assert(rast_info->polygonMode == VK_POLYGON_MODE_FILL);
struct tu_cs rast_cs;
- tu_cs_begin_sub_stream(builder->device, &pipeline->cs, 20, &rast_cs);
+ tu_cs_begin_sub_stream(&pipeline->cs, 20, &rast_cs);
/* move to hw ctx init? */
tu6_emit_gras_unknowns(&rast_cs);
@@ -1807,7 +1807,7 @@ tu_pipeline_builder_parse_depth_stencil(struct tu_pipeline_builder *builder,
: &dummy_ds_info;
struct tu_cs ds_cs;
- tu_cs_begin_sub_stream(builder->device, &pipeline->cs, 12, &ds_cs);
+ tu_cs_begin_sub_stream(&pipeline->cs, 12, &ds_cs);
/* move to hw ctx init? */
tu6_emit_alpha_control_disable(&ds_cs);
@@ -1862,8 +1862,7 @@ tu_pipeline_builder_parse_multisample_and_color_blend(
: &dummy_blend_info;
struct tu_cs blend_cs;
- tu_cs_begin_sub_stream(builder->device, &pipeline->cs, MAX_RTS * 3 + 9,
- &blend_cs);
+ tu_cs_begin_sub_stream(&pipeline->cs, MAX_RTS * 3 + 9, &blend_cs);
uint32_t blend_enable_mask;
tu6_emit_rb_mrt_controls(&blend_cs, blend_info,
@@ -1883,7 +1882,7 @@ tu_pipeline_finish(struct tu_pipeline *pipeline,
struct tu_device *dev,
const VkAllocationCallbacks *alloc)
{
- tu_cs_finish(dev, &pipeline->cs);
+ tu_cs_finish(&pipeline->cs);
if (pipeline->program.binary_bo.gem_handle)
tu_bo_finish(dev, &pipeline->program.binary_bo);
@@ -2123,7 +2122,7 @@ tu_compute_pipeline_create(VkDevice device,
pipeline->compute.local_size[i] = v->shader->nir->info.cs.local_size[i];
struct tu_cs prog_cs;
- tu_cs_begin_sub_stream(dev, &pipeline->cs, 512, &prog_cs);
+ tu_cs_begin_sub_stream(&pipeline->cs, 512, &prog_cs);
tu6_emit_compute_program(&prog_cs, shader, &pipeline->program.binary_bo);
pipeline->program.state_ib = tu_cs_end_sub_stream(&pipeline->cs, &prog_cs);
diff --git a/src/freedreno/vulkan/tu_private.h b/src/freedreno/vulkan/tu_private.h
index eb3cc5dd684..08d8734a476 100644
--- a/src/freedreno/vulkan/tu_private.h
+++ b/src/freedreno/vulkan/tu_private.h
@@ -569,6 +569,7 @@ struct tu_cs
uint32_t *reserved_end;
uint32_t *end;
+ struct tu_device *device;
enum tu_cs_mode mode;
uint32_t next_bo_size;
diff --git a/src/freedreno/vulkan/tu_query.c b/src/freedreno/vulkan/tu_query.c
index 5e3e2c1893a..1dad575965d 100644
--- a/src/freedreno/vulkan/tu_query.c
+++ b/src/freedreno/vulkan/tu_query.c
@@ -290,7 +290,7 @@ copy_query_value_gpu(struct tu_cmd_buffer *cmdbuf,
sizeof(uint64_t) : sizeof(uint32_t);
uint64_t write_iova = base_write_iova + (offset * element_size);
- tu_cs_reserve_space(cmdbuf->device, cs, 6);
+ tu_cs_reserve_space(cs, 6);
tu_cs_emit_pkt7(cs, CP_MEM_TO_MEM, 5);
uint32_t mem_to_mem_flags = flags & VK_QUERY_RESULT_64_BIT ?
CP_MEM_TO_MEM_0_DOUBLE : 0;
@@ -319,7 +319,7 @@ emit_copy_occlusion_query_pool_results(struct tu_cmd_buffer *cmdbuf,
* To ensure that previous writes to the available bit are coherent, first
* wait for all writes to complete.
*/
- tu_cs_reserve_space(cmdbuf->device, cs, 1);
+ tu_cs_reserve_space(cs, 1);
tu_cs_emit_pkt7(cs, CP_WAIT_MEM_WRITES, 0);
for (uint32_t i = 0; i < queryCount; i++) {
@@ -330,7 +330,7 @@ emit_copy_occlusion_query_pool_results(struct tu_cmd_buffer *cmdbuf,
/* Wait for the available bit to be set if executed with the
* VK_QUERY_RESULT_WAIT_BIT flag. */
if (flags & VK_QUERY_RESULT_WAIT_BIT) {
- tu_cs_reserve_space(cmdbuf->device, cs, 7);
+ tu_cs_reserve_space(cs, 7);
tu_cs_emit_pkt7(cs, CP_WAIT_REG_MEM, 6);
tu_cs_emit(cs, CP_WAIT_REG_MEM_0_FUNCTION(WRITE_EQ) |
CP_WAIT_REG_MEM_0_POLL_MEMORY);
@@ -356,7 +356,7 @@ emit_copy_occlusion_query_pool_results(struct tu_cmd_buffer *cmdbuf,
* tests that ADDR0 != 0 and ADDR1 < REF. The packet here simply tests
* that 0 < available < 2, aka available == 1.
*/
- tu_cs_reserve_space(cmdbuf->device, cs, 7 + 6);
+ tu_cs_reserve_space(cs, 7 + 6);
tu_cs_emit_pkt7(cs, CP_COND_EXEC, 6);
tu_cs_emit_qw(cs, available_iova);
tu_cs_emit_qw(cs, available_iova);
@@ -419,7 +419,7 @@ emit_reset_occlusion_query_pool(struct tu_cmd_buffer *cmdbuf,
uint32_t query = firstQuery + i;
uint64_t available_iova = occlusion_query_iova(pool, query, available);
uint64_t result_iova = occlusion_query_iova(pool, query, result);
- tu_cs_reserve_space(cmdbuf->device, cs, 11);
+ tu_cs_reserve_space(cs, 11);
tu_cs_emit_pkt7(cs, CP_MEM_WRITE, 4);
tu_cs_emit_qw(cs, available_iova);
tu_cs_emit_qw(cs, 0x0);
@@ -475,7 +475,7 @@ emit_begin_occlusion_query(struct tu_cmd_buffer *cmdbuf,
uint64_t begin_iova = occlusion_query_iova(pool, query, begin);
- tu_cs_reserve_space(cmdbuf->device, cs, 7);
+ tu_cs_reserve_space(cs, 7);
tu_cs_emit_regs(cs,
A6XX_RB_SAMPLE_COUNT_CONTROL(.copy = true));
@@ -540,7 +540,7 @@ emit_end_occlusion_query(struct tu_cmd_buffer *cmdbuf,
uint64_t begin_iova = occlusion_query_iova(pool, query, begin);
uint64_t end_iova = occlusion_query_iova(pool, query, end);
uint64_t result_iova = occlusion_query_iova(pool, query, result);
- tu_cs_reserve_space(cmdbuf->device, cs, 31);
+ tu_cs_reserve_space(cs, 31);
tu_cs_emit_pkt7(cs, CP_MEM_WRITE, 4);
tu_cs_emit_qw(cs, end_iova);
tu_cs_emit_qw(cs, 0xffffffffffffffffull);
@@ -583,7 +583,7 @@ emit_end_occlusion_query(struct tu_cmd_buffer *cmdbuf,
*/
cs = &cmdbuf->draw_epilogue_cs;
- tu_cs_reserve_space(cmdbuf->device, cs, 5);
+ tu_cs_reserve_space(cs, 5);
tu_cs_emit_pkt7(cs, CP_MEM_WRITE, 4);
tu_cs_emit_qw(cs, available_iova);
tu_cs_emit_qw(cs, 0x1);
More information about the mesa-commit
mailing list