fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-04-08 07:40:37 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

lima: rename lima_submit to lima_job

Browse source 
Reviewed-by: Vasily Khoruzhick <anarsoul@gmail.com>
Signed-off-by: Qiang Yu <yuq825@gmail.com>
Tested-by: Marge Bot <https://gitlab.freedesktop.org/mesa/mesa/merge_requests/3755>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/merge_requests/3755>
This commit is contained in:
Qiang Yu 2020-02-10 16:25:11 +08:00 • committed by Marge Bot
parent 57d9a51d45
commit 6fc0890cd9
14 changed files with 331 additions and 331 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/gallium/drivers/lima/Android.mk
View file

@ -66,8 +66,8 @@ LOCAL_SRC_FILES := \
lima_screen.c \
lima_screen.h \
lima_state.c \
lima_submit.c \
lima_submit.h \
lima_job.c \
lima_job.h \
lima_texture.c \
lima_texture.h \
lima_util.c \

22
src/gallium/drivers/lima/lima_context.c
View file

@ -35,7 +35,7 @@
#include "lima_context.h"
#include "lima_resource.h"
#include "lima_bo.h"
#include "lima_submit.h"
#include "lima_job.h"
#include "lima_util.h"
#include "lima_fence.h"
@ -47,12 +47,12 @@ int lima_ctx_num_plb = LIMA_CTX_PLB_DEF_NUM;
uint32_t
lima_ctx_buff_va(struct lima_context *ctx, enum lima_ctx_buff buff)
{
struct lima_submit *submit = lima_submit_get(ctx);
struct lima_job *job = lima_job_get(ctx);
struct lima_ctx_buff_state *cbs = ctx->buffer_state + buff;
struct lima_resource *res = lima_resource(cbs->res);
int pipe = buff < lima_ctx_buff_num_gp ? LIMA_PIPE_GP : LIMA_PIPE_PP;
lima_submit_add_bo(submit, pipe, res->bo, LIMA_SUBMIT_BO_READ);
lima_job_add_bo(job, pipe, res->bo, LIMA_SUBMIT_BO_READ);
return res->bo->va + cbs->offset;
}
@ -108,16 +108,16 @@ lima_invalidate_resource(struct pipe_context *pctx, struct pipe_resource *prsc)
{
struct lima_context *ctx = lima_context(pctx);
struct hash_entry *entry = _mesa_hash_table_search(ctx->write_submits, prsc);
struct hash_entry *entry = _mesa_hash_table_search(ctx->write_jobs, prsc);
if (!entry)
return;
struct lima_submit *submit = entry->data;
if (submit->key.zsbuf && (submit->key.zsbuf->texture == prsc))
submit->resolve &= ~(PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL);
struct lima_job *job = entry->data;
if (job->key.zsbuf && (job->key.zsbuf->texture == prsc))
job->resolve &= ~(PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL);
if (submit->key.cbuf && (submit->key.cbuf->texture == prsc))
submit->resolve &= ~PIPE_CLEAR_COLOR0;
if (job->key.cbuf && (job->key.cbuf->texture == prsc))
job->resolve &= ~PIPE_CLEAR_COLOR0;
}
static void
@ -126,7 +126,7 @@ lima_context_destroy(struct pipe_context *pctx)
struct lima_context *ctx = lima_context(pctx);
struct lima_screen *screen = lima_screen(pctx->screen);
lima_submit_fini(ctx);
lima_job_fini(ctx);
for (int i = 0; i < lima_ctx_buff_num; i++)
pipe_resource_reference(&ctx->buffer_state[i].res, NULL);
@ -274,7 +274,7 @@ lima_context_create(struct pipe_screen *pscreen, void *priv, unsigned flags)
goto err_out;
}
if (!lima_submit_init(ctx))
if (!lima_job_init(ctx))
goto err_out;
return &ctx->base;

16
src/gallium/drivers/lima/lima_context.h
View file

