From 172676384bfa92c4172a3893d5c710061b8a706e Mon Sep 17 00:00:00 2001
From: William Lai <willlai@google.com>
Date: Wed, 23 Sep 2026 17:06:56 +0800
Subject: [PATCH] tp: Ingest Fuchsia CPU frequency and idle tracks

Fuchsia CPU frequency counters land in generic process counter tracks,
and Fuchsia traces have no CPU idle tracks at all, so they cannot be
inspected with the UI views and SQL queries used for Linux and Android
traces on the same hardware.

Extend the Fuchsia importer to emit CPU frequency and CPU idle data
into the standard cpu_counter_track schema, so the existing UI plugins
and SQL queries work unchanged on Fuchsia traces.

Bug: 372951249

Change-Id: I9796186294ef8707ebd44c332fe79515b6621664
---
 .../importers/fuchsia/fuchsia_trace_parser.cc | 209 ++++++++++++++----
 .../importers/fuchsia/fuchsia_trace_parser.h  |  19 ++
 .../parser/fuchsia/fuchsia_cpu_frequency.py   | 145 ++++++++++++
 .../parser/fuchsia/fuchsia_cpu_idle.py        | 142 ++++++++++++
 .../diff_tests/parser/fuchsia/tests.py        | 121 ++++++++--
 5 files changed, 575 insertions(+), 61 deletions(-)
 create mode 100755 test/trace_processor/diff_tests/parser/fuchsia/fuchsia_cpu_frequency.py
 create mode 100755 test/trace_processor/diff_tests/parser/fuchsia/fuchsia_cpu_idle.py

diff --git a/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.cc b/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.cc
index 5df25c2a57a..bc5ce4c6f10 100644
--- a/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.cc
+++ b/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.cc
@@ -16,6 +16,7 @@
 
 #include "src/trace_processor/importers/fuchsia/fuchsia_trace_parser.h"
 
+#include <cmath>
 #include <cstddef>
 #include <cstdint>
 #include <functional>
@@ -91,6 +92,21 @@ constexpr uint32_t kThreadDead = 5;
 
 constexpr int32_t kIdleWeight = std::numeric_limits<int32_t>::min();
 
+// CPU idle states (matching Linux/Android conventions: 0 is idle, 0xFFFFFFFF is
+// active/exit idle)
+constexpr double kCpuIdleState = 0.0;
+constexpr double kCpuActiveState =
+    static_cast<double>(std::numeric_limits<uint32_t>::max());
+
+// Trace contract for CPU frequency counter events emitted by Fuchsia CPU
+// drivers, aligned with the Linux ftrace "power/cpu_frequency" event: the
+// counter record carries the logical core index in the "cpu" argument and the
+// frequency in kHz in the "value" argument.
+constexpr char kCpuFrequencyCategory[] = "power";
+constexpr char kCpuFrequencyEventName[] = "cpu_frequency";
+constexpr char kCpuFrequencyCpuArg[] = "cpu";
+constexpr char kCpuFrequencyValueArg[] = "value";
+
 constexpr auto kCounterBlueprint = tracks::CounterBlueprint(
     "fuchsia_counter",
     tracks::UnknownUnitBlueprint(),
@@ -98,6 +114,65 @@ constexpr auto kCounterBlueprint = tracks::CounterBlueprint(
                                 tracks::kNameFromTraceDimensionBlueprint),
     tracks::DynamicNameBlueprint());
 
