[v3,01/25] panfrost: s/job/batch/

Submitted by Boris Brezillon on Sept. 5, 2019, 7:41 p.m.

Details

Message ID 20190905194150.17608-2-boris.brezillon@collabora.com
State Accepted
Commit 2c526993bc4098a7c541c69ec0abc0a4076d66e6
Headers show
Series "panfrost: Rework the batch pipelining logic" ( rev: 1 ) in Mesa

Not browsing as part of any series.

Commit Message

Boris Brezillon Sept. 5, 2019, 7:41 p.m.
What we currently call a job is actually a batch containing several jobs
all attached to a rendering operation targeting a specific FBO.

Let's rename structs, functions, variables and fields to reflect this
fact.

Suggested-by: Alyssa Rosenzweig <alyssa.rosenzweig@collabora.com>
Signed-off-by: Boris Brezillon <boris.brezillon@collabora.com>
---
Changes in v3:
* s/panfrost_job_/panfrost_batch_/

Changes in v2:
* s/panfrost_job_get_batch_for_fbo/panfrost_get_batch_for_fbo/
* s/panfrost_job_batch/panfrost_batch/g
---
 src/gallium/drivers/panfrost/pan_allocate.c   |   6 +-
 src/gallium/drivers/panfrost/pan_blend_cso.c  |   4 +-
 src/gallium/drivers/panfrost/pan_compute.c    |   2 +-
 src/gallium/drivers/panfrost/pan_context.c    |  72 +++----
 src/gallium/drivers/panfrost/pan_context.h    |  12 +-
 src/gallium/drivers/panfrost/pan_drm.c        |  33 +--
 src/gallium/drivers/panfrost/pan_fragment.c   |  20 +-
 src/gallium/drivers/panfrost/pan_instancing.c |   6 +-
 src/gallium/drivers/panfrost/pan_job.c        | 198 +++++++++---------
 src/gallium/drivers/panfrost/pan_job.h        |  72 +++----
 src/gallium/drivers/panfrost/pan_mfbd.c       |  30 +--
 src/gallium/drivers/panfrost/pan_resource.c   |   4 +-
 src/gallium/drivers/panfrost/pan_scoreboard.c |  22 +-
 src/gallium/drivers/panfrost/pan_screen.h     |   2 +-
 src/gallium/drivers/panfrost/pan_sfbd.c       |  36 ++--
 src/gallium/drivers/panfrost/pan_varyings.c   |   4 +-
 16 files changed, 264 insertions(+), 259 deletions(-)

Patch hide | download patch | download mbox

diff --git a/src/gallium/drivers/panfrost/pan_allocate.c b/src/gallium/drivers/panfrost/pan_allocate.c
index 2efb01c75589..d8a594551c76 100644
--- a/src/gallium/drivers/panfrost/pan_allocate.c
+++ b/src/gallium/drivers/panfrost/pan_allocate.c
@@ -63,7 +63,7 @@  struct panfrost_transfer
 panfrost_allocate_transient(struct panfrost_context *ctx, size_t sz)
 {
         struct panfrost_screen *screen = pan_screen(ctx->base.screen);
-        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
 
         /* Pad the size */
         sz = ALIGN_POT(sz, ALIGNMENT);
@@ -111,7 +111,7 @@  panfrost_allocate_transient(struct panfrost_context *ctx, size_t sz)
                         bo = panfrost_create_slab(screen, &index);
                 }
 
-                panfrost_job_add_bo(batch, bo);
+                panfrost_batch_add_bo(batch, bo);
 
                 /* Remember we created this */
                 util_dynarray_append(&batch->transient_indices, unsigned, index);