@ -221,14 +221,14 @@ struct lima_context {
struct lima_ctx_buff_state buffer_state[lima_ctx_buff_num];
/* current submit */
struct lima_submit *submit;
/* current job */
struct lima_job *job;
/* map from lima_submit_key to lima_submit */
struct hash_table *submits;
/* map from lima_job_key to lima_job */
struct hash_table *jobs;
/* map from pipe_resource to lima_submit which write to it */
struct hash_table *write_submits;
/* map from pipe_resource to lima_job which write to it */
struct hash_table *write_jobs;
int in_sync_fd;
uint32_t in_sync[2];
@ -283,9 +283,9 @@ struct pipe_context *
lima_context_create(struct pipe_screen *pscreen, void *priv, unsigned flags);
void lima_flush(struct lima_context *ctx);
void lima_flush_submit_accessing_bo(
void lima_flush_job_accessing_bo(
struct lima_context *ctx, struct lima_bo *bo, bool write);
void lima_flush_previous_submit_writing_resource(
void lima_flush_previous_job_writing_resource(
struct lima_context *ctx, struct pipe_resource *prsc);
#endif

106
src/gallium/drivers/lima/lima_draw.c
View file

@ -40,7 +40,7 @@
#include "lima_resource.h"
#include "lima_program.h"
#include "lima_bo.h"
#include "lima_submit.h"
#include "lima_job.h"
#include "lima_texture.h"
#include "lima_util.h"
#include "lima_gpu.h"
@ -60,30 +60,30 @@ lima_is_scissor_zero(struct lima_context *ctx)
}
static void
lima_update_submit_wb(struct lima_context *ctx, unsigned buffers)
lima_update_job_wb(struct lima_context *ctx, unsigned buffers)
{
struct lima_submit *submit = lima_submit_get(ctx);
struct lima_job *job = lima_job_get(ctx);
struct lima_context_framebuffer *fb = &ctx->framebuffer;
/* add to submit when the buffer is dirty and resolve is clear (not added before) */
/* add to job when the buffer is dirty and resolve is clear (not added before) */
if (fb->base.nr_cbufs && (buffers & PIPE_CLEAR_COLOR0) &&
!(submit->resolve & PIPE_CLEAR_COLOR0)) {
!(job->resolve & PIPE_CLEAR_COLOR0)) {
struct lima_resource *res = lima_resource(fb->base.cbufs[0]->texture);
lima_flush_submit_accessing_bo(ctx, res->bo, true);
_mesa_hash_table_insert(ctx->write_submits, &res->base, submit);
lima_submit_add_bo(submit, LIMA_PIPE_PP, res->bo, LIMA_SUBMIT_BO_WRITE);
lima_flush_job_accessing_bo(ctx, res->bo, true);
_mesa_hash_table_insert(ctx->write_jobs, &res->base, job);
lima_job_add_bo(job, LIMA_PIPE_PP, res->bo, LIMA_SUBMIT_BO_WRITE);
}
/* add to submit when the buffer is dirty and resolve is clear (not added before) */
/* add to job when the buffer is dirty and resolve is clear (not added before) */
if (fb->base.zsbuf && (buffers & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL)) &&
!(submit->resolve & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL))) {
!(job->resolve & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL))) {
struct lima_resource *res = lima_resource(fb->base.zsbuf->texture);
lima_flush_submit_accessing_bo(ctx, res->bo, true);
_mesa_hash_table_insert(ctx->write_submits, &res->base, submit);
lima_submit_add_bo(submit, LIMA_PIPE_PP, res->bo, LIMA_SUBMIT_BO_WRITE);
lima_flush_job_accessing_bo(ctx, res->bo, true);
_mesa_hash_table_insert(ctx->write_jobs, &res->base, job);
lima_job_add_bo(job, LIMA_PIPE_PP, res->bo, LIMA_SUBMIT_BO_WRITE);
}
submit->resolve |= buffers;
job->resolve |= buffers;
}
static void
@ -102,16 +102,16 @@ lima_clear(struct pipe_context *pctx, unsigned buffers,
const union pipe_color_union *color, double depth, unsigned stencil)
{
struct lima_context *ctx = lima_context(pctx);
struct lima_submit *submit = lima_submit_get(ctx);
struct lima_job *job = lima_job_get(ctx);
/* flush if this submit already contains any draw, otherwise multi clear can be
* combined into a single submit */
if (lima_submit_has_draw_pending(submit)) {
lima_do_submit(submit);
submit = lima_submit_get(ctx);
/* flush if this job already contains any draw, otherwise multi clear can be
* combined into a single job */
if (lima_job_has_draw_pending(job)) {
lima_do_job(job);
job = lima_job_get(ctx);
}
lima_update_submit_wb(ctx, buffers);
lima_update_job_wb(ctx, buffers);
/* no need to reload if cleared */
if (ctx->framebuffer.base.nr_cbufs && (buffers & PIPE_CLEAR_COLOR0)) {
@ -119,7 +119,7 @@ lima_clear(struct pipe_context *pctx, unsigned buffers,
surf->reload = false;
}
struct lima_submit_clear *clear = &submit->clear;
struct lima_job_clear *clear = &job->clear;
clear->buffers = buffers;
if (buffers & PIPE_CLEAR_COLOR0) {
@ -144,7 +144,7 @@ lima_clear(struct pipe_context *pctx, unsigned buffers,
ctx->dirty |= LIMA_CONTEXT_DIRTY_CLEAR;
lima_damage_rect_union(&submit->damage_rect,
lima_damage_rect_union(&job->damage_rect,
0, ctx->framebuffer.base.width,
0, ctx->framebuffer.base.height);
}
@ -213,9 +213,9 @@ lima_pipe_format_to_attrib_type(enum pipe_format format)
static void
lima_pack_vs_cmd(struct lima_context *ctx, const struct pipe_draw_info *info)
{
struct lima_submit *submit = lima_submit_get(ctx);
struct lima_job *job = lima_job_get(ctx);
VS_CMD_BEGIN(&submit->vs_cmd_array, 24);
VS_CMD_BEGIN(&job->vs_cmd_array, 24);
if (!info->index_size) {
VS_CMD_ARRAYS_SEMAPHORE_BEGIN_1();
@ -265,8 +265,8 @@ lima_pack_plbu_cmd(struct lima_context *ctx, const struct pipe_draw_info *info)
if (lima_is_scissor_zero(ctx))
return;
struct lima_submit *submit = lima_submit_get(ctx);
PLBU_CMD_BEGIN(&submit->plbu_cmd_array, 32);
struct lima_job *job = lima_job_get(ctx);
PLBU_CMD_BEGIN(&job->plbu_cmd_array, 32);
PLBU_CMD_VIEWPORT_LEFT(fui(ctx->viewport.left));
PLBU_CMD_VIEWPORT_RIGHT(fui(ctx->viewport.right));
@ -325,7 +325,7 @@ lima_pack_plbu_cmd(struct lima_context *ctx, const struct pipe_draw_info *info)
maxy = MIN2(maxy, ctx->viewport.top);
PLBU_CMD_SCISSORS(minx, maxx, miny, maxy);
lima_damage_rect_union(&submit->damage_rect, minx, maxx, miny, maxy);
lima_damage_rect_union(&job->damage_rect, minx, maxx, miny, maxy);
PLBU_CMD_UNKNOWN1();
@ -748,22 +748,22 @@ lima_pack_render_state(struct lima_context *ctx, const struct pipe_draw_info *in
render->varyings_address = 0x00000000;
}
struct lima_submit *submit = lima_submit_get(ctx);
struct lima_job *job = lima_job_get(ctx);
lima_dump_command_stream_print(
submit->dump, render, sizeof(*render),
job->dump, render, sizeof(*render),
false, "add render state at va %x\n",
lima_ctx_buff_va(ctx, lima_ctx_buff_pp_plb_rsw));
lima_dump_rsw_command_stream_print(
submit->dump, render, sizeof(*render),
job->dump, render, sizeof(*render),
lima_ctx_buff_va(ctx, lima_ctx_buff_pp_plb_rsw));
}
static void
lima_update_gp_attribute_info(struct lima_context *ctx, const struct pipe_draw_info *info)
{
struct lima_submit *submit = lima_submit_get(ctx);
struct lima_job *job = lima_job_get(ctx);
struct lima_vertex_element_state *ve = ctx->vertex_elements;
struct lima_context_vertex_buffer *vb = &ctx->vertex_buffers;
@ -781,7 +781,7 @@ lima_update_gp_attribute_info(struct lima_context *ctx, const struct pipe_draw_i
struct pipe_vertex_buffer *pvb = vb->vb + pve->vertex_buffer_index;
struct lima_resource *res = lima_resource(pvb->buffer.resource);
lima_submit_add_bo(submit, LIMA_PIPE_GP, res->bo, LIMA_SUBMIT_BO_READ);
lima_job_add_bo(job, LIMA_PIPE_GP, res->bo, LIMA_SUBMIT_BO_READ);
unsigned start = info->index_size ? (ctx->min_index + info->index_bias) : info->start;
attribute[n++] = res->bo->va + pvb->buffer_offset + pve->src_offset
@ -792,7 +792,7 @@ lima_update_gp_attribute_info(struct lima_context *ctx, const struct pipe_draw_i
}
lima_dump_command_stream_print(
submit->dump, attribute, n * 4, false, "update attribute info at va %x\n",
job->dump, attribute, n * 4, false, "update attribute info at va %x\n",
lima_ctx_buff_va(ctx, lima_ctx_buff_gp_attribute_info));
}
@ -821,10 +821,10 @@ lima_update_gp_uniform(struct lima_context *ctx)
memcpy(vs_const_buff + vs->uniform_pending_offset + 32,
vs->constant, vs->constant_size);
struct lima_submit *submit = lima_submit_get(ctx);
struct lima_job *job = lima_job_get(ctx);
lima_dump_command_stream_print(
submit->dump, vs_const_buff, size, true,
job->dump, vs_const_buff, size, true,
"update gp uniform at va %x\n",
lima_ctx_buff_va(ctx, lima_ctx_buff_gp_uniform));
}
@ -850,21 +850,21 @@ lima_update_pp_uniform(struct lima_context *ctx)
*array = lima_ctx_buff_va(ctx, lima_ctx_buff_pp_uniform);
struct lima_submit *submit = lima_submit_get(ctx);
struct lima_job *job = lima_job_get(ctx);
lima_dump_command_stream_print(
submit->dump, fp16_const_buff, const_buff_size * 2,
job->dump, fp16_const_buff, const_buff_size * 2,
false, "add pp uniform data at va %x\n",
lima_ctx_buff_va(ctx, lima_ctx_buff_pp_uniform));
lima_dump_command_stream_print(
submit->dump, array, 4, false, "add pp uniform info at va %x\n",
job->dump, array, 4, false, "add pp uniform info at va %x\n",
lima_ctx_buff_va(ctx, lima_ctx_buff_pp_uniform_array));
}
static void
lima_update_varying(struct lima_context *ctx, const struct pipe_draw_info *info)
{
struct lima_submit *submit = lima_submit_get(ctx);
struct lima_job *job = lima_job_get(ctx);
struct lima_screen *screen = lima_screen(ctx->base.screen);
struct lima_vs_shader_state *vs = ctx->vs;
uint32_t gp_output_size;
@ -916,8 +916,8 @@ lima_update_varying(struct lima_context *ctx, const struct pipe_draw_info *info)
*/
ctx->gp_output = lima_bo_create(screen, gp_output_size, 0);
assert(ctx->gp_output);
lima_submit_add_bo(submit, LIMA_PIPE_GP, ctx->gp_output, LIMA_SUBMIT_BO_WRITE);
lima_submit_add_bo(submit, LIMA_PIPE_PP, ctx->gp_output, LIMA_SUBMIT_BO_READ);
lima_job_add_bo(job, LIMA_PIPE_GP, ctx->gp_output, LIMA_SUBMIT_BO_WRITE);
lima_job_add_bo(job, LIMA_PIPE_PP, ctx->gp_output, LIMA_SUBMIT_BO_READ);
for (int i = 0; i < vs->num_outputs; i++) {
struct lima_varying_info *v = vs->varying + i;
@ -940,7 +940,7 @@ lima_update_varying(struct lima_context *ctx, const struct pipe_draw_info *info)
}
lima_dump_command_stream_print(
submit->dump, varying, n * 4, false, "update varying info at va %x\n",
job->dump, varying, n * 4, false, "update varying info at va %x\n",
lima_ctx_buff_va(ctx, lima_ctx_buff_gp_varying_info));
}
@ -963,7 +963,7 @@ lima_draw_vbo_update(struct pipe_context *pctx,
if (fb->base.nr_cbufs)
buffers |= PIPE_CLEAR_COLOR0;
lima_update_submit_wb(ctx, buffers);
lima_update_job_wb(ctx, buffers);
lima_update_gp_attribute_info(ctx, info);
@ -993,7 +993,7 @@ lima_draw_vbo_update(struct pipe_context *pctx,
lima_pack_plbu_cmd(ctx, info);
if (ctx->gp_output) {
lima_bo_unreference(ctx->gp_output); /* held by submit */
lima_bo_unreference(ctx->gp_output); /* held by job */
ctx->gp_output = NULL;
}
@ -1005,7 +1005,7 @@ lima_draw_vbo_indexed(struct pipe_context *pctx,
const struct pipe_draw_info *info)
{
struct lima_context *ctx = lima_context(pctx);
struct lima_submit *submit = lima_submit_get(ctx);
struct lima_job *job = lima_job_get(ctx);
struct pipe_resource *indexbuf = NULL;
/* Mali Utgard GPU always need min/max index info for index draw,
@ -1026,8 +1026,8 @@ lima_draw_vbo_indexed(struct pipe_context *pctx,
ctx->index_offset = 0;
}
lima_submit_add_bo(submit, LIMA_PIPE_GP, ctx->index_res->bo, LIMA_SUBMIT_BO_READ);
lima_submit_add_bo(submit, LIMA_PIPE_PP, ctx->index_res->bo, LIMA_SUBMIT_BO_READ);
lima_job_add_bo(job, LIMA_PIPE_GP, ctx->index_res->bo, LIMA_SUBMIT_BO_READ);
lima_job_add_bo(job, LIMA_PIPE_PP, ctx->index_res->bo, LIMA_SUBMIT_BO_READ);
lima_draw_vbo_update(pctx, info);
if (indexbuf)
@ -1081,18 +1081,18 @@ lima_draw_vbo(struct pipe_context *pctx,
if (!lima_update_vs_state(ctx) || !lima_update_fs_state(ctx))
return;
struct lima_submit *submit = lima_submit_get(ctx);
struct lima_job *job = lima_job_get(ctx);
lima_dump_command_stream_print(
submit->dump, ctx->vs->bo->map, ctx->vs->shader_size, false,
job->dump, ctx->vs->bo->map, ctx->vs->shader_size, false,
"add vs at va %x\n", ctx->vs->bo->va);
lima_dump_command_stream_print(
submit->dump, ctx->fs->bo->map, ctx->fs->shader_size, false,
job->dump, ctx->fs->bo->map, ctx->fs->shader_size, false,
"add fs at va %x\n", ctx->fs->bo->va);
lima_submit_add_bo(submit, LIMA_PIPE_GP, ctx->vs->bo, LIMA_SUBMIT_BO_READ);
lima_submit_add_bo(submit, LIMA_PIPE_PP, ctx->fs->bo, LIMA_SUBMIT_BO_READ);
lima_job_add_bo(job, LIMA_PIPE_GP, ctx->vs->bo, LIMA_SUBMIT_BO_READ);
lima_job_add_bo(job, LIMA_PIPE_PP, ctx->fs->bo, LIMA_SUBMIT_BO_READ);
if (info->index_size)
lima_draw_vbo_indexed(pctx, info);

2
src/gallium/drivers/lima/lima_fence.c
View file

@ -33,7 +33,7 @@
#include "lima_screen.h"
#include "lima_context.h"
#include "lima_fence.h"
#include "lima_submit.h"
#include "lima_job.h"
struct pipe_fence_handle {
struct pipe_reference reference;

434
src/gallium/drivers/lima/lima_submit.c → src/gallium/drivers/lima/lima_job.c
View file

@ -36,7 +36,7 @@
#include "lima_screen.h"
#include "lima_context.h"
#include "lima_submit.h"
#include "lima_job.h"
#include "lima_bo.h"
#include "lima_util.h"
#include "lima_format.h"
@ -48,10 +48,10 @@
#define VOID2U64(x) ((uint64_t)(unsigned long)(x))
static void
lima_get_fb_info(struct lima_submit *submit)
lima_get_fb_info(struct lima_job *job)
{
struct lima_context *ctx = submit->ctx;
struct lima_submit_fb_info *fb = &submit->fb;
struct lima_context *ctx = job->ctx;
struct lima_job_fb_info *fb = &job->fb;
fb->width = ctx->framebuffer.base.width;
fb->height = ctx->framebuffer.base.height;
@ -84,12 +84,12 @@ lima_get_fb_info(struct lima_submit *submit)
fb->shift_min = MIN3(fb->shift_w, fb->shift_h, 2);
}
static struct lima_submit *
lima_submit_create(struct lima_context *ctx)
static struct lima_job *
lima_job_create(struct lima_context *ctx)
{
struct lima_submit *s;
struct lima_job *s;
s = rzalloc(ctx, struct lima_submit);
s = rzalloc(ctx, struct lima_job);
if (!s)
return NULL;
@ -120,103 +120,103 @@ lima_submit_create(struct lima_context *ctx)
}
static void
lima_submit_free(struct lima_submit *submit)
lima_job_free(struct lima_job *job)
{
struct lima_context *ctx = submit->ctx;
struct lima_context *ctx = job->ctx;
_mesa_hash_table_remove_key(ctx->submits, &submit->key);
_mesa_hash_table_remove_key(ctx->jobs, &job->key);
if (submit->key.cbuf && (submit->resolve & PIPE_CLEAR_COLOR0))
_mesa_hash_table_remove_key(ctx->write_submits, submit->key.cbuf->texture);
if (submit->key.zsbuf && (submit->resolve & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL)))
_mesa_hash_table_remove_key(ctx->write_submits, submit->key.zsbuf->texture);
if (job->key.cbuf && (job->resolve & PIPE_CLEAR_COLOR0))
_mesa_hash_table_remove_key(ctx->write_jobs, job->key.cbuf->texture);
if (job->key.zsbuf && (job->resolve & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL)))
_mesa_hash_table_remove_key(ctx->write_jobs, job->key.zsbuf->texture);
pipe_surface_reference(&submit->key.cbuf, NULL);
pipe_surface_reference(&submit->key.zsbuf, NULL);
pipe_surface_reference(&job->key.cbuf, NULL);
pipe_surface_reference(&job->key.zsbuf, NULL);
lima_dump_free(submit->dump);
submit->dump = NULL;
lima_dump_free(job->dump);
job->dump = NULL;
/* TODO: do we need a cache for submit? */
ralloc_free(submit);
/* TODO: do we need a cache for job? */
ralloc_free(job);
}
static struct lima_submit *
_lima_submit_get(struct lima_context *ctx)
static struct lima_job *
_lima_job_get(struct lima_context *ctx)
{
struct lima_context_framebuffer *fb = &ctx->framebuffer;
struct lima_submit_key local_key = {
struct lima_job_key local_key = {
.cbuf = fb->base.cbufs[0],
.zsbuf = fb->base.zsbuf,
};
struct hash_entry *entry = _mesa_hash_table_search(ctx->submits, &local_key);
struct hash_entry *entry = _mesa_hash_table_search(ctx->jobs, &local_key);
if (entry)
return entry->data;
struct lima_submit *submit = lima_submit_create(ctx);
if (!submit)
struct lima_job *job = lima_job_create(ctx);
if (!job)
return NULL;
_mesa_hash_table_insert(ctx->submits, &submit->key, submit);
_mesa_hash_table_insert(ctx->jobs, &job->key, job);
return submit;
return job;
}
/*
* Note: this function can only be called in draw code path,
* must not exist in flush code path.
*/
struct lima_submit *
lima_submit_get(struct lima_context *ctx)
struct lima_job *
lima_job_get(struct lima_context *ctx)
{
if (ctx->submit)
return ctx->submit;
if (ctx->job)
return ctx->job;
ctx->submit = _lima_submit_get(ctx);
return ctx->submit;
ctx->job = _lima_job_get(ctx);
return ctx->job;
}
bool lima_submit_add_bo(struct lima_submit *submit, int pipe,
struct lima_bo *bo, uint32_t flags)
bool lima_job_add_bo(struct lima_job *job, int pipe,
struct lima_bo *bo, uint32_t flags)
{
util_dynarray_foreach(submit->gem_bos + pipe, struct drm_lima_gem_submit_bo, gem_bo) {
util_dynarray_foreach(job->gem_bos + pipe, struct drm_lima_gem_submit_bo, gem_bo) {
if (bo->handle == gem_bo->handle) {
gem_bo->flags |= flags;
return true;
}
}
struct drm_lima_gem_submit_bo *submit_bo =
util_dynarray_grow(submit->gem_bos + pipe, struct drm_lima_gem_submit_bo, 1);
submit_bo->handle = bo->handle;
submit_bo->flags = flags;
struct drm_lima_gem_submit_bo *job_bo =
util_dynarray_grow(job->gem_bos + pipe, struct drm_lima_gem_submit_bo, 1);
job_bo->handle = bo->handle;
job_bo->flags = flags;
struct lima_bo **jbo = util_dynarray_grow(submit->bos + pipe, struct lima_bo *, 1);
struct lima_bo **jbo = util_dynarray_grow(job->bos + pipe, struct lima_bo *, 1);
*jbo = bo;
/* prevent bo from being freed when submit start */
/* prevent bo from being freed when job start */
lima_bo_reference(bo);
return true;
}
static bool
lima_submit_start(struct lima_submit *submit, int pipe, void *frame, uint32_t size)
lima_job_start(struct lima_job *job, int pipe, void *frame, uint32_t size)
{
struct lima_context *ctx = submit->ctx;
struct lima_context *ctx = job->ctx;
struct drm_lima_gem_submit req = {
.ctx = ctx->id,
.pipe = pipe,
.nr_bos = submit->gem_bos[pipe].size / sizeof(struct drm_lima_gem_submit_bo),
.bos = VOID2U64(util_dynarray_begin(submit->gem_bos + pipe)),
.nr_bos = job->gem_bos[pipe].size / sizeof(struct drm_lima_gem_submit_bo),
.bos = VOID2U64(util_dynarray_begin(job->gem_bos + pipe)),
.frame = VOID2U64(frame),
.frame_size = size,
.out_sync = ctx->out_sync[pipe],
};
if (ctx->in_sync_fd >= 0) {
int err = drmSyncobjImportSyncFile(submit->fd, ctx->in_sync[pipe],
int err = drmSyncobjImportSyncFile(job->fd, ctx->in_sync[pipe],
ctx->in_sync_fd);
if (err)
return false;
@ -226,9 +226,9 @@ lima_submit_start(struct lima_submit *submit, int pipe, void *frame, uint32_t si
ctx->in_sync_fd = -1;
}
bool ret = drmIoctl(submit->fd, DRM_IOCTL_LIMA_GEM_SUBMIT, &req) == 0;
bool ret = drmIoctl(job->fd, DRM_IOCTL_LIMA_GEM_SUBMIT, &req) == 0;
util_dynarray_foreach(submit->bos + pipe, struct lima_bo *, bo) {
util_dynarray_foreach(job->bos + pipe, struct lima_bo *, bo) {
lima_bo_unreference(*bo);
}
@ -236,21 +236,21 @@ lima_submit_start(struct lima_submit *submit, int pipe, void *frame, uint32_t si
}
static bool
lima_submit_wait(struct lima_submit *submit, int pipe, uint64_t timeout_ns)
lima_job_wait(struct lima_job *job, int pipe, uint64_t timeout_ns)
{
int64_t abs_timeout = os_time_get_absolute_timeout(timeout_ns);
if (abs_timeout == OS_TIMEOUT_INFINITE)
abs_timeout = INT64_MAX;
struct lima_context *ctx = submit->ctx;
return !drmSyncobjWait(submit->fd, ctx->out_sync + pipe, 1, abs_timeout, 0, NULL);
struct lima_context *ctx = job->ctx;
return !drmSyncobjWait(job->fd, ctx->out_sync + pipe, 1, abs_timeout, 0, NULL);
}
static bool
lima_submit_has_bo(struct lima_submit *submit, struct lima_bo *bo, bool all)
lima_job_has_bo(struct lima_job *job, struct lima_bo *bo, bool all)
{
for (int i = 0; i < 2; i++) {
util_dynarray_foreach(submit->gem_bos + i, struct drm_lima_gem_submit_bo, gem_bo) {
util_dynarray_foreach(job->gem_bos + i, struct drm_lima_gem_submit_bo, gem_bo) {
if (bo->handle == gem_bo->handle) {
if (all || gem_bo->flags & LIMA_SUBMIT_BO_WRITE)
return true;
@ -264,10 +264,10 @@ lima_submit_has_bo(struct lima_submit *submit, struct lima_bo *bo, bool all)
}
void *
lima_submit_create_stream_bo(struct lima_submit *submit, int pipe,
unsigned size, uint32_t *va)
lima_job_create_stream_bo(struct lima_job *job, int pipe,
unsigned size, uint32_t *va)
{
struct lima_context *ctx = submit->ctx;
struct lima_context *ctx = job->ctx;
void *cpu;
unsigned offset;
@ -277,7 +277,7 @@ lima_submit_create_stream_bo(struct lima_submit *submit, int pipe,
struct lima_resource *res = lima_resource(pres);
*va = res->bo->va + offset;
lima_submit_add_bo(submit, pipe, res->bo, LIMA_SUBMIT_BO_READ);
lima_job_add_bo(job, pipe, res->bo, LIMA_SUBMIT_BO_READ);
pipe_resource_reference(&pres, NULL);
@ -285,24 +285,24 @@ lima_submit_create_stream_bo(struct lima_submit *submit, int pipe,
}
static inline struct lima_damage_region *
lima_submit_get_damage(struct lima_submit *submit)
lima_job_get_damage(struct lima_job *job)
{
if (!(submit->key.cbuf && (submit->resolve & PIPE_CLEAR_COLOR0)))
if (!(job->key.cbuf && (job->resolve & PIPE_CLEAR_COLOR0)))
return NULL;
struct lima_surface *surf = lima_surface(submit->key.cbuf);
struct lima_surface *surf = lima_surface(job->key.cbuf);
struct lima_resource *res = lima_resource(surf->base.texture);
return &res->damage;
}
static bool
lima_fb_need_reload(struct lima_submit *submit)
lima_fb_need_reload(struct lima_job *job)
{
/* Depth buffer is always discarded */
if (!(submit->key.cbuf && (submit->resolve & PIPE_CLEAR_COLOR0)))
if (!(job->key.cbuf && (job->resolve & PIPE_CLEAR_COLOR0)))
return false;
struct lima_surface *surf = lima_surface(submit->key.cbuf);
struct lima_surface *surf = lima_surface(job->key.cbuf);
struct lima_resource *res = lima_resource(surf->base.texture);
if (res->damage.region) {
/* for EGL_KHR_partial_update, when EGL_EXT_buffer_age is enabled,
@ -319,7 +319,7 @@ lima_fb_need_reload(struct lima_submit *submit)
}
static void
lima_pack_reload_plbu_cmd(struct lima_submit *submit)
lima_pack_reload_plbu_cmd(struct lima_job *job)
{
#define lima_reload_render_state_offset 0x0000
#define lima_reload_gl_pos_offset 0x0040
@ -328,11 +328,11 @@ lima_pack_reload_plbu_cmd(struct lima_submit *submit)
#define lima_reload_tex_array_offset 0x0100
#define lima_reload_buffer_size 0x0140
struct lima_context *ctx = submit->ctx;
struct lima_context *ctx = job->ctx;
uint32_t va;
void *cpu = lima_submit_create_stream_bo(
submit, LIMA_PIPE_PP, lima_reload_buffer_size, &va);
void *cpu = lima_job_create_stream_bo(
job, LIMA_PIPE_PP, lima_reload_buffer_size, &va);
struct lima_screen *screen = lima_screen(ctx->base.screen);
@ -358,7 +358,7 @@ lima_pack_reload_plbu_cmd(struct lima_submit *submit)
lima_tex_desc *td = cpu + lima_reload_tex_desc_offset;
memset(td, 0, lima_min_tex_desc_size);
lima_texture_desc_set_res(ctx, td, submit->key.cbuf->texture, 0, 0);
lima_texture_desc_set_res(ctx, td, job->key.cbuf->texture, 0, 0);
td->unnorm_coords = 1;
td->texture_type = LIMA_TEXTURE_TYPE_2D;
td->min_img_filter_nearest = 1;
@ -370,7 +370,7 @@ lima_pack_reload_plbu_cmd(struct lima_submit *submit)
uint32_t *ta = cpu + lima_reload_tex_array_offset;
ta[0] = va + lima_reload_tex_desc_offset;
struct lima_submit_fb_info *fb = &submit->fb;
struct lima_job_fb_info *fb = &job->fb;
float reload_gl_pos[] = {
fb->width, 0, 0, 1,
0, 0, 0, 1,
@ -386,7 +386,7 @@ lima_pack_reload_plbu_cmd(struct lima_submit *submit)
memcpy(cpu + lima_reload_varying_offset, reload_varying,
sizeof(reload_varying));
PLBU_CMD_BEGIN(&submit->plbu_cmd_head, 20);
PLBU_CMD_BEGIN(&job->plbu_cmd_head, 20);
PLBU_CMD_VIEWPORT_LEFT(0);
PLBU_CMD_VIEWPORT_RIGHT(fui(fb->width));
@ -408,12 +408,12 @@ lima_pack_reload_plbu_cmd(struct lima_submit *submit)
}
static void
lima_pack_head_plbu_cmd(struct lima_submit *submit)
lima_pack_head_plbu_cmd(struct lima_job *job)
{
struct lima_context *ctx = submit->ctx;
struct lima_submit_fb_info *fb = &submit->fb;
struct lima_context *ctx = job->ctx;
struct lima_job_fb_info *fb = &job->fb;
PLBU_CMD_BEGIN(&submit->plbu_cmd_head, 10);
PLBU_CMD_BEGIN(&job->plbu_cmd_head, 10);
PLBU_CMD_UNKNOWN2();
PLBU_CMD_BLOCK_STEP(fb->shift_min, fb->shift_h, fb->shift_w);
@ -426,8 +426,8 @@ lima_pack_head_plbu_cmd(struct lima_submit *submit)
PLBU_CMD_END();
if (lima_fb_need_reload(submit))
lima_pack_reload_plbu_cmd(submit);
if (lima_fb_need_reload(job))
lima_pack_reload_plbu_cmd(job);
}
static void
@ -511,13 +511,13 @@ inside_damage_region(int x, int y, struct lima_damage_region *ds)
}
static void
lima_generate_pp_stream(struct lima_submit *submit, int off_x, int off_y,
int tiled_w, int tiled_h)
lima_generate_pp_stream(struct lima_job *job, int off_x, int off_y,
int tiled_w, int tiled_h)
{
struct lima_context *ctx = submit->ctx;
struct lima_context *ctx = job->ctx;
struct lima_pp_stream_state *ps = &ctx->pp_stream;
struct lima_submit_fb_info *fb = &submit->fb;
struct lima_damage_region *damage = lima_submit_get_damage(submit);
struct lima_job_fb_info *fb = &job->fb;
struct lima_damage_region *damage = lima_job_get_damage(job);
struct lima_screen *screen = lima_screen(ctx->base.screen);
int i, num_pp = screen->num_pp;
@ -575,20 +575,20 @@ lima_generate_pp_stream(struct lima_submit *submit, int off_x, int off_y,
stream[i][si[i]++] = 0;
lima_dump_command_stream_print(
submit->dump, stream[i], si[i] * 4,
job->dump, stream[i], si[i] * 4,
false, "pp plb stream %d at va %x\n",
i, ps->va + ps->offset[i]);
}
}
static void
lima_update_damage_pp_stream(struct lima_submit *submit)
lima_update_damage_pp_stream(struct lima_job *job)
{
struct lima_context *ctx = submit->ctx;
struct lima_damage_region *ds = lima_submit_get_damage(submit);
struct lima_submit_fb_info *fb = &submit->fb;
struct lima_context *ctx = job->ctx;
struct lima_damage_region *ds = lima_job_get_damage(job);
struct lima_job_fb_info *fb = &job->fb;
struct pipe_scissor_state bound;
struct pipe_scissor_state *dr = &submit->damage_rect;
struct pipe_scissor_state *dr = &job->damage_rect;
if (ds && ds->region) {
struct pipe_scissor_state *dbound = &ds->bound;
@ -616,17 +616,17 @@ lima_update_damage_pp_stream(struct lima_submit *submit)
int size = lima_get_pp_stream_size(
screen->num_pp, tiled_w, tiled_h, ctx->pp_stream.offset);
ctx->pp_stream.map = lima_submit_create_stream_bo(
submit, LIMA_PIPE_PP, size, &ctx->pp_stream.va);
ctx->pp_stream.map = lima_job_create_stream_bo(
job, LIMA_PIPE_PP, size, &ctx->pp_stream.va);
lima_generate_pp_stream(submit, bound.minx, bound.miny, tiled_w, tiled_h);
lima_generate_pp_stream(job, bound.minx, bound.miny, tiled_w, tiled_h);
}
static void
lima_update_full_pp_stream(struct lima_submit *submit)
lima_update_full_pp_stream(struct lima_job *job)
{
struct lima_context *ctx = submit->ctx;
struct lima_submit_fb_info *fb = &submit->fb;
struct lima_context *ctx = job->ctx;
struct lima_job_fb_info *fb = &job->fb;
struct lima_ctx_plb_pp_stream_key key = {
.plb_index = ctx->plb_index,
.tiled_w = fb->tiled_w,
@ -652,60 +652,60 @@ lima_update_full_pp_stream(struct lima_submit *submit)
ctx->pp_stream.va = s->bo->va;
memcpy(ctx->pp_stream.offset, s->offset, sizeof(s->offset));
lima_generate_pp_stream(submit, 0, 0, fb->tiled_w, fb->tiled_h);
lima_generate_pp_stream(job, 0, 0, fb->tiled_w, fb->tiled_h);
}
lima_submit_add_bo(submit, LIMA_PIPE_PP, s->bo, LIMA_SUBMIT_BO_READ);
lima_job_add_bo(job, LIMA_PIPE_PP, s->bo, LIMA_SUBMIT_BO_READ);
}
static bool
lima_damage_fullscreen(struct lima_submit *submit)
lima_damage_fullscreen(struct lima_job *job)
{
struct pipe_scissor_state *dr = &submit->damage_rect;
struct pipe_scissor_state *dr = &job->damage_rect;
return dr->minx == 0 &&
dr->miny == 0 &&
dr->maxx == submit->fb.width &&
dr->maxy == submit->fb.height;
dr->maxx == job->fb.width &&
dr->maxy == job->fb.height;
}
static void
lima_update_pp_stream(struct lima_submit *submit)
lima_update_pp_stream(struct lima_job *job)
{
struct lima_context *ctx = submit->ctx;
struct lima_damage_region *damage = lima_submit_get_damage(submit);
if ((damage && damage->region) || !lima_damage_fullscreen(submit))
lima_update_damage_pp_stream(submit);
struct lima_context *ctx = job->ctx;
struct lima_damage_region *damage = lima_job_get_damage(job);
if ((damage && damage->region) || !lima_damage_fullscreen(job))
lima_update_damage_pp_stream(job);
else if (ctx->plb_pp_stream)
lima_update_full_pp_stream(submit);
lima_update_full_pp_stream(job);
else
ctx->pp_stream.map = NULL;
}
static void
lima_update_submit_bo(struct lima_submit *submit)
lima_update_job_bo(struct lima_job *job)
{
struct lima_context *ctx = submit->ctx;
struct lima_context *ctx = job->ctx;
lima_submit_add_bo(submit, LIMA_PIPE_GP, ctx->plb_gp_stream,
lima_job_add_bo(job, LIMA_PIPE_GP, ctx->plb_gp_stream,
LIMA_SUBMIT_BO_READ);
lima_submit_add_bo(submit, LIMA_PIPE_GP, ctx->plb[ctx->plb_index],
lima_job_add_bo(job, LIMA_PIPE_GP, ctx->plb[ctx->plb_index],
LIMA_SUBMIT_BO_WRITE);
lima_submit_add_bo(submit, LIMA_PIPE_GP, ctx->gp_tile_heap[ctx->plb_index],
lima_job_add_bo(job, LIMA_PIPE_GP, ctx->gp_tile_heap[ctx->plb_index],
LIMA_SUBMIT_BO_WRITE);
lima_dump_command_stream_print(
submit->dump, ctx->plb_gp_stream->map + ctx->plb_index * ctx->plb_gp_size,
job->dump, ctx->plb_gp_stream->map + ctx->plb_index * ctx->plb_gp_size,
ctx->plb_gp_size, false, "gp plb stream at va %x\n",
ctx->plb_gp_stream->va + ctx->plb_index * ctx->plb_gp_size);
lima_submit_add_bo(submit, LIMA_PIPE_PP, ctx->plb[ctx->plb_index],
lima_job_add_bo(job, LIMA_PIPE_PP, ctx->plb[ctx->plb_index],
LIMA_SUBMIT_BO_READ);
lima_submit_add_bo(submit, LIMA_PIPE_PP, ctx->gp_tile_heap[ctx->plb_index],
lima_job_add_bo(job, LIMA_PIPE_PP, ctx->gp_tile_heap[ctx->plb_index],
LIMA_SUBMIT_BO_READ);
struct lima_screen *screen = lima_screen(ctx->base.screen);
lima_submit_add_bo(submit, LIMA_PIPE_PP, screen->pp_buffer, LIMA_SUBMIT_BO_READ);
lima_job_add_bo(job, LIMA_PIPE_PP, screen->pp_buffer, LIMA_SUBMIT_BO_READ);
}
static void
@ -721,10 +721,10 @@ lima_finish_plbu_cmd(struct util_dynarray *plbu_cmd_array)
}
static void
lima_pack_wb_zsbuf_reg(struct lima_submit *submit, uint32_t *wb_reg, int wb_idx)
lima_pack_wb_zsbuf_reg(struct lima_job *job, uint32_t *wb_reg, int wb_idx)
{
struct lima_submit_fb_info *fb = &submit->fb;
struct pipe_surface *zsbuf = submit->key.zsbuf;
struct lima_job_fb_info *fb = &job->fb;
struct pipe_surface *zsbuf = job->key.zsbuf;
struct lima_resource *res = lima_resource(zsbuf->texture);
int level = zsbuf->u.tex.level;
uint32_t format = lima_format_get_pixel(zsbuf->format);
@ -744,10 +744,10 @@ lima_pack_wb_zsbuf_reg(struct lima_submit *submit, uint32_t *wb_reg, int wb_idx)
}
static void
lima_pack_wb_cbuf_reg(struct lima_submit *submit, uint32_t *wb_reg, int wb_idx)
lima_pack_wb_cbuf_reg(struct lima_job *job, uint32_t *wb_reg, int wb_idx)
{
struct lima_submit_fb_info *fb = &submit->fb;
struct pipe_surface *cbuf = submit->key.cbuf;
struct lima_job_fb_info *fb = &job->fb;
struct pipe_surface *cbuf = job->key.cbuf;
struct lima_resource *res = lima_resource(cbuf->texture);
int level = cbuf->u.tex.level;
unsigned layer = cbuf->u.tex.first_layer;
@ -769,23 +769,23 @@ lima_pack_wb_cbuf_reg(struct lima_submit *submit, uint32_t *wb_reg, int wb_idx)
}
static void
lima_pack_pp_frame_reg(struct lima_submit *submit, uint32_t *frame_reg,
lima_pack_pp_frame_reg(struct lima_job *job, uint32_t *frame_reg,
uint32_t *wb_reg)
{
struct lima_context *ctx = submit->ctx;
struct lima_submit_fb_info *fb = &submit->fb;
struct lima_context *ctx = job->ctx;
struct lima_job_fb_info *fb = &job->fb;
struct lima_pp_frame_reg *frame = (void *)frame_reg;
struct lima_screen *screen = lima_screen(ctx->base.screen);
int wb_idx = 0;
frame->render_address = screen->pp_buffer->va + pp_frame_rsw_offset;
frame->flags = 0x02;
frame->clear_value_depth = submit->clear.depth;
frame->clear_value_stencil = submit->clear.stencil;
frame->clear_value_color = submit->clear.color_8pc;
frame->clear_value_color_1 = submit->clear.color_8pc;
frame->clear_value_color_2 = submit->clear.color_8pc;
frame->clear_value_color_3 = submit->clear.color_8pc;
frame->clear_value_depth = job->clear.depth;
frame->clear_value_stencil = job->clear.stencil;
frame->clear_value_color = job->clear.color_8pc;
frame->clear_value_color_1 = job->clear.color_8pc;
frame->clear_value_color_2 = job->clear.color_8pc;
frame->clear_value_color_3 = job->clear.color_8pc;
frame->one = 1;
frame->width = fb->width - 1;
@ -796,7 +796,7 @@ lima_pack_pp_frame_reg(struct lima_submit *submit, uint32_t *frame_reg,
/* These are "stack size" and "stack offset" shifted,
* here they are assumed to be always the same. */
frame->fragment_stack_size = submit->pp_max_stack_size << 16 | submit->pp_max_stack_size;
frame->fragment_stack_size = job->pp_max_stack_size << 16 | job->pp_max_stack_size;
/* related with MSAA and different value when r4p0/r7p0 */
frame->supersampled_height = fb->height * 2 - 1;
@ -807,53 +807,53 @@ lima_pack_pp_frame_reg(struct lima_submit *submit, uint32_t *frame_reg,
frame->blocking = (fb->shift_min << 28) | (fb->shift_h << 16) | fb->shift_w;
frame->foureight = 0x8888;
if (submit->key.cbuf && (submit->resolve & PIPE_CLEAR_COLOR0))
lima_pack_wb_cbuf_reg(submit, wb_reg, wb_idx++);
if (job->key.cbuf && (job->resolve & PIPE_CLEAR_COLOR0))
lima_pack_wb_cbuf_reg(job, wb_reg, wb_idx++);
if (submit->key.zsbuf &&
(submit->resolve & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL)))
lima_pack_wb_zsbuf_reg(submit, wb_reg, wb_idx++);
if (job->key.zsbuf &&
(job->resolve & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL)))
lima_pack_wb_zsbuf_reg(job, wb_reg, wb_idx++);
}
void
lima_do_submit(struct lima_submit *submit)
lima_do_job(struct lima_job *job)
{
#define pp_stack_pp_size 0x400
struct lima_context *ctx = submit->ctx;
struct lima_context *ctx = job->ctx;
lima_pack_head_plbu_cmd(submit);
lima_finish_plbu_cmd(&submit->plbu_cmd_array);
lima_pack_head_plbu_cmd(job);
lima_finish_plbu_cmd(&job->plbu_cmd_array);
lima_update_submit_bo(submit);
lima_update_job_bo(job);
int vs_cmd_size = submit->vs_cmd_array.size;
int vs_cmd_size = job->vs_cmd_array.size;
uint32_t vs_cmd_va = 0;
if (vs_cmd_size) {
void *vs_cmd = lima_submit_create_stream_bo(
submit, LIMA_PIPE_GP, vs_cmd_size, &vs_cmd_va);
memcpy(vs_cmd, util_dynarray_begin(&submit->vs_cmd_array), vs_cmd_size);
void *vs_cmd = lima_job_create_stream_bo(
job, LIMA_PIPE_GP, vs_cmd_size, &vs_cmd_va);
memcpy(vs_cmd, util_dynarray_begin(&job->vs_cmd_array), vs_cmd_size);
lima_dump_command_stream_print(
submit->dump, vs_cmd, vs_cmd_size, false, "flush vs cmd at va %x\n", vs_cmd_va);
lima_dump_vs_command_stream_print(submit->dump, vs_cmd, vs_cmd_size, vs_cmd_va);
job->dump, vs_cmd, vs_cmd_size, false, "flush vs cmd at va %x\n", vs_cmd_va);
lima_dump_vs_command_stream_print(job->dump, vs_cmd, vs_cmd_size, vs_cmd_va);
}
uint32_t plbu_cmd_va;
int plbu_cmd_size = submit->plbu_cmd_array.size + submit->plbu_cmd_head.size;
void *plbu_cmd = lima_submit_create_stream_bo(
submit, LIMA_PIPE_GP, plbu_cmd_size, &plbu_cmd_va);
int plbu_cmd_size = job->plbu_cmd_array.size + job->plbu_cmd_head.size;
void *plbu_cmd = lima_job_create_stream_bo(
job, LIMA_PIPE_GP, plbu_cmd_size, &plbu_cmd_va);
memcpy(plbu_cmd,
util_dynarray_begin(&submit->plbu_cmd_head),
submit->plbu_cmd_head.size);
memcpy(plbu_cmd + submit->plbu_cmd_head.size,
util_dynarray_begin(&submit->plbu_cmd_array),
submit->plbu_cmd_array.size);
util_dynarray_begin(&job->plbu_cmd_head),
job->plbu_cmd_head.size);
memcpy(plbu_cmd + job->plbu_cmd_head.size,
util_dynarray_begin(&job->plbu_cmd_array),
job->plbu_cmd_array.size);
lima_dump_command_stream_print(
submit->dump, plbu_cmd, plbu_cmd_size, false, "flush plbu cmd at va %x\n", plbu_cmd_va);
lima_dump_plbu_command_stream_print(submit->dump, plbu_cmd, plbu_cmd_size, plbu_cmd_va);
job->dump, plbu_cmd, plbu_cmd_size, false, "flush plbu cmd at va %x\n", plbu_cmd_va);
lima_dump_plbu_command_stream_print(job->dump, plbu_cmd, plbu_cmd_size, plbu_cmd_va);
struct lima_screen *screen = lima_screen(ctx->base.screen);
struct drm_lima_gp_frame gp_frame;
@ -866,69 +866,69 @@ lima_do_submit(struct lima_submit *submit)
gp_frame_reg->tile_heap_end = ctx->gp_tile_heap[ctx->plb_index]->va + ctx->gp_tile_heap_size;
lima_dump_command_stream_print(
submit->dump, &gp_frame, sizeof(gp_frame), false, "add gp frame\n");
job->dump, &gp_frame, sizeof(gp_frame), false, "add gp frame\n");
if (!lima_submit_start(submit, LIMA_PIPE_GP, &gp_frame, sizeof(gp_frame)))
fprintf(stderr, "gp submit error\n");
if (!lima_job_start(job, LIMA_PIPE_GP, &gp_frame, sizeof(gp_frame)))
fprintf(stderr, "gp job error\n");
if (submit->dump) {
if (lima_submit_wait(submit, LIMA_PIPE_GP, PIPE_TIMEOUT_INFINITE)) {
if (job->dump) {
if (lima_job_wait(job, LIMA_PIPE_GP, PIPE_TIMEOUT_INFINITE)) {
if (ctx->gp_output) {
float *pos = lima_bo_map(ctx->gp_output);
lima_dump_command_stream_print(
submit->dump, pos, 4 * 4 * 16, true, "gl_pos dump at va %x\n",
job->dump, pos, 4 * 4 * 16, true, "gl_pos dump at va %x\n",
ctx->gp_output->va);
}
uint32_t *plb = lima_bo_map(ctx->plb[ctx->plb_index]);
lima_dump_command_stream_print(
submit->dump, plb, LIMA_CTX_PLB_BLK_SIZE, false, "plb dump at va %x\n",
job->dump, plb, LIMA_CTX_PLB_BLK_SIZE, false, "plb dump at va %x\n",
ctx->plb[ctx->plb_index]->va);
}
else {
fprintf(stderr, "gp submit wait error\n");
fprintf(stderr, "gp job wait error\n");
exit(1);
}
}
uint32_t pp_stack_va = 0;
if (submit->pp_max_stack_size) {
lima_submit_create_stream_bo(
submit, LIMA_PIPE_PP,
screen->num_pp * submit->pp_max_stack_size * pp_stack_pp_size,
if (job->pp_max_stack_size) {
lima_job_create_stream_bo(
job, LIMA_PIPE_PP,
screen->num_pp * job->pp_max_stack_size * pp_stack_pp_size,
&pp_stack_va);
}
lima_update_pp_stream(submit);
lima_update_pp_stream(job);
struct lima_pp_stream_state *ps = &ctx->pp_stream;
if (screen->gpu_type == DRM_LIMA_PARAM_GPU_ID_MALI400) {
struct drm_lima_m400_pp_frame pp_frame = {0};
lima_pack_pp_frame_reg(submit, pp_frame.frame, pp_frame.wb);
lima_pack_pp_frame_reg(job, pp_frame.frame, pp_frame.wb);
pp_frame.num_pp = screen->num_pp;
for (int i = 0; i < screen->num_pp; i++) {
pp_frame.plbu_array_address[i] = ps->va + ps->offset[i];
if (submit->pp_max_stack_size)
if (job->pp_max_stack_size)
pp_frame.fragment_stack_address[i] = pp_stack_va +
submit->pp_max_stack_size * pp_stack_pp_size * i;
job->pp_max_stack_size * pp_stack_pp_size * i;
}
lima_dump_command_stream_print(
submit->dump, &pp_frame, sizeof(pp_frame), false, "add pp frame\n");
job->dump, &pp_frame, sizeof(pp_frame), false, "add pp frame\n");
if (!lima_submit_start(submit, LIMA_PIPE_PP, &pp_frame, sizeof(pp_frame)))
fprintf(stderr, "pp submit error\n");
if (!lima_job_start(job, LIMA_PIPE_PP, &pp_frame, sizeof(pp_frame)))
fprintf(stderr, "pp job error\n");
}
else {
struct drm_lima_m450_pp_frame pp_frame = {0};
lima_pack_pp_frame_reg(submit, pp_frame.frame, pp_frame.wb);
lima_pack_pp_frame_reg(job, pp_frame.frame, pp_frame.wb);
pp_frame.num_pp = screen->num_pp;
if (submit->pp_max_stack_size)
if (job->pp_max_stack_size)
for (int i = 0; i < screen->num_pp; i++)
pp_frame.fragment_stack_address[i] = pp_stack_va +
submit->pp_max_stack_size * pp_stack_pp_size * i;
job->pp_max_stack_size * pp_stack_pp_size * i;
if (ps->map) {
for (int i = 0; i < screen->num_pp; i++)
@ -937,7 +937,7 @@ lima_do_submit(struct lima_submit *submit)
else {
pp_frame.use_dlbu = true;
struct lima_submit_fb_info *fb = &submit->fb;
struct lima_job_fb_info *fb = &job->fb;
pp_frame.dlbu_regs[0] = ctx->plb[ctx->plb_index]->va;
pp_frame.dlbu_regs[1] = ((fb->tiled_h - 1) << 16) | (fb->tiled_w - 1);
unsigned s = util_logbase2(LIMA_CTX_PLB_BLK_SIZE) - 7;
@ -946,14 +946,14 @@ lima_do_submit(struct lima_submit *submit)
}
lima_dump_command_stream_print(
submit->dump, &pp_frame, sizeof(pp_frame), false, "add pp frame\n");
job->dump, &pp_frame, sizeof(pp_frame), false, "add pp frame\n");
if (!lima_submit_start(submit, LIMA_PIPE_PP, &pp_frame, sizeof(pp_frame)))
fprintf(stderr, "pp submit error\n");
if (!lima_job_start(job, LIMA_PIPE_PP, &pp_frame, sizeof(pp_frame)))
fprintf(stderr, "pp job error\n");
}
if (submit->dump) {
if (!lima_submit_wait(submit, LIMA_PIPE_PP, PIPE_TIMEOUT_INFINITE)) {
if (job->dump) {
if (!lima_job_wait(job, LIMA_PIPE_PP, PIPE_TIMEOUT_INFINITE)) {
fprintf(stderr, "pp wait error\n");
exit(1);
}
@ -961,54 +961,54 @@ lima_do_submit(struct lima_submit *submit)
ctx->plb_index = (ctx->plb_index + 1) % lima_ctx_num_plb;
if (submit->key.cbuf && (submit->resolve & PIPE_CLEAR_COLOR0)) {
if (job->key.cbuf && (job->resolve & PIPE_CLEAR_COLOR0)) {
/* Set reload flag for next draw. It'll be unset if buffer is cleared */
struct lima_surface *surf = lima_surface(submit->key.cbuf);
struct lima_surface *surf = lima_surface(job->key.cbuf);
surf->reload = true;
}
if (ctx->submit == submit)
ctx->submit = NULL;
if (ctx->job == job)
ctx->job = NULL;
lima_submit_free(submit);
lima_job_free(job);
}
void
lima_flush(struct lima_context *ctx)
{
hash_table_foreach(ctx->submits, entry) {
struct lima_submit *submit = entry->data;
lima_do_submit(submit);
hash_table_foreach(ctx->jobs, entry) {
struct lima_job *job = entry->data;
lima_do_job(job);
}
}
void
lima_flush_submit_accessing_bo(
lima_flush_job_accessing_bo(
struct lima_context *ctx, struct lima_bo *bo, bool write)
{
hash_table_foreach(ctx->submits, entry) {
struct lima_submit *submit = entry->data;
if (lima_submit_has_bo(submit, bo, write))
lima_do_submit(submit);
hash_table_foreach(ctx->jobs, entry) {
struct lima_job *job = entry->data;
if (lima_job_has_bo(job, bo, write))
lima_do_job(job);
}
}
/*
* This is for current submit flush previous submit which write to the resource it wants
* This is for current job flush previous job which write to the resource it wants
* to read. Tipical usage is flush the FBO which is used as current task's texture.
*/
void
lima_flush_previous_submit_writing_resource(
lima_flush_previous_job_writing_resource(
struct lima_context *ctx, struct pipe_resource *prsc)
{
struct hash_entry *entry = _mesa_hash_table_search(ctx->write_submits, prsc);
struct hash_entry *entry = _mesa_hash_table_search(ctx->write_jobs, prsc);
if (entry) {
struct lima_submit *submit = entry->data;
struct lima_job *job = entry->data;
/* do not flush current submit */
if (submit != ctx->submit)
lima_do_submit(submit);
/* do not flush current job */
if (job != ctx->job)
lima_do_job(job);
}
}
@ -1030,28 +1030,28 @@ lima_pipe_flush(struct pipe_context *pctx, struct pipe_fence_handle **fence,
}
static bool
lima_submit_compare(const void *s1, const void *s2)
lima_job_compare(const void *s1, const void *s2)
{
return memcmp(s1, s2, sizeof(struct lima_submit_key)) == 0;
return memcmp(s1, s2, sizeof(struct lima_job_key)) == 0;
}
static uint32_t
lima_submit_hash(const void *key)
lima_job_hash(const void *key)
{
return _mesa_hash_data(key, sizeof(struct lima_submit_key));
return _mesa_hash_data(key, sizeof(struct lima_job_key));
}
bool lima_submit_init(struct lima_context *ctx)
bool lima_job_init(struct lima_context *ctx)
{
int fd = lima_screen(ctx->base.screen)->fd;
ctx->submits = _mesa_hash_table_create(ctx, lima_submit_hash, lima_submit_compare);
if (!ctx->submits)
ctx->jobs = _mesa_hash_table_create(ctx, lima_job_hash, lima_job_compare);
if (!ctx->jobs)
return false;
ctx->write_submits = _mesa_hash_table_create(
ctx->write_jobs = _mesa_hash_table_create(
ctx, _mesa_hash_pointer, _mesa_key_pointer_equal);
if (!ctx->write_submits)
if (!ctx->write_jobs)
return false;
ctx->in_sync_fd = -1;
@ -1067,7 +1067,7 @@ bool lima_submit_init(struct lima_context *ctx)
return true;
}
void lima_submit_fini(struct lima_context *ctx)
void lima_job_fini(struct lima_context *ctx)
{
int fd = lima_screen(ctx->base.screen)->fd;

38
src/gallium/drivers/lima/lima_submit.h → src/gallium/drivers/lima/lima_job.h
View file

@ -21,8 +21,8 @@
*
*/
#ifndef H_LIMA_SUBMIT
#define H_LIMA_SUBMIT
#ifndef H_LIMA_JOB
#define H_LIMA_JOB
#include <stdbool.h>
#include <stdint.h>
@ -36,12 +36,12 @@ struct lima_bo;
struct lima_dump;
struct pipe_surface;
struct lima_submit_key {
struct lima_job_key {
struct pipe_surface *cbuf;
struct pipe_surface *zsbuf;
};
struct lima_submit_clear {
struct lima_job_clear {
unsigned buffers;
uint32_t color_8pc;
uint32_t depth;
@ -49,7 +49,7 @@ struct lima_submit_clear {
uint64_t color_16pc;
};
struct lima_submit_fb_info {
struct lima_job_fb_info {
int width, height;
int tiled_w, tiled_h;
int shift_w, shift_h;
@ -57,14 +57,14 @@ struct lima_submit_fb_info {
int shift_min;
};
struct lima_submit {
struct lima_job {
int fd;
struct lima_context *ctx;
struct util_dynarray gem_bos[2];
struct util_dynarray bos[2];
struct lima_submit_key key;
struct lima_job_key key;
struct util_dynarray vs_cmd_array;
struct util_dynarray plbu_cmd_array;
@ -76,30 +76,30 @@ struct lima_submit {
struct pipe_scissor_state damage_rect;
struct lima_submit_clear clear;
struct lima_job_clear clear;
struct lima_submit_fb_info fb;
struct lima_job_fb_info fb;
/* for dump command stream */
struct lima_dump *dump;
};
static inline bool
lima_submit_has_draw_pending(struct lima_submit *submit)
lima_job_has_draw_pending(struct lima_job *job)
{
return !!submit->plbu_cmd_array.size;
return !!job->plbu_cmd_array.size;
}
struct lima_submit *lima_submit_get(struct lima_context *ctx);
struct lima_job *lima_job_get(struct lima_context *ctx);
bool lima_submit_add_bo(struct lima_submit *submit, int pipe,
struct lima_bo *bo, uint32_t flags);
void *lima_submit_create_stream_bo(struct lima_submit *submit, int pipe,
unsigned size, uint32_t *va);
bool lima_job_add_bo(struct lima_job *job, int pipe,
struct lima_bo *bo, uint32_t flags);
void *lima_job_create_stream_bo(struct lima_job *job, int pipe,
unsigned size, uint32_t *va);
void lima_do_submit(struct lima_submit *submit);
void lima_do_job(struct lima_job *job);
bool lima_submit_init(struct lima_context *ctx);
void lima_submit_fini(struct lima_context *ctx);
bool lima_job_init(struct lima_context *ctx);
void lima_job_fini(struct lima_context *ctx);
#endif

6
src/gallium/drivers/lima/lima_program.c
View file

@ -34,7 +34,7 @@
#include "lima_screen.h"
#include "lima_context.h"
#include "lima_submit.h"
#include "lima_job.h"
#include "lima_program.h"
#include "lima_bo.h"
#include "ir/lima_ir.h"
@ -350,8 +350,8 @@ lima_update_fs_state(struct lima_context *ctx)
fs->shader = NULL;
}
struct lima_submit *submit = lima_submit_get(ctx);
submit->pp_max_stack_size = MAX2(submit->pp_max_stack_size, ctx->fs->stack_size);
struct lima_job *job = lima_job_get(ctx);
job->pp_max_stack_size = MAX2(job->pp_max_stack_size, ctx->fs->stack_size);
return true;
}

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

@ -595,7 +595,7 @@ lima_transfer_map(struct pipe_context *pctx,
* range, so no need to sync */
if (pres->usage != PIPE_USAGE_STREAM) {
if (usage & PIPE_TRANSFER_READ_WRITE) {
lima_flush_submit_accessing_bo(ctx, bo, usage & PIPE_TRANSFER_WRITE);
lima_flush_job_accessing_bo(ctx, bo, usage & PIPE_TRANSFER_WRITE);
unsigned op = usage & PIPE_TRANSFER_WRITE ?
LIMA_GEM_WAIT_WRITE : LIMA_GEM_WAIT_READ;

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

@ -466,8 +466,8 @@ static const struct debug_named_value debug_options[] = {
"don't use tiled buffers" },
{ "nogrowheap", LIMA_DEBUG_NO_GROW_HEAP,
"disable growable heap buffer" },
{ "singlesubmit", LIMA_DEBUG_SINGLE_SUBMIT,
"disable multi submit optimization" },
{ "singlejob", LIMA_DEBUG_SINGLE_JOB,
"disable multi job optimization" },
{ NULL }
};

2
src/gallium/drivers/lima/lima_screen.h
View file

@ -41,7 +41,7 @@
#define LIMA_DEBUG_BO_CACHE (1 << 5)
#define LIMA_DEBUG_NO_TILING (1 << 6)
#define LIMA_DEBUG_NO_GROW_HEAP (1 << 7)
#define LIMA_DEBUG_SINGLE_SUBMIT (1 << 8)
#define LIMA_DEBUG_SINGLE_JOB (1 << 8)
extern uint32_t lima_debug;
extern int lima_ctx_num_plb;

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

@ -41,15 +41,15 @@ lima_set_framebuffer_state(struct pipe_context *pctx,
{
struct lima_context *ctx = lima_context(pctx);
/* make sure there are always single submit in this context */
if (lima_debug & LIMA_DEBUG_SINGLE_SUBMIT)
/* make sure there are always single job in this context */
if (lima_debug & LIMA_DEBUG_SINGLE_JOB)
lima_flush(ctx);
struct lima_context_framebuffer *fb = &ctx->framebuffer;
util_copy_framebuffer_state(&fb->base, framebuffer);
ctx->submit = NULL;
ctx->job = NULL;
ctx->dirty |= LIMA_CONTEXT_DIRTY_FRAMEBUFFER;
}

16
src/gallium/drivers/lima/lima_texture.c
View file

@ -34,7 +34,7 @@
#include "lima_screen.h"
#include "lima_texture.h"
#include "lima_resource.h"
#include "lima_submit.h"
#include "lima_job.h"
#include "lima_util.h"
#include "lima_format.h"
@ -65,7 +65,7 @@ lima_texture_desc_set_va(lima_tex_desc *desc,
/*
* Note: this function is used by both draw and flush code path,
* make sure no lima_submit_get() is called inside this.
* make sure no lima_job_get() is called inside this.
*/
void
lima_texture_desc_set_res(struct lima_context *ctx, lima_tex_desc *desc,
@ -257,7 +257,7 @@ lima_calc_tex_desc_size(struct lima_sampler_view *texture)
void
lima_update_textures(struct lima_context *ctx)
{
struct lima_submit *submit = lima_submit_get(ctx);
struct lima_job *job = lima_job_get(ctx);
struct lima_texture_stateobj *lima_tex = &ctx->tex_stateobj;
assert (lima_tex->num_samplers <= 16);
@ -266,12 +266,12 @@ lima_update_textures(struct lima_context *ctx)
if (!lima_tex->num_samplers || !lima_tex->num_textures)
return;
/* we always need to add texture bo to submit */
/* we always need to add texture bo to job */
for (int i = 0; i < lima_tex->num_samplers; i++) {
struct lima_sampler_view *texture = lima_sampler_view(lima_tex->textures[i]);
struct lima_resource *rsc = lima_resource(texture->base.texture);
lima_flush_previous_submit_writing_resource(ctx, texture->base.texture);
lima_submit_add_bo(submit, LIMA_PIPE_PP, rsc->bo, LIMA_SUBMIT_BO_READ);
lima_flush_previous_job_writing_resource(ctx, texture->base.texture);
lima_job_add_bo(job, LIMA_PIPE_PP, rsc->bo, LIMA_SUBMIT_BO_READ);
}
/* do not regenerate texture desc if no change */
@ -299,11 +299,11 @@ lima_update_textures(struct lima_context *ctx)
}
lima_dump_command_stream_print(
submit->dump, descs, size, false, "add textures_desc at va %x\n",
job->dump, descs, size, false, "add textures_desc at va %x\n",
lima_ctx_buff_va(ctx, lima_ctx_buff_pp_tex_desc));
lima_dump_texture_descriptor(
submit->dump, descs, size,
job->dump, descs, size,
lima_ctx_buff_va(ctx, lima_ctx_buff_pp_tex_desc) + lima_tex_list_size,
lima_tex_list_size);
}

4
src/gallium/drivers/lima/meson.build
View file

@ -62,8 +62,8 @@ files_lima = files(
'lima_query.c',
'lima_bo.c',
'lima_bo.h',
'lima_submit.c',
'lima_submit.h',
'lima_job.c',
'lima_job.h',
'lima_parser.c',
'lima_parser.h',
'lima_util.c',