+// Returns the numeric value carried by |value| as a double, or std::nullopt if
+// the argument does not hold a numeric type. Range and finiteness checks are
+// left to the caller.
+std::optional<double> ArgValueToDouble(
+    const fuchsia_trace_utils::ArgValue& value) {
+  switch (value.Type()) {
+    case fuchsia_trace_utils::ArgValue::kInt32:
+      return static_cast<double>(value.Int32());
+    case fuchsia_trace_utils::ArgValue::kUint32:
+      return static_cast<double>(value.Uint32());
+    case fuchsia_trace_utils::ArgValue::kInt64:
+      return static_cast<double>(value.Int64());
+    case fuchsia_trace_utils::ArgValue::kUint64:
+      return static_cast<double>(value.Uint64());
+    case fuchsia_trace_utils::ArgValue::kDouble:
+      return value.Double();
+    case fuchsia_trace_utils::ArgValue::kNull:
+    case fuchsia_trace_utils::ArgValue::kString:
+    case fuchsia_trace_utils::ArgValue::kPointer:
+    case fuchsia_trace_utils::ArgValue::kKoid:
+    case fuchsia_trace_utils::ArgValue::kBool:
+    case fuchsia_trace_utils::ArgValue::kUnknown:
+      return std::nullopt;
+  }
+  PERFETTO_FATAL("For GCC");
+}
+
+// Returns the logical CPU core index carried by |value|, or std::nullopt if the
+// value is not a valid core index. Negative and out of range indices
+// (>= CpuTracker::kMaxCpusPerMachine) are rejected, as are non-integer and
+// non-numeric argument types.
+std::optional<uint32_t> ExtractCpuCoreIndex(
+    const fuchsia_trace_utils::ArgValue& value) {
+  if (value.Type() == fuchsia_trace_utils::ArgValue::kDouble) {
+    return std::nullopt;
+  }
+  // Integers up to 2^53 round-trip exactly through a double, so every value in
+  // the valid core index range is compared and converted without loss below.
+  std::optional<double> core_index = ArgValueToDouble(value);
+  if (!core_index.has_value() || *core_index < 0 ||
+      *core_index >= CpuTracker::kMaxCpusPerMachine) {
+    return std::nullopt;
+  }
+  return static_cast<uint32_t>(*core_index);
+}
+
+// Returns the frequency in kHz carried by |value|, or std::nullopt if the
+// value is not a valid frequency. Negative and non-finite (NaN, infinity)
+// frequencies are rejected, as are non-numeric argument types.
+std::optional<double> ExtractFrequencyKhz(
+    const fuchsia_trace_utils::ArgValue& value) {
+  std::optional<double> frequency_khz = ArgValueToDouble(value);
+  if (!frequency_khz.has_value() || !std::isfinite(*frequency_khz) ||
+      *frequency_khz < 0) {
+    return std::nullopt;
+  }
+  return frequency_khz;
+}
+
 }  // namespace
 
 FuchsiaTraceParser::FuchsiaTraceParser(TraceProcessorContext* context)
@@ -106,6 +181,14 @@ FuchsiaTraceParser::FuchsiaTraceParser(TraceProcessorContext* context)
       waker_id_(context->storage->InternString("waker")),
       incoming_weight_id_(context->storage->InternString("incoming_weight")),
       outgoing_weight_id_(context->storage->InternString("outgoing_weight")),
+      cpu_frequency_category_id_(
+          context->storage->InternString(kCpuFrequencyCategory)),
+      cpu_frequency_name_id_(
+          context->storage->InternString(kCpuFrequencyEventName)),
+      cpu_frequency_cpu_arg_id_(
+          context->storage->InternString(kCpuFrequencyCpuArg)),
+      cpu_frequency_value_arg_id_(
+          context->storage->InternString(kCpuFrequencyValueArg)),
       running_string_id_(context->storage->InternString("Running")),
       runnable_string_id_(context->storage->InternString("R")),
       waking_string_id_(context->storage->InternString("W")),
