trace_processor: Parse adreno_cmdbatch_retired/submitted events

Add custom parsing for kgsl adreno_cmdbatch_retired and
adreno_cmdbatch_submitted ftrace events to produce GPU timeline slices
in the trace processor.

- Tokenizer: adjust timestamps using GPU tick-based sync info from
  submitted events to correct retired event ordering before sorting.
- Parser: create scoped GPU slices per context ID using
  TrackCompressor, visible as "GPU (Ctx=N)" tracks.
- UI: register gpu_adreno_cmdbatch track type so tracks appear in the
  timeline under HARDWARE / GPU Adreno.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: rossning92

src/trace_processor/importers/ftrace/ftrace_parser.cc

@@ -136,6 +136,13 @@ using protos::pbzero::perfetto_pbzero_enum_KprobeEvent::KprobeType;
 using protozero::ConstBytes;
 using protozero::ProtoDecoder;
 
+// Adreno GPU ticks run at 19.2 MHz.
+constexpr uint64_t kGpuTicksPerUs = 19200;
+
+uint64_t GpuTicksToNs(uint64_t ticks) {
+  return ticks * 1000000 / kGpuTicksPerUs;
+}
+
 struct FtraceEventAndFieldId {
   uint32_t event_id;
   uint32_t field_id;
@@ -541,6 +548,7 @@ FtraceParser::FtraceParser(TraceProcessorContext* context,
       gpu_power_state_off_id_(context->storage->InternString("OFF")),
       gpu_power_state_pg_id_(context->storage->InternString("PG")),
       gpu_power_state_on_id_(context->storage->InternString("ON")),
+      gpu_cmdbatch_slice_name_id_(context->storage->InternString("GPU")),
       ddic_underrun_id_(context_->storage->InternString("ddic_underrun")),
       memcg_reclaim_order_id_(
           context->storage->InternString("memcg_reclaim_order")),
@@ -925,6 +933,10 @@ base::Status FtraceParser::ParseFtraceEvent(uint32_t cpu,
         ParseKgslGpuFreq(ts, fld_bytes);
         break;
       }
+      case FtraceEvent::kKgslAdrenoCmdbatchRetiredFieldNumber: {
+        ParseKgslAdrenoCmdbatchRetired(ts, fld_bytes);
+        break;
+      }
       case FtraceEvent::kCpuIdleFieldNumber: {
         ParseCpuIdle(ts, fld_bytes);
         break;
@@ -1920,6 +1932,33 @@ void FtraceParser::ParseKgslGpuFreq(int64_t timestamp, ConstBytes blob) {
   context_->event_tracker->PushCounter(timestamp, new_freq, track);
 }
 
+void FtraceParser::ParseKgslAdrenoCmdbatchRetired(int64_t timestamp,
+                                                  protozero::ConstBytes data) {
+  protos::pbzero::KgslAdrenoCmdbatchRetiredFtraceEvent::Decoder evt(data);
+
+  static constexpr auto kBlueprint = TrackCompressor::SliceBlueprint(
+      "gpu_adreno_cmdbatch",
+      tracks::DimensionBlueprints(tracks::UintDimensionBlueprint("context_id"),
+                                  tracks::UintDimensionBlueprint("prio")),
+      tracks::FnNameBlueprint([](uint32_t context_id, uint32_t prio) {
+        return base::StackString<64>("GPU (Ctx=%u, Prio=%u)", context_id, prio);
+      }));
+
+  if (evt.retire() < evt.start()) {
+    return;
+  }
+  const int64_t duration =
+      static_cast<int64_t>(GpuTicksToNs(evt.retire() - evt.start()));
+
+  const uint32_t context_id = evt.id();
+  TrackId track_id = context_->track_compressor->InternScoped(
+      kBlueprint,
+      tracks::Dimensions(context_id, static_cast<uint32_t>(evt.prio())),
+      timestamp, duration);
+  context_->slice_tracker->Scoped(timestamp, track_id, kNullStringId,
+                                  gpu_cmdbatch_slice_name_id_, duration);
+}
+
 void FtraceParser::ParseCpuIdle(int64_t timestamp, ConstBytes blob) {
   protos::pbzero::CpuIdleFtraceEvent::Decoder idle(blob);
   TrackId track = context_->track_tracker->InternTrack(

src/trace_processor/importers/ftrace/ftrace_parser.h

@@ -95,6 +95,7 @@ class FtraceParser {
   void ParseCpuFreqThrottle(int64_t timestamp, protozero::ConstBytes);
   void ParseGpuFreq(int64_t timestamp, protozero::ConstBytes);
   void ParseKgslGpuFreq(int64_t timestamp, protozero::ConstBytes);
+  void ParseKgslAdrenoCmdbatchRetired(int64_t timestamp, protozero::ConstBytes);
   void ParseCpuIdle(int64_t timestamp, protozero::ConstBytes);
   void ParsePrint(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
   void ParseZero(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
@@ -463,6 +464,7 @@ class FtraceParser {
   const StringId gpu_power_state_off_id_;
   const StringId gpu_power_state_pg_id_;
   const StringId gpu_power_state_on_id_;
+  const StringId gpu_cmdbatch_slice_name_id_;
   const StringId ddic_underrun_id_;
   std::array<StringId, 8> f2fs_checkpoint_reason_ids_;
 

src/trace_processor/importers/ftrace/ftrace_tokenizer.cc

@@ -51,6 +51,7 @@
 #include "protos/perfetto/trace/ftrace/ftrace_event.pbzero.h"
 #include "protos/perfetto/trace/ftrace/ftrace_event_bundle.pbzero.h"
 #include "protos/perfetto/trace/ftrace/fwtp_ftrace.pbzero.h"
+#include "protos/perfetto/trace/ftrace/kgsl.pbzero.h"
 #include "protos/perfetto/trace/ftrace/power.pbzero.h"
 #include "protos/perfetto/trace/ftrace/thermal_exynos.pbzero.h"
 #include "src/trace_processor/util/clock_synchronizer.h"
@@ -69,6 +70,13 @@ namespace {
 
 constexpr uint32_t kSequenceScopedClockId = 64;
 
+// Adreno GPU ticks run at 19.2 MHz.
+constexpr uint64_t kGpuTicksPerUs = 19200;
+
+uint64_t GpuTicksToNs(uint64_t ticks) {
+  return ticks * 1000000 / kGpuTicksPerUs;
+}
+
 // Fast path for parsing the event id of an ftrace event.
 // Speculate on the fact that, if the timestamp was found, the common pid
 // will appear immediately after and the event id immediately after that.
@@ -301,6 +309,41 @@ void FtraceTokenizer::TokenizeFtraceEvent(
     return;
   }
 
+  if (event_id ==
+      protos::pbzero::FtraceEvent::kKgslAdrenoCmdbatchRetiredFieldNumber) {
+    auto retired_field = GetFtraceEventField(
+        protos::pbzero::FtraceEvent::kKgslAdrenoCmdbatchRetiredFieldNumber,
+        event);
+    if (retired_field.has_value()) {
+      protos::pbzero::KgslAdrenoCmdbatchRetiredFtraceEvent::Decoder evt(
+          retired_field->as_bytes());
+
+      const uint32_t ts = evt.timestamp();
+      auto* info = cmdbatch_sync_map_.Find(ts);
+      if (info && evt.start() >= info->ticks) {
+        raw_timestamp =
+            info->sync_time + GpuTicksToNs(evt.start() - info->ticks);
+        cmdbatch_sync_map_.Erase(ts);
+      } else if (evt.retire() >= evt.start()) {
+        raw_timestamp -= GpuTicksToNs(evt.retire() - evt.start());
+      }
+    }
+  } else if (event_id == protos::pbzero::FtraceEvent::
+                             kKgslAdrenoCmdbatchSubmittedFieldNumber) {
+    auto submitted_field = GetFtraceEventField(
+        protos::pbzero::FtraceEvent::kKgslAdrenoCmdbatchSubmittedFieldNumber,
+        event);
+    if (submitted_field.has_value()) {
+      protos::pbzero::KgslAdrenoCmdbatchSubmittedFtraceEvent::Decoder evt(
+          submitted_field->as_bytes());
+      const uint64_t sync_time_ns =
+          static_cast<uint64_t>(evt.secs()) * 1000000000ULL +
+          static_cast<uint64_t>(evt.usecs()) * 1000ULL;
+      const uint32_t ts = evt.timestamp();
+      cmdbatch_sync_map_.Insert(ts, {sync_time_ns, evt.ticks()});
+    }
+  }
+
   std::optional<int64_t> timestamp = context_->clock_tracker->ToTraceTime(
       clock_id, static_cast<int64_t>(raw_timestamp));
   // ClockTracker will increment some error stats if it failed to convert the

src/trace_processor/importers/ftrace/ftrace_tokenizer.h

@@ -25,6 +25,7 @@
 #include "perfetto/base/compiler.h"
 #include "perfetto/base/logging.h"
 #include "perfetto/base/status.h"
+#include "perfetto/ext/base/flat_hash_map.h"
 #include "perfetto/ext/base/status_or.h"
 #include "perfetto/protozero/field.h"
 #include "perfetto/trace_processor/ref_counted.h"
@@ -110,6 +111,12 @@ class FtraceTokenizer {
 
   int64_t latest_ftrace_clock_snapshot_ts_ = 0;
   std::vector<bool> per_cpu_seen_first_bundle_;
+
+  struct CmdbatchSyncInfo {
+    uint64_t sync_time;
+    uint64_t ticks;
+  };
+  base::FlatHashMap<uint32_t, CmdbatchSyncInfo> cmdbatch_sync_map_;
 };
 
 }  // namespace perfetto::trace_processor

ui/src/plugins/dev.perfetto.TraceProcessorTrack/slice_tracks.ts

@@ -248,6 +248,11 @@ export const SLICE_TRACK_SCHEMAS: ReadonlyArray<SliceTrackTypeSchema> = [
     topLevelGroup: 'HARDWARE',
     group: undefined,
   },
+  {
+    type: 'gpu_adreno_cmdbatch',
+    topLevelGroup: 'HARDWARE',
+    group: 'GPU Adreno',
+  },
   {
     type: 'triggers',
     topLevelGroup: 'SYSTEM',