@@ -120,7 +120,7 @@  panfrost_allocate_transient(struct panfrost_context *ctx, size_t sz)
         } else {
                 /* Create a new BO and reference it */
                 bo = panfrost_drm_create_bo(screen, ALIGN_POT(sz, 4096), 0);
-                panfrost_job_add_bo(batch, bo);
+                panfrost_batch_add_bo(batch, bo);
 
                 /* Creating a BO adds a reference, and then the job adds a
                  * second one. So we need to pop back one reference */
diff --git a/src/gallium/drivers/panfrost/pan_blend_cso.c b/src/gallium/drivers/panfrost/pan_blend_cso.c
index 43121335f5e7..ab49772f3ba3 100644
--- a/src/gallium/drivers/panfrost/pan_blend_cso.c
+++ b/src/gallium/drivers/panfrost/pan_blend_cso.c
@@ -227,7 +227,7 @@  struct panfrost_blend_final
 panfrost_get_blend_for_context(struct panfrost_context *ctx, unsigned rti)
 {
         struct panfrost_screen *screen = pan_screen(ctx->base.screen);
-        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
 
         /* Grab the format, falling back gracefully if called invalidly (which
          * has to happen for no-color-attachment FBOs, for instance)  */
@@ -276,7 +276,7 @@  panfrost_get_blend_for_context(struct panfrost_context *ctx, unsigned rti)
         memcpy(final.shader.bo->cpu, shader->buffer, shader->size);
 
         /* Pass BO ownership to job */
-        panfrost_job_add_bo(job, final.shader.bo);
+        panfrost_batch_add_bo(batch, final.shader.bo);
         panfrost_bo_unreference(ctx->base.screen, final.shader.bo);
 
         if (shader->patch_index) {
diff --git a/src/gallium/drivers/panfrost/pan_compute.c b/src/gallium/drivers/panfrost/pan_compute.c
index 50e70cd8298e..51967fe481ef 100644
--- a/src/gallium/drivers/panfrost/pan_compute.c
+++ b/src/gallium/drivers/panfrost/pan_compute.c
@@ -128,7 +128,7 @@  panfrost_launch_grid(struct pipe_context *pipe,
         memcpy(transfer.cpu + sizeof(job), payload, sizeof(*payload));
 
         /* TODO: Do we want a special compute-only batch? */
-        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
 
         /* Queue the job */
         panfrost_scoreboard_queue_compute_job(batch, transfer);
diff --git a/src/gallium/drivers/panfrost/pan_context.c b/src/gallium/drivers/panfrost/pan_context.c
index 2db360b0d490..ce895822014d 100644
--- a/src/gallium/drivers/panfrost/pan_context.c
+++ b/src/gallium/drivers/panfrost/pan_context.c
@@ -61,7 +61,7 @@  panfrost_emit_midg_tiler(
         unsigned vertex_count)
 {
         struct midgard_tiler_descriptor t = {};
-        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
 
         t.hierarchy_mask =
                 panfrost_choose_hierarchy_mask(width, height, vertex_count);
@@ -77,8 +77,9 @@  panfrost_emit_midg_tiler(
         /* Sanity check */
 
         if (t.hierarchy_mask) {
-                t.polygon_list = panfrost_job_get_polygon_list(batch,
-                                header_size + t.polygon_list_size);
+                t.polygon_list = panfrost_batch_get_polygon_list(batch,
+                                                                 header_size +
+                                                                 t.polygon_list_size);
 
 
                 /* Allow the entire tiler heap */
@@ -177,9 +178,9 @@  panfrost_clear(
         double depth, unsigned stencil)
 {
         struct panfrost_context *ctx = pan_context(pipe);
-        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
 
-        panfrost_job_clear(ctx, job, buffers, color, depth, stencil);
+        panfrost_batch_clear(ctx, batch, buffers, color, depth, stencil);
 }
 
 static mali_ptr
@@ -617,8 +618,8 @@  panfrost_upload_tex(
         unsigned afbc_bit = (is_afbc && !is_zs) ? 1 : 0;
 
         /* Add the BO to the job so it's retained until the job is done. */
-        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
-        panfrost_job_add_bo(job, rsrc->bo);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
+        panfrost_batch_add_bo(batch, rsrc->bo);
 
         /* Add the usage flags in, since they can change across the CSO
          * lifetime due to layout switches */
@@ -732,10 +733,10 @@  static void panfrost_upload_ssbo_sysval(
         struct pipe_shader_buffer sb = ctx->ssbo[st][ssbo_id];
 
         /* Compute address */
-        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
         struct panfrost_bo *bo = pan_resource(sb.buffer)->bo;
 
-        panfrost_job_add_bo(batch, bo);
+        panfrost_batch_add_bo(batch, bo);
 
         /* Upload address and size as sysval */
         uniform->du[0] = bo->gpu + sb.buffer_offset;
@@ -883,13 +884,13 @@  panfrost_patch_shader_state_compute(
 void
 panfrost_emit_for_draw(struct panfrost_context *ctx, bool with_vertex_data)
 {
-        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
         struct panfrost_screen *screen = pan_screen(ctx->base.screen);
 
         panfrost_attach_vt_framebuffer(ctx);
 
         if (with_vertex_data) {
-                panfrost_emit_vertex_data(job);
+                panfrost_emit_vertex_data(batch);
 
                 /* Varyings emitted for -all- geometry */
                 unsigned total_count = ctx->padded_count * ctx->instance_count;
@@ -906,7 +907,7 @@  panfrost_emit_for_draw(struct panfrost_context *ctx, bool with_vertex_data)
                 SET_BIT(ctx->fragment_shader_core.unknown2_4, MALI_NO_MSAA, !msaa);
         }
 
-        panfrost_job_set_requirements(ctx, job);
+        panfrost_batch_set_requirements(ctx, batch);
 
         if (ctx->occlusion_query) {
                 ctx->payloads[PIPE_SHADER_FRAGMENT].gl_enables |= MALI_OCCLUSION_QUERY | MALI_OCCLUSION_PRECISE;
@@ -937,7 +938,7 @@  panfrost_emit_for_draw(struct panfrost_context *ctx, bool with_vertex_data)
 
                 panfrost_patch_shader_state(ctx, variant, PIPE_SHADER_FRAGMENT, false);
 
-                panfrost_job_add_bo(job, variant->bo);
+                panfrost_batch_add_bo(batch, variant->bo);
 
 #define COPY(name) ctx->fragment_shader_core.name = variant->tripipe->name
 
@@ -1271,7 +1272,7 @@  panfrost_emit_for_draw(struct panfrost_context *ctx, bool with_vertex_data)
          * just... be faster :) */
 
         if (!ctx->wallpaper_batch)
-                panfrost_job_union_scissor(job, minx, miny, maxx, maxy);
+                panfrost_batch_union_scissor(batch, minx, miny, maxx, maxy);
 
         /* Upload */
 
@@ -1311,7 +1312,7 @@  panfrost_queue_draw(struct panfrost_context *ctx)
         if (!rasterizer_discard)
                 tiler = panfrost_vertex_tiler_job(ctx, true);
 
-        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
 
         if (rasterizer_discard)
                 panfrost_scoreboard_queue_vertex_job(batch, vertex, FALSE);
@@ -1326,9 +1327,9 @@  panfrost_queue_draw(struct panfrost_context *ctx)
 static void
 panfrost_submit_frame(struct panfrost_context *ctx, bool flush_immediate,
                       struct pipe_fence_handle **fence,
-                      struct panfrost_job *job)
+                      struct panfrost_batch *batch)
 {
-        panfrost_job_submit(ctx, job);
+        panfrost_batch_submit(ctx, batch);
 
         /* If visual, we can stall a frame */
 
@@ -1336,7 +1337,7 @@  panfrost_submit_frame(struct panfrost_context *ctx, bool flush_immediate,
                 panfrost_drm_force_flush_fragment(ctx, fence);
 
         ctx->last_fragment_flushed = false;
-        ctx->last_job = job;
+        ctx->last_batch = batch;
 
         /* If readback, flush now (hurts the pipelined performance) */
         if (flush_immediate)
@@ -1362,7 +1363,7 @@  panfrost_draw_wallpaper(struct pipe_context *pipe)
                 return;
 
         /* Save the batch */
-        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
 
         ctx->wallpaper_batch = batch;
 
@@ -1374,10 +1375,11 @@  panfrost_draw_wallpaper(struct pipe_context *pipe)
         unsigned damage_height = (rsrc->damage.extent.maxy - rsrc->damage.extent.miny);
 
         if (damage_width && damage_height) {
-                panfrost_job_intersection_scissor(batch, rsrc->damage.extent.minx,
-                                                  rsrc->damage.extent.miny,
-                                                  rsrc->damage.extent.maxx,
-                                                  rsrc->damage.extent.maxy);
+                panfrost_batch_intersection_scissor(batch,
+                                                    rsrc->damage.extent.minx,
+                                                    rsrc->damage.extent.miny,
+                                                    rsrc->damage.extent.maxx,
+                                                    rsrc->damage.extent.maxy);
         }
 
         /* FIXME: Looks like aligning on a tile is not enough, but
@@ -1454,12 +1456,12 @@  panfrost_flush(
         unsigned flags)
 {
         struct panfrost_context *ctx = pan_context(pipe);
-        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
 
         /* Nothing to do! */
-        if (!job->last_job.gpu && !job->clear) return;
+        if (!batch->last_job.gpu && !batch->clear) return;
 
-        if (!job->clear && job->last_tiler.gpu)
+        if (!batch->clear && batch->last_tiler.gpu)
                 panfrost_draw_wallpaper(&ctx->base);
 
         /* Whether to stall the pipeline for immediately correct results. Since
@@ -1468,7 +1470,7 @@  panfrost_flush(
         bool flush_immediate = /*flags & PIPE_FLUSH_END_OF_FRAME*/true;
 
         /* Submit the frame itself */
-        panfrost_submit_frame(ctx, flush_immediate, fence, job);
+        panfrost_submit_frame(ctx, flush_immediate, fence, batch);
 
         /* Prepare for the next frame */
         panfrost_invalidate_frame(ctx);
@@ -1525,11 +1527,11 @@  panfrost_get_index_buffer_mapped(struct panfrost_context *ctx, const struct pipe
         struct panfrost_resource *rsrc = (struct panfrost_resource *) (info->index.resource);
 
         off_t offset = info->start * info->index_size;
-        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
 
         if (!info->has_user_indices) {
                 /* Only resources can be directly mapped */
-                panfrost_job_add_bo(batch, rsrc->bo);
+                panfrost_batch_add_bo(batch, rsrc->bo);
                 return rsrc->bo->gpu + offset;
         } else {
                 /* Otherwise, we need to upload to transient memory */
@@ -1621,7 +1623,7 @@  panfrost_draw_vbo(
         /* Now that we have a guaranteed terminating path, find the job.
          * Assignment commented out to prevent unused warning */
 
-        /* struct panfrost_job *job = */ panfrost_get_job_for_fbo(ctx);
+        /* struct panfrost_batch *batch = */ panfrost_get_batch_for_fbo(ctx);
 
         ctx->payloads[PIPE_SHADER_FRAGMENT].prefix.draw_mode = g2m_draw_mode(mode);
 
@@ -2394,9 +2396,9 @@  panfrost_set_framebuffer_state(struct pipe_context *pctx,
          * state is being restored by u_blitter
          */
 
-        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
         bool is_scanout = panfrost_is_scanout(ctx);
-        bool has_draws = job->last_job.gpu;
+        bool has_draws = batch->last_job.gpu;
 
         /* Bail out early when the current and new states are the same. */
         if (util_framebuffer_state_equal(&ctx->pipe_framebuffer, fb))
@@ -2424,7 +2426,7 @@  panfrost_set_framebuffer_state(struct pipe_context *pctx,
         /* Invalidate the FBO job cache since we've just been assigned a new
          * FB state.
          */
-        ctx->job = NULL;
+        ctx->batch = NULL;
 
         util_copy_framebuffer_state(&ctx->pipe_framebuffer, fb);
 
@@ -2853,11 +2855,11 @@  panfrost_create_context(struct pipe_screen *screen, void *priv, unsigned flags)
         assert(ctx->blitter_wallpaper);
 
         ctx->last_fragment_flushed = true;
-        ctx->last_job = NULL;
+        ctx->last_batch = NULL;
 
         /* Prepare for render! */
 
-        panfrost_job_init(ctx);
+        panfrost_batch_init(ctx);
         panfrost_emit_vertex_payload(ctx);
         panfrost_emit_tiler_payload(ctx);
         panfrost_invalidate_frame(ctx);
diff --git a/src/gallium/drivers/panfrost/pan_context.h b/src/gallium/drivers/panfrost/pan_context.h
index 9f96e983a86e..5af950e10013 100644
--- a/src/gallium/drivers/panfrost/pan_context.h
+++ b/src/gallium/drivers/panfrost/pan_context.h
@@ -110,9 +110,9 @@  struct panfrost_context {
         /* Compiler context */
         struct midgard_screen compiler;
 
-        /* Bound job and map of panfrost_job_key to jobs */
-        struct panfrost_job *job;
-        struct hash_table *jobs;
+        /* Bound job batch and map of panfrost_batch_key to job batches */
+        struct panfrost_batch *batch;
+        struct hash_table *batches;
 
         /* panfrost_resource -> panfrost_job */
         struct hash_table *write_jobs;
@@ -189,7 +189,7 @@  struct panfrost_context {
          * errors due to unsupported reucrsion */
 
         struct blitter_context *blitter_wallpaper;
-        struct panfrost_job *wallpaper_batch;
+        struct panfrost_batch *wallpaper_batch;
 
         struct panfrost_blend_state *blend;
 
@@ -208,7 +208,7 @@  struct panfrost_context {
          * still busy executing frame N-1. So hold a reference to
          * yesterjob */
         int last_fragment_flushed;
-        struct panfrost_job *last_job;
+        struct panfrost_batch *last_batch;
 };
 
 /* Corresponds to the CSO */
@@ -353,7 +353,7 @@  mali_ptr
 panfrost_vertex_buffer_address(struct panfrost_context *ctx, unsigned i);
 
 void
-panfrost_emit_vertex_data(struct panfrost_job *batch);
+panfrost_emit_vertex_data(struct panfrost_batch *batch);
 
 struct pan_shift_odd {
         unsigned shift;
diff --git a/src/gallium/drivers/panfrost/pan_drm.c b/src/gallium/drivers/panfrost/pan_drm.c
index 4e6928248097..75fc5a726b1f 100644
--- a/src/gallium/drivers/panfrost/pan_drm.c
+++ b/src/gallium/drivers/panfrost/pan_drm.c
@@ -248,11 +248,12 @@  panfrost_drm_export_bo(struct panfrost_screen *screen, const struct panfrost_bo
 }
 
 static int
-panfrost_drm_submit_job(struct panfrost_context *ctx, u64 job_desc, int reqs)
+panfrost_drm_submit_batch(struct panfrost_context *ctx, u64 first_job_desc,
+                          int reqs)
 {
         struct pipe_context *gallium = (struct pipe_context *) ctx;
         struct panfrost_screen *screen = pan_screen(gallium->screen);
-        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
         struct drm_panfrost_submit submit = {0,};
         int *bo_handles, ret;
 
@@ -261,13 +262,13 @@  panfrost_drm_submit_job(struct panfrost_context *ctx, u64 job_desc, int reqs)
 
         submit.out_sync = ctx->out_sync;
 
-        submit.jc = job_desc;
+        submit.jc = first_job_desc;
         submit.requirements = reqs;
 
-        bo_handles = calloc(job->bos->entries, sizeof(*bo_handles));
+        bo_handles = calloc(batch->bos->entries, sizeof(*bo_handles));
         assert(bo_handles);
 
-        set_foreach(job->bos, entry) {
+        set_foreach(batch->bos, entry) {
                 struct panfrost_bo *bo = (struct panfrost_bo *)entry->key;
                 assert(bo->gem_handle > 0);
                 bo_handles[submit.bo_handle_count++] = bo->gem_handle;
@@ -292,23 +293,25 @@  panfrost_drm_submit_job(struct panfrost_context *ctx, u64 job_desc, int reqs)
 }
 
 int
-panfrost_drm_submit_vs_fs_job(struct panfrost_context *ctx, bool has_draws)
+panfrost_drm_submit_vs_fs_batch(struct panfrost_context *ctx, bool has_draws)
 {
         int ret = 0;
 
-        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
 
-        panfrost_job_add_bo(job, ctx->scratchpad.bo);
-        panfrost_job_add_bo(job, ctx->tiler_heap.bo);
-        panfrost_job_add_bo(job, job->polygon_list);
+        panfrost_batch_add_bo(batch, ctx->scratchpad.bo);
+        panfrost_batch_add_bo(batch, ctx->tiler_heap.bo);
+        panfrost_batch_add_bo(batch, batch->polygon_list);
 
-        if (job->first_job.gpu) {
-                ret = panfrost_drm_submit_job(ctx, job->first_job.gpu, 0);
+        if (batch->first_job.gpu) {
+                ret = panfrost_drm_submit_batch(ctx, batch->first_job.gpu, 0);
                 assert(!ret);
         }
 
-        if (job->first_tiler.gpu || job->clear) {
-                ret = panfrost_drm_submit_job(ctx, panfrost_fragment_job(ctx, has_draws), PANFROST_JD_REQ_FS);
+        if (batch->first_tiler.gpu || batch->clear) {
+                ret = panfrost_drm_submit_batch(ctx,
+                                                panfrost_fragment_job(ctx, has_draws),
+                                                PANFROST_JD_REQ_FS);
                 assert(!ret);
         }
 
@@ -353,7 +356,7 @@  panfrost_drm_force_flush_fragment(struct panfrost_context *ctx,
                 ctx->last_fragment_flushed = true;
 
                 /* The job finished up, so we're safe to clean it up now */
-                panfrost_free_job(ctx, ctx->last_job);
+                panfrost_free_batch(ctx, ctx->last_batch);
         }
 
         if (fence) {
diff --git a/src/gallium/drivers/panfrost/pan_fragment.c b/src/gallium/drivers/panfrost/pan_fragment.c
index 778bc85100f8..f92bf4e35226 100644
--- a/src/gallium/drivers/panfrost/pan_fragment.c
+++ b/src/gallium/drivers/panfrost/pan_fragment.c
@@ -32,7 +32,7 @@ 
 
 static void
 panfrost_initialize_surface(
-                struct panfrost_job *batch,
+                struct panfrost_batch *batch,
                 struct pipe_surface *surf)
 {
         if (!surf)
@@ -44,7 +44,7 @@  panfrost_initialize_surface(
         rsrc->slices[level].initialized = true;
 
         assert(rsrc->bo);
-        panfrost_job_add_bo(batch, rsrc->bo);
+        panfrost_batch_add_bo(batch, rsrc->bo);
 }
 
 /* Generate a fragment job. This should be called once per frame. (According to
@@ -63,7 +63,7 @@  panfrost_fragment_job(struct panfrost_context *ctx, bool has_draws)
          * Also, add the surfaces we're writing to to the batch */
 
         struct pipe_framebuffer_state *fb = &ctx->pipe_framebuffer;
-        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
 
         for (unsigned i = 0; i < fb->nr_cbufs; ++i) {
                 panfrost_initialize_surface(batch, fb->cbufs[i]);
@@ -78,8 +78,6 @@  panfrost_fragment_job(struct panfrost_context *ctx, bool has_draws)
                 .job_descriptor_size = 1
         };
 
-        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
-
         /* The passed tile coords can be out of range in some cases, so we need
          * to clamp them to the framebuffer size to avoid a TILE_RANGE_FAULT.
          * Theoretically we also need to clamp the coordinates positive, but we
@@ -91,18 +89,18 @@  panfrost_fragment_job(struct panfrost_context *ctx, bool has_draws)
          * But that can't happen if any actual drawing occurs (beyond a
          * wallpaper reload), so this is again irrelevant in practice. */
 
-        job->maxx = MIN2(job->maxx, fb->width);
-        job->maxy = MIN2(job->maxy, fb->height);
+        batch->maxx = MIN2(batch->maxx, fb->width);
+        batch->maxy = MIN2(batch->maxy, fb->height);
 
         /* Rendering region must be at least 1x1; otherwise, there is nothing
          * to do and the whole job chain should have been discarded. */
 
-        assert(job->maxx > job->minx);
-        assert(job->maxy > job->miny);
+        assert(batch->maxx > batch->minx);
+        assert(batch->maxy > batch->miny);
 
         struct mali_payload_fragment payload = {
-                .min_tile_coord = MALI_COORDINATE_TO_TILE_MIN(job->minx, job->miny),
-                .max_tile_coord = MALI_COORDINATE_TO_TILE_MAX(job->maxx, job->maxy),
+                .min_tile_coord = MALI_COORDINATE_TO_TILE_MIN(batch->minx, batch->miny),
+                .max_tile_coord = MALI_COORDINATE_TO_TILE_MAX(batch->maxx, batch->maxy),
                 .framebuffer = framebuffer,
         };
 
diff --git a/src/gallium/drivers/panfrost/pan_instancing.c b/src/gallium/drivers/panfrost/pan_instancing.c
index fc63cdbb25d7..44fe0a344aab 100644
--- a/src/gallium/drivers/panfrost/pan_instancing.c
+++ b/src/gallium/drivers/panfrost/pan_instancing.c
@@ -164,7 +164,7 @@  panfrost_padded_vertex_count(
 
 static unsigned
 panfrost_vertex_instanced(
-        struct panfrost_job *batch,
+        struct panfrost_batch *batch,
         struct panfrost_resource *rsrc,
         unsigned divisor,
         union mali_attr *attrs,
@@ -253,7 +253,7 @@  panfrost_vertex_instanced(
 }
 
 void
-panfrost_emit_vertex_data(struct panfrost_job *batch)
+panfrost_emit_vertex_data(struct panfrost_batch *batch)
 {
         struct panfrost_context *ctx = batch->ctx;
         struct panfrost_vertex_state *so = ctx->vertex;
@@ -297,7 +297,7 @@  panfrost_emit_vertex_data(struct panfrost_job *batch)
                 unsigned chopped_addr = raw_addr - addr;
 
                 /* Add a dependency of the batch on the vertex buffer */
-                panfrost_job_add_bo(batch, rsrc->bo);
+                panfrost_batch_add_bo(batch, rsrc->bo);
 
                 /* Set common fields */
                 attrs[k].elements = addr;
diff --git a/src/gallium/drivers/panfrost/pan_job.c b/src/gallium/drivers/panfrost/pan_job.c
index f7ff57c4331a..a019c2adf69a 100644
--- a/src/gallium/drivers/panfrost/pan_job.c
+++ b/src/gallium/drivers/panfrost/pan_job.c
@@ -31,35 +31,35 @@ 
 #include "util/u_format.h"
 #include "util/u_pack_color.h"
 
-struct panfrost_job *
-panfrost_create_job(struct panfrost_context *ctx)
+struct panfrost_batch *
+panfrost_create_batch(struct panfrost_context *ctx)
 {
-        struct panfrost_job *job = rzalloc(ctx, struct panfrost_job);
+        struct panfrost_batch *batch = rzalloc(ctx, struct panfrost_batch);
 
-        job->ctx = ctx;
+        batch->ctx = ctx;
 
-        job->bos = _mesa_set_create(job,
-                                    _mesa_hash_pointer,
-                                    _mesa_key_pointer_equal);
+        batch->bos = _mesa_set_create(batch,
+                                      _mesa_hash_pointer,
+                                      _mesa_key_pointer_equal);
 
-        job->minx = job->miny = ~0;
-        job->maxx = job->maxy = 0;
-        job->transient_offset = 0;
+        batch->minx = batch->miny = ~0;
+        batch->maxx = batch->maxy = 0;
+        batch->transient_offset = 0;
 
-        util_dynarray_init(&job->headers, job);
-        util_dynarray_init(&job->gpu_headers, job);
-        util_dynarray_init(&job->transient_indices, job);
+        util_dynarray_init(&batch->headers, batch);
+        util_dynarray_init(&batch->gpu_headers, batch);
+        util_dynarray_init(&batch->transient_indices, batch);
 
-        return job;
+        return batch;
 }
 
 void
-panfrost_free_job(struct panfrost_context *ctx, struct panfrost_job *job)
+panfrost_free_batch(struct panfrost_context *ctx, struct panfrost_batch *batch)
 {
-        if (!job)
+        if (!batch)
                 return;
 
-        set_foreach(job->bos, entry) {
+        set_foreach(batch->bos, entry) {
                 struct panfrost_bo *bo = (struct panfrost_bo *)entry->key;
                 panfrost_bo_unreference(ctx->base.screen, bo);
         }
@@ -68,30 +68,30 @@  panfrost_free_job(struct panfrost_context *ctx, struct panfrost_job *job)
         struct panfrost_screen *screen = pan_screen(ctx->base.screen);
 
         pthread_mutex_lock(&screen->transient_lock);
-        util_dynarray_foreach(&job->transient_indices, unsigned, index) {
+        util_dynarray_foreach(&batch->transient_indices, unsigned, index) {
                 /* Mark it free */
                 BITSET_SET(screen->free_transient, *index);
         }
         pthread_mutex_unlock(&screen->transient_lock);
 
         /* Unreference the polygon list */
-        panfrost_bo_unreference(ctx->base.screen, job->polygon_list);
+        panfrost_bo_unreference(ctx->base.screen, batch->polygon_list);
 
-        _mesa_hash_table_remove_key(ctx->jobs, &job->key);
+        _mesa_hash_table_remove_key(ctx->batches, &batch->key);
 
-        if (ctx->job == job)
-                ctx->job = NULL;
+        if (ctx->batch == batch)
+                ctx->batch = NULL;
 
-        ralloc_free(job);
+        ralloc_free(batch);
 }
 
-struct panfrost_job *
-panfrost_get_job(struct panfrost_context *ctx,
+struct panfrost_batch *
+panfrost_get_batch(struct panfrost_context *ctx,
                  struct pipe_surface **cbufs, struct pipe_surface *zsbuf)
 {
         /* Lookup the job first */
 
-        struct panfrost_job_key key = {
+        struct panfrost_batch_key key = {
                 .cbufs = {
                         cbufs[0],
                         cbufs[1],
@@ -101,27 +101,27 @@  panfrost_get_job(struct panfrost_context *ctx,
                 .zsbuf = zsbuf
         };
 
-        struct hash_entry *entry = _mesa_hash_table_search(ctx->jobs, &key);
+        struct hash_entry *entry = _mesa_hash_table_search(ctx->batches, &key);
 
         if (entry)
                 return entry->data;
 
         /* Otherwise, let's create a job */
 
-        struct panfrost_job *job = panfrost_create_job(ctx);
+        struct panfrost_batch *batch = panfrost_create_batch(ctx);
 
         /* Save the created job */
 
-        memcpy(&job->key, &key, sizeof(key));
-        _mesa_hash_table_insert(ctx->jobs, &job->key, job);
+        memcpy(&batch->key, &key, sizeof(key));
+        _mesa_hash_table_insert(ctx->batches, &batch->key, batch);
 
-        return job;
+        return batch;
 }
 
 /* Get the job corresponding to the FBO we're currently rendering into */
 
-struct panfrost_job *
-panfrost_get_job_for_fbo(struct panfrost_context *ctx)
+struct panfrost_batch *
+panfrost_get_batch_for_fbo(struct panfrost_context *ctx)
 {
         /* If we're wallpapering, we special case to workaround
          * u_blitter abuse */
@@ -131,38 +131,38 @@  panfrost_get_job_for_fbo(struct panfrost_context *ctx)
 
         /* If we already began rendering, use that */
 
-        if (ctx->job) {
-                assert(ctx->job->key.zsbuf == ctx->pipe_framebuffer.zsbuf &&
-                       !memcmp(ctx->job->key.cbufs,
+        if (ctx->batch) {
+                assert(ctx->batch->key.zsbuf == ctx->pipe_framebuffer.zsbuf &&
+                       !memcmp(ctx->batch->key.cbufs,
                                ctx->pipe_framebuffer.cbufs,
-                               sizeof(ctx->job->key.cbufs)));
-                return ctx->job;
+                               sizeof(ctx->batch->key.cbufs)));
+                return ctx->batch;
         }
 
         /* If not, look up the job */
 
         struct pipe_surface **cbufs = ctx->pipe_framebuffer.cbufs;
         struct pipe_surface *zsbuf = ctx->pipe_framebuffer.zsbuf;
-        struct panfrost_job *job = panfrost_get_job(ctx, cbufs, zsbuf);
+        struct panfrost_batch *batch = panfrost_get_batch(ctx, cbufs, zsbuf);
 
         /* Set this job as the current FBO job. Will be reset when updating the
          * FB state and when submitting or releasing a job.
          */
-        ctx->job = job;
-        return job;
+        ctx->batch = batch;
+        return batch;
 }
 
 void
-panfrost_job_add_bo(struct panfrost_job *job, struct panfrost_bo *bo)
+panfrost_batch_add_bo(struct panfrost_batch *batch, struct panfrost_bo *bo)
 {
         if (!bo)
                 return;
 
-        if (_mesa_set_search(job->bos, bo))
+        if (_mesa_set_search(batch->bos, bo))
                 return;
 
         panfrost_bo_reference(bo);
-        _mesa_set_add(job->bos, bo);
+        _mesa_set_add(batch->bos, bo);
 }
 
 /* Returns the polygon list's GPU address if available, or otherwise allocates
@@ -170,7 +170,7 @@  panfrost_job_add_bo(struct panfrost_job *job, struct panfrost_bo *bo)
  * since we'll hit the BO cache and this is one-per-batch anyway. */
 
 mali_ptr
-panfrost_job_get_polygon_list(struct panfrost_job *batch, unsigned size)
+panfrost_batch_get_polygon_list(struct panfrost_batch *batch, unsigned size)
 {
         if (batch->polygon_list) {
                 assert(batch->polygon_list->size >= size);
@@ -194,52 +194,52 @@  panfrost_flush_jobs_writing_resource(struct panfrost_context *panfrost,
         struct hash_entry *entry = _mesa_hash_table_search(panfrost->write_jobs,
                                    prsc);
         if (entry) {
-                struct panfrost_job *job = entry->data;
-                panfrost_job_submit(panfrost, job);
+                struct panfrost_batch *batch = entry->data;
+                panfrost_batch_submit(panfrost, job);
         }
 #endif
         /* TODO stub */
 }
 
 void
-panfrost_job_submit(struct panfrost_context *ctx, struct panfrost_job *job)
+panfrost_batch_submit(struct panfrost_context *ctx, struct panfrost_batch *batch)
 {
         int ret;
 
-        assert(job);
-        panfrost_scoreboard_link_batch(job);
+        assert(batch);
+        panfrost_scoreboard_link_batch(batch);
 
-        bool has_draws = job->last_job.gpu;
+        bool has_draws = batch->last_job.gpu;
 
-        ret = panfrost_drm_submit_vs_fs_job(ctx, has_draws);
+        ret = panfrost_drm_submit_vs_fs_batch(ctx, has_draws);
 
         if (ret)
-                fprintf(stderr, "panfrost_job_submit failed: %d\n", ret);
+                fprintf(stderr, "panfrost_batch_submit failed: %d\n", ret);
 
         /* The job has been submitted, let's invalidate the current FBO job
          * cache.
 	 */
-        assert(!ctx->job || job == ctx->job);
-        ctx->job = NULL;
+        assert(!ctx->batch || batch == ctx->batch);
+        ctx->batch = NULL;
 
-        /* Remove the job from the ctx->jobs set so that future
-         * panfrost_get_job() calls don't see it.
+        /* Remove the job from the ctx->batches set so that future
+         * panfrost_get_batch() calls don't see it.
          * We must reset the job key to avoid removing another valid entry when
          * the job is freed.
          */
-        _mesa_hash_table_remove_key(ctx->jobs, &job->key);
-        memset(&job->key, 0, sizeof(job->key));
+        _mesa_hash_table_remove_key(ctx->batches, &batch->key);
+        memset(&batch->key, 0, sizeof(batch->key));
 }
 
 void
-panfrost_job_set_requirements(struct panfrost_context *ctx,
-                              struct panfrost_job *job)
+panfrost_batch_set_requirements(struct panfrost_context *ctx,
+                                struct panfrost_batch *batch)
 {
         if (ctx->rasterizer && ctx->rasterizer->base.multisample)
-                job->requirements |= PAN_REQ_MSAA;
+                batch->requirements |= PAN_REQ_MSAA;
 
         if (ctx->depth_stencil && ctx->depth_stencil->depth.writemask)
-                job->requirements |= PAN_REQ_DEPTH_WRITE;
+                batch->requirements |= PAN_REQ_DEPTH_WRITE;
 }
 
 /* Helper to smear a 32-bit color across 128-bit components */
@@ -336,11 +336,11 @@  pan_pack_color(uint32_t *packed, const union pipe_color_union *color, enum pipe_
 }
 
 void
-panfrost_job_clear(struct panfrost_context *ctx,
-                   struct panfrost_job *job,
-                   unsigned buffers,
-                   const union pipe_color_union *color,
-                   double depth, unsigned stencil)
+panfrost_batch_clear(struct panfrost_context *ctx,
+                     struct panfrost_batch *batch,
+                     unsigned buffers,
+                     const union pipe_color_union *color,
+                     double depth, unsigned stencil)
 
 {
         if (buffers & PIPE_CLEAR_COLOR) {
@@ -349,28 +349,28 @@  panfrost_job_clear(struct panfrost_context *ctx,
                                 continue;
 
                         enum pipe_format format = ctx->pipe_framebuffer.cbufs[i]->format;
-                        pan_pack_color(job->clear_color[i], color, format);
+                        pan_pack_color(batch->clear_color[i], color, format);
                 }
         }
 
         if (buffers & PIPE_CLEAR_DEPTH) {
-                job->clear_depth = depth;
+                batch->clear_depth = depth;
         }
 
         if (buffers & PIPE_CLEAR_STENCIL) {
-                job->clear_stencil = stencil;
+                batch->clear_stencil = stencil;
         }
 
-        job->clear |= buffers;
+        batch->clear |= buffers;
 
         /* Clearing affects the entire framebuffer (by definition -- this is
          * the Gallium clear callback, which clears the whole framebuffer. If
          * the scissor test were enabled from the GL side, the state tracker
          * would emit a quad instead and we wouldn't go down this code path) */
 
-        panfrost_job_union_scissor(job, 0, 0,
-                                   ctx->pipe_framebuffer.width,
-                                   ctx->pipe_framebuffer.height);
+        panfrost_batch_union_scissor(batch, 0, 0,
+                                     ctx->pipe_framebuffer.width,
+                                     ctx->pipe_framebuffer.height);
 }
 
 void
@@ -381,60 +381,60 @@  panfrost_flush_jobs_reading_resource(struct panfrost_context *panfrost,
 
         panfrost_flush_jobs_writing_resource(panfrost, prsc);
 
-        hash_table_foreach(panfrost->jobs, entry) {
-                struct panfrost_job *job = entry->data;
+        hash_table_foreach(panfrost->batches, entry) {
+                struct panfrost_batch *batch = entry->data;
 
-                if (_mesa_set_search(job->bos, rsc->bo)) {
+                if (_mesa_set_search(batch->bos, rsc->bo)) {
                         printf("TODO: submit job for flush\n");
-                        //panfrost_job_submit(panfrost, job);
+                        //panfrost_batch_submit(panfrost, job);
                         continue;
                 }
         }
 }
 
 static bool
-panfrost_job_compare(const void *a, const void *b)
+panfrost_batch_compare(const void *a, const void *b)
 {
-        return memcmp(a, b, sizeof(struct panfrost_job_key)) == 0;
+        return memcmp(a, b, sizeof(struct panfrost_batch_key)) == 0;
 }
 
 static uint32_t
-panfrost_job_hash(const void *key)
+panfrost_batch_hash(const void *key)
 {
-        return _mesa_hash_data(key, sizeof(struct panfrost_job_key));
+        return _mesa_hash_data(key, sizeof(struct panfrost_batch_key));
 }
 
 /* Given a new bounding rectangle (scissor), let the job cover the union of the
  * new and old bounding rectangles */
 
 void
-panfrost_job_union_scissor(struct panfrost_job *job,
-                           unsigned minx, unsigned miny,
-                           unsigned maxx, unsigned maxy)
+panfrost_batch_union_scissor(struct panfrost_batch *batch,
+                             unsigned minx, unsigned miny,
+                             unsigned maxx, unsigned maxy)
 {
-        job->minx = MIN2(job->minx, minx);
-        job->miny = MIN2(job->miny, miny);
-        job->maxx = MAX2(job->maxx, maxx);
-        job->maxy = MAX2(job->maxy, maxy);
+        batch->minx = MIN2(batch->minx, minx);
+        batch->miny = MIN2(batch->miny, miny);
+        batch->maxx = MAX2(batch->maxx, maxx);
+        batch->maxy = MAX2(batch->maxy, maxy);
 }
 
 void
-panfrost_job_intersection_scissor(struct panfrost_job *job,
+panfrost_batch_intersection_scissor(struct panfrost_batch *batch,
                                   unsigned minx, unsigned miny,
                                   unsigned maxx, unsigned maxy)
 {
-        job->minx = MAX2(job->minx, minx);
-        job->miny = MAX2(job->miny, miny);
-        job->maxx = MIN2(job->maxx, maxx);
-        job->maxy = MIN2(job->maxy, maxy);
+        batch->minx = MAX2(batch->minx, minx);
+        batch->miny = MAX2(batch->miny, miny);
+        batch->maxx = MIN2(batch->maxx, maxx);
+        batch->maxy = MIN2(batch->maxy, maxy);
 }
 
 void
-panfrost_job_init(struct panfrost_context *ctx)
+panfrost_batch_init(struct panfrost_context *ctx)
 {
-        ctx->jobs = _mesa_hash_table_create(ctx,
-                                            panfrost_job_hash,
-                                            panfrost_job_compare);
+        ctx->batches = _mesa_hash_table_create(ctx,
+                                               panfrost_batch_hash,
+                                               panfrost_batch_compare);
 
         ctx->write_jobs = _mesa_hash_table_create(ctx,
                           _mesa_hash_pointer,
diff --git a/src/gallium/drivers/panfrost/pan_job.h b/src/gallium/drivers/panfrost/pan_job.h
index 0f559b861a01..a0020efb617c 100644
--- a/src/gallium/drivers/panfrost/pan_job.h
+++ b/src/gallium/drivers/panfrost/pan_job.h
@@ -33,7 +33,7 @@ 
 
 /* Used as a hash table key */
 
-struct panfrost_job_key {
+struct panfrost_batch_key {
         struct pipe_surface *cbufs[4];
         struct pipe_surface *zsbuf;
 };
@@ -41,12 +41,12 @@  struct panfrost_job_key {
 #define PAN_REQ_MSAA            (1 << 0)
 #define PAN_REQ_DEPTH_WRITE     (1 << 1)
 
-/* A panfrost_job corresponds to a bound FBO we're rendering to,
+/* A panfrost_batch corresponds to a bound FBO we're rendering to,
  * collecting over multiple draws. */
 
-struct panfrost_job {
+struct panfrost_batch {
         struct panfrost_context *ctx;
-        struct panfrost_job_key key;
+        struct panfrost_batch_key key;
 
         /* Buffers cleared (PIPE_CLEAR_* bitmask) */
         unsigned clear;
@@ -119,24 +119,26 @@  struct panfrost_job {
 
 /* Functions for managing the above */
 
-struct panfrost_job *
-panfrost_create_job(struct panfrost_context *ctx);
+struct panfrost_batch *
+panfrost_create_batch(struct panfrost_context *ctx);
 
 void
-panfrost_free_job(struct panfrost_context *ctx, struct panfrost_job *job);
+panfrost_free_batch(struct panfrost_context *ctx,
+                    struct panfrost_batch *batch);
 
-struct panfrost_job *
-panfrost_get_job(struct panfrost_context *ctx,
-                 struct pipe_surface **cbufs, struct pipe_surface *zsbuf);
+struct panfrost_batch *
+panfrost_get_batch(struct panfrost_context *ctx,
+                   struct pipe_surface **cbufs,
+                   struct pipe_surface *zsbuf);
 
-struct panfrost_job *
-panfrost_get_job_for_fbo(struct panfrost_context *ctx);
+struct panfrost_batch *
+panfrost_get_batch_for_fbo(struct panfrost_context *ctx);
 
 void
-panfrost_job_init(struct panfrost_context *ctx);
+panfrost_batch_init(struct panfrost_context *ctx);
 
 void
-panfrost_job_add_bo(struct panfrost_job *job, struct panfrost_bo *bo);
+panfrost_batch_add_bo(struct panfrost_batch *batch, struct panfrost_bo *bo);
 
 void
 panfrost_flush_jobs_writing_resource(struct panfrost_context *panfrost,
@@ -147,62 +149,62 @@  panfrost_flush_jobs_reading_resource(struct panfrost_context *panfrost,
                                      struct pipe_resource *prsc);
 
 void
-panfrost_job_submit(struct panfrost_context *ctx, struct panfrost_job *job);
+panfrost_batch_submit(struct panfrost_context *ctx, struct panfrost_batch *batch);
 
 void
-panfrost_job_set_requirements(struct panfrost_context *ctx,
-                              struct panfrost_job *job);
+panfrost_batch_set_requirements(struct panfrost_context *ctx,
+                                struct panfrost_batch *batch);
 
 mali_ptr
-panfrost_job_get_polygon_list(struct panfrost_job *batch, unsigned size);
+panfrost_batch_get_polygon_list(struct panfrost_batch *batch, unsigned size);
 
 void
-panfrost_job_clear(struct panfrost_context *ctx,
-                   struct panfrost_job *job,
-                   unsigned buffers,
-                   const union pipe_color_union *color,
-                   double depth, unsigned stencil);
+panfrost_batch_clear(struct panfrost_context *ctx,
+                     struct panfrost_batch *batch,
+                     unsigned buffers,
+                     const union pipe_color_union *color,
+                     double depth, unsigned stencil);
 
 void
-panfrost_job_union_scissor(struct panfrost_job *job,
-                           unsigned minx, unsigned miny,
-                           unsigned maxx, unsigned maxy);
+panfrost_batch_union_scissor(struct panfrost_batch *batch,
+                             unsigned minx, unsigned miny,
+                             unsigned maxx, unsigned maxy);
 
 void
-panfrost_job_intersection_scissor(struct panfrost_job *job,
-                                  unsigned minx, unsigned miny,
-                                  unsigned maxx, unsigned maxy);
+panfrost_batch_intersection_scissor(struct panfrost_batch *batch,
+                                    unsigned minx, unsigned miny,
+                                    unsigned maxx, unsigned maxy);
 
 /* Scoreboarding */
 
 void
 panfrost_scoreboard_queue_compute_job(
-        struct panfrost_job *batch,
+        struct panfrost_batch *batch,
         struct panfrost_transfer job);
 
 void
 panfrost_scoreboard_queue_vertex_job(
-        struct panfrost_job *batch,
+        struct panfrost_batch *batch,
         struct panfrost_transfer vertex,
         bool requires_tiling);
 
 void
 panfrost_scoreboard_queue_tiler_job(
-        struct panfrost_job *batch,
+        struct panfrost_batch *batch,
         struct panfrost_transfer tiler);
 
 void
 panfrost_scoreboard_queue_fused_job(
-        struct panfrost_job *batch,
+        struct panfrost_batch *batch,
         struct panfrost_transfer vertex,
         struct panfrost_transfer tiler);
 void
 panfrost_scoreboard_queue_fused_job_prepend(
-        struct panfrost_job *batch,
+        struct panfrost_batch *batch,
         struct panfrost_transfer vertex,
         struct panfrost_transfer tiler);
 
 void
-panfrost_scoreboard_link_batch(struct panfrost_job *batch);
+panfrost_scoreboard_link_batch(struct panfrost_batch *batch);
 
 #endif
diff --git a/src/gallium/drivers/panfrost/pan_mfbd.c b/src/gallium/drivers/panfrost/pan_mfbd.c
index aaa31aa1b5ba..3ad22f82c4ab 100644
--- a/src/gallium/drivers/panfrost/pan_mfbd.c
+++ b/src/gallium/drivers/panfrost/pan_mfbd.c
@@ -179,28 +179,28 @@  panfrost_mfbd_format(struct pipe_surface *surf)
 
 static void
 panfrost_mfbd_clear(
-        struct panfrost_job *job,
+        struct panfrost_batch *batch,
         struct bifrost_framebuffer *fb,
         struct bifrost_fb_extra *fbx,
         struct bifrost_render_target *rts,
         unsigned rt_count)
 {
         for (unsigned i = 0; i < rt_count; ++i) {
-                if (!(job->clear & (PIPE_CLEAR_COLOR0 << i)))
+                if (!(batch->clear & (PIPE_CLEAR_COLOR0 << i)))
                         continue;
 
-                rts[i].clear_color_1 = job->clear_color[i][0];
-                rts[i].clear_color_2 = job->clear_color[i][1];
-                rts[i].clear_color_3 = job->clear_color[i][2];
-                rts[i].clear_color_4 = job->clear_color[i][3];
+                rts[i].clear_color_1 = batch->clear_color[i][0];
+                rts[i].clear_color_2 = batch->clear_color[i][1];
+                rts[i].clear_color_3 = batch->clear_color[i][2];
+                rts[i].clear_color_4 = batch->clear_color[i][3];
         }
 
-        if (job->clear & PIPE_CLEAR_DEPTH) {
-                fb->clear_depth = job->clear_depth;
+        if (batch->clear & PIPE_CLEAR_DEPTH) {
+                fb->clear_depth = batch->clear_depth;
         }
 
-        if (job->clear & PIPE_CLEAR_STENCIL) {
-                fb->clear_stencil = job->clear_stencil;
+        if (batch->clear & PIPE_CLEAR_STENCIL) {
+                fb->clear_stencil = batch->clear_stencil;
         }
 }
 
@@ -394,7 +394,7 @@  panfrost_mfbd_upload(
 mali_ptr
 panfrost_mfbd_fragment(struct panfrost_context *ctx, bool has_draws)
 {
-        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
 
         struct bifrost_framebuffer fb = panfrost_emit_mfbd(ctx, has_draws);
         struct bifrost_fb_extra fbx = {};
@@ -410,7 +410,7 @@  panfrost_mfbd_fragment(struct panfrost_context *ctx, bool has_draws)
         fb.mfbd_flags = 0x100;
 
         /* TODO: MRT clear */
-        panfrost_mfbd_clear(job, &fb, &fbx, rts, fb.rt_count_2);
+        panfrost_mfbd_clear(batch, &fb, &fbx, rts, fb.rt_count_2);
 
 
         /* Upload either the render target or a dummy GL_NONE target */
@@ -455,12 +455,12 @@  panfrost_mfbd_fragment(struct panfrost_context *ctx, bool has_draws)
          * can safely ignore it. */
 
         if (panfrost_is_scanout(ctx)) {
-                job->requirements &= ~PAN_REQ_DEPTH_WRITE;
+                batch->requirements &= ~PAN_REQ_DEPTH_WRITE;
         }
 
         /* Actualize the requirements */
 
-        if (job->requirements & PAN_REQ_MSAA) {
+        if (batch->requirements & PAN_REQ_MSAA) {
                 rts[0].format.flags |= MALI_MFBD_FORMAT_MSAA;
 
                 /* XXX */
@@ -468,7 +468,7 @@  panfrost_mfbd_fragment(struct panfrost_context *ctx, bool has_draws)
                 fb.rt_count_2 = 4;
         }
 
-        if (job->requirements & PAN_REQ_DEPTH_WRITE)
+        if (batch->requirements & PAN_REQ_DEPTH_WRITE)
                 fb.mfbd_flags |= MALI_MFBD_DEPTH_WRITE;
 
         /* Checksumming only works with a single render target */
diff --git a/src/gallium/drivers/panfrost/pan_resource.c b/src/gallium/drivers/panfrost/pan_resource.c
index 6b72f2a5559b..0be6b2b1c330 100644
--- a/src/gallium/drivers/panfrost/pan_resource.c
+++ b/src/gallium/drivers/panfrost/pan_resource.c
@@ -770,8 +770,8 @@  panfrost_generate_mipmap(
          * reorder-type optimizations in place. But for now prioritize
          * correctness. */
 
-        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
-        bool has_draws = job->last_job.gpu;
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
+        bool has_draws = batch->last_job.gpu;
 
         if (has_draws)
                 panfrost_flush(pctx, NULL, PIPE_FLUSH_END_OF_FRAME);
diff --git a/src/gallium/drivers/panfrost/pan_scoreboard.c b/src/gallium/drivers/panfrost/pan_scoreboard.c
index 0873dd1fbe14..776833a13aba 100644
--- a/src/gallium/drivers/panfrost/pan_scoreboard.c
+++ b/src/gallium/drivers/panfrost/pan_scoreboard.c
@@ -121,11 +121,11 @@  job_descriptor_header(struct panfrost_transfer t)
 
 static void
 panfrost_assign_index(
-        struct panfrost_job *job,
+        struct panfrost_batch *batch,
         struct panfrost_transfer transfer)
 {
         /* Assign the index */
-        unsigned index = ++job->job_index;
+        unsigned index = ++batch->job_index;
         job_descriptor_header(transfer)->job_index = index;
 }
 
@@ -157,7 +157,7 @@  panfrost_add_dependency(
 
 static void
 panfrost_scoreboard_queue_job_internal(
-        struct panfrost_job *batch,
+        struct panfrost_batch *batch,
         struct panfrost_transfer job)
 {
         panfrost_assign_index(batch, job);
@@ -174,7 +174,7 @@  panfrost_scoreboard_queue_job_internal(
 
 void
 panfrost_scoreboard_queue_compute_job(
-        struct panfrost_job *batch,
+        struct panfrost_batch *batch,
         struct panfrost_transfer job)
 {
         panfrost_scoreboard_queue_job_internal(batch, job);
@@ -192,7 +192,7 @@  panfrost_scoreboard_queue_compute_job(
 
 void
 panfrost_scoreboard_queue_vertex_job(
-        struct panfrost_job *batch,
+        struct panfrost_batch *batch,
         struct panfrost_transfer vertex,
         bool requires_tiling)
 {
@@ -207,7 +207,7 @@  panfrost_scoreboard_queue_vertex_job(
 
 void
 panfrost_scoreboard_queue_tiler_job(
-        struct panfrost_job *batch,
+        struct panfrost_batch *batch,
         struct panfrost_transfer tiler)
 {
         panfrost_scoreboard_queue_compute_job(batch, tiler);
@@ -226,7 +226,7 @@  panfrost_scoreboard_queue_tiler_job(
 
 void
 panfrost_scoreboard_queue_fused_job(
-        struct panfrost_job *batch,
+        struct panfrost_batch *batch,
         struct panfrost_transfer vertex,
         struct panfrost_transfer tiler)
 {
@@ -240,7 +240,7 @@  panfrost_scoreboard_queue_fused_job(
 
 void
 panfrost_scoreboard_queue_fused_job_prepend(
-        struct panfrost_job *batch,
+        struct panfrost_batch *batch,
         struct panfrost_transfer vertex,
         struct panfrost_transfer tiler)
 {
@@ -293,7 +293,7 @@  panfrost_set_value_job(struct panfrost_context *ctx, mali_ptr polygon_list)
  * linked to the first vertex job feeding into tiling. */
 
 static void
-panfrost_scoreboard_set_value(struct panfrost_job *batch)
+panfrost_scoreboard_set_value(struct panfrost_batch *batch)
 {
         /* Check if we even need tiling */
         if (!batch->last_tiler.gpu)
@@ -303,7 +303,7 @@  panfrost_scoreboard_set_value(struct panfrost_job *batch)
          * regardless of size. */
 
         struct panfrost_context *ctx = batch->ctx;
-        mali_ptr polygon_list = panfrost_job_get_polygon_list(batch, 0);
+        mali_ptr polygon_list = panfrost_batch_get_polygon_list(batch, 0);
 
         struct panfrost_transfer job =
                 panfrost_set_value_job(ctx, polygon_list);
@@ -346,7 +346,7 @@  panfrost_scoreboard_set_value(struct panfrost_job *batch)
                 mali_ptr, count))
 
 void
-panfrost_scoreboard_link_batch(struct panfrost_job *batch)
+panfrost_scoreboard_link_batch(struct panfrost_batch *batch)
 {
         /* Finalize the batch */
         panfrost_scoreboard_set_value(batch);
diff --git a/src/gallium/drivers/panfrost/pan_screen.h b/src/gallium/drivers/panfrost/pan_screen.h
index d8ea55912b4e..3017b9c154f4 100644
--- a/src/gallium/drivers/panfrost/pan_screen.h
+++ b/src/gallium/drivers/panfrost/pan_screen.h
@@ -163,7 +163,7 @@  panfrost_drm_import_bo(struct panfrost_screen *screen, int fd);
 int
 panfrost_drm_export_bo(struct panfrost_screen *screen, const struct panfrost_bo *bo);
 int
-panfrost_drm_submit_vs_fs_job(struct panfrost_context *ctx, bool has_draws);
+panfrost_drm_submit_vs_fs_batch(struct panfrost_context *ctx, bool has_draws);
 void
 panfrost_drm_force_flush_fragment(struct panfrost_context *ctx,
                                   struct pipe_fence_handle **fence);
diff --git a/src/gallium/drivers/panfrost/pan_sfbd.c b/src/gallium/drivers/panfrost/pan_sfbd.c
index 63dde9303823..f58c054c8f24 100644
--- a/src/gallium/drivers/panfrost/pan_sfbd.c
+++ b/src/gallium/drivers/panfrost/pan_sfbd.c
@@ -37,39 +37,39 @@  panfrost_sfbd_format(struct pipe_surface *surf)
 
 static void
 panfrost_sfbd_clear(
-        struct panfrost_job *job,
+        struct panfrost_batch *batch,
         struct mali_single_framebuffer *sfbd)
 {
-        if (job->clear & PIPE_CLEAR_COLOR) {
-                sfbd->clear_color_1 = job->clear_color[0][0];
-                sfbd->clear_color_2 = job->clear_color[0][1];
-                sfbd->clear_color_3 = job->clear_color[0][2];
-                sfbd->clear_color_4 = job->clear_color[0][3];
+        if (batch->clear & PIPE_CLEAR_COLOR) {
+                sfbd->clear_color_1 = batch->clear_color[0][0];
+                sfbd->clear_color_2 = batch->clear_color[0][1];
+                sfbd->clear_color_3 = batch->clear_color[0][2];
+                sfbd->clear_color_4 = batch->clear_color[0][3];
         }
 
-        if (job->clear & PIPE_CLEAR_DEPTH) {
-                sfbd->clear_depth_1 = job->clear_depth;
-                sfbd->clear_depth_2 = job->clear_depth;
-                sfbd->clear_depth_3 = job->clear_depth;
-                sfbd->clear_depth_4 = job->clear_depth;
+        if (batch->clear & PIPE_CLEAR_DEPTH) {
+                sfbd->clear_depth_1 = batch->clear_depth;
+                sfbd->clear_depth_2 = batch->clear_depth;
+                sfbd->clear_depth_3 = batch->clear_depth;
+                sfbd->clear_depth_4 = batch->clear_depth;
         }
 
-        if (job->clear & PIPE_CLEAR_STENCIL) {
-                sfbd->clear_stencil = job->clear_stencil;
+        if (batch->clear & PIPE_CLEAR_STENCIL) {
+                sfbd->clear_stencil = batch->clear_stencil;
         }
 
         /* Set flags based on what has been cleared, for the SFBD case */
         /* XXX: What do these flags mean? */
         int clear_flags = 0x101100;
 
-        if (!(job->clear & ~(PIPE_CLEAR_COLOR | PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL))) {
+        if (!(batch->clear & ~(PIPE_CLEAR_COLOR | PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL))) {
                 /* On a tiler like this, it's fastest to clear all three buffers at once */
 
                 clear_flags |= MALI_CLEAR_FAST;
         } else {
                 clear_flags |= MALI_CLEAR_SLOW;
 
-                if (job->clear & PIPE_CLEAR_STENCIL)
+                if (batch->clear & PIPE_CLEAR_STENCIL)
                         clear_flags |= MALI_CLEAR_SLOW_STENCIL;
         }
 
@@ -132,10 +132,10 @@  panfrost_sfbd_set_zsbuf(
 mali_ptr
 panfrost_sfbd_fragment(struct panfrost_context *ctx, bool has_draws)
 {
-        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
         struct mali_single_framebuffer fb = panfrost_emit_sfbd(ctx, has_draws);
 
-        panfrost_sfbd_clear(job, &fb);
+        panfrost_sfbd_clear(batch, &fb);
 
         /* SFBD does not support MRT natively; sanity check */
         assert(ctx->pipe_framebuffer.nr_cbufs == 1);
@@ -144,7 +144,7 @@  panfrost_sfbd_fragment(struct panfrost_context *ctx, bool has_draws)
         if (ctx->pipe_framebuffer.zsbuf)
                 panfrost_sfbd_set_zsbuf(&fb, ctx->pipe_framebuffer.zsbuf);
 
-        if (job->requirements & PAN_REQ_MSAA)
+        if (batch->requirements & PAN_REQ_MSAA)
                 fb.format |= MALI_FRAMEBUFFER_MSAA_A | MALI_FRAMEBUFFER_MSAA_B;
 
         return panfrost_upload_transient(ctx, &fb, sizeof(fb)) | MALI_SFBD;
diff --git a/src/gallium/drivers/panfrost/pan_varyings.c b/src/gallium/drivers/panfrost/pan_varyings.c
index 113043b699dc..12760109b7cb 100644
--- a/src/gallium/drivers/panfrost/pan_varyings.c
+++ b/src/gallium/drivers/panfrost/pan_varyings.c
@@ -65,9 +65,9 @@  panfrost_emit_streamout(
         slot->size = MIN2(max_size, expected_size);
 
         /* Grab the BO and bind it to the batch */
-        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
+        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
         struct panfrost_bo *bo = pan_resource(target->buffer)->bo;
-        panfrost_job_add_bo(batch, bo);
+        panfrost_batch_add_bo(batch, bo);
 
         mali_ptr addr = bo->gpu + target->buffer_offset + (offset * slot->stride);
         slot->elements = addr;

Comments

Reviewed-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>

On Thu, Sep 05, 2019 at 09:41:26PM +0200, Boris Brezillon wrote:
> What we currently call a job is actually a batch containing several jobs
> all attached to a rendering operation targeting a specific FBO.
> 
> Let's rename structs, functions, variables and fields to reflect this
> fact.
> 
> Suggested-by: Alyssa Rosenzweig <alyssa.rosenzweig@collabora.com>
> Signed-off-by: Boris Brezillon <boris.brezillon@collabora.com>
> ---
> Changes in v3:
> * s/panfrost_job_/panfrost_batch_/
> 
> Changes in v2:
> * s/panfrost_job_get_batch_for_fbo/panfrost_get_batch_for_fbo/
> * s/panfrost_job_batch/panfrost_batch/g
> ---
>  src/gallium/drivers/panfrost/pan_allocate.c   |   6 +-
>  src/gallium/drivers/panfrost/pan_blend_cso.c  |   4 +-
>  src/gallium/drivers/panfrost/pan_compute.c    |   2 +-
>  src/gallium/drivers/panfrost/pan_context.c    |  72 +++----
>  src/gallium/drivers/panfrost/pan_context.h    |  12 +-
>  src/gallium/drivers/panfrost/pan_drm.c        |  33 +--
>  src/gallium/drivers/panfrost/pan_fragment.c   |  20 +-
>  src/gallium/drivers/panfrost/pan_instancing.c |   6 +-
>  src/gallium/drivers/panfrost/pan_job.c        | 198 +++++++++---------
>  src/gallium/drivers/panfrost/pan_job.h        |  72 +++----
>  src/gallium/drivers/panfrost/pan_mfbd.c       |  30 +--
>  src/gallium/drivers/panfrost/pan_resource.c   |   4 +-
>  src/gallium/drivers/panfrost/pan_scoreboard.c |  22 +-
>  src/gallium/drivers/panfrost/pan_screen.h     |   2 +-
>  src/gallium/drivers/panfrost/pan_sfbd.c       |  36 ++--
>  src/gallium/drivers/panfrost/pan_varyings.c   |   4 +-
>  16 files changed, 264 insertions(+), 259 deletions(-)
> 
> diff --git a/src/gallium/drivers/panfrost/pan_allocate.c b/src/gallium/drivers/panfrost/pan_allocate.c
> index 2efb01c75589..d8a594551c76 100644
> --- a/src/gallium/drivers/panfrost/pan_allocate.c
> +++ b/src/gallium/drivers/panfrost/pan_allocate.c
> @@ -63,7 +63,7 @@ struct panfrost_transfer
>  panfrost_allocate_transient(struct panfrost_context *ctx, size_t sz)
>  {
>          struct panfrost_screen *screen = pan_screen(ctx->base.screen);
> -        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>  
>          /* Pad the size */
>          sz = ALIGN_POT(sz, ALIGNMENT);
> @@ -111,7 +111,7 @@ panfrost_allocate_transient(struct panfrost_context *ctx, size_t sz)
>                          bo = panfrost_create_slab(screen, &index);
>                  }
>  
> -                panfrost_job_add_bo(batch, bo);
> +                panfrost_batch_add_bo(batch, bo);
>  
>                  /* Remember we created this */
>                  util_dynarray_append(&batch->transient_indices, unsigned, index);
> @@ -120,7 +120,7 @@ panfrost_allocate_transient(struct panfrost_context *ctx, size_t sz)
>          } else {
>                  /* Create a new BO and reference it */
>                  bo = panfrost_drm_create_bo(screen, ALIGN_POT(sz, 4096), 0);
> -                panfrost_job_add_bo(batch, bo);
> +                panfrost_batch_add_bo(batch, bo);
>  
>                  /* Creating a BO adds a reference, and then the job adds a
>                   * second one. So we need to pop back one reference */
> diff --git a/src/gallium/drivers/panfrost/pan_blend_cso.c b/src/gallium/drivers/panfrost/pan_blend_cso.c
> index 43121335f5e7..ab49772f3ba3 100644
> --- a/src/gallium/drivers/panfrost/pan_blend_cso.c
> +++ b/src/gallium/drivers/panfrost/pan_blend_cso.c
> @@ -227,7 +227,7 @@ struct panfrost_blend_final
>  panfrost_get_blend_for_context(struct panfrost_context *ctx, unsigned rti)
>  {
>          struct panfrost_screen *screen = pan_screen(ctx->base.screen);
> -        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>  
>          /* Grab the format, falling back gracefully if called invalidly (which
>           * has to happen for no-color-attachment FBOs, for instance)  */
> @@ -276,7 +276,7 @@ panfrost_get_blend_for_context(struct panfrost_context *ctx, unsigned rti)
>          memcpy(final.shader.bo->cpu, shader->buffer, shader->size);
>  
>          /* Pass BO ownership to job */
> -        panfrost_job_add_bo(job, final.shader.bo);
> +        panfrost_batch_add_bo(batch, final.shader.bo);
>          panfrost_bo_unreference(ctx->base.screen, final.shader.bo);
>  
>          if (shader->patch_index) {
> diff --git a/src/gallium/drivers/panfrost/pan_compute.c b/src/gallium/drivers/panfrost/pan_compute.c
> index 50e70cd8298e..51967fe481ef 100644
> --- a/src/gallium/drivers/panfrost/pan_compute.c
> +++ b/src/gallium/drivers/panfrost/pan_compute.c
> @@ -128,7 +128,7 @@ panfrost_launch_grid(struct pipe_context *pipe,
>          memcpy(transfer.cpu + sizeof(job), payload, sizeof(*payload));
>  
>          /* TODO: Do we want a special compute-only batch? */
> -        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>  
>          /* Queue the job */
>          panfrost_scoreboard_queue_compute_job(batch, transfer);
> diff --git a/src/gallium/drivers/panfrost/pan_context.c b/src/gallium/drivers/panfrost/pan_context.c
> index 2db360b0d490..ce895822014d 100644
> --- a/src/gallium/drivers/panfrost/pan_context.c
> +++ b/src/gallium/drivers/panfrost/pan_context.c
> @@ -61,7 +61,7 @@ panfrost_emit_midg_tiler(
>          unsigned vertex_count)
>  {
>          struct midgard_tiler_descriptor t = {};
> -        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>  
>          t.hierarchy_mask =
>                  panfrost_choose_hierarchy_mask(width, height, vertex_count);
> @@ -77,8 +77,9 @@ panfrost_emit_midg_tiler(
>          /* Sanity check */
>  
>          if (t.hierarchy_mask) {
> -                t.polygon_list = panfrost_job_get_polygon_list(batch,
> -                                header_size + t.polygon_list_size);
> +                t.polygon_list = panfrost_batch_get_polygon_list(batch,
> +                                                                 header_size +
> +                                                                 t.polygon_list_size);
>  
>  
>                  /* Allow the entire tiler heap */
> @@ -177,9 +178,9 @@ panfrost_clear(
>          double depth, unsigned stencil)
>  {
>          struct panfrost_context *ctx = pan_context(pipe);
> -        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>  
> -        panfrost_job_clear(ctx, job, buffers, color, depth, stencil);
> +        panfrost_batch_clear(ctx, batch, buffers, color, depth, stencil);
>  }
>  
>  static mali_ptr
> @@ -617,8 +618,8 @@ panfrost_upload_tex(
>          unsigned afbc_bit = (is_afbc && !is_zs) ? 1 : 0;
>  
>          /* Add the BO to the job so it's retained until the job is done. */
> -        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
> -        panfrost_job_add_bo(job, rsrc->bo);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
> +        panfrost_batch_add_bo(batch, rsrc->bo);
>  
>          /* Add the usage flags in, since they can change across the CSO
>           * lifetime due to layout switches */
> @@ -732,10 +733,10 @@ static void panfrost_upload_ssbo_sysval(
>          struct pipe_shader_buffer sb = ctx->ssbo[st][ssbo_id];
>  
>          /* Compute address */
> -        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>          struct panfrost_bo *bo = pan_resource(sb.buffer)->bo;
>  
> -        panfrost_job_add_bo(batch, bo);
> +        panfrost_batch_add_bo(batch, bo);
>  
>          /* Upload address and size as sysval */
>          uniform->du[0] = bo->gpu + sb.buffer_offset;
> @@ -883,13 +884,13 @@ panfrost_patch_shader_state_compute(
>  void
>  panfrost_emit_for_draw(struct panfrost_context *ctx, bool with_vertex_data)
>  {
> -        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>          struct panfrost_screen *screen = pan_screen(ctx->base.screen);
>  
>          panfrost_attach_vt_framebuffer(ctx);
>  
>          if (with_vertex_data) {
> -                panfrost_emit_vertex_data(job);
> +                panfrost_emit_vertex_data(batch);
>  
>                  /* Varyings emitted for -all- geometry */
>                  unsigned total_count = ctx->padded_count * ctx->instance_count;
> @@ -906,7 +907,7 @@ panfrost_emit_for_draw(struct panfrost_context *ctx, bool with_vertex_data)
>                  SET_BIT(ctx->fragment_shader_core.unknown2_4, MALI_NO_MSAA, !msaa);
>          }
>  
> -        panfrost_job_set_requirements(ctx, job);
> +        panfrost_batch_set_requirements(ctx, batch);
>  
>          if (ctx->occlusion_query) {
>                  ctx->payloads[PIPE_SHADER_FRAGMENT].gl_enables |= MALI_OCCLUSION_QUERY | MALI_OCCLUSION_PRECISE;
> @@ -937,7 +938,7 @@ panfrost_emit_for_draw(struct panfrost_context *ctx, bool with_vertex_data)
>  
>                  panfrost_patch_shader_state(ctx, variant, PIPE_SHADER_FRAGMENT, false);
>  
> -                panfrost_job_add_bo(job, variant->bo);
> +                panfrost_batch_add_bo(batch, variant->bo);
>  
>  #define COPY(name) ctx->fragment_shader_core.name = variant->tripipe->name
>  
> @@ -1271,7 +1272,7 @@ panfrost_emit_for_draw(struct panfrost_context *ctx, bool with_vertex_data)
>           * just... be faster :) */
>  
>          if (!ctx->wallpaper_batch)
> -                panfrost_job_union_scissor(job, minx, miny, maxx, maxy);
> +                panfrost_batch_union_scissor(batch, minx, miny, maxx, maxy);
>  
>          /* Upload */
>  
> @@ -1311,7 +1312,7 @@ panfrost_queue_draw(struct panfrost_context *ctx)
>          if (!rasterizer_discard)
>                  tiler = panfrost_vertex_tiler_job(ctx, true);
>  
> -        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>  
>          if (rasterizer_discard)
>                  panfrost_scoreboard_queue_vertex_job(batch, vertex, FALSE);
> @@ -1326,9 +1327,9 @@ panfrost_queue_draw(struct panfrost_context *ctx)
>  static void
>  panfrost_submit_frame(struct panfrost_context *ctx, bool flush_immediate,
>                        struct pipe_fence_handle **fence,
> -                      struct panfrost_job *job)
> +                      struct panfrost_batch *batch)
>  {
> -        panfrost_job_submit(ctx, job);
> +        panfrost_batch_submit(ctx, batch);
>  
>          /* If visual, we can stall a frame */
>  
> @@ -1336,7 +1337,7 @@ panfrost_submit_frame(struct panfrost_context *ctx, bool flush_immediate,
>                  panfrost_drm_force_flush_fragment(ctx, fence);
>  
>          ctx->last_fragment_flushed = false;
> -        ctx->last_job = job;
> +        ctx->last_batch = batch;
>  
>          /* If readback, flush now (hurts the pipelined performance) */
>          if (flush_immediate)
> @@ -1362,7 +1363,7 @@ panfrost_draw_wallpaper(struct pipe_context *pipe)
>                  return;
>  
>          /* Save the batch */
> -        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>  
>          ctx->wallpaper_batch = batch;
>  
> @@ -1374,10 +1375,11 @@ panfrost_draw_wallpaper(struct pipe_context *pipe)
>          unsigned damage_height = (rsrc->damage.extent.maxy - rsrc->damage.extent.miny);
>  
>          if (damage_width && damage_height) {
> -                panfrost_job_intersection_scissor(batch, rsrc->damage.extent.minx,
> -                                                  rsrc->damage.extent.miny,
> -                                                  rsrc->damage.extent.maxx,
> -                                                  rsrc->damage.extent.maxy);
> +                panfrost_batch_intersection_scissor(batch,
> +                                                    rsrc->damage.extent.minx,
> +                                                    rsrc->damage.extent.miny,
> +                                                    rsrc->damage.extent.maxx,
> +                                                    rsrc->damage.extent.maxy);
>          }
>  
>          /* FIXME: Looks like aligning on a tile is not enough, but
> @@ -1454,12 +1456,12 @@ panfrost_flush(
>          unsigned flags)
>  {
>          struct panfrost_context *ctx = pan_context(pipe);
> -        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>  
>          /* Nothing to do! */
> -        if (!job->last_job.gpu && !job->clear) return;
> +        if (!batch->last_job.gpu && !batch->clear) return;
>  
> -        if (!job->clear && job->last_tiler.gpu)
> +        if (!batch->clear && batch->last_tiler.gpu)
>                  panfrost_draw_wallpaper(&ctx->base);
>  
>          /* Whether to stall the pipeline for immediately correct results. Since
> @@ -1468,7 +1470,7 @@ panfrost_flush(
>          bool flush_immediate = /*flags & PIPE_FLUSH_END_OF_FRAME*/true;
>  
>          /* Submit the frame itself */
> -        panfrost_submit_frame(ctx, flush_immediate, fence, job);
> +        panfrost_submit_frame(ctx, flush_immediate, fence, batch);
>  
>          /* Prepare for the next frame */
>          panfrost_invalidate_frame(ctx);
> @@ -1525,11 +1527,11 @@ panfrost_get_index_buffer_mapped(struct panfrost_context *ctx, const struct pipe
>          struct panfrost_resource *rsrc = (struct panfrost_resource *) (info->index.resource);
>  
>          off_t offset = info->start * info->index_size;
> -        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>  
>          if (!info->has_user_indices) {
>                  /* Only resources can be directly mapped */
> -                panfrost_job_add_bo(batch, rsrc->bo);
> +                panfrost_batch_add_bo(batch, rsrc->bo);
>                  return rsrc->bo->gpu + offset;
>          } else {
>                  /* Otherwise, we need to upload to transient memory */
> @@ -1621,7 +1623,7 @@ panfrost_draw_vbo(
>          /* Now that we have a guaranteed terminating path, find the job.
>           * Assignment commented out to prevent unused warning */
>  
> -        /* struct panfrost_job *job = */ panfrost_get_job_for_fbo(ctx);
> +        /* struct panfrost_batch *batch = */ panfrost_get_batch_for_fbo(ctx);
>  
>          ctx->payloads[PIPE_SHADER_FRAGMENT].prefix.draw_mode = g2m_draw_mode(mode);
>  
> @@ -2394,9 +2396,9 @@ panfrost_set_framebuffer_state(struct pipe_context *pctx,
>           * state is being restored by u_blitter
>           */
>  
> -        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>          bool is_scanout = panfrost_is_scanout(ctx);
> -        bool has_draws = job->last_job.gpu;
> +        bool has_draws = batch->last_job.gpu;
>  
>          /* Bail out early when the current and new states are the same. */
>          if (util_framebuffer_state_equal(&ctx->pipe_framebuffer, fb))
> @@ -2424,7 +2426,7 @@ panfrost_set_framebuffer_state(struct pipe_context *pctx,
>          /* Invalidate the FBO job cache since we've just been assigned a new
>           * FB state.
>           */
> -        ctx->job = NULL;
> +        ctx->batch = NULL;
>  
>          util_copy_framebuffer_state(&ctx->pipe_framebuffer, fb);
>  
> @@ -2853,11 +2855,11 @@ panfrost_create_context(struct pipe_screen *screen, void *priv, unsigned flags)
>          assert(ctx->blitter_wallpaper);
>  
>          ctx->last_fragment_flushed = true;
> -        ctx->last_job = NULL;
> +        ctx->last_batch = NULL;
>  
>          /* Prepare for render! */
>  
> -        panfrost_job_init(ctx);
> +        panfrost_batch_init(ctx);
>          panfrost_emit_vertex_payload(ctx);
>          panfrost_emit_tiler_payload(ctx);
>          panfrost_invalidate_frame(ctx);
> diff --git a/src/gallium/drivers/panfrost/pan_context.h b/src/gallium/drivers/panfrost/pan_context.h
> index 9f96e983a86e..5af950e10013 100644
> --- a/src/gallium/drivers/panfrost/pan_context.h
> +++ b/src/gallium/drivers/panfrost/pan_context.h
> @@ -110,9 +110,9 @@ struct panfrost_context {
>          /* Compiler context */
>          struct midgard_screen compiler;
>  
> -        /* Bound job and map of panfrost_job_key to jobs */
> -        struct panfrost_job *job;
> -        struct hash_table *jobs;
> +        /* Bound job batch and map of panfrost_batch_key to job batches */
> +        struct panfrost_batch *batch;
> +        struct hash_table *batches;
>  
>          /* panfrost_resource -> panfrost_job */
>          struct hash_table *write_jobs;
> @@ -189,7 +189,7 @@ struct panfrost_context {
>           * errors due to unsupported reucrsion */
>  
>          struct blitter_context *blitter_wallpaper;
> -        struct panfrost_job *wallpaper_batch;
> +        struct panfrost_batch *wallpaper_batch;
>  
>          struct panfrost_blend_state *blend;
>  
> @@ -208,7 +208,7 @@ struct panfrost_context {
>           * still busy executing frame N-1. So hold a reference to
>           * yesterjob */
>          int last_fragment_flushed;
> -        struct panfrost_job *last_job;
> +        struct panfrost_batch *last_batch;
>  };
>  
>  /* Corresponds to the CSO */
> @@ -353,7 +353,7 @@ mali_ptr
>  panfrost_vertex_buffer_address(struct panfrost_context *ctx, unsigned i);
>  
>  void
> -panfrost_emit_vertex_data(struct panfrost_job *batch);
> +panfrost_emit_vertex_data(struct panfrost_batch *batch);
>  
>  struct pan_shift_odd {
>          unsigned shift;
> diff --git a/src/gallium/drivers/panfrost/pan_drm.c b/src/gallium/drivers/panfrost/pan_drm.c
> index 4e6928248097..75fc5a726b1f 100644
> --- a/src/gallium/drivers/panfrost/pan_drm.c
> +++ b/src/gallium/drivers/panfrost/pan_drm.c
> @@ -248,11 +248,12 @@ panfrost_drm_export_bo(struct panfrost_screen *screen, const struct panfrost_bo
>  }
>  
>  static int
> -panfrost_drm_submit_job(struct panfrost_context *ctx, u64 job_desc, int reqs)
> +panfrost_drm_submit_batch(struct panfrost_context *ctx, u64 first_job_desc,
> +                          int reqs)
>  {
>          struct pipe_context *gallium = (struct pipe_context *) ctx;
>          struct panfrost_screen *screen = pan_screen(gallium->screen);
> -        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>          struct drm_panfrost_submit submit = {0,};
>          int *bo_handles, ret;
>  
> @@ -261,13 +262,13 @@ panfrost_drm_submit_job(struct panfrost_context *ctx, u64 job_desc, int reqs)
>  
>          submit.out_sync = ctx->out_sync;
>  
> -        submit.jc = job_desc;
> +        submit.jc = first_job_desc;
>          submit.requirements = reqs;
>  
> -        bo_handles = calloc(job->bos->entries, sizeof(*bo_handles));
> +        bo_handles = calloc(batch->bos->entries, sizeof(*bo_handles));
>          assert(bo_handles);
>  
> -        set_foreach(job->bos, entry) {
> +        set_foreach(batch->bos, entry) {
>                  struct panfrost_bo *bo = (struct panfrost_bo *)entry->key;
>                  assert(bo->gem_handle > 0);
>                  bo_handles[submit.bo_handle_count++] = bo->gem_handle;
> @@ -292,23 +293,25 @@ panfrost_drm_submit_job(struct panfrost_context *ctx, u64 job_desc, int reqs)
>  }
>  
>  int
> -panfrost_drm_submit_vs_fs_job(struct panfrost_context *ctx, bool has_draws)
> +panfrost_drm_submit_vs_fs_batch(struct panfrost_context *ctx, bool has_draws)
>  {
>          int ret = 0;
>  
> -        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>  
> -        panfrost_job_add_bo(job, ctx->scratchpad.bo);
> -        panfrost_job_add_bo(job, ctx->tiler_heap.bo);
> -        panfrost_job_add_bo(job, job->polygon_list);
> +        panfrost_batch_add_bo(batch, ctx->scratchpad.bo);
> +        panfrost_batch_add_bo(batch, ctx->tiler_heap.bo);
> +        panfrost_batch_add_bo(batch, batch->polygon_list);
>  
> -        if (job->first_job.gpu) {
> -                ret = panfrost_drm_submit_job(ctx, job->first_job.gpu, 0);
> +        if (batch->first_job.gpu) {
> +                ret = panfrost_drm_submit_batch(ctx, batch->first_job.gpu, 0);
>                  assert(!ret);
>          }
>  
> -        if (job->first_tiler.gpu || job->clear) {
> -                ret = panfrost_drm_submit_job(ctx, panfrost_fragment_job(ctx, has_draws), PANFROST_JD_REQ_FS);
> +        if (batch->first_tiler.gpu || batch->clear) {
> +                ret = panfrost_drm_submit_batch(ctx,
> +                                                panfrost_fragment_job(ctx, has_draws),
> +                                                PANFROST_JD_REQ_FS);
>                  assert(!ret);
>          }
>  
> @@ -353,7 +356,7 @@ panfrost_drm_force_flush_fragment(struct panfrost_context *ctx,
>                  ctx->last_fragment_flushed = true;
>  
>                  /* The job finished up, so we're safe to clean it up now */
> -                panfrost_free_job(ctx, ctx->last_job);
> +                panfrost_free_batch(ctx, ctx->last_batch);
>          }
>  
>          if (fence) {
> diff --git a/src/gallium/drivers/panfrost/pan_fragment.c b/src/gallium/drivers/panfrost/pan_fragment.c
> index 778bc85100f8..f92bf4e35226 100644
> --- a/src/gallium/drivers/panfrost/pan_fragment.c
> +++ b/src/gallium/drivers/panfrost/pan_fragment.c
> @@ -32,7 +32,7 @@
>  
>  static void
>  panfrost_initialize_surface(
> -                struct panfrost_job *batch,
> +                struct panfrost_batch *batch,
>                  struct pipe_surface *surf)
>  {
>          if (!surf)
> @@ -44,7 +44,7 @@ panfrost_initialize_surface(
>          rsrc->slices[level].initialized = true;
>  
>          assert(rsrc->bo);
> -        panfrost_job_add_bo(batch, rsrc->bo);
> +        panfrost_batch_add_bo(batch, rsrc->bo);
>  }
>  
>  /* Generate a fragment job. This should be called once per frame. (According to
> @@ -63,7 +63,7 @@ panfrost_fragment_job(struct panfrost_context *ctx, bool has_draws)
>           * Also, add the surfaces we're writing to to the batch */
>  
>          struct pipe_framebuffer_state *fb = &ctx->pipe_framebuffer;
> -        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>  
>          for (unsigned i = 0; i < fb->nr_cbufs; ++i) {
>                  panfrost_initialize_surface(batch, fb->cbufs[i]);
> @@ -78,8 +78,6 @@ panfrost_fragment_job(struct panfrost_context *ctx, bool has_draws)
>                  .job_descriptor_size = 1
>          };
>  
> -        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
> -
>          /* The passed tile coords can be out of range in some cases, so we need
>           * to clamp them to the framebuffer size to avoid a TILE_RANGE_FAULT.
>           * Theoretically we also need to clamp the coordinates positive, but we
> @@ -91,18 +89,18 @@ panfrost_fragment_job(struct panfrost_context *ctx, bool has_draws)
>           * But that can't happen if any actual drawing occurs (beyond a
>           * wallpaper reload), so this is again irrelevant in practice. */
>  
> -        job->maxx = MIN2(job->maxx, fb->width);
> -        job->maxy = MIN2(job->maxy, fb->height);
> +        batch->maxx = MIN2(batch->maxx, fb->width);
> +        batch->maxy = MIN2(batch->maxy, fb->height);
>  
>          /* Rendering region must be at least 1x1; otherwise, there is nothing
>           * to do and the whole job chain should have been discarded. */
>  
> -        assert(job->maxx > job->minx);
> -        assert(job->maxy > job->miny);
> +        assert(batch->maxx > batch->minx);
> +        assert(batch->maxy > batch->miny);
>  
>          struct mali_payload_fragment payload = {
> -                .min_tile_coord = MALI_COORDINATE_TO_TILE_MIN(job->minx, job->miny),
> -                .max_tile_coord = MALI_COORDINATE_TO_TILE_MAX(job->maxx, job->maxy),
> +                .min_tile_coord = MALI_COORDINATE_TO_TILE_MIN(batch->minx, batch->miny),
> +                .max_tile_coord = MALI_COORDINATE_TO_TILE_MAX(batch->maxx, batch->maxy),
>                  .framebuffer = framebuffer,
>          };
>  
> diff --git a/src/gallium/drivers/panfrost/pan_instancing.c b/src/gallium/drivers/panfrost/pan_instancing.c
> index fc63cdbb25d7..44fe0a344aab 100644
> --- a/src/gallium/drivers/panfrost/pan_instancing.c
> +++ b/src/gallium/drivers/panfrost/pan_instancing.c
> @@ -164,7 +164,7 @@ panfrost_padded_vertex_count(
>  
>  static unsigned
>  panfrost_vertex_instanced(
> -        struct panfrost_job *batch,
> +        struct panfrost_batch *batch,
>          struct panfrost_resource *rsrc,
>          unsigned divisor,
>          union mali_attr *attrs,
> @@ -253,7 +253,7 @@ panfrost_vertex_instanced(
>  }
>  
>  void
> -panfrost_emit_vertex_data(struct panfrost_job *batch)
> +panfrost_emit_vertex_data(struct panfrost_batch *batch)
>  {
>          struct panfrost_context *ctx = batch->ctx;
>          struct panfrost_vertex_state *so = ctx->vertex;
> @@ -297,7 +297,7 @@ panfrost_emit_vertex_data(struct panfrost_job *batch)
>                  unsigned chopped_addr = raw_addr - addr;
>  
>                  /* Add a dependency of the batch on the vertex buffer */
> -                panfrost_job_add_bo(batch, rsrc->bo);
> +                panfrost_batch_add_bo(batch, rsrc->bo);
>  
>                  /* Set common fields */
>                  attrs[k].elements = addr;
> diff --git a/src/gallium/drivers/panfrost/pan_job.c b/src/gallium/drivers/panfrost/pan_job.c
> index f7ff57c4331a..a019c2adf69a 100644
> --- a/src/gallium/drivers/panfrost/pan_job.c
> +++ b/src/gallium/drivers/panfrost/pan_job.c
> @@ -31,35 +31,35 @@
>  #include "util/u_format.h"
>  #include "util/u_pack_color.h"
>  
> -struct panfrost_job *
> -panfrost_create_job(struct panfrost_context *ctx)
> +struct panfrost_batch *
> +panfrost_create_batch(struct panfrost_context *ctx)
>  {
> -        struct panfrost_job *job = rzalloc(ctx, struct panfrost_job);
> +        struct panfrost_batch *batch = rzalloc(ctx, struct panfrost_batch);
>  
> -        job->ctx = ctx;
> +        batch->ctx = ctx;
>  
> -        job->bos = _mesa_set_create(job,
> -                                    _mesa_hash_pointer,
> -                                    _mesa_key_pointer_equal);
> +        batch->bos = _mesa_set_create(batch,
> +                                      _mesa_hash_pointer,
> +                                      _mesa_key_pointer_equal);
>  
> -        job->minx = job->miny = ~0;
> -        job->maxx = job->maxy = 0;
> -        job->transient_offset = 0;
> +        batch->minx = batch->miny = ~0;
> +        batch->maxx = batch->maxy = 0;
> +        batch->transient_offset = 0;
>  
> -        util_dynarray_init(&job->headers, job);
> -        util_dynarray_init(&job->gpu_headers, job);
> -        util_dynarray_init(&job->transient_indices, job);
> +        util_dynarray_init(&batch->headers, batch);
> +        util_dynarray_init(&batch->gpu_headers, batch);
> +        util_dynarray_init(&batch->transient_indices, batch);
>  
> -        return job;
> +        return batch;
>  }
>  
>  void
> -panfrost_free_job(struct panfrost_context *ctx, struct panfrost_job *job)
> +panfrost_free_batch(struct panfrost_context *ctx, struct panfrost_batch *batch)
>  {
> -        if (!job)
> +        if (!batch)
>                  return;
>  
> -        set_foreach(job->bos, entry) {
> +        set_foreach(batch->bos, entry) {
>                  struct panfrost_bo *bo = (struct panfrost_bo *)entry->key;
>                  panfrost_bo_unreference(ctx->base.screen, bo);
>          }
> @@ -68,30 +68,30 @@ panfrost_free_job(struct panfrost_context *ctx, struct panfrost_job *job)
>          struct panfrost_screen *screen = pan_screen(ctx->base.screen);
>  
>          pthread_mutex_lock(&screen->transient_lock);
> -        util_dynarray_foreach(&job->transient_indices, unsigned, index) {
> +        util_dynarray_foreach(&batch->transient_indices, unsigned, index) {
>                  /* Mark it free */
>                  BITSET_SET(screen->free_transient, *index);
>          }
>          pthread_mutex_unlock(&screen->transient_lock);
>  
>          /* Unreference the polygon list */
> -        panfrost_bo_unreference(ctx->base.screen, job->polygon_list);
> +        panfrost_bo_unreference(ctx->base.screen, batch->polygon_list);
>  
> -        _mesa_hash_table_remove_key(ctx->jobs, &job->key);
> +        _mesa_hash_table_remove_key(ctx->batches, &batch->key);
>  
> -        if (ctx->job == job)
> -                ctx->job = NULL;
> +        if (ctx->batch == batch)
> +                ctx->batch = NULL;
>  
> -        ralloc_free(job);
> +        ralloc_free(batch);
>  }
>  
> -struct panfrost_job *
> -panfrost_get_job(struct panfrost_context *ctx,
> +struct panfrost_batch *
> +panfrost_get_batch(struct panfrost_context *ctx,
>                   struct pipe_surface **cbufs, struct pipe_surface *zsbuf)
>  {
>          /* Lookup the job first */
>  
> -        struct panfrost_job_key key = {
> +        struct panfrost_batch_key key = {
>                  .cbufs = {
>                          cbufs[0],
>                          cbufs[1],
> @@ -101,27 +101,27 @@ panfrost_get_job(struct panfrost_context *ctx,
>                  .zsbuf = zsbuf
>          };
>  
> -        struct hash_entry *entry = _mesa_hash_table_search(ctx->jobs, &key);
> +        struct hash_entry *entry = _mesa_hash_table_search(ctx->batches, &key);
>  
>          if (entry)
>                  return entry->data;
>  
>          /* Otherwise, let's create a job */
>  
> -        struct panfrost_job *job = panfrost_create_job(ctx);
> +        struct panfrost_batch *batch = panfrost_create_batch(ctx);
>  
>          /* Save the created job */
>  
> -        memcpy(&job->key, &key, sizeof(key));
> -        _mesa_hash_table_insert(ctx->jobs, &job->key, job);
> +        memcpy(&batch->key, &key, sizeof(key));
> +        _mesa_hash_table_insert(ctx->batches, &batch->key, batch);
>  
> -        return job;
> +        return batch;
>  }
>  
>  /* Get the job corresponding to the FBO we're currently rendering into */
>  
> -struct panfrost_job *
> -panfrost_get_job_for_fbo(struct panfrost_context *ctx)
> +struct panfrost_batch *
> +panfrost_get_batch_for_fbo(struct panfrost_context *ctx)
>  {
>          /* If we're wallpapering, we special case to workaround
>           * u_blitter abuse */
> @@ -131,38 +131,38 @@ panfrost_get_job_for_fbo(struct panfrost_context *ctx)
>  
>          /* If we already began rendering, use that */
>  
> -        if (ctx->job) {
> -                assert(ctx->job->key.zsbuf == ctx->pipe_framebuffer.zsbuf &&
> -                       !memcmp(ctx->job->key.cbufs,
> +        if (ctx->batch) {
> +                assert(ctx->batch->key.zsbuf == ctx->pipe_framebuffer.zsbuf &&
> +                       !memcmp(ctx->batch->key.cbufs,
>                                 ctx->pipe_framebuffer.cbufs,
> -                               sizeof(ctx->job->key.cbufs)));
> -                return ctx->job;
> +                               sizeof(ctx->batch->key.cbufs)));
> +                return ctx->batch;
>          }
>  
>          /* If not, look up the job */
>  
>          struct pipe_surface **cbufs = ctx->pipe_framebuffer.cbufs;
>          struct pipe_surface *zsbuf = ctx->pipe_framebuffer.zsbuf;
> -        struct panfrost_job *job = panfrost_get_job(ctx, cbufs, zsbuf);
> +        struct panfrost_batch *batch = panfrost_get_batch(ctx, cbufs, zsbuf);
>  
>          /* Set this job as the current FBO job. Will be reset when updating the
>           * FB state and when submitting or releasing a job.
>           */
> -        ctx->job = job;
> -        return job;
> +        ctx->batch = batch;
> +        return batch;
>  }
>  
>  void
> -panfrost_job_add_bo(struct panfrost_job *job, struct panfrost_bo *bo)
> +panfrost_batch_add_bo(struct panfrost_batch *batch, struct panfrost_bo *bo)
>  {
>          if (!bo)
>                  return;
>  
> -        if (_mesa_set_search(job->bos, bo))
> +        if (_mesa_set_search(batch->bos, bo))
>                  return;
>  
>          panfrost_bo_reference(bo);
> -        _mesa_set_add(job->bos, bo);
> +        _mesa_set_add(batch->bos, bo);
>  }
>  
>  /* Returns the polygon list's GPU address if available, or otherwise allocates
> @@ -170,7 +170,7 @@ panfrost_job_add_bo(struct panfrost_job *job, struct panfrost_bo *bo)
>   * since we'll hit the BO cache and this is one-per-batch anyway. */
>  
>  mali_ptr
> -panfrost_job_get_polygon_list(struct panfrost_job *batch, unsigned size)
> +panfrost_batch_get_polygon_list(struct panfrost_batch *batch, unsigned size)
>  {
>          if (batch->polygon_list) {
>                  assert(batch->polygon_list->size >= size);
> @@ -194,52 +194,52 @@ panfrost_flush_jobs_writing_resource(struct panfrost_context *panfrost,
>          struct hash_entry *entry = _mesa_hash_table_search(panfrost->write_jobs,
>                                     prsc);
>          if (entry) {
> -                struct panfrost_job *job = entry->data;
> -                panfrost_job_submit(panfrost, job);
> +                struct panfrost_batch *batch = entry->data;
> +                panfrost_batch_submit(panfrost, job);
>          }
>  #endif
>          /* TODO stub */
>  }
>  
>  void
> -panfrost_job_submit(struct panfrost_context *ctx, struct panfrost_job *job)
> +panfrost_batch_submit(struct panfrost_context *ctx, struct panfrost_batch *batch)
>  {
>          int ret;
>  
> -        assert(job);
> -        panfrost_scoreboard_link_batch(job);
> +        assert(batch);
> +        panfrost_scoreboard_link_batch(batch);
>  
> -        bool has_draws = job->last_job.gpu;
> +        bool has_draws = batch->last_job.gpu;
>  
> -        ret = panfrost_drm_submit_vs_fs_job(ctx, has_draws);
> +        ret = panfrost_drm_submit_vs_fs_batch(ctx, has_draws);
>  
>          if (ret)
> -                fprintf(stderr, "panfrost_job_submit failed: %d\n", ret);
> +                fprintf(stderr, "panfrost_batch_submit failed: %d\n", ret);
>  
>          /* The job has been submitted, let's invalidate the current FBO job
>           * cache.
>  	 */
> -        assert(!ctx->job || job == ctx->job);
> -        ctx->job = NULL;
> +        assert(!ctx->batch || batch == ctx->batch);
> +        ctx->batch = NULL;
>  
> -        /* Remove the job from the ctx->jobs set so that future
> -         * panfrost_get_job() calls don't see it.
> +        /* Remove the job from the ctx->batches set so that future
> +         * panfrost_get_batch() calls don't see it.
>           * We must reset the job key to avoid removing another valid entry when
>           * the job is freed.
>           */
> -        _mesa_hash_table_remove_key(ctx->jobs, &job->key);
> -        memset(&job->key, 0, sizeof(job->key));
> +        _mesa_hash_table_remove_key(ctx->batches, &batch->key);
> +        memset(&batch->key, 0, sizeof(batch->key));
>  }
>  
>  void
> -panfrost_job_set_requirements(struct panfrost_context *ctx,
> -                              struct panfrost_job *job)
> +panfrost_batch_set_requirements(struct panfrost_context *ctx,
> +                                struct panfrost_batch *batch)
>  {
>          if (ctx->rasterizer && ctx->rasterizer->base.multisample)
> -                job->requirements |= PAN_REQ_MSAA;
> +                batch->requirements |= PAN_REQ_MSAA;
>  
>          if (ctx->depth_stencil && ctx->depth_stencil->depth.writemask)
> -                job->requirements |= PAN_REQ_DEPTH_WRITE;
> +                batch->requirements |= PAN_REQ_DEPTH_WRITE;
>  }
>  
>  /* Helper to smear a 32-bit color across 128-bit components */
> @@ -336,11 +336,11 @@ pan_pack_color(uint32_t *packed, const union pipe_color_union *color, enum pipe_
>  }
>  
>  void
> -panfrost_job_clear(struct panfrost_context *ctx,
> -                   struct panfrost_job *job,
> -                   unsigned buffers,
> -                   const union pipe_color_union *color,
> -                   double depth, unsigned stencil)
> +panfrost_batch_clear(struct panfrost_context *ctx,
> +                     struct panfrost_batch *batch,
> +                     unsigned buffers,
> +                     const union pipe_color_union *color,
> +                     double depth, unsigned stencil)
>  
>  {
>          if (buffers & PIPE_CLEAR_COLOR) {
> @@ -349,28 +349,28 @@ panfrost_job_clear(struct panfrost_context *ctx,
>                                  continue;
>  
>                          enum pipe_format format = ctx->pipe_framebuffer.cbufs[i]->format;
> -                        pan_pack_color(job->clear_color[i], color, format);
> +                        pan_pack_color(batch->clear_color[i], color, format);
>                  }
>          }
>  
>          if (buffers & PIPE_CLEAR_DEPTH) {
> -                job->clear_depth = depth;
> +                batch->clear_depth = depth;
>          }
>  
>          if (buffers & PIPE_CLEAR_STENCIL) {
> -                job->clear_stencil = stencil;
> +                batch->clear_stencil = stencil;
>          }
>  
> -        job->clear |= buffers;
> +        batch->clear |= buffers;
>  
>          /* Clearing affects the entire framebuffer (by definition -- this is
>           * the Gallium clear callback, which clears the whole framebuffer. If
>           * the scissor test were enabled from the GL side, the state tracker
>           * would emit a quad instead and we wouldn't go down this code path) */
>  
> -        panfrost_job_union_scissor(job, 0, 0,
> -                                   ctx->pipe_framebuffer.width,
> -                                   ctx->pipe_framebuffer.height);
> +        panfrost_batch_union_scissor(batch, 0, 0,
> +                                     ctx->pipe_framebuffer.width,
> +                                     ctx->pipe_framebuffer.height);
>  }
>  
>  void
> @@ -381,60 +381,60 @@ panfrost_flush_jobs_reading_resource(struct panfrost_context *panfrost,
>  
>          panfrost_flush_jobs_writing_resource(panfrost, prsc);
>  
> -        hash_table_foreach(panfrost->jobs, entry) {
> -                struct panfrost_job *job = entry->data;
> +        hash_table_foreach(panfrost->batches, entry) {
> +                struct panfrost_batch *batch = entry->data;
>  
> -                if (_mesa_set_search(job->bos, rsc->bo)) {
> +                if (_mesa_set_search(batch->bos, rsc->bo)) {
>                          printf("TODO: submit job for flush\n");
> -                        //panfrost_job_submit(panfrost, job);
> +                        //panfrost_batch_submit(panfrost, job);
>                          continue;
>                  }
>          }
>  }
>  
>  static bool
> -panfrost_job_compare(const void *a, const void *b)
> +panfrost_batch_compare(const void *a, const void *b)
>  {
> -        return memcmp(a, b, sizeof(struct panfrost_job_key)) == 0;
> +        return memcmp(a, b, sizeof(struct panfrost_batch_key)) == 0;
>  }
>  
>  static uint32_t
> -panfrost_job_hash(const void *key)
> +panfrost_batch_hash(const void *key)
>  {
> -        return _mesa_hash_data(key, sizeof(struct panfrost_job_key));
> +        return _mesa_hash_data(key, sizeof(struct panfrost_batch_key));
>  }
>  
>  /* Given a new bounding rectangle (scissor), let the job cover the union of the
>   * new and old bounding rectangles */
>  
>  void
> -panfrost_job_union_scissor(struct panfrost_job *job,
> -                           unsigned minx, unsigned miny,
> -                           unsigned maxx, unsigned maxy)
> +panfrost_batch_union_scissor(struct panfrost_batch *batch,
> +                             unsigned minx, unsigned miny,
> +                             unsigned maxx, unsigned maxy)
>  {
> -        job->minx = MIN2(job->minx, minx);
> -        job->miny = MIN2(job->miny, miny);
> -        job->maxx = MAX2(job->maxx, maxx);
> -        job->maxy = MAX2(job->maxy, maxy);
> +        batch->minx = MIN2(batch->minx, minx);
> +        batch->miny = MIN2(batch->miny, miny);
> +        batch->maxx = MAX2(batch->maxx, maxx);
> +        batch->maxy = MAX2(batch->maxy, maxy);
>  }
>  
>  void
> -panfrost_job_intersection_scissor(struct panfrost_job *job,
> +panfrost_batch_intersection_scissor(struct panfrost_batch *batch,
>                                    unsigned minx, unsigned miny,
>                                    unsigned maxx, unsigned maxy)
>  {
> -        job->minx = MAX2(job->minx, minx);
> -        job->miny = MAX2(job->miny, miny);
> -        job->maxx = MIN2(job->maxx, maxx);
> -        job->maxy = MIN2(job->maxy, maxy);
> +        batch->minx = MAX2(batch->minx, minx);
> +        batch->miny = MAX2(batch->miny, miny);
> +        batch->maxx = MIN2(batch->maxx, maxx);
> +        batch->maxy = MIN2(batch->maxy, maxy);
>  }
>  
>  void
> -panfrost_job_init(struct panfrost_context *ctx)
> +panfrost_batch_init(struct panfrost_context *ctx)
>  {
> -        ctx->jobs = _mesa_hash_table_create(ctx,
> -                                            panfrost_job_hash,
> -                                            panfrost_job_compare);
> +        ctx->batches = _mesa_hash_table_create(ctx,
> +                                               panfrost_batch_hash,
> +                                               panfrost_batch_compare);
>  
>          ctx->write_jobs = _mesa_hash_table_create(ctx,
>                            _mesa_hash_pointer,
> diff --git a/src/gallium/drivers/panfrost/pan_job.h b/src/gallium/drivers/panfrost/pan_job.h
> index 0f559b861a01..a0020efb617c 100644
> --- a/src/gallium/drivers/panfrost/pan_job.h
> +++ b/src/gallium/drivers/panfrost/pan_job.h
> @@ -33,7 +33,7 @@
>  
>  /* Used as a hash table key */
>  
> -struct panfrost_job_key {
> +struct panfrost_batch_key {
>          struct pipe_surface *cbufs[4];
>          struct pipe_surface *zsbuf;
>  };
> @@ -41,12 +41,12 @@ struct panfrost_job_key {
>  #define PAN_REQ_MSAA            (1 << 0)
>  #define PAN_REQ_DEPTH_WRITE     (1 << 1)
>  
> -/* A panfrost_job corresponds to a bound FBO we're rendering to,
> +/* A panfrost_batch corresponds to a bound FBO we're rendering to,
>   * collecting over multiple draws. */
>  
> -struct panfrost_job {
> +struct panfrost_batch {
>          struct panfrost_context *ctx;
> -        struct panfrost_job_key key;
> +        struct panfrost_batch_key key;
>  
>          /* Buffers cleared (PIPE_CLEAR_* bitmask) */
>          unsigned clear;
> @@ -119,24 +119,26 @@ struct panfrost_job {
>  
>  /* Functions for managing the above */
>  
> -struct panfrost_job *
> -panfrost_create_job(struct panfrost_context *ctx);
> +struct panfrost_batch *
> +panfrost_create_batch(struct panfrost_context *ctx);
>  
>  void
> -panfrost_free_job(struct panfrost_context *ctx, struct panfrost_job *job);
> +panfrost_free_batch(struct panfrost_context *ctx,
> +                    struct panfrost_batch *batch);
>  
> -struct panfrost_job *
> -panfrost_get_job(struct panfrost_context *ctx,
> -                 struct pipe_surface **cbufs, struct pipe_surface *zsbuf);
> +struct panfrost_batch *
> +panfrost_get_batch(struct panfrost_context *ctx,
> +                   struct pipe_surface **cbufs,
> +                   struct pipe_surface *zsbuf);
>  
> -struct panfrost_job *
> -panfrost_get_job_for_fbo(struct panfrost_context *ctx);
> +struct panfrost_batch *
> +panfrost_get_batch_for_fbo(struct panfrost_context *ctx);
>  
>  void
> -panfrost_job_init(struct panfrost_context *ctx);
> +panfrost_batch_init(struct panfrost_context *ctx);
>  
>  void
> -panfrost_job_add_bo(struct panfrost_job *job, struct panfrost_bo *bo);
> +panfrost_batch_add_bo(struct panfrost_batch *batch, struct panfrost_bo *bo);
>  
>  void
>  panfrost_flush_jobs_writing_resource(struct panfrost_context *panfrost,
> @@ -147,62 +149,62 @@ panfrost_flush_jobs_reading_resource(struct panfrost_context *panfrost,
>                                       struct pipe_resource *prsc);
>  
>  void
> -panfrost_job_submit(struct panfrost_context *ctx, struct panfrost_job *job);
> +panfrost_batch_submit(struct panfrost_context *ctx, struct panfrost_batch *batch);
>  
>  void
> -panfrost_job_set_requirements(struct panfrost_context *ctx,
> -                              struct panfrost_job *job);
> +panfrost_batch_set_requirements(struct panfrost_context *ctx,
> +                                struct panfrost_batch *batch);
>  
>  mali_ptr
> -panfrost_job_get_polygon_list(struct panfrost_job *batch, unsigned size);
> +panfrost_batch_get_polygon_list(struct panfrost_batch *batch, unsigned size);
>  
>  void
> -panfrost_job_clear(struct panfrost_context *ctx,
> -                   struct panfrost_job *job,
> -                   unsigned buffers,
> -                   const union pipe_color_union *color,
> -                   double depth, unsigned stencil);
> +panfrost_batch_clear(struct panfrost_context *ctx,
> +                     struct panfrost_batch *batch,
> +                     unsigned buffers,
> +                     const union pipe_color_union *color,
> +                     double depth, unsigned stencil);
>  
>  void
> -panfrost_job_union_scissor(struct panfrost_job *job,
> -                           unsigned minx, unsigned miny,
> -                           unsigned maxx, unsigned maxy);
> +panfrost_batch_union_scissor(struct panfrost_batch *batch,
> +                             unsigned minx, unsigned miny,
> +                             unsigned maxx, unsigned maxy);
>  
>  void
> -panfrost_job_intersection_scissor(struct panfrost_job *job,
> -                                  unsigned minx, unsigned miny,
> -                                  unsigned maxx, unsigned maxy);
> +panfrost_batch_intersection_scissor(struct panfrost_batch *batch,
> +                                    unsigned minx, unsigned miny,
> +                                    unsigned maxx, unsigned maxy);
>  
>  /* Scoreboarding */
>  
>  void
>  panfrost_scoreboard_queue_compute_job(
> -        struct panfrost_job *batch,
> +        struct panfrost_batch *batch,
>          struct panfrost_transfer job);
>  
>  void
>  panfrost_scoreboard_queue_vertex_job(
> -        struct panfrost_job *batch,
> +        struct panfrost_batch *batch,
>          struct panfrost_transfer vertex,
>          bool requires_tiling);
>  
>  void
>  panfrost_scoreboard_queue_tiler_job(
> -        struct panfrost_job *batch,
> +        struct panfrost_batch *batch,
>          struct panfrost_transfer tiler);
>  
>  void
>  panfrost_scoreboard_queue_fused_job(
> -        struct panfrost_job *batch,
> +        struct panfrost_batch *batch,
>          struct panfrost_transfer vertex,
>          struct panfrost_transfer tiler);
>  void
>  panfrost_scoreboard_queue_fused_job_prepend(
> -        struct panfrost_job *batch,
> +        struct panfrost_batch *batch,
>          struct panfrost_transfer vertex,
>          struct panfrost_transfer tiler);
>  
>  void
> -panfrost_scoreboard_link_batch(struct panfrost_job *batch);
> +panfrost_scoreboard_link_batch(struct panfrost_batch *batch);
>  
>  #endif
> diff --git a/src/gallium/drivers/panfrost/pan_mfbd.c b/src/gallium/drivers/panfrost/pan_mfbd.c
> index aaa31aa1b5ba..3ad22f82c4ab 100644
> --- a/src/gallium/drivers/panfrost/pan_mfbd.c
> +++ b/src/gallium/drivers/panfrost/pan_mfbd.c
> @@ -179,28 +179,28 @@ panfrost_mfbd_format(struct pipe_surface *surf)
>  
>  static void
>  panfrost_mfbd_clear(
> -        struct panfrost_job *job,
> +        struct panfrost_batch *batch,
>          struct bifrost_framebuffer *fb,
>          struct bifrost_fb_extra *fbx,
>          struct bifrost_render_target *rts,
>          unsigned rt_count)
>  {
>          for (unsigned i = 0; i < rt_count; ++i) {
> -                if (!(job->clear & (PIPE_CLEAR_COLOR0 << i)))
> +                if (!(batch->clear & (PIPE_CLEAR_COLOR0 << i)))
>                          continue;
>  
> -                rts[i].clear_color_1 = job->clear_color[i][0];
> -                rts[i].clear_color_2 = job->clear_color[i][1];
> -                rts[i].clear_color_3 = job->clear_color[i][2];
> -                rts[i].clear_color_4 = job->clear_color[i][3];
> +                rts[i].clear_color_1 = batch->clear_color[i][0];
> +                rts[i].clear_color_2 = batch->clear_color[i][1];
> +                rts[i].clear_color_3 = batch->clear_color[i][2];
> +                rts[i].clear_color_4 = batch->clear_color[i][3];
>          }
>  
> -        if (job->clear & PIPE_CLEAR_DEPTH) {
> -                fb->clear_depth = job->clear_depth;
> +        if (batch->clear & PIPE_CLEAR_DEPTH) {
> +                fb->clear_depth = batch->clear_depth;
>          }
>  
> -        if (job->clear & PIPE_CLEAR_STENCIL) {
> -                fb->clear_stencil = job->clear_stencil;
> +        if (batch->clear & PIPE_CLEAR_STENCIL) {
> +                fb->clear_stencil = batch->clear_stencil;
>          }
>  }
>  
> @@ -394,7 +394,7 @@ panfrost_mfbd_upload(
>  mali_ptr
>  panfrost_mfbd_fragment(struct panfrost_context *ctx, bool has_draws)
>  {
> -        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>  
>          struct bifrost_framebuffer fb = panfrost_emit_mfbd(ctx, has_draws);
>          struct bifrost_fb_extra fbx = {};
> @@ -410,7 +410,7 @@ panfrost_mfbd_fragment(struct panfrost_context *ctx, bool has_draws)
>          fb.mfbd_flags = 0x100;
>  
>          /* TODO: MRT clear */
> -        panfrost_mfbd_clear(job, &fb, &fbx, rts, fb.rt_count_2);
> +        panfrost_mfbd_clear(batch, &fb, &fbx, rts, fb.rt_count_2);
>  
>  
>          /* Upload either the render target or a dummy GL_NONE target */
> @@ -455,12 +455,12 @@ panfrost_mfbd_fragment(struct panfrost_context *ctx, bool has_draws)
>           * can safely ignore it. */
>  
>          if (panfrost_is_scanout(ctx)) {
> -                job->requirements &= ~PAN_REQ_DEPTH_WRITE;
> +                batch->requirements &= ~PAN_REQ_DEPTH_WRITE;
>          }
>  
>          /* Actualize the requirements */
>  
> -        if (job->requirements & PAN_REQ_MSAA) {
> +        if (batch->requirements & PAN_REQ_MSAA) {
>                  rts[0].format.flags |= MALI_MFBD_FORMAT_MSAA;
>  
>                  /* XXX */
> @@ -468,7 +468,7 @@ panfrost_mfbd_fragment(struct panfrost_context *ctx, bool has_draws)
>                  fb.rt_count_2 = 4;
>          }
>  
> -        if (job->requirements & PAN_REQ_DEPTH_WRITE)
> +        if (batch->requirements & PAN_REQ_DEPTH_WRITE)
>                  fb.mfbd_flags |= MALI_MFBD_DEPTH_WRITE;
>  
>          /* Checksumming only works with a single render target */
> diff --git a/src/gallium/drivers/panfrost/pan_resource.c b/src/gallium/drivers/panfrost/pan_resource.c
> index 6b72f2a5559b..0be6b2b1c330 100644
> --- a/src/gallium/drivers/panfrost/pan_resource.c
> +++ b/src/gallium/drivers/panfrost/pan_resource.c
> @@ -770,8 +770,8 @@ panfrost_generate_mipmap(
>           * reorder-type optimizations in place. But for now prioritize
>           * correctness. */
>  
> -        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
> -        bool has_draws = job->last_job.gpu;
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
> +        bool has_draws = batch->last_job.gpu;
>  
>          if (has_draws)
>                  panfrost_flush(pctx, NULL, PIPE_FLUSH_END_OF_FRAME);
> diff --git a/src/gallium/drivers/panfrost/pan_scoreboard.c b/src/gallium/drivers/panfrost/pan_scoreboard.c
> index 0873dd1fbe14..776833a13aba 100644
> --- a/src/gallium/drivers/panfrost/pan_scoreboard.c
> +++ b/src/gallium/drivers/panfrost/pan_scoreboard.c
> @@ -121,11 +121,11 @@ job_descriptor_header(struct panfrost_transfer t)
>  
>  static void
>  panfrost_assign_index(
> -        struct panfrost_job *job,
> +        struct panfrost_batch *batch,
>          struct panfrost_transfer transfer)
>  {
>          /* Assign the index */
> -        unsigned index = ++job->job_index;
> +        unsigned index = ++batch->job_index;
>          job_descriptor_header(transfer)->job_index = index;
>  }
>  
> @@ -157,7 +157,7 @@ panfrost_add_dependency(
>  
>  static void
>  panfrost_scoreboard_queue_job_internal(
> -        struct panfrost_job *batch,
> +        struct panfrost_batch *batch,
>          struct panfrost_transfer job)
>  {
>          panfrost_assign_index(batch, job);
> @@ -174,7 +174,7 @@ panfrost_scoreboard_queue_job_internal(
>  
>  void
>  panfrost_scoreboard_queue_compute_job(
> -        struct panfrost_job *batch,
> +        struct panfrost_batch *batch,
>          struct panfrost_transfer job)
>  {
>          panfrost_scoreboard_queue_job_internal(batch, job);
> @@ -192,7 +192,7 @@ panfrost_scoreboard_queue_compute_job(
>  
>  void
>  panfrost_scoreboard_queue_vertex_job(
> -        struct panfrost_job *batch,
> +        struct panfrost_batch *batch,
>          struct panfrost_transfer vertex,
>          bool requires_tiling)
>  {
> @@ -207,7 +207,7 @@ panfrost_scoreboard_queue_vertex_job(
>  
>  void
>  panfrost_scoreboard_queue_tiler_job(
> -        struct panfrost_job *batch,
> +        struct panfrost_batch *batch,
>          struct panfrost_transfer tiler)
>  {
>          panfrost_scoreboard_queue_compute_job(batch, tiler);
> @@ -226,7 +226,7 @@ panfrost_scoreboard_queue_tiler_job(
>  
>  void
>  panfrost_scoreboard_queue_fused_job(
> -        struct panfrost_job *batch,
> +        struct panfrost_batch *batch,
>          struct panfrost_transfer vertex,
>          struct panfrost_transfer tiler)
>  {
> @@ -240,7 +240,7 @@ panfrost_scoreboard_queue_fused_job(
>  
>  void
>  panfrost_scoreboard_queue_fused_job_prepend(
> -        struct panfrost_job *batch,
> +        struct panfrost_batch *batch,
>          struct panfrost_transfer vertex,
>          struct panfrost_transfer tiler)
>  {
> @@ -293,7 +293,7 @@ panfrost_set_value_job(struct panfrost_context *ctx, mali_ptr polygon_list)
>   * linked to the first vertex job feeding into tiling. */
>  
>  static void
> -panfrost_scoreboard_set_value(struct panfrost_job *batch)
> +panfrost_scoreboard_set_value(struct panfrost_batch *batch)
>  {
>          /* Check if we even need tiling */
>          if (!batch->last_tiler.gpu)
> @@ -303,7 +303,7 @@ panfrost_scoreboard_set_value(struct panfrost_job *batch)
>           * regardless of size. */
>  
>          struct panfrost_context *ctx = batch->ctx;
> -        mali_ptr polygon_list = panfrost_job_get_polygon_list(batch, 0);
> +        mali_ptr polygon_list = panfrost_batch_get_polygon_list(batch, 0);
>  
>          struct panfrost_transfer job =
>                  panfrost_set_value_job(ctx, polygon_list);
> @@ -346,7 +346,7 @@ panfrost_scoreboard_set_value(struct panfrost_job *batch)
>                  mali_ptr, count))
>  
>  void
> -panfrost_scoreboard_link_batch(struct panfrost_job *batch)
> +panfrost_scoreboard_link_batch(struct panfrost_batch *batch)
>  {
>          /* Finalize the batch */
>          panfrost_scoreboard_set_value(batch);
> diff --git a/src/gallium/drivers/panfrost/pan_screen.h b/src/gallium/drivers/panfrost/pan_screen.h
> index d8ea55912b4e..3017b9c154f4 100644
> --- a/src/gallium/drivers/panfrost/pan_screen.h
> +++ b/src/gallium/drivers/panfrost/pan_screen.h
> @@ -163,7 +163,7 @@ panfrost_drm_import_bo(struct panfrost_screen *screen, int fd);
>  int
>  panfrost_drm_export_bo(struct panfrost_screen *screen, const struct panfrost_bo *bo);
>  int
> -panfrost_drm_submit_vs_fs_job(struct panfrost_context *ctx, bool has_draws);
> +panfrost_drm_submit_vs_fs_batch(struct panfrost_context *ctx, bool has_draws);
>  void
>  panfrost_drm_force_flush_fragment(struct panfrost_context *ctx,
>                                    struct pipe_fence_handle **fence);
> diff --git a/src/gallium/drivers/panfrost/pan_sfbd.c b/src/gallium/drivers/panfrost/pan_sfbd.c
> index 63dde9303823..f58c054c8f24 100644
> --- a/src/gallium/drivers/panfrost/pan_sfbd.c
> +++ b/src/gallium/drivers/panfrost/pan_sfbd.c
> @@ -37,39 +37,39 @@ panfrost_sfbd_format(struct pipe_surface *surf)
>  
>  static void
>  panfrost_sfbd_clear(
> -        struct panfrost_job *job,
> +        struct panfrost_batch *batch,
>          struct mali_single_framebuffer *sfbd)
>  {
> -        if (job->clear & PIPE_CLEAR_COLOR) {
> -                sfbd->clear_color_1 = job->clear_color[0][0];
> -                sfbd->clear_color_2 = job->clear_color[0][1];
> -                sfbd->clear_color_3 = job->clear_color[0][2];
> -                sfbd->clear_color_4 = job->clear_color[0][3];
> +        if (batch->clear & PIPE_CLEAR_COLOR) {
> +                sfbd->clear_color_1 = batch->clear_color[0][0];
> +                sfbd->clear_color_2 = batch->clear_color[0][1];
> +                sfbd->clear_color_3 = batch->clear_color[0][2];
> +                sfbd->clear_color_4 = batch->clear_color[0][3];
>          }
>  
> -        if (job->clear & PIPE_CLEAR_DEPTH) {
> -                sfbd->clear_depth_1 = job->clear_depth;
> -                sfbd->clear_depth_2 = job->clear_depth;
> -                sfbd->clear_depth_3 = job->clear_depth;
> -                sfbd->clear_depth_4 = job->clear_depth;
> +        if (batch->clear & PIPE_CLEAR_DEPTH) {
> +                sfbd->clear_depth_1 = batch->clear_depth;
> +                sfbd->clear_depth_2 = batch->clear_depth;
> +                sfbd->clear_depth_3 = batch->clear_depth;
> +                sfbd->clear_depth_4 = batch->clear_depth;
>          }
>  
> -        if (job->clear & PIPE_CLEAR_STENCIL) {
> -                sfbd->clear_stencil = job->clear_stencil;
> +        if (batch->clear & PIPE_CLEAR_STENCIL) {
> +                sfbd->clear_stencil = batch->clear_stencil;
>          }
>  
>          /* Set flags based on what has been cleared, for the SFBD case */
>          /* XXX: What do these flags mean? */
>          int clear_flags = 0x101100;
>  
> -        if (!(job->clear & ~(PIPE_CLEAR_COLOR | PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL))) {
> +        if (!(batch->clear & ~(PIPE_CLEAR_COLOR | PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL))) {
>                  /* On a tiler like this, it's fastest to clear all three buffers at once */
>  
>                  clear_flags |= MALI_CLEAR_FAST;
>          } else {
>                  clear_flags |= MALI_CLEAR_SLOW;
>  
> -                if (job->clear & PIPE_CLEAR_STENCIL)
> +                if (batch->clear & PIPE_CLEAR_STENCIL)
>                          clear_flags |= MALI_CLEAR_SLOW_STENCIL;
>          }
>  
> @@ -132,10 +132,10 @@ panfrost_sfbd_set_zsbuf(
>  mali_ptr
>  panfrost_sfbd_fragment(struct panfrost_context *ctx, bool has_draws)
>  {
> -        struct panfrost_job *job = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>          struct mali_single_framebuffer fb = panfrost_emit_sfbd(ctx, has_draws);
>  
> -        panfrost_sfbd_clear(job, &fb);
> +        panfrost_sfbd_clear(batch, &fb);
>  
>          /* SFBD does not support MRT natively; sanity check */
>          assert(ctx->pipe_framebuffer.nr_cbufs == 1);
> @@ -144,7 +144,7 @@ panfrost_sfbd_fragment(struct panfrost_context *ctx, bool has_draws)
>          if (ctx->pipe_framebuffer.zsbuf)
>                  panfrost_sfbd_set_zsbuf(&fb, ctx->pipe_framebuffer.zsbuf);
>  
> -        if (job->requirements & PAN_REQ_MSAA)
> +        if (batch->requirements & PAN_REQ_MSAA)
>                  fb.format |= MALI_FRAMEBUFFER_MSAA_A | MALI_FRAMEBUFFER_MSAA_B;
>  
>          return panfrost_upload_transient(ctx, &fb, sizeof(fb)) | MALI_SFBD;
> diff --git a/src/gallium/drivers/panfrost/pan_varyings.c b/src/gallium/drivers/panfrost/pan_varyings.c
> index 113043b699dc..12760109b7cb 100644
> --- a/src/gallium/drivers/panfrost/pan_varyings.c
> +++ b/src/gallium/drivers/panfrost/pan_varyings.c
> @@ -65,9 +65,9 @@ panfrost_emit_streamout(
>          slot->size = MIN2(max_size, expected_size);
>  
>          /* Grab the BO and bind it to the batch */
> -        struct panfrost_job *batch = panfrost_get_job_for_fbo(ctx);
> +        struct panfrost_batch *batch = panfrost_get_batch_for_fbo(ctx);
>          struct panfrost_bo *bo = pan_resource(target->buffer)->bo;
> -        panfrost_job_add_bo(batch, bo);
> +        panfrost_batch_add_bo(batch, bo);
>  
>          mali_ptr addr = bo->gpu + target->buffer_offset + (offset * slot->stride);
>          slot->elements = addr;
> -- 
> 2.21.0