@@ -329,69 +412,50 @@ void FuchsiaTraceParser::Parse(int64_t, FuchsiaRecord fr) {
           break;
         }
         case kCounter: {
-          UniquePid upid =
-              procs->GetOrCreateProcess(static_cast<uint32_t>(tinfo.pid));
-          std::string name_str =
-              context_->storage->GetString(name).ToStdString();
           uint64_t counter_id;
           if (!cursor.ReadUint64(&counter_id)) {
             context_->stats_tracker->IncrementStats(
                 stats::fuchsia_record_read_error);
             return;
           }
+
+          // CPU frequency counters go to the standard per-core cpufreq tracks
+          // instead of to a generic process counter track.
+          if (cat == cpu_frequency_category_id_ &&
+              name == cpu_frequency_name_id_) {
+            ParseCpuFrequencyCounter(ts, *maybe_args);
+            break;
+          }
+
+          UniquePid upid =
+              procs->GetOrCreateProcess(static_cast<uint32_t>(tinfo.pid));
+          std::string name_str =
+              context_->storage->GetString(name).ToStdString();
+
           // Note: In the Fuchsia trace format, counter values are stored
           // in the arguments for the record, with the data series defined
           // by both the record name and the argument name. In Perfetto,
           // counters only have one name, so we combine both names into
           // one here.
           for (const Arg& arg : *maybe_args) {
+            std::optional<double> counter_value = ArgValueToDouble(arg.value);
+            if (!counter_value.has_value()) {
+              context_->stats_tracker->IncrementStats(
+                  stats::fuchsia_non_numeric_counters);
+              continue;
+            }
             std::string counter_name_str = name_str + ":";
             counter_name_str +=
                 context_->storage->GetString(arg.name).ToStdString();
             counter_name_str += ":" + std::to_string(counter_id);
-            bool is_valid_value = false;
-            double counter_value = -1;
-            switch (arg.value.Type()) {
-              case fuchsia_trace_utils::ArgValue::kInt32:
-                is_valid_value = true;
-                counter_value = static_cast<double>(arg.value.Int32());
-                break;
-              case fuchsia_trace_utils::ArgValue::kUint32:
-                is_valid_value = true;
-                counter_value = static_cast<double>(arg.value.Uint32());
-                break;
-              case fuchsia_trace_utils::ArgValue::kInt64:
-                is_valid_value = true;
-                counter_value = static_cast<double>(arg.value.Int64());
-                break;
-              case fuchsia_trace_utils::ArgValue::kUint64:
-                is_valid_value = true;
-                counter_value = static_cast<double>(arg.value.Uint64());
-                break;
-              case fuchsia_trace_utils::ArgValue::kDouble:
-                is_valid_value = true;
-                counter_value = arg.value.Double();
-                break;
-              case fuchsia_trace_utils::ArgValue::kNull:
-              case fuchsia_trace_utils::ArgValue::kString:
-              case fuchsia_trace_utils::ArgValue::kPointer:
-              case fuchsia_trace_utils::ArgValue::kKoid:
-              case fuchsia_trace_utils::ArgValue::kBool:
-              case fuchsia_trace_utils::ArgValue::kUnknown:
-                context_->stats_tracker->IncrementStats(
-                    stats::fuchsia_non_numeric_counters);
-                break;
-            }
-            if (is_valid_value) {
-              base::StringView counter_name_str_view(counter_name_str);
-              StringId counter_name_id =
-                  context_->storage->InternString(counter_name_str_view);
-              TrackId track = context_->track_tracker->InternTrack(
-                  kCounterBlueprint,
-                  tracks::Dimensions(upid, counter_name_str_view),
-                  tracks::DynamicName(counter_name_id));
-              context_->event_tracker->PushCounter(ts, counter_value, track);
-            }
+            base::StringView counter_name_str_view(counter_name_str);
+            StringId counter_name_id =
+                context_->storage->InternString(counter_name_str_view);
+            TrackId track = context_->track_tracker->InternTrack(
+                kCounterBlueprint,
+                tracks::Dimensions(upid, counter_name_str_view),
+                tracks::DynamicName(counter_name_id));
+            context_->event_tracker->PushCounter(ts, *counter_value, track);
           }
           break;
         }
@@ -614,6 +678,9 @@ void FuchsiaTraceParser::Parse(int64_t, FuchsiaRecord fr) {
           if (!incoming_is_idle) {
             SwitchTo(&incoming_thread, ts, cpu, incoming_priority);
           }
+
+          MaybePushCpuIdleTransition(ts, cpu, outgoing_is_idle,
+                                     incoming_is_idle);
           break;
         }
         case kSchedulerEventContextSwitch: {
@@ -695,6 +762,9 @@ void FuchsiaTraceParser::Parse(int64_t, FuchsiaRecord fr) {
           if (!incoming_is_idle) {
             SwitchTo(&incoming_thread, ts, cpu, incoming_weight);
           }
+
+          MaybePushCpuIdleTransition(ts, cpu, outgoing_is_idle,
+                                     incoming_is_idle);
           break;
         }
         case kSchedulerEventThreadWakeup: {
@@ -922,6 +992,51 @@ void FuchsiaTraceParser::Wake(Thread* thread,
   thread->last_state_row = state_row_number;
 }
 
+void FuchsiaTraceParser::ParseCpuFrequencyCounter(
+    int64_t ts,
+    const std::vector<Arg>& args) {
+  std::optional<uint32_t> cpu;
+  std::optional<double> frequency_khz;
+  // A record which repeats "cpu" or "value", or which carries an unusable core
+  // index or frequency, does not honour the contract and is dropped whole.
+  bool is_valid_event = true;
+  for (const Arg& arg : args) {
+    if (arg.name == cpu_frequency_cpu_arg_id_) {
+      is_valid_event = is_valid_event && !cpu.has_value();
+      cpu = ExtractCpuCoreIndex(arg.value);
+      is_valid_event = is_valid_event && cpu.has_value();
+    } else if (arg.name == cpu_frequency_value_arg_id_) {
+      is_valid_event = is_valid_event && !frequency_khz.has_value();
+      frequency_khz = ExtractFrequencyKhz(arg.value);
+      is_valid_event = is_valid_event && frequency_khz.has_value();
+    }
+  }
+
+  if (!is_valid_event || !cpu.has_value() || !frequency_khz.has_value()) {
+    context_->stats_tracker->IncrementStats(stats::fuchsia_invalid_event);
+    return;
+  }
+
+  context_->cpu_tracker->GetOrCreateCpu(*cpu);
+  TrackId track = context_->track_tracker->InternTrack(
+      tracks::kCpuFrequencyBlueprint, tracks::Dimensions(*cpu));
+  context_->event_tracker->PushCounter(ts, *frequency_khz, track);
+}
+
+void FuchsiaTraceParser::MaybePushCpuIdleTransition(int64_t ts,
+                                                    uint32_t cpu,
+                                                    bool outgoing_is_idle,
+                                                    bool incoming_is_idle) {
+  if (outgoing_is_idle == incoming_is_idle) {
+    return;
+  }
+  context_->cpu_tracker->GetOrCreateCpu(cpu);
+  TrackId idle_track = context_->track_tracker->InternTrack(
+      tracks::kCpuIdleBlueprint, tracks::Dimensions(cpu));
+  double value = incoming_is_idle ? kCpuIdleState : kCpuActiveState;
+  context_->event_tracker->PushCounter(ts, value, idle_track);
+}
+
 StringId FuchsiaTraceParser::IdForOutgoingThreadState(uint32_t state) {
   switch (state) {
     case kThreadNew:
diff --git a/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.h b/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.h
index f75241ff90c..84d93aa7090 100644
--- a/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.h
+++ b/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.h
@@ -91,6 +91,19 @@ class FuchsiaTraceParser
             uint32_t cpu,
             std::optional<UniqueTid> waker_utid = std::nullopt,
             std::optional<uint64_t> waker_tid = std::nullopt);
+  // Routes a "power" / "cpu_frequency" counter record to the per-core cpufreq
+  // track named by its "cpu" argument, using the kHz frequency carried in its
+  // "value" argument. Records violating that contract are dropped and counted
+  // in stats::fuchsia_invalid_event.
+  void ParseCpuFrequencyCounter(int64_t ts, const std::vector<Arg>& args);
+  // Synthesizes a CPU idle counter event for the given CPU core matching
+  // Linux/Android cpuidle conventions: entering idle pushes the idle state,
+  // leaving idle pushes the exit-idle active state. Context switches which do
+  // not change the idle state of the core push nothing.
+  void MaybePushCpuIdleTransition(int64_t ts,
+                                  uint32_t cpu,
+                                  bool outgoing_is_idle,
+                                  bool incoming_is_idle);
 
   StringId IdForOutgoingThreadState(uint32_t state);
 
@@ -102,6 +115,12 @@ class FuchsiaTraceParser
   const StringId incoming_weight_id_;
   const StringId outgoing_weight_id_;
 
+  // Interned string ids for the CPU frequency counter trace contract.
+  const StringId cpu_frequency_category_id_;
+  const StringId cpu_frequency_name_id_;
+  const StringId cpu_frequency_cpu_arg_id_;
+  const StringId cpu_frequency_value_arg_id_;
+
   // Interned string ids for the relevant thread states.
   const StringId running_string_id_;
   const StringId runnable_string_id_;
diff --git a/test/trace_processor/diff_tests/parser/fuchsia/fuchsia_cpu_frequency.py b/test/trace_processor/diff_tests/parser/fuchsia/fuchsia_cpu_frequency.py
new file mode 100755
index 00000000000..00e0b76ed72
--- /dev/null
+++ b/test/trace_processor/diff_tests/parser/fuchsia/fuchsia_cpu_frequency.py
@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+# Copyright 2026 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# Emits a Fuchsia trace holding "power" / "cpu_frequency" counter records, both
+# well formed ones and ones violating the trace contract.
+
+import math
+import struct
+import sys
+
+# String indices interned below.
+POWER = 1
+CPU_FREQUENCY = 2
+CPU = 3
+VALUE = 4
+CLUSTER = 5
+NOT_A_NUMBER = 6
+
+
+def push_word(w):
+  sys.stdout.buffer.write(struct.pack('<Q', w))
+
+
+def push_string(index, s):
+  s_bytes = s.encode('utf-8')
+  s_len = len(s_bytes)
+  num_words = 1 + (s_len + 7) // 8
+  header = (s_len << 32) | (index << 16) | (num_words << 4) | 2
+  push_word(header)
+  padded = s_bytes.ljust((num_words - 1) * 8, b'\x00')
+  for i in range(0, len(padded), 8):
+    push_word(struct.unpack('<Q', padded[i:i + 8])[0])
+
+
+# Argument builders. Each returns the words encoding one record argument.
+def int32_arg(name_ref, value):
+  return [((value & 0xffffffff) << 32) | (name_ref << 16) | (1 << 4) | 1]
+
+
+def uint32_arg(name_ref, value):
+  return [(value << 32) | (name_ref << 16) | (1 << 4) | 2]
+
+
+def int64_arg(name_ref, value):
+  return [(name_ref << 16) | (2 << 4) | 3, value & 0xffffffffffffffff]
+
+
+def uint64_arg(name_ref, value):
+  return [(name_ref << 16) | (2 << 4) | 4, value]
+
+
+def double_arg(name_ref, value):
+  bits = struct.unpack('<Q', struct.pack('<d', value))[0]
+  return [(name_ref << 16) | (2 << 4) | 5, bits]
+
+
+def string_arg(name_ref, value_ref):
+  return [(value_ref << 32) | (name_ref << 16) | (1 << 4) | 6]
+
+
+def push_counter_event(ts, args, counter_id=0):
+  arg_words = [w for arg in args for w in arg]
+  # Words: header, timestamp, arguments and counter id.
+  num_words = 3 + len(arg_words)
+  # record_type = 4 (event), event_type = 1 (counter), thread_ref = 1.
+  header = (CPU_FREQUENCY << 48) | (POWER << 32) | (1 << 24) | (
+      len(args) << 20) | (1 << 16) | (num_words << 4) | 4
+  push_word(header)
+  push_word(ts)
+  for word in arg_words:
+    push_word(word)
+  push_word(counter_id)
+
+
+def main():
+  # Fuchsia trace magic word: 0x0016547846040010
+  sys.stdout.buffer.write(b'\x10\x00\x04\x46\x78\x54\x16\x00')
+
+  push_string(POWER, 'power')
+  push_string(CPU_FREQUENCY, 'cpu_frequency')
+  push_string(CPU, 'cpu')
+  push_string(VALUE, 'value')
+  push_string(CLUSTER, 'cluster')
+  push_string(NOT_A_NUMBER, 'not_a_number')
+
+  # Thread record: pid=100, tid=200.
+  push_word((1 << 16) | (3 << 4) | 3)
+  push_word(100)
+  push_word(200)
+
+  # Frequencies emitted as integers are ingested as kHz.
+  push_counter_event(
+      1000, [uint32_arg(CPU, 0), uint64_arg(VALUE, 1996800)], counter_id=0)
+  push_counter_event(
+      2000, [uint32_arg(CPU, 3), uint64_arg(VALUE, 2688000)], counter_id=3)
+  # CPU 0 DVFS transition.
+  push_counter_event(
+      3000, [uint32_arg(CPU, 0), uint64_arg(VALUE, 1190400)], counter_id=0)
+
+  # Arguments beyond "cpu" and "value" are not part of the contract and are
+  # ignored rather than rejected.
+  push_counter_event(
+      4000,
+      [uint32_arg(CPU, 5),
+       uint32_arg(CLUSTER, 1),
+       uint64_arg(VALUE, 2800000)],
+      counter_id=5)
+
+  # Frequencies emitted as finite, non-negative doubles are also ingested.
+  push_counter_event(
+      5000,
+      [uint32_arg(CPU, 4), double_arg(VALUE, 1804800.0)], counter_id=4)
+
+  # Negative, non-finite, non-numeric and ambiguous records violate the
+  # contract: they are dropped and counted in the fuchsia_invalid_event stat, so
+  # no track is created for CPUs 1, 2, 6, 7 and 8.
+  push_counter_event(6000, [uint32_arg(CPU, 1), int32_arg(VALUE, -500)])
+  push_counter_event(7000, [uint32_arg(CPU, 2), int64_arg(VALUE, -1000)])
+  push_counter_event(8000, [uint32_arg(CPU, 6), double_arg(VALUE, math.nan)])
+  push_counter_event(9000, [uint32_arg(CPU, 6), double_arg(VALUE, math.inf)])
+  push_counter_event(10000, [uint32_arg(CPU, 6), double_arg(VALUE, -1500.0)])
+  # A frequency which is not a number at all.
+  push_counter_event(
+      11000,
+      [uint32_arg(CPU, 7), string_arg(VALUE, NOT_A_NUMBER)])
+  # Repeating "value" leaves the frequency ambiguous.
+  push_counter_event(12000, [
+      uint32_arg(CPU, 7),
+      uint64_arg(VALUE, 1000000),
+      uint64_arg(VALUE, 2000000)
+  ])
+  # A record without a "cpu" argument names no core.
+  push_counter_event(13000, [uint64_arg(VALUE, 1000000)])
+  # Core indices are integers in the [0, kMaxCpusPerMachine) range.
+  push_counter_event(14000, [double_arg(CPU, 8.0), uint64_arg(VALUE, 1000000)])
+  push_counter_event(14500, [uint32_arg(CPU, 4096), uint64_arg(VALUE, 1000000)])
+  push_counter_event(15000,
+                     [uint64_arg(CPU, 2**32),
+                      uint64_arg(VALUE, 1000000)])
+
+
+if __name__ == '__main__':
+  main()
diff --git a/test/trace_processor/diff_tests/parser/fuchsia/fuchsia_cpu_idle.py b/test/trace_processor/diff_tests/parser/fuchsia/fuchsia_cpu_idle.py
new file mode 100755
index 00000000000..2d327c08111
--- /dev/null
+++ b/test/trace_processor/diff_tests/parser/fuchsia/fuchsia_cpu_idle.py
@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# Copyright 2026 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# Emits a Fuchsia trace holding kernel:sched context switches to and from the
+# idle thread, in both the weighted and the legacy encoding.
+
+import struct
+import sys
+from typing import NamedTuple
+
+# String indices interned below.
+INCOMING_WEIGHT = 1
+OUTGOING_WEIGHT = 2
+
+# Weight identifying the idle thread in weighted context switches.
+IDLE_WEIGHT = -2**31
+
+WEIGHTED_CPU = 2
+LEGACY_CPU = 5
+
+
+class WeightedThread(NamedTuple):
+  tid: int
+  weight: int
+
+
+class LegacyThread(NamedTuple):
+  pid: int
+  tid: int
+  priority: int
+
+
+IDLE_WEIGHTED_THREAD = WeightedThread(tid=0, weight=IDLE_WEIGHT)
+IDLE_LEGACY_THREAD = LegacyThread(pid=0, tid=0, priority=0)
+
+
+def push_word(w):
+  sys.stdout.buffer.write(struct.pack('<Q', w))
+
+
+def push_string(index, s):
+  s_bytes = s.encode('utf-8')
+  s_len = len(s_bytes)
+  num_words = 1 + (s_len + 7) // 8
+  header = (s_len << 32) | (index << 16) | (num_words << 4) | 2
+  push_word(header)
+  padded = s_bytes.ljust((num_words - 1) * 8, b'\x00')
+  for i in range(0, len(padded), 8):
+    push_word(struct.unpack('<Q', padded[i:i + 8])[0])
+
+
+def int32_arg(name_ref, value):
+  return ((value & 0xffffffff) << 32) | (name_ref << 16) | (1 << 4) | 1
+
+
+def push_context_switch(ts, cpu, outgoing: WeightedThread,
+                        incoming: WeightedThread):
+  # record_type = 8 (scheduler), event_type = 1 (context switch),
+  # outgoing_state = 2, argument_count = 2, 6 words.
+  push_word((1 << 60) | (2 << 36) | (cpu << 20) | (2 << 16) | (6 << 4) | 8)
+  push_word(ts)
+  push_word(outgoing.tid)
+  push_word(incoming.tid)
+  push_word(int32_arg(INCOMING_WEIGHT, incoming.weight))
+  push_word(int32_arg(OUTGOING_WEIGHT, outgoing.weight))
+
+
+def push_legacy_context_switch(ts, cpu, outgoing: LegacyThread,
+                               incoming: LegacyThread):
+  # record_type = 8 (scheduler), event_type = 0 (legacy context switch),
+  # outgoing_state = 2, inline thread refs, 6 words.
+  push_word((0 << 60) | (incoming.priority << 52) | (outgoing.priority << 44)
+            | (2 << 24) | (cpu << 16) | (6 << 4) | 8)
+  push_word(ts)
+  push_word(outgoing.pid)
+  push_word(outgoing.tid)
+  push_word(incoming.pid)
+  push_word(incoming.tid)
+
+
+def main():
+  # Fuchsia trace magic word: 0x0016547846040010
+  sys.stdout.buffer.write(b'\x10\x00\x04\x46\x78\x54\x16\x00')
+
+  push_string(INCOMING_WEIGHT, 'incoming_weight')
+  push_string(OUTGOING_WEIGHT, 'outgoing_weight')
+
+  # Weighted context switches: the idle thread carries the idle weight.
+  # Leaving idle marks the core active.
+  push_context_switch(
+      1000,
+      WEIGHTED_CPU,
+      outgoing=IDLE_WEIGHTED_THREAD,
+      incoming=WeightedThread(tid=101, weight=0))
+  # Switching between two running threads leaves the idle state untouched.
+  push_context_switch(
+      2000,
+      WEIGHTED_CPU,
+      outgoing=WeightedThread(tid=101, weight=0),
+      incoming=WeightedThread(tid=102, weight=10))
+  # Entering idle marks the core idle.
+  push_context_switch(
+      3000,
+      WEIGHTED_CPU,
+      outgoing=WeightedThread(tid=102, weight=10),
+      incoming=IDLE_WEIGHTED_THREAD)
+  # Switching from idle to idle emits nothing.
+  push_context_switch(
+      3500,
+      WEIGHTED_CPU,
+      outgoing=IDLE_WEIGHTED_THREAD,
+      incoming=IDLE_WEIGHTED_THREAD)
+
+  # Legacy context switches: the idle thread is identified by pid 0 and
+  # priority 0.
+  push_legacy_context_switch(
+      4000,
+      LEGACY_CPU,
+      outgoing=IDLE_LEGACY_THREAD,
+      incoming=LegacyThread(pid=1, tid=501, priority=1))
+  # Switching between two running threads leaves the idle state untouched.
+  push_legacy_context_switch(
+      4500,
+      LEGACY_CPU,
+      outgoing=LegacyThread(pid=1, tid=501, priority=1),
+      incoming=LegacyThread(pid=1, tid=502, priority=1))
+  push_legacy_context_switch(
+      5000,
+      LEGACY_CPU,
+      outgoing=LegacyThread(pid=1, tid=502, priority=1),
+      incoming=IDLE_LEGACY_THREAD)
+  push_legacy_context_switch(
+      5500,
+      LEGACY_CPU,
+      outgoing=IDLE_LEGACY_THREAD,
+      incoming=IDLE_LEGACY_THREAD)
+
+
+if __name__ == '__main__':
+  main()
diff --git a/test/trace_processor/diff_tests/parser/fuchsia/tests.py b/test/trace_processor/diff_tests/parser/fuchsia/tests.py
index 749e89d9a3c..d2880bff5de 100644
--- a/test/trace_processor/diff_tests/parser/fuchsia/tests.py
+++ b/test/trace_processor/diff_tests/parser/fuchsia/tests.py
@@ -133,6 +133,7 @@ def test_fuchsia_smoke_counters(self):
           value,
           name
         FROM counters
+        WHERE name = 'cpu_usage:average_cpu_percentage:0'
         LIMIT 10;
         """,
         out=Csv("""
@@ -174,23 +175,18 @@ def test_fuchsia_smoke_type(self):
         trace=DataPath('fuchsia_trace.fxt'),
         query="""
         SELECT
-          id,
-          name
+          type,
+          name,
+          count(*) AS count
         FROM track
-        LIMIT 10;
+        GROUP BY type, name
+        ORDER BY type, name;
         """,
         out=Csv("""
-        "id","name"
-        0,"[NULL]"
-        1,"[NULL]"
-        2,"[NULL]"
-        3,"[NULL]"
-        4,"[NULL]"
-        5,"cpu_usage:average_cpu_percentage:0"
-        6,"[NULL]"
-        7,"[NULL]"
-        8,"[NULL]"
-        9,"[NULL]"
+        "type","name","count"
+        "cpu_idle","cpuidle",4
+        "fuchsia_counter","cpu_usage:average_cpu_percentage:0",1
+        "thread_execution","[NULL]",16
         """))
 
   # Smoke test a high-CPU trace.
@@ -291,3 +287,100 @@ def test_fuchsia_critical_path(self):
         trace=DataPath('fuchsia_trace_sched_with_waker.fxt'),
         query=Path('fuchsia_critical_path.sql'),
         out=Path('fuchsia_critical_path.out'))
+
+  # Every core emitting a valid "power" / "cpu_frequency" event gets a standard
+  # cpufreq track. Cores 1, 2 and 6 only emit events violating the contract, so
+  # they get no track.
+  def test_fuchsia_cpu_frequency_tracks(self):
+    return DiffTestBlueprint(
+        trace=Path('fuchsia_cpu_frequency.py'),
+        query="""
+        SELECT cpu, name, type
+        FROM cpu_counter_track
+        WHERE type = 'cpu_frequency'
+        ORDER BY cpu;
+        """,
+        out=Csv("""
+        "cpu","name","type"
+        0,"cpufreq","cpu_frequency"
+        3,"cpufreq","cpu_frequency"
+        4,"cpufreq","cpu_frequency"
+        5,"cpufreq","cpu_frequency"
+        """))
+
+  # The counters on a cpufreq track carry the emitted kHz values, whether the
+  # driver encoded them as an integer or as a double.
+  def test_fuchsia_cpu_frequency_counter_values(self):
+    return DiffTestBlueprint(
+        trace=Path('fuchsia_cpu_frequency.py'),
+        query="""
+        SELECT t.cpu, c.ts, c.value
+        FROM counter AS c
+        JOIN cpu_counter_track AS t ON c.track_id = t.id
+        WHERE t.type = 'cpu_frequency'
+        ORDER BY t.cpu, c.ts;
+        """,
+        out=Csv("""
+        "cpu","ts","value"
+        0,1000,1996800.000000
+        0,3000,1190400.000000
+        3,2000,2688000.000000
+        4,5000,1804800.000000
+        5,4000,2800000.000000
+        """))
+
+  # Frequencies which are negative, non-finite or not numbers, and records
+  # naming no core, an out of range core or repeating an argument, are dropped
+  # and counted rather than silently disappearing.
+  def test_fuchsia_cpu_frequency_invalid_events(self):
+    return DiffTestBlueprint(
+        trace=Path('fuchsia_cpu_frequency.py'),
+        query="""
+        SELECT name, value
+        FROM stats
+        WHERE name = 'fuchsia_invalid_event';
+        """,
+        out=Csv("""
+        "name","value"
+        "fuchsia_invalid_event",11
+        """))
+
+  # Every core context-switching to and from the idle thread gets a standard
+  # cpuidle track.
+  def test_fuchsia_cpu_idle_tracks(self):
+    return DiffTestBlueprint(
+        trace=DataPath('fuchsia_trace_sched.fxt'),
+        query="""
+        SELECT cpu, name, type
+        FROM cpu_counter_track
+        WHERE type = 'cpu_idle'
+        ORDER BY cpu;
+        """,
+        out=Csv("""
+        "cpu","name","type"
+        0,"cpuidle","cpu_idle"
+        1,"cpuidle","cpu_idle"
+        2,"cpuidle","cpu_idle"
+        3,"cpuidle","cpu_idle"
+        """))
+
+  # Entering idle pushes 0 and leaving idle pushes 0xFFFFFFFF, for both the
+  # weighted (CPU 2) and the legacy (CPU 5) context switch encoding. Switches
+  # which do not change the idle state of the core push nothing.
+  def test_fuchsia_cpu_idle_counter_values(self):
+    return DiffTestBlueprint(
+        trace=Path('fuchsia_cpu_idle.py'),
+        query="""
+        SELECT t.cpu, c.ts, c.value
+        FROM counter AS c
+        JOIN cpu_counter_track AS t ON c.track_id = t.id
+        WHERE t.type = 'cpu_idle'
+        ORDER BY t.cpu, c.ts;
+        """,
+        out=Csv("""
+        "cpu","ts","value"
+        2,1000,4294967295.000000
+        2,3000,0.000000
+        5,4000,4294967295.000000
+        5,5000,0.000000
+        """))