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.

Author: rossning92

src/trace_processor/importers/ftrace/ftrace_parser.cc

@@ -541,6 +541,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 +926,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 +1925,37 @@ 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(
+      "adreno_gpu_cmdbatch",
+      tracks::DimensionBlueprints(tracks::UintDimensionBlueprint("context_id"),
+                                  tracks::UintDimensionBlueprint("prio")),
+      tracks::FnNameBlueprint([](uint32_t context_id, uint32_t prio) {
+        return base::StackString<64>("Adreno GPU Cmdbatch (Ctx=%u, Prio=%u)",
+                                     context_id, prio);
+      }));
+
+  if (evt.retire() < evt.start()) {
+    return;
+  }
+  // Adreno GPU ticks run at 19.2 MHz, fixed across all Qualcomm mobile SoCs
+  // (see KGSL_XO_CLK_FREQ in kgsl_pwrctrl.h).
+  constexpr uint64_t kAdrenoGpuTicksPerUs = 19200;
+  const int64_t duration = static_cast<int64_t>((evt.retire() - evt.start()) *
+                                                1000000 / kAdrenoGpuTicksPerUs);
+
+  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"
@@ -68,6 +69,7 @@ using protos::pbzero::FtraceEventBundle;
 namespace {
 
 constexpr uint32_t kSequenceScopedClockId = 64;
+constexpr uint32_t kAdrenoGpuClockId = 65;
 
 // Fast path for parsing the event id of an ftrace event.
 // Speculate on the fact that, if the timestamp was found, the common pid
@@ -154,7 +156,7 @@ base::Status FtraceTokenizer::TokenizeFtraceBundle(
 
   for (auto it = decoder.event(); it; ++it) {
     TokenizeFtraceEvent(cpu, clock_id, bundle.slice(it->data(), it->size()),
-                        state);
+                        state, packet_sequence_id);
   }
 
   // v50+: optional proto descriptors for generic (i.e. not known at
@@ -214,7 +216,8 @@ void FtraceTokenizer::TokenizeFtraceEvent(
     uint32_t cpu,
     ClockTracker::ClockId clock_id,
     TraceBlobView event,
-    RefPtr<PacketSequenceStateGeneration> state) {
+    RefPtr<PacketSequenceStateGeneration> state,
+    uint32_t packet_sequence_id) {
   constexpr auto kTimestampFieldNumber =
       protos::pbzero::FtraceEvent::kTimestampFieldNumber;
   constexpr auto kTimestampFieldTag = MakeTagVarInt(kTimestampFieldNumber);
@@ -301,6 +304,60 @@ void FtraceTokenizer::TokenizeFtraceEvent(
     return;
   }
 
+  // The submitted event provides a CPU <-> GPU clock sync point; we register
+  // it as a sequence-scoped clock so the clock tracker can convert GPU tick
+  // timestamps to trace time, skipping duplicates since the GPU clock runs at
+  // a fixed frequency and a single snapshot is sufficient.
+  // Adreno GPU ticks run at 19.2 MHz (KGSL_XO_CLK_FREQ in kgsl_pwrctrl.h).
+  constexpr int64_t kAdrenoGpuTicksPerUs = 19200;
+  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());
+      if (!adreno_gpu_clock_registered_) {
+        const int64_t sync_time_ns =
+            static_cast<int64_t>(evt.secs()) * 1000000000LL +
+            static_cast<int64_t>(evt.usecs()) * 1000LL;
+        if (sync_time_ns > 0) {
+          const int64_t gpu_ticks_ns = static_cast<int64_t>(evt.ticks()) *
+                                       1000000 / kAdrenoGpuTicksPerUs;
+          auto gpu_clock =
+              ClockId::Sequence(context_->trace_id().value, packet_sequence_id,
+                                kAdrenoGpuClockId);
+          context_->clock_tracker->AddSnapshot({
+              ClockTracker::ClockTimestamp(gpu_clock, gpu_ticks_ns),
+              ClockTracker::ClockTimestamp(clock_id, sync_time_ns),
+          });
+          adreno_gpu_clock_registered_ = true;
+        }
+      }
+    }
+  } else 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());
+      auto gpu_clock = ClockId::Sequence(context_->trace_id().value,
+                                         packet_sequence_id, kAdrenoGpuClockId);
+      const int64_t gpu_start_ns =
+          static_cast<int64_t>(evt.start()) * 1000000 / kAdrenoGpuTicksPerUs;
+      auto ts = context_->clock_tracker->ToTraceTime(
+          gpu_clock, gpu_start_ns, std::nullopt, /*suppress_errors=*/true);
+      if (ts.has_value()) {
+        module_context_->PushFtraceEvent(
+            cpu, *ts, TracePacketData{std::move(event), std::move(state)});
+        return;
+      }
+    }
+  }
+
   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

@@ -58,7 +58,8 @@ class FtraceTokenizer {
   void TokenizeFtraceEvent(uint32_t cpu,
                            ClockTracker::ClockId,
                            TraceBlobView event,
-                           RefPtr<PacketSequenceStateGeneration> state);
+                           RefPtr<PacketSequenceStateGeneration> state,
+                           uint32_t packet_sequence_id);
   void TokenizeFtraceCompactSched(uint32_t cpu,
                                   ClockTracker::ClockId,
                                   protozero::ConstBytes);
@@ -109,6 +110,7 @@ class FtraceTokenizer {
   GenericFtraceTracker* generic_tracker_;
 
   int64_t latest_ftrace_clock_snapshot_ts_ = 0;
+  bool adreno_gpu_clock_registered_ = false;
   std::vector<bool> per_cpu_seen_first_bundle_;
 };
 

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: 'adreno_gpu_cmdbatch',
+    topLevelGroup: 'HARDWARE',
+    group: 'GPU Adreno',
+  },
   {
     type: 'triggers',
     topLevelGroup: 'SYSTEM',