From a02dcb970fff17e73648b58bf4a603bc4f9c0c36 Mon Sep 17 00:00:00 2001 From: Rob Clark Date: Mon, 30 Nov 2020 08:38:18 -0800 Subject: [PATCH] freedreno: Add GPU tracepoints Add support for u_trace, and freedreno tracepoints. Signed-off-by: Rob Clark Part-of: --- .../drivers/freedreno/a6xx/fd6_blitter.c | 5 + .../drivers/freedreno/a6xx/fd6_compute.c | 7 ++ src/gallium/drivers/freedreno/a6xx/fd6_emit.c | 3 + src/gallium/drivers/freedreno/a6xx/fd6_gmem.c | 20 +++ .../drivers/freedreno/freedreno_batch.c | 5 + .../drivers/freedreno/freedreno_batch.h | 6 + .../drivers/freedreno/freedreno_context.c | 49 ++++++++ .../drivers/freedreno/freedreno_context.h | 3 + .../drivers/freedreno/freedreno_gmem.c | 20 ++- .../freedreno/freedreno_tracepoints.py | 114 ++++++++++++++++++ src/gallium/drivers/freedreno/meson.build | 16 ++- 11 files changed, 246 insertions(+), 2 deletions(-) create mode 100644 src/gallium/drivers/freedreno/freedreno_tracepoints.py diff --git a/src/gallium/drivers/freedreno/a6xx/fd6_blitter.c b/src/gallium/drivers/freedreno/a6xx/fd6_blitter.c index 01b540ea252..68539c44cb0 100644 --- a/src/gallium/drivers/freedreno/a6xx/fd6_blitter.c +++ b/src/gallium/drivers/freedreno/a6xx/fd6_blitter.c @@ -32,6 +32,7 @@ #include "freedreno_fence.h" #include "freedreno_log.h" #include "freedreno_resource.h" +#include "freedreno_tracepoints.h" #include "fd6_blitter.h" #include "fd6_format.h" @@ -823,6 +824,8 @@ handle_rgba_blit(struct fd_context *ctx, const struct pipe_blit_info *info) emit_setup(batch); + trace_start_blit(&batch->trace, info->src.resource->target, info->dst.resource->target); + if ((info->src.resource->target == PIPE_BUFFER) && (info->dst.resource->target == PIPE_BUFFER)) { assert(fd_resource(info->src.resource)->layout.tile_mode == TILE6_LINEAR); @@ -839,6 +842,8 @@ handle_rgba_blit(struct fd_context *ctx, const struct pipe_blit_info *info) fd_log(batch, "END BLIT (TEXTURE)"); } + trace_end_blit(&batch->trace); + fd6_event_write(batch, batch->draw, PC_CCU_FLUSH_COLOR_TS, true); fd6_event_write(batch, batch->draw, PC_CCU_FLUSH_DEPTH_TS, true); fd6_event_write(batch, batch->draw, CACHE_FLUSH_TS, true); diff --git a/src/gallium/drivers/freedreno/a6xx/fd6_compute.c b/src/gallium/drivers/freedreno/a6xx/fd6_compute.c index aa6e4996661..27146a4fe06 100644 --- a/src/gallium/drivers/freedreno/a6xx/fd6_compute.c +++ b/src/gallium/drivers/freedreno/a6xx/fd6_compute.c @@ -26,9 +26,11 @@ #include "pipe/p_state.h" #include "util/u_dump.h" +#include "u_tracepoints.h" #include "freedreno_log.h" #include "freedreno_resource.h" +#include "freedreno_tracepoints.h" #include "fd6_compute.h" #include "fd6_const.h" @@ -192,6 +194,9 @@ fd6_launch_grid(struct fd_context *ctx, const struct pipe_grid_info *info) OUT_RING(ring, 1); /* HLSQ_CS_KERNEL_GROUP_Y */ OUT_RING(ring, 1); /* HLSQ_CS_KERNEL_GROUP_Z */ + trace_grid_info(&ctx->batch->trace, info); + trace_start_compute(&ctx->batch->trace); + fd_log(ctx->batch, "COMPUTE: START"); fd_log_stream(ctx->batch, stream, util_dump_grid_info(stream, info)); @@ -212,6 +217,8 @@ fd6_launch_grid(struct fd_context *ctx, const struct pipe_grid_info *info) OUT_RING(ring, CP_EXEC_CS_3_NGROUPS_Z(info->grid[2])); } + trace_end_compute(&ctx->batch->trace); + fd_log(ctx->batch, "COMPUTE: END"); OUT_WFI5(ring); fd_log(ctx->batch, ".."); diff --git a/src/gallium/drivers/freedreno/a6xx/fd6_emit.c b/src/gallium/drivers/freedreno/a6xx/fd6_emit.c index 59ab1f45274..1da9e06183d 100644 --- a/src/gallium/drivers/freedreno/a6xx/fd6_emit.c +++ b/src/gallium/drivers/freedreno/a6xx/fd6_emit.c @@ -35,6 +35,7 @@ #include "freedreno_log.h" #include "freedreno_resource.h" #include "freedreno_state.h" +#include "freedreno_tracepoints.h" #include "freedreno_query_hw.h" #include "common/freedreno_guardband.h" @@ -1176,6 +1177,7 @@ fd6_emit_restore(struct fd_batch *batch, struct fd_ringbuffer *ring) if (!batch->nondraw) { fd_log(batch, "START RESTORE"); + trace_start_state_restore(&batch->trace); } fd6_cache_inv(batch, ring); @@ -1293,6 +1295,7 @@ fd6_emit_restore(struct fd_batch *batch, struct fd_ringbuffer *ring) OUT_RING(ring, 0x00000000); if (!batch->nondraw) { + trace_end_state_restore(&batch->trace); fd_log(batch, "END RESTORE"); } } diff --git a/src/gallium/drivers/freedreno/a6xx/fd6_gmem.c b/src/gallium/drivers/freedreno/a6xx/fd6_gmem.c index 9f1a1ecfef3..42271d92220 100644 --- a/src/gallium/drivers/freedreno/a6xx/fd6_gmem.c +++ b/src/gallium/drivers/freedreno/a6xx/fd6_gmem.c @@ -37,6 +37,7 @@ #include "freedreno_log.h" #include "freedreno_state.h" #include "freedreno_resource.h" +#include "freedreno_tracepoints.h" #include "fd6_blitter.h" #include "fd6_gmem.h" @@ -577,7 +578,9 @@ emit_binning_pass(struct fd_batch *batch) /* emit IB to binning drawcmds: */ fd_log(batch, "GMEM: START BINNING IB"); + trace_start_binning_ib(&batch->trace); fd6_emit_ib(ring, batch->draw); + trace_end_binning_ib(&batch->trace); fd_log(batch, "GMEM: END BINNING IB"); fd_reset_wfi(batch); @@ -599,7 +602,9 @@ emit_binning_pass(struct fd_batch *batch) OUT_PKT7(ring, CP_WAIT_FOR_ME, 0); fd_log(batch, "START VSC OVERFLOW TEST"); + trace_start_vsc_overflow_test(&batch->trace); emit_vsc_overflow_test(batch); + trace_end_vsc_overflow_test(&batch->trace); fd_log(batch, "END VSC OVERFLOW TEST"); OUT_PKT7(ring, CP_SET_VISIBILITY_OVERRIDE, 1); @@ -658,7 +663,9 @@ fd6_emit_tile_init(struct fd_batch *batch) if (batch->prologue) { fd_log(batch, "START PROLOGUE"); + trace_start_prologue(&batch->trace); fd6_emit_ib(ring, batch->prologue); + trace_end_prologue(&batch->trace); fd_log(batch, "END PROLOGUE"); } @@ -1119,11 +1126,13 @@ fd6_emit_tile_renderprep(struct fd_batch *batch, const struct fd_tile *tile) return; fd_log(batch, "TILE: START CLEAR/RESTORE"); + trace_start_clear_restore(&batch->trace, batch->fast_cleared); if (batch->fast_cleared || !use_hw_binning(batch)) { fd6_emit_ib(batch->gmem, batch->tile_setup); } else { emit_conditional_ib(batch, tile, batch->tile_setup); } + trace_end_clear_restore(&batch->trace); fd_log(batch, "TILE: END CLEAR/RESTORE"); } @@ -1245,11 +1254,13 @@ fd6_emit_tile_gmem2mem(struct fd_batch *batch, const struct fd_tile *tile) emit_marker6(ring, 7); fd_log(batch, "TILE: START RESOLVE"); + trace_start_resolve(&batch->trace); if (batch->fast_cleared || !use_hw_binning(batch)) { fd6_emit_ib(batch->gmem, batch->tile_fini); } else { emit_conditional_ib(batch, tile, batch->tile_fini); } + trace_end_resolve(&batch->trace); fd_log(batch, "TILE: END RESOLVE"); } @@ -1278,6 +1289,11 @@ emit_sysmem_clears(struct fd_batch *batch, struct fd_ringbuffer *ring) uint32_t buffers = batch->fast_cleared; + if (!buffers) + return; + + trace_start_clear_restore(&batch->trace, buffers); + if (buffers & PIPE_CLEAR_COLOR) { for (int i = 0; i < pfb->nr_cbufs; i++) { union pipe_color_union *color = &batch->clear_color[i]; @@ -1321,6 +1337,8 @@ emit_sysmem_clears(struct fd_batch *batch, struct fd_ringbuffer *ring) } fd6_event_write(batch, ring, PC_CCU_FLUSH_COLOR_TS, true); + + trace_end_clear_restore(&batch->trace); } static void @@ -1356,9 +1374,11 @@ fd6_emit_sysmem_prep(struct fd_batch *batch) if (batch->prologue) { if (!batch->nondraw) { fd_log(batch, "START PROLOGUE"); + trace_start_prologue(&batch->trace); } fd6_emit_ib(ring, batch->prologue); if (!batch->nondraw) { + trace_end_prologue(&batch->trace); fd_log(batch, "END PROLOGUE"); } } diff --git a/src/gallium/drivers/freedreno/freedreno_batch.c b/src/gallium/drivers/freedreno/freedreno_batch.c index ccef2d40c8d..7526b913f61 100644 --- a/src/gallium/drivers/freedreno/freedreno_batch.c +++ b/src/gallium/drivers/freedreno/freedreno_batch.c @@ -111,6 +111,9 @@ batch_init(struct fd_batch *batch) util_dynarray_init(&batch->samples, NULL); list_inithead(&batch->log_chunks); + + u_trace_init(&batch->trace, &ctx->trace_context); + batch->last_timestamp_cmd = NULL; } struct fd_batch * @@ -222,6 +225,8 @@ batch_fini(struct fd_batch *batch) util_dynarray_fini(&batch->samples); assert(list_is_empty(&batch->log_chunks)); + + u_trace_fini(&batch->trace); } static void diff --git a/src/gallium/drivers/freedreno/freedreno_batch.h b/src/gallium/drivers/freedreno/freedreno_batch.h index a08b7826d06..275888bc1a7 100644 --- a/src/gallium/drivers/freedreno/freedreno_batch.h +++ b/src/gallium/drivers/freedreno/freedreno_batch.h @@ -29,6 +29,7 @@ #include "util/u_inlines.h" #include "util/u_queue.h" +#include "util/u_trace.h" #include "util/list.h" #include "util/simple_mtx.h" @@ -52,6 +53,11 @@ struct fd_batch { unsigned seqno; unsigned idx; /* index into cache->batches[] */ + struct u_trace trace; + + /* To detect cases where we can skip cmdstream to record timestamp: */ + uint32_t *last_timestamp_cmd; + int in_fence_fd; bool needs_out_fence_fd; struct pipe_fence_handle *fence; diff --git a/src/gallium/drivers/freedreno/freedreno_context.c b/src/gallium/drivers/freedreno/freedreno_context.c index 11efe3a6367..84dfbc89a9f 100644 --- a/src/gallium/drivers/freedreno/freedreno_context.c +++ b/src/gallium/drivers/freedreno/freedreno_context.c @@ -115,6 +115,9 @@ out: if (flags & PIPE_FLUSH_END_OF_FRAME) fd_log_eof(ctx); + + u_trace_context_process(&ctx->trace_context, + !!(flags & PIPE_FLUSH_END_OF_FRAME)); } static void @@ -344,6 +347,8 @@ fd_context_destroy(struct pipe_context *pctx) simple_mtx_destroy(&ctx->gmem_lock); + u_trace_context_fini(&ctx->trace_context); + if (fd_mesa_debug & (FD_DBG_BSTAT | FD_DBG_MSGS)) { printf("batch_total=%u, batch_sysmem=%u, batch_gmem=%u, batch_nondraw=%u, batch_restore=%u\n", (uint32_t)ctx->stats.batch_total, (uint32_t)ctx->stats.batch_sysmem, @@ -397,6 +402,47 @@ fd_get_device_reset_status(struct pipe_context *pctx) return status; } +static void +fd_trace_record_ts(struct u_trace *ut, struct pipe_resource *timestamps, + unsigned idx) +{ + struct fd_batch *batch = container_of(ut, batch, trace); + struct fd_ringbuffer *ring = batch->nondraw ? batch->draw : batch->gmem; + + if (ring->cur == batch->last_timestamp_cmd) { + uint64_t *ts = fd_bo_map(fd_resource(timestamps)->bo); + ts[idx] = U_TRACE_NO_TIMESTAMP; + return; + } + + unsigned ts_offset = idx * sizeof(uint64_t); + batch->ctx->record_timestamp(ring, fd_resource(timestamps)->bo, ts_offset); + batch->last_timestamp_cmd = ring->cur; +} + +static uint64_t +fd_trace_read_ts(struct u_trace_context *utctx, + struct pipe_resource *timestamps, unsigned idx) +{ + struct fd_context *ctx = container_of(utctx, ctx, trace_context); + struct fd_bo *ts_bo = fd_resource(timestamps)->bo; + + /* Only need to stall on results for the first entry: */ + if (idx == 0) { + int ret = fd_bo_cpu_prep(ts_bo, ctx->pipe, DRM_FREEDRENO_PREP_READ); + if (ret) + return U_TRACE_NO_TIMESTAMP; + } + + uint64_t *ts = fd_bo_map(ts_bo); + + /* Don't translate the no-timestamp marker: */ + if (ts[idx] == U_TRACE_NO_TIMESTAMP) + return U_TRACE_NO_TIMESTAMP; + + return ctx->ts_to_ns(ts[idx]); +} + /* TODO we could combine a few of these small buffers (solid_vbuf, * blit_texcoord_vbuf, and vsc_size_mem, into a single buffer and * save a tiny bit of memory @@ -561,6 +607,9 @@ fd_context_init(struct fd_context *ctx, struct pipe_screen *pscreen, ctx->log_out = stdout; + u_trace_context_init(&ctx->trace_context, pctx, + fd_trace_record_ts, fd_trace_read_ts); + if ((fd_mesa_debug & FD_DBG_LOG) && !(ctx->record_timestamp && ctx->ts_to_ns)) { printf("logging not supported!\n"); diff --git a/src/gallium/drivers/freedreno/freedreno_context.h b/src/gallium/drivers/freedreno/freedreno_context.h index 1788f70cdaa..b2e5cbbadc3 100644 --- a/src/gallium/drivers/freedreno/freedreno_context.h +++ b/src/gallium/drivers/freedreno/freedreno_context.h @@ -34,6 +34,7 @@ #include "util/list.h" #include "util/slab.h" #include "util/u_string.h" +#include "util/u_trace.h" #include "freedreno_screen.h" #include "freedreno_gmem.h" @@ -393,6 +394,8 @@ struct fd_context { struct pipe_debug_callback debug; + struct u_trace_context trace_context; + /* Called on rebind_resource() for any per-gen cleanup required: */ void (*rebind_resource)(struct fd_context *ctx, struct fd_resource *rsc); diff --git a/src/gallium/drivers/freedreno/freedreno_gmem.c b/src/gallium/drivers/freedreno/freedreno_gmem.c index b2031cba0ea..ce72eb9557b 100644 --- a/src/gallium/drivers/freedreno/freedreno_gmem.c +++ b/src/gallium/drivers/freedreno/freedreno_gmem.c @@ -32,6 +32,7 @@ #include "util/u_memory.h" #include "util/u_inlines.h" #include "util/format/u_format.h" +#include "u_tracepoints.h" #include "freedreno_gmem.h" #include "freedreno_context.h" @@ -39,6 +40,7 @@ #include "freedreno_log.h" #include "freedreno_resource.h" #include "freedreno_query_hw.h" +#include "freedreno_tracepoints.h" #include "freedreno_util.h" /* @@ -589,6 +591,8 @@ render_tiles(struct fd_batch *batch, struct fd_gmem_stateobj *gmem) fd_log(batch, "bin_h=%d, yoff=%d, bin_w=%d, xoff=%d", tile->bin_h, tile->yoff, tile->bin_w, tile->xoff); + trace_start_tile(&batch->trace, tile->bin_h, + tile->yoff, tile->bin_w, tile->xoff); ctx->emit_tile_prep(batch, tile); @@ -603,12 +607,13 @@ render_tiles(struct fd_batch *batch, struct fd_gmem_stateobj *gmem) /* emit IB to drawcmds: */ fd_log(batch, "TILE[%d]: START DRAW IB", i); + trace_start_draw_ib(&batch->trace); if (ctx->emit_tile) { ctx->emit_tile(batch, tile); } else { ctx->screen->emit_ib(batch->gmem, batch->draw); } - + trace_end_draw_ib(&batch->trace); fd_log(batch, "TILE[%d]: END DRAW IB", i); fd_reset_wfi(batch); @@ -634,11 +639,13 @@ render_sysmem(struct fd_batch *batch) if (!batch->nondraw) { fd_log(batch, "SYSMEM: START DRAW IB"); + trace_start_draw_ib(&batch->trace); } /* emit IB to drawcmds: */ ctx->screen->emit_ib(batch->gmem, batch->draw); if (!batch->nondraw) { + trace_end_draw_ib(&batch->trace); fd_log(batch, "SYSMEM: END DRAW IB"); } @@ -672,6 +679,12 @@ fd_gmem_render_tiles(struct fd_batch *batch) struct pipe_framebuffer_state *pfb = &batch->framebuffer; bool sysmem = false; + if (!batch->nondraw) { + trace_flush_batch(&batch->trace, batch, batch->cleared, + batch->gmem_reason, batch->num_draws); + trace_framebuffer_state(&batch->trace, pfb); + } + if (ctx->emit_sysmem_prep && !batch->nondraw) { if (batch->cleared || batch->gmem_reason || ((batch->num_draws > 5) && !batch->blit) || @@ -731,6 +744,7 @@ fd_gmem_render_tiles(struct fd_batch *batch) util_format_short_name(pipe_surface_format(pfb->cbufs[0])), util_format_short_name(pipe_surface_format(pfb->zsbuf)), batch->num_draws); + trace_render_sysmem(&batch->trace); if (ctx->query_prepare) ctx->query_prepare(batch, 1); render_sysmem(batch); @@ -742,6 +756,8 @@ fd_gmem_render_tiles(struct fd_batch *batch) batch, pfb->width, pfb->height, gmem->nbins_x, gmem->nbins_y, util_format_short_name(pipe_surface_format(pfb->cbufs[0])), util_format_short_name(pipe_surface_format(pfb->zsbuf))); + trace_render_gmem(&batch->trace, gmem->nbins_x, gmem->nbins_y, + gmem->bin_w, gmem->bin_h); if (ctx->query_prepare) ctx->query_prepare(batch, gmem->nbins_x * gmem->nbins_y); render_tiles(batch, gmem); @@ -755,6 +771,8 @@ fd_gmem_render_tiles(struct fd_batch *batch) } flush_ring(batch); + + u_trace_flush(&batch->trace); } /* Determine a worst-case estimate (ie. assuming we don't eliminate an diff --git a/src/gallium/drivers/freedreno/freedreno_tracepoints.py b/src/gallium/drivers/freedreno/freedreno_tracepoints.py new file mode 100644 index 00000000000..d8e8595aca6 --- /dev/null +++ b/src/gallium/drivers/freedreno/freedreno_tracepoints.py @@ -0,0 +1,114 @@ +# +# Copyright (C) 2020 Google, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files (the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and/or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice (including the next +# paragraph) shall be included in all copies or substantial portions of the +# Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. +# + +import argparse +import sys + +# +# TODO can we do this with less boilerplate? +# +parser = argparse.ArgumentParser() +parser.add_argument('-p', '--import-path', required=True) +parser.add_argument('-C', '--src', required=True) +parser.add_argument('-H', '--hdr', required=True) +args = parser.parse_args() +sys.path.insert(0, args.import_path) + + +from u_trace import Header +from u_trace import Tracepoint +from u_trace import utrace_generate + +# +# Tracepoint definitions: +# + +Header('util/u_dump.h') +Header('freedreno_batch.h') + +Tracepoint('start_state_restore') +Tracepoint('end_state_restore') + +Tracepoint('flush_batch', + args=[['struct fd_batch *', 'batch'], + ['uint16_t', 'cleared'], + ['uint16_t', 'gmem_reason'], + ['uint16_t', 'num_draws']], + tp_print=['%p: cleared=%x, gmem_reason=%x, num_draws=%u', '__entry->batch', + '__entry->cleared', '__entry->gmem_reason', '__entry->num_draws'], +) + +Tracepoint('render_gmem', + args=[['uint16_t', 'nbins_x'], + ['uint16_t', 'nbins_y'], + ['uint16_t', 'bin_w'], + ['uint16_t', 'bin_h']], + tp_print=['%ux%u bins of %ux%u', + '__entry->nbins_x', '__entry->nbins_y', '__entry->bin_w', '__entry->bin_h'], +) + +Tracepoint('render_sysmem') + +Tracepoint('start_binning_ib') +Tracepoint('end_binning_ib') + +Tracepoint('start_vsc_overflow_test') +Tracepoint('end_vsc_overflow_test') + +Tracepoint('start_prologue') +Tracepoint('end_prologue') + +# For GMEM pass, where this could either be a clear or resolve +Tracepoint('start_clear_restore', + args=[['uint16_t', 'fast_cleared']], + tp_print=['fast_cleared: 0x%x', '__entry->fast_cleared'] +) +Tracepoint('end_clear_restore') + +Tracepoint('start_resolve') +Tracepoint('end_resolve') + +Tracepoint('start_tile', + args=[['uint16_t', 'bin_h'], + ['uint16_t', 'yoff'], + ['uint16_t', 'bin_w'], + ['uint16_t', 'xoff']], + tp_print=['bin_h=%d, yoff=%d, bin_w=%d, xoff=%d', + '__entry->bin_h', '__entry->yoff', '__entry->bin_w', '__entry->xoff'], +) + +Tracepoint('start_draw_ib') +Tracepoint('end_draw_ib') + +Tracepoint('start_blit', + args=[['enum pipe_texture_target', 'src_target'], + ['enum pipe_texture_target', 'dst_target']], + tp_print=['%s -> %s', 'util_str_tex_target(__entry->src_target, true)', + 'util_str_tex_target(__entry->dst_target, true)'], +) +Tracepoint('end_blit') + +Tracepoint('start_compute') +Tracepoint('end_compute') + +utrace_generate(cpath=args.src, hpath=args.hdr) diff --git a/src/gallium/drivers/freedreno/meson.build b/src/gallium/drivers/freedreno/meson.build index 20c0d4fd819..667783fe80d 100644 --- a/src/gallium/drivers/freedreno/meson.build +++ b/src/gallium/drivers/freedreno/meson.build @@ -217,6 +217,19 @@ files_libfreedreno = files( 'ir3/ir3_gallium.h', ) +files_libfreedreno += custom_target( + 'freedreno_tracepoints.[ch]', + input: 'freedreno_tracepoints.py', + output: ['freedreno_tracepoints.c', 'freedreno_tracepoints.h'], + command: [ + prog_python, '@INPUT@', + '-p', join_paths(meson.source_root(), 'src/gallium/auxiliary/util/'), + '-C', '@OUTPUT0@', + '-H', '@OUTPUT1@', + ], + depend_files: u_trace_py, +) + freedreno_includes = [ inc_mesa, inc_mapi, inc_src, inc_include, inc_gallium, inc_gallium_aux, @@ -244,7 +257,8 @@ libfreedreno = static_library( dep_libdrm, idep_mesautil, idep_nir_headers, - idep_libfreedreno_common + idep_libfreedreno_common, + idep_u_tracepoints, ], )