Update perfetto to 249090360a31856f2a5022f52abfb8dc54f69a0b
Also moves protos to prebuilts dir to keep in sync, since we need new
protos
Change-Id: I1d8863b60d1df05fcdcce2a0f8f3276dec19d40c
diff --git a/generate_perfetto_binaries.py b/generate_perfetto_binaries.py
index aedf9f8..b55243f 100755
--- a/generate_perfetto_binaries.py
+++ b/generate_perfetto_binaries.py
@@ -37,12 +37,20 @@
# List of each arch, with a tuple of:
# - perfetto-name (arg in perfetto build)
# - android-tag (used in final output path, used for binary disambig at apk build time)
-# - associated ndk subdir for stripping (This includes a %s for host OS)
ARCH_LIST = (
- ('arm', 'arm', 'arm-%s-androideabi'),
- ('arm64', 'aarch64', 'aarch64-%s-android'),
- ('x64', 'x86_64', 'x86_64-%s-android'),
- ('x86', 'x86', 'x86_64-%s-android'),
+ ('arm', 'arm'),
+ ('arm64', 'aarch64'),
+ ('x64', 'x86_64'),
+ ('x86', 'x86'), # Broken, see b/328101283
+)
+
+# List of each proto to copy / check in. As imports in the top level
+# protos are changed, this list will need to be updated.
+PROTO_LIST = (
+ 'protos/perfetto/trace_processor/trace_processor.proto',
+ 'protos/perfetto/common/descriptor.proto',
+ 'protos/perfetto/metrics/perfetto_merged_metrics.proto',
+ 'protos/perfetto/trace_processor/metatrace_categories.proto',
)
ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
@@ -60,7 +68,24 @@
gn = os.path.join(perfetto_dir, 'tools', 'gn')
- for arch, arch_tag, ndk_dir_pattern in ARCH_LIST: #ARCH_TABLE.items():
+ ### Protos
+ print('\n\033[32mCopying Protos\033[0m')
+ # use root as proto dir, as all protos have 'protos' prefix, so will be in protos dir
+ out_proto_dir = ROOT_DIR
+ # cleanup old protos
+ subprocess.check_call(['rm', '-rf', 'protos'], cwd=ROOT_DIR)
+ for src_path in PROTO_LIST:
+ print(src_path)
+ split_path_in_repo = src_path.split('/')
+ src = os.path.join(perfetto_dir, *split_path_in_repo)
+ dst = os.path.join(out_proto_dir, *split_path_in_repo)
+
+ # Preserve tree when copying to support import paths
+ os.makedirs(os.path.dirname(dst), exist_ok=True)
+ copyfile(src, dst)
+
+ ### Binaries
+ for arch, arch_tag in ARCH_LIST:
config_name ='android_%s' % (arch)
gn_args = ANDROID_ARGS + ('target_cpu="%s"' % arch,)
@@ -100,9 +125,8 @@
"llvm",
"prebuilt",
platform_folder,
- ndk_dir_pattern % ("linux"), # TODO: support macos
"bin",
- "strip")
+ "llvm-strip")
subprocess.check_call((strip_path, out_file))
if __name__ == '__main__':
diff --git a/protos/perfetto/common/descriptor.proto b/protos/perfetto/common/descriptor.proto
new file mode 100644
index 0000000..6684a70
--- /dev/null
+++ b/protos/perfetto/common/descriptor.proto
@@ -0,0 +1,238 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This is a subset of descriptor.proto from the Protobuf library.
+syntax = "proto2";
+
+package perfetto.protos;
+
+// The protocol compiler can output a FileDescriptorSet containing the .proto
+// files it parses.
+message FileDescriptorSet {
+ repeated FileDescriptorProto file = 1;
+}
+
+// Describes a complete .proto file.
+message FileDescriptorProto {
+ // file name, relative to root of source tree
+ optional string name = 1;
+ // e.g. "foo", "foo.bar", etc.
+ optional string package = 2;
+
+ // Names of files imported by this file.
+ repeated string dependency = 3;
+ // Indexes of the public imported files in the dependency list above.
+ repeated int32 public_dependency = 10;
+ // Indexes of the weak imported files in the dependency list.
+ // For Google-internal migration only. Do not use.
+ repeated int32 weak_dependency = 11;
+
+ // All top-level definitions in this file.
+ repeated DescriptorProto message_type = 4;
+ repeated EnumDescriptorProto enum_type = 5;
+ repeated FieldDescriptorProto extension = 7;
+
+ reserved 6;
+ reserved 8;
+ reserved 9;
+ reserved 12;
+}
+
+// Describes a message type.
+message DescriptorProto {
+ optional string name = 1;
+
+ repeated FieldDescriptorProto field = 2;
+ repeated FieldDescriptorProto extension = 6;
+
+ repeated DescriptorProto nested_type = 3;
+ repeated EnumDescriptorProto enum_type = 4;
+
+ reserved 5;
+
+ repeated OneofDescriptorProto oneof_decl = 8;
+
+ reserved 7;
+
+ // Range of reserved tag numbers. Reserved tag numbers may not be used by
+ // fields or extension ranges in the same message. Reserved ranges may
+ // not overlap.
+ message ReservedRange {
+ // Inclusive.
+ optional int32 start = 1;
+ // Exclusive.
+ optional int32 end = 2;
+ }
+ repeated ReservedRange reserved_range = 9;
+ // Reserved field names, which may not be used by fields in the same message.
+ // A given name may only be reserved once.
+ repeated string reserved_name = 10;
+}
+
+// A message representing a option the parser does not recognize. This only
+// appears in options protos created by the compiler::Parser class.
+// DescriptorPool resolves these when building Descriptor objects. Therefore,
+// options protos in descriptor objects (e.g. returned by Descriptor::options(),
+// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
+// in them.
+message UninterpretedOption {
+ // The name of the uninterpreted option. Each string represents a segment in
+ // a dot-separated name. is_extension is true iff a segment represents an
+ // extension (denoted with parentheses in options specs in .proto files).
+ // E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents
+ // "foo.(bar.baz).moo".
+ message NamePart {
+ optional string name_part = 1;
+ optional bool is_extension = 2;
+ }
+ repeated NamePart name = 2;
+
+ // The value of the uninterpreted option, in whatever type the tokenizer
+ // identified it as during parsing. Exactly one of these should be set.
+ optional string identifier_value = 3;
+ optional uint64 positive_int_value = 4;
+ optional int64 negative_int_value = 5;
+ optional double double_value = 6;
+ optional bytes string_value = 7;
+ optional string aggregate_value = 8;
+}
+
+message FieldOptions {
+ // The packed option can be enabled for repeated primitive fields to enable
+ // a more efficient representation on the wire. Rather than repeatedly
+ // writing the tag and type for each element, the entire array is encoded as
+ // a single length-delimited blob. In proto3, only explicit setting it to
+ // false will avoid using packed encoding.
+ optional bool packed = 2;
+
+ // The parser stores options it doesn't recognize here. See above.
+ repeated UninterpretedOption uninterpreted_option = 999;
+}
+
+// Describes a field within a message.
+message FieldDescriptorProto {
+ enum Type {
+ // 0 is reserved for errors.
+ // Order is weird for historical reasons.
+ TYPE_DOUBLE = 1;
+ TYPE_FLOAT = 2;
+ // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if
+ // negative values are likely.
+ TYPE_INT64 = 3;
+ TYPE_UINT64 = 4;
+ // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if
+ // negative values are likely.
+ TYPE_INT32 = 5;
+ TYPE_FIXED64 = 6;
+ TYPE_FIXED32 = 7;
+ TYPE_BOOL = 8;
+ TYPE_STRING = 9;
+ // Tag-delimited aggregate.
+ // Group type is deprecated and not supported in proto3. However, Proto3
+ // implementations should still be able to parse the group wire format and
+ // treat group fields as unknown fields.
+ TYPE_GROUP = 10;
+ // Length-delimited aggregate.
+ TYPE_MESSAGE = 11;
+
+ // New in version 2.
+ TYPE_BYTES = 12;
+ TYPE_UINT32 = 13;
+ TYPE_ENUM = 14;
+ TYPE_SFIXED32 = 15;
+ TYPE_SFIXED64 = 16;
+ // Uses ZigZag encoding.
+ TYPE_SINT32 = 17;
+ // Uses ZigZag encoding.
+ TYPE_SINT64 = 18;
+ };
+
+ enum Label {
+ // 0 is reserved for errors
+ LABEL_OPTIONAL = 1;
+ LABEL_REQUIRED = 2;
+ LABEL_REPEATED = 3;
+ };
+
+ optional string name = 1;
+ optional int32 number = 3;
+ optional Label label = 4;
+
+ // If type_name is set, this need not be set. If both this and type_name
+ // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
+ optional Type type = 5;
+
+ // For message and enum types, this is the name of the type. If the name
+ // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping
+ // rules are used to find the type (i.e. first the nested types within this
+ // message are searched, then within the parent, on up to the root
+ // namespace).
+ optional string type_name = 6;
+
+ // For extensions, this is the name of the type being extended. It is
+ // resolved in the same manner as type_name.
+ optional string extendee = 2;
+
+ // For numeric types, contains the original text representation of the value.
+ // For booleans, "true" or "false".
+ // For strings, contains the default text contents (not escaped in any way).
+ // For bytes, contains the C escaped value. All bytes >= 128 are escaped.
+ // TODO(kenton): Base-64 encode?
+ optional string default_value = 7;
+
+ optional FieldOptions options = 8;
+
+ // If set, gives the index of a oneof in the containing type's oneof_decl
+ // list. This field is a member of that oneof.
+ optional int32 oneof_index = 9;
+
+ reserved 10;
+}
+
+// Describes a oneof.
+message OneofDescriptorProto {
+ optional string name = 1;
+ optional OneofOptions options = 2;
+}
+
+// Describes an enum type.
+message EnumDescriptorProto {
+ optional string name = 1;
+
+ repeated EnumValueDescriptorProto value = 2;
+
+ reserved 3;
+ reserved 4;
+
+ // Reserved enum value names, which may not be reused. A given name may only
+ // be reserved once.
+ repeated string reserved_name = 5;
+}
+
+// Describes a value within an enum.
+message EnumValueDescriptorProto {
+ optional string name = 1;
+ optional int32 number = 2;
+
+ reserved 3;
+}
+
+message OneofOptions {
+ reserved 999;
+
+ // Clients can define custom options in extensions of this message. See above.
+ extensions 1000 to max;
+}
diff --git a/protos/perfetto/metrics/perfetto_merged_metrics.proto b/protos/perfetto/metrics/perfetto_merged_metrics.proto
new file mode 100644
index 0000000..eb9ab74
--- /dev/null
+++ b/protos/perfetto/metrics/perfetto_merged_metrics.proto
@@ -0,0 +1,2710 @@
+// AUTOGENERATED - DO NOT EDIT
+// ---------------------------
+// This file has been generated by
+// AOSP://external/perfetto/tools/gen_merged_protos
+// merging the perfetto config protos.
+// This fused proto is intended to be copied in:
+// - Android tree, for statsd.
+// - Google internal repos.
+
+syntax = "proto2";
+
+package perfetto.protos;
+
+option go_package = "github.com/google/perfetto/perfetto_proto";
+
+// Begin of protos/perfetto/metrics/android/ad_services_metric.proto
+
+// Next: 8
+message AdServicesUiMetric {
+ optional double common_service_initialization_latency = 1;
+ optional double common_service_permission_check_latency = 2;
+ optional double common_service_ux_engine_flow_latency = 3;
+ optional double main_activity_creation_latency = 4;
+ optional double consent_manager_initialization_latency = 5;
+ optional double consent_manager_read_latency = 6;
+ optional double consent_manager_write_latency = 7;
+}
+
+// Next: 2
+message AdServicesAdIdMetric {
+ optional double latency = 1;
+}
+
+// Next: 2
+message AdServicesAppSetIdMetric {
+ optional double latency = 1;
+}
+
+// Next: 5
+message OnDevicePersonalizationMetric {
+ optional double managing_service_initialization_latency = 1;
+ optional double service_delegate_execute_flow_latency = 2;
+ optional double service_delegate_request_surface_package_latency = 3;
+ optional double service_delegate_register_web_trigger_latency = 4;
+}
+
+// Next: 5
+message AdServicesMetric {
+ repeated AdServicesUiMetric ui_metric = 1;
+ repeated AdServicesAdIdMetric ad_id_metric = 2;
+ repeated AdServicesAppSetIdMetric app_set_id_metric = 3;
+ repeated OnDevicePersonalizationMetric odp_metric = 4;
+}
+// End of protos/perfetto/metrics/android/ad_services_metric.proto
+
+// Begin of protos/perfetto/metrics/android/android_blocking_call.proto
+
+// Blocking call on the main thread.
+message AndroidBlockingCall {
+ // Name of the blocking call
+ optional string name = 1;
+ // Number of times it happened within the CUJ
+ optional int64 cnt = 2;
+ // Total duration within the CUJ
+ optional int64 total_dur_ms = 3;
+ // Maximal duration within the CUJ
+ optional int64 max_dur_ms = 4;
+ // Minimal duration within the CUJ
+ optional int64 min_dur_ms = 5;
+ // Total duration within the CUJ in nanoseconds
+ optional int64 total_dur_ns = 6;
+ // Maximal duration within the CUJ in nanoseconds
+ optional int64 max_dur_ns = 7;
+ // Minimal duration within the CUJ in nanoseconds
+ optional int64 min_dur_ns = 8;
+}
+
+// End of protos/perfetto/metrics/android/android_blocking_call.proto
+
+// Begin of protos/perfetto/metrics/android/process_metadata.proto
+
+message AndroidProcessMetadata {
+ // Process name. Usually, cmdline or <package_name>(:<custom_name>)?.
+ optional string name = 1;
+
+ // User id under which this process runs.
+ optional int64 uid = 2;
+
+ // Package metadata from Android package list.
+ message Package {
+ optional string package_name = 1;
+ optional int64 apk_version_code = 2;
+ optional bool debuggable = 3;
+ }
+
+ // Package that this process belongs to.
+ //
+ // If this process shares its uid (see `packages_for_uid` field), the package
+ // is determined based on the process name and package name. If there is no
+ // match this field is empty.
+ optional Package package = 7;
+
+ // All packages using this uid.
+ //
+ // Shared uid documentation:
+ // https://developer.android.com/guide/topics/manifest/manifest-element#uid
+ repeated Package packages_for_uid = 8;
+
+ // Pid of the process name.
+ optional int64 pid = 9;
+
+ reserved 3, 4, 5, 6;
+}
+
+// End of protos/perfetto/metrics/android/process_metadata.proto
+
+// Begin of protos/perfetto/metrics/android/android_blocking_calls_cuj_metric.proto
+
+// Blocking calls inside Android CUJs. Shows count and total duration for each.
+message AndroidBlockingCallsCujMetric {
+ repeated Cuj cuj = 1;
+
+ // Next id: 7
+ message Cuj {
+ // ID of the CUJ that is unique within the trace.
+ optional int32 id = 1;
+
+ // Name of the CUJ, extracted from the CUJ jank or latency trace marker.
+ // For example SHADE_EXPAND_COLLAPSE from J<SHADE_EXPAND_COLLAPSE>.
+ optional string name = 2;
+
+ // Details about the process (uid, version, etc)
+ optional AndroidProcessMetadata process = 3;
+
+ // ts of the CUJ trace marker slice, in ns.
+ optional int64 ts = 4;
+
+ // dur of the CUJ trace marker slice, in ns.
+ optional int64 dur = 5;
+
+ // List of blocking calls on the process main thread.
+ repeated AndroidBlockingCall blocking_calls = 6;
+ }
+}
+
+// End of protos/perfetto/metrics/android/android_blocking_calls_cuj_metric.proto
+
+// Begin of protos/perfetto/metrics/android/android_boot.proto
+
+// This metric computes how much time processes spend in UNINTERRUPTIBLE_SLEEP
+// state
+message ProcessStateDurations {
+ optional int64 total_dur = 2;
+ optional int64 uninterruptible_sleep_dur = 3;
+}
+
+message AndroidBootMetric {
+ optional ProcessStateDurations system_server_durations = 1;
+ optional ProcessStateDurations systemui_durations = 2;
+ optional ProcessStateDurations launcher_durations = 3;
+ optional ProcessStateDurations gms_durations = 4;
+ // Launcher related boot metrics
+ message LauncherBreakdown {
+ // reports cold start time of NexusLauncher
+ optional int64 cold_start_dur = 1;
+ }
+ optional LauncherBreakdown launcher_breakdown = 5;
+
+ message ProcessStartAggregation {
+ optional int64 total_start_sum = 1;
+ optional int64 num_of_processes = 2;
+ optional double average_start_time = 3;
+ }
+ message GarbageCollectionAggregation {
+ optional int64 total_gc_count = 1;
+ optional int64 num_of_processes_with_gc = 2;
+ optional int64 num_of_threads_with_gc = 3;
+ optional double avg_gc_duration = 4;
+ optional double avg_running_gc_duration = 5;
+ optional int64 full_gc_count = 6;
+ optional int64 collector_transition_gc_count = 7;
+ optional int64 young_gc_count = 8;
+ optional int64 native_alloc_gc_count = 9;
+ optional int64 explicit_gc_count = 10;
+ optional int64 alloc_gc_count = 11;
+ optional double mb_per_ms_of_gc = 12;
+ }
+ optional ProcessStartAggregation full_trace_process_start_aggregation = 6;
+ optional ProcessStartAggregation post_boot_process_start_aggregation = 7;
+ optional GarbageCollectionAggregation full_trace_gc_aggregation = 8;
+ optional GarbageCollectionAggregation post_boot_gc_aggregation = 9;
+}
+
+// End of protos/perfetto/metrics/android/android_boot.proto
+
+// Begin of protos/perfetto/metrics/android/android_garbage_collection_unagg_metric.proto
+
+message AndroidGarbageCollectionUnaggMetric {
+ message GarbageCollectionEvent {
+ // Name of thread running garbage collection.
+ optional string thread_name = 1;
+ // Name of process running garbage collection.
+ optional string process_name = 2;
+ // Type of garbage collection.
+ optional string gc_type = 3;
+ // Whether gargage collection is mark compact or copying.
+ optional int64 is_mark_compact = 4;
+ // MB reclaimed after garbage collection.
+ optional double reclaimed_mb = 5;
+ // Minimum heap size in MB during garbage collection.
+ optional double min_heap_mb = 6;
+ // Maximum heap size in MB during garbage collection.
+ optional double max_heap_mb = 7;
+ // Memory reclaimed per ms of running time.
+ optional double mb_per_ms_of_running_gc = 8;
+ // Memory reclaimed per ms of wall time.
+ optional double mb_per_ms_of_wall_gc = 9;
+ // Garbage collection wall duration.
+ optional int64 gc_dur = 10;
+ // Garbage collection duration spent executing on CPU.
+ optional int64 gc_running_dur = 11;
+ // Garbage collection duration spent waiting for CPU.
+ optional int64 gc_runnable_dur = 12;
+ // Garbage collection duration spent waiting in the Linux kernel on IO.
+ optional int64 gc_unint_io_dur = 13;
+ // Garbage collection duration spent waiting in the Linux kernel without IO.
+ optional int64 gc_unint_non_io_dur = 14;
+ // Garbage collection duration spent waiting in interruptible sleep.
+ optional int64 gc_int_dur = 15;
+ // ts of the event in trace.
+ optional int64 gc_ts = 16;
+ // pid of the event in trace.
+ optional int64 pid = 17;
+ // tid of the event in trace.
+ optional int64 tid = 18;
+ // monotonic duration of event.
+ optional int64 gc_monotonic_dur = 19;
+ }
+ repeated GarbageCollectionEvent gc_events = 1;
+}
+// End of protos/perfetto/metrics/android/android_garbage_collection_unagg_metric.proto
+
+// Begin of protos/perfetto/metrics/android/app_process_starts_metric.proto
+
+message AndroidAppProcessStartsMetric {
+ // Next id : 4
+ message ProcessStart {
+ optional string process_name = 1;
+ optional string intent = 2;
+ optional string reason = 3;
+ optional int64 proc_start_dur = 4;
+ optional int64 bind_app_dur = 5;
+ optional int64 intent_dur = 6;
+ optional int64 total_dur = 7;
+ }
+ // Provides java process startup information for
+ // all processes starting after Boot completed broadcast in a trace.
+ repeated ProcessStart all_apps = 1;
+ // Provides java process startup information for all
+ // processes started from a broadcast after Boot Complete broadcasts.
+ repeated ProcessStart started_by_broadcast = 2;
+ // Provides java process startup information for all
+ // processes started from a service after Boot Complete broadcasts.
+ repeated ProcessStart started_by_service = 3;
+}
+
+// End of protos/perfetto/metrics/android/app_process_starts_metric.proto
+
+// Begin of protos/perfetto/metrics/android/android_boot_unagg.proto
+
+message AndroidBootUnagg {
+ // Looks at all apps started after boot complete broadcast.
+ optional AndroidAppProcessStartsMetric android_app_process_start_metric = 1;
+ // Looks at all GC that occurs after boot complete broadcast.
+ optional AndroidGarbageCollectionUnaggMetric android_post_boot_gc_metric = 2;
+}
+
+// End of protos/perfetto/metrics/android/android_boot_unagg.proto
+
+// Begin of protos/perfetto/metrics/android/android_frame_timeline_metric.proto
+
+message AndroidFrameTimelineMetric {
+ message JankTypeMetric {
+ // The jank type
+ optional string type = 1;
+
+ // The count of frames with this jank type
+ optional int64 total_count = 2;
+
+ // The count of frames with this jank type and present type = PRESENT_UNSPECIFIED
+ optional int64 present_unspecified_count = 3;
+
+ // The count of frames with this jank type and present type = PRESENT_ON_TIME
+ optional int64 present_on_time_count = 4;
+
+ // The count of frames with this jank type and present type = PRESENT_LATE
+ optional int64 present_late_count = 5;
+
+ // The count of frames with this jank type and present type = PRESENT_EARLY
+ optional int64 present_early_count = 6;
+
+ // The count of frames with this jank type and present type = PRESENT_DROPPED
+ optional int64 present_dropped_count = 7;
+
+ // The count of frames with this jank type and present type = PRESENT_UNKNOWN
+ optional int64 present_unknown_count = 8;
+ }
+
+ message ProcessBreakdown {
+ optional AndroidProcessMetadata process = 3;
+
+ optional int64 total_frames = 4;
+ optional int64 missed_frames = 5;
+ optional int64 missed_app_frames = 6;
+ optional int64 missed_sf_frames = 7;
+
+ optional int64 frame_dur_max = 8;
+ optional int64 frame_dur_avg = 9;
+ optional int64 frame_dur_p50 = 10;
+ optional int64 frame_dur_p90 = 11;
+ optional int64 frame_dur_p95 = 12;
+ optional int64 frame_dur_p99 = 13;
+ optional double frame_dur_ms_p50 = 14;
+ optional double frame_dur_ms_p90 = 15;
+ optional double frame_dur_ms_p95 = 16;
+ optional double frame_dur_ms_p99 = 17;
+ optional int64 dropped_frames = 18;
+
+ // Metrics for each jank type in this process
+ repeated JankTypeMetric jank_types = 19;
+
+ reserved 1, 2;
+ }
+
+ optional int64 total_frames = 4;
+ optional int64 missed_app_frames = 5;
+ optional int64 dropped_frames = 6;
+
+ repeated ProcessBreakdown process = 2;
+
+ // Metrics for each jank type globally
+ repeated JankTypeMetric jank_types = 7;
+
+ reserved 1;
+}
+
+
+// End of protos/perfetto/metrics/android/android_frame_timeline_metric.proto
+
+// Begin of protos/perfetto/metrics/android/android_sysui_notifications_blocking_calls_metric.proto
+
+// Blocking calls inside System UI Notifications. Shows count and total duration for each.
+message AndroidSysUINotificationsBlockingCallsMetric {
+ repeated AndroidBlockingCall blocking_calls = 1;
+}
+
+// End of protos/perfetto/metrics/android/android_sysui_notifications_blocking_calls_metric.proto
+
+// Begin of protos/perfetto/metrics/android/android_trusty_workqueues.proto
+
+// Metric used to generate a simplified view of the Trusty kworker events.
+message AndroidTrustyWorkqueues {}
+
+// End of protos/perfetto/metrics/android/android_trusty_workqueues.proto
+
+// Begin of protos/perfetto/metrics/android/anr_metric.proto
+
+ message AndroidAnrMetric {
+ repeated Anr anr = 1;
+
+ // Next id: 12
+ message Anr {
+ // UUID that identifies the ANR.
+ optional string error_id = 1;
+
+ // Name of the process that ANRed.
+ optional string process_name = 2;
+
+ // PID of the ANRing process.
+ optional int32 pid = 3;
+
+ // ANR subject line.
+ optional string subject = 4;
+
+ // Timestamp of the ANR in the trace.
+ optional int64 ts = 5;
+ }
+}
+// End of protos/perfetto/metrics/android/anr_metric.proto
+
+// Begin of protos/perfetto/metrics/android/batt_metric.proto
+
+message AndroidBatteryMetric {
+ message BatteryCounters {
+ // Timestamp measured from boot time [ns].
+ optional int64 timestamp_ns = 1;
+ // Fields 2-5 are the same as in BatteryCounters proto in TracePacket.
+ optional double charge_counter_uah = 2;
+ optional float capacity_percent = 3;
+ optional double current_ua = 4;
+ optional double current_avg_ua = 5;
+ }
+
+ message BatteryAggregates {
+ // Field numbers for these 3 == the int values from Android
+ optional int64 total_screen_off_ns = 1;
+ optional int64 total_screen_on_ns = 2;
+ optional int64 total_screen_doze_ns = 3;
+ // Total time a wakelock was held
+ optional int64 total_wakelock_ns = 4;
+ // Amount of time the device was suspended. Depends on the ftrace source
+ // "power/suspend_resume".
+ optional int64 sleep_ns = 5;
+ optional int64 sleep_screen_off_ns = 6;
+ optional int64 sleep_screen_on_ns = 7;
+ optional int64 sleep_screen_doze_ns = 8;
+ }
+
+ // Period of time during the trace that the device went to sleep completely.
+ message SuspendPeriod {
+ optional int64 timestamp_ns = 1;
+ optional int64 duration_ns = 2;
+ }
+
+ // Battery counters info for each ts of the trace. This should only be
+ // extracted for short traces.
+ repeated BatteryCounters battery_counters = 1;
+
+ optional BatteryAggregates battery_aggregates = 2;
+
+ repeated SuspendPeriod suspend_period = 3;
+}
+
+// End of protos/perfetto/metrics/android/batt_metric.proto
+
+// Begin of protos/perfetto/metrics/android/binder_metric.proto
+
+// This metric provides the following:
+// 1. Per-process Binder statistics for traces with binder_driver enabled.
+// Specifically, transactions are categorized and counted
+// 2. Unaggregated binder txn durations with per-txn aggregated thread state and
+// blocked function
+// durations
+message AndroidBinderMetric {
+ message PerProcessBreakdown {
+ optional string process_name = 1;
+ optional uint32 pid = 2;
+ optional string slice_name = 3;
+ optional uint32 count = 4;
+ }
+
+ // Next field id: 30
+ message UnaggregatedTxnBreakdown {
+ // General
+ optional string aidl_name = 1;
+ optional int64 aidl_ts = 22;
+ optional int64 aidl_dur = 23;
+ optional bool is_sync = 21;
+ // Client
+ // Removed: was binder_txn_id
+ reserved 2;
+ optional string client_process = 3;
+ optional string client_thread = 4;
+ optional bool is_main_thread = 5;
+ optional int64 client_ts = 6;
+ optional int64 client_dur = 7;
+ optional int64 client_monotonic_dur = 28;
+ optional int64 client_oom_score = 19;
+ optional int64 client_package_version_code = 24;
+ optional bool is_client_package_debuggable = 25;
+ // Server
+ // Removed: was binder_reply_id
+ reserved 8;
+ optional string server_process = 9;
+ optional string server_thread = 10;
+ optional int64 server_ts = 11;
+ optional int64 server_dur = 12;
+ optional int64 server_monotonic_dur = 29;
+ optional int64 server_oom_score = 20;
+ optional int64 server_package_version_code = 26;
+ optional bool is_server_package_debuggable = 27;
+ // Aggregations
+ repeated ThreadStateBreakdown thread_states = 13;
+ repeated BlockedFunctionBreakdown blocked_functions = 14;
+
+ optional uint32 client_tid = 15;
+ optional uint32 server_tid = 16;
+
+ optional uint32 client_pid = 17;
+ optional uint32 server_pid = 18;
+ }
+
+ message ThreadStateBreakdown {
+ optional string thread_state_type = 1;
+ optional string thread_state = 2;
+ optional int64 thread_state_dur = 3;
+ optional int64 thread_state_count = 4;
+ }
+
+ message BlockedFunctionBreakdown {
+ optional string thread_state_type = 1;
+ optional string blocked_function = 2;
+ optional int64 blocked_function_dur = 3;
+ optional int64 blocked_function_count = 4;
+ }
+
+ repeated PerProcessBreakdown process_breakdown = 1;
+ repeated UnaggregatedTxnBreakdown unaggregated_txn_breakdown = 2;
+}
+
+// End of protos/perfetto/metrics/android/binder_metric.proto
+
+// Begin of protos/perfetto/metrics/android/camera_metric.proto
+
+message AndroidCameraMetric {
+ message Counter {
+ optional double min = 1;
+ optional double max = 2;
+ optional double avg = 3;
+ }
+
+ // Counter for the sum of DMA and RSS across GCA, cameraserver
+ // and HAL. This provides a single number for the memory
+ // pressure using the camera is putting on the rest of the
+ // system.
+ //
+ // Note: this number assumes that all DMA pressure is coming
+ // from the camera as this is usually a pretty good
+ // approximation. Being more accurate here would increase the
+ // complexity of the metric significantly.
+ //
+ // Note: if there are multiple GCA/cameraserver/HAL processes
+ // in the trace, this metric will simply take the latest
+ // one in the trace and ignore the others.
+ optional Counter gc_rss_and_dma = 1;
+}
+
+// End of protos/perfetto/metrics/android/camera_metric.proto
+
+// Begin of protos/perfetto/metrics/android/camera_unagg_metric.proto
+
+message AndroidCameraUnaggregatedMetric {
+ message Value {
+ optional int64 ts = 1;
+ optional double gca_rss_val = 2;
+ optional double hal_rss_val = 3;
+ optional double cameraserver_rss_val = 4;
+ optional double dma_val = 5;
+ optional double value = 6;
+ }
+
+ // Timeseries for the sum of DMA and RSS across GCA, cameraserver
+ // and HAL. This provides a single number for the memory
+ // pressure using the camera is putting on the rest of the
+ // system.
+ //
+ // Note: this number assumes that all DMA pressure is coming
+ // from the camera as this is usually a pretty good
+ // approximation. Being more accurate here would increase the
+ // complexity of the metric significantly.
+ //
+ // Note: if there are multiple GCA/cameraserver/HAL processes
+ // in the trace, this metric will simply take the latest
+ // one in the trace and ignore the others.
+ repeated Value gc_rss_and_dma = 1;
+}
+
+// End of protos/perfetto/metrics/android/camera_unagg_metric.proto
+
+// Begin of protos/perfetto/metrics/android/cpu_metric.proto
+
+message AndroidCpuMetric {
+ // Next id: 6
+ message Metrics {
+ // CPU megacycles (i.e. cycles divided by 1e6).
+ optional int64 mcycles = 1;
+
+ // Total time the thread was running for this breakdown in
+ // nanoseconds.
+ optional int64 runtime_ns = 2;
+
+ // Min/max/average CPU frequency weighted by the time the CPU was
+ // running at each frequency in this breakdown.
+ optional int64 min_freq_khz = 3;
+ optional int64 max_freq_khz = 4;
+ optional int64 avg_freq_khz = 5;
+ }
+
+ // Next id: 7
+ message CoreData {
+ optional uint32 id = 1;
+ optional Metrics metrics = 6;
+
+ reserved 2 to 5;
+ }
+
+ // Next id: 3
+ message CoreTypeData {
+ optional string type = 1;
+ optional Metrics metrics = 2;
+ }
+
+ // Next id: 7
+ message Thread {
+ optional string name = 1;
+ optional Metrics metrics = 4;
+
+ // Breakdowns of above metrics.
+ repeated CoreData core = 2;
+ repeated CoreTypeData core_type = 5;
+
+ reserved 3;
+ }
+
+ // Next id: 8
+ message Process {
+ optional string name = 1;
+ optional AndroidProcessMetadata process = 8;
+ optional Metrics metrics = 4;
+
+ // Breakdowns of above metrics.
+ repeated Thread threads = 6;
+ repeated CoreData core = 7;
+ repeated CoreTypeData core_type = 5;
+
+ reserved 3;
+ }
+
+ repeated Process process_info = 1;
+}
+
+// End of protos/perfetto/metrics/android/cpu_metric.proto
+
+// Begin of protos/perfetto/metrics/android/codec_metrics.proto
+
+// These metrices collects various function and thread
+// usage within androd's codec framework. This can give an
+// idea about performance and cpu usage when using codec
+// framework
+message AndroidCodecMetrics {
+
+ // profile details in messages
+ message Detail {
+ // function thread
+ optional string thread_name = 1;
+ // total time
+ optional int64 total_cpu_ns = 2;
+ // CPU time ( time 'Running' on cpu)
+ optional int64 running_cpu_ns = 3;
+ }
+
+ // These are traces and could indicate framework queue latency
+ // buffer-packing, buffer-preprocess, buffer post-process
+ // latency etc. These metrics are monitored to track quality.
+ // Same message can come from different
+ // processes.
+ message CodecFunction {
+ // codec string
+ optional string codec_string = 1;
+ // process_name
+ optional string process_name = 2;
+ // details
+ optional Detail detail = 3;
+ }
+
+ // This message can indicate overall cpu
+ // utilization of codec framework threads.
+ message CpuUsage {
+ // name of process using codec framework
+ optional string process_name = 1;
+ // name of the codec thread
+ optional string thread_name = 2;
+ // was thread_cpu_us
+ reserved 3;
+ // total cpu usage of the codec thread
+ optional int64 thread_cpu_ns = 6;
+ // can be number of codec framework thread
+ optional uint32 num_threads = 4;
+ // core type data info used by codec thread
+ repeated AndroidCpuMetric.CoreTypeData core_data = 5;
+ }
+
+ repeated CpuUsage cpu_usage = 1;
+ repeated CodecFunction codec_function = 2;
+
+}
+
+// End of protos/perfetto/metrics/android/codec_metrics.proto
+
+// Begin of protos/perfetto/metrics/android/display_metrics.proto
+
+message AndroidDisplayMetrics {
+ // Stat that reports the number of duplicate frames submitted
+ // to the display for rendering. That is frames that have the same
+ // pixels values but where still submitted. It is tracked based on
+ // comparing the MISR of the current frame vs previous frame.
+ optional uint32 total_duplicate_frames = 1;
+
+ // Stat reports whether there is any duplicate_frames tracked
+ optional uint32 duplicate_frames_logged = 2;
+
+ // Stat that reports the number of dpu underrrun occurs count.
+ optional uint32 total_dpu_underrun_count = 3;
+
+
+ message RefreshRateStat {
+ // The refresh rate value (the number of frames per second)
+ optional uint32 refresh_rate_fps = 1;
+
+ // Calculate the number of refresh rate switches to this fps
+ optional uint32 count = 2;
+
+ // Calculate the total duration of refresh rate stays at this fps
+ optional double total_dur_ms = 3;
+
+ // Calculate the average duration of refresh rate stays at this fps
+ optional double avg_dur_ms = 4;
+ }
+
+ // Calculate the total number of refresh rate changes
+ optional uint32 refresh_rate_switches = 4;
+
+ // The statistics for each refresh rate value
+ repeated RefreshRateStat refresh_rate_stats = 5;
+
+ // Stats to measure the runtime of updating the power state in
+ // DisplayPowerController
+ message UpdatePowerState {
+ optional uint32 avg_runtime_micro_secs = 2;
+
+ // Removed: avg_runtime_ms
+ reserved 1;
+ }
+
+ optional UpdatePowerState update_power_state = 6;
+}
+
+// End of protos/perfetto/metrics/android/display_metrics.proto
+
+// Begin of protos/perfetto/metrics/android/dma_heap_metric.proto
+
+// dma-buf heap memory stats on Android.
+message AndroidDmaHeapMetric {
+ optional double avg_size_bytes = 1;
+ optional double min_size_bytes = 2;
+ optional double max_size_bytes = 3;
+
+ // Total allocation size.
+ // Essentially the sum of positive allocs.
+ optional double total_alloc_size_bytes = 4;
+}
+
+// End of protos/perfetto/metrics/android/dma_heap_metric.proto
+
+// Begin of protos/perfetto/metrics/android/dvfs_metric.proto
+
+message AndroidDvfsMetric {
+
+ message BandStat {
+ // Operating frequency
+ optional int32 freq_value = 1;
+
+ // Percentage of duration in this operating frequency compared to all frequencies
+ optional double percentage = 2;
+
+ // Total duration in ns when the state was in this operating frequency
+ optional int64 duration_ns = 3;
+ }
+
+ message FrequencyResidency {
+ // Frequency representative name
+ optional string freq_name = 1;
+ // Each band statistics meta
+ repeated BandStat band_stat = 2;
+ }
+
+ // Frequency residency metrics from clock_set_rate ftrace event.
+ repeated FrequencyResidency freq_residencies = 1;
+}
+
+// End of protos/perfetto/metrics/android/dvfs_metric.proto
+
+// Begin of protos/perfetto/metrics/android/fastrpc_metric.proto
+
+// fastrpc memory stats on Android.
+message AndroidFastrpcMetric {
+ message Subsystem {
+ optional string name = 1;
+ optional double avg_size_bytes = 2;
+ optional double min_size_bytes = 3;
+ optional double max_size_bytes = 4;
+
+ // Total allocation size.
+ // Essentially the sum of positive allocs.
+ optional double total_alloc_size_bytes = 5;
+ }
+
+ repeated Subsystem subsystem = 1;
+}
+
+// End of protos/perfetto/metrics/android/fastrpc_metric.proto
+
+// Begin of protos/perfetto/metrics/android/g2d_metric.proto
+
+message G2dMetrics {
+ message G2dInstance {
+ // G2d name.
+ optional string name = 1;
+
+ optional uint32 frame_count = 5;
+ optional uint32 error_count = 6;
+
+ optional double max_dur_ms = 7;
+ optional double min_dur_ms = 8;
+ optional double avg_dur_ms = 9;
+
+ // Removed: was int64 versions of max_dur_ns, min_dur_ns and avg_dur_ns.
+ reserved 2 to 4;
+ }
+ message G2dMetric {
+ // G2D Metric for each G2D Instance.
+ repeated G2dInstance instances = 1;
+
+ // the number of frames processed by G2D
+ optional uint32 frame_count = 5;
+ // the number of error events
+ optional uint32 error_count = 6;
+
+ // max/min/avg G2d frame durations for all instances.
+ optional double max_dur_ms = 7;
+ optional double min_dur_ms = 8;
+ optional double avg_dur_ms = 9;
+
+ // Removed: was int64 versions of max_dur_ns, min_dur_ns and avg_dur_ns.
+ reserved 2 to 4;
+ }
+
+ optional G2dMetric g2d_hw = 1;
+ optional G2dMetric g2d_sw = 2;
+}
+
+// End of protos/perfetto/metrics/android/g2d_metric.proto
+
+// Begin of protos/perfetto/metrics/android/gpu_metric.proto
+
+message AndroidGpuMetric {
+ message Process {
+ // Process name.
+ optional string name = 1;
+
+ // max/min/avg GPU memory used by this process.
+ optional int64 mem_max = 2;
+ optional int64 mem_min = 3;
+ optional int64 mem_avg = 4;
+ }
+
+ // GPU metric for processes using GPU.
+ repeated Process processes = 1;
+
+ // max/min/avg GPU memory used by the entire system.
+ optional int64 mem_max = 2;
+ optional int64 mem_min = 3;
+ optional int64 mem_avg = 4;
+
+ message FrequencyMetric {
+ // Identifier for GPU in a multi-gpu device.
+ optional uint32 gpu_id = 1;
+
+ // max/min/avg GPU frequency for this gpu_id
+ // the calculation of avg is weighted by the duration of each frequency
+ optional int64 freq_max = 2;
+ optional int64 freq_min = 3;
+ optional double freq_avg = 4;
+
+ message MetricsPerFrequency {
+ // Used frequency
+ optional int64 freq = 1;
+
+ // Total duration in ms when the state of GPU was in this frequency
+ optional double dur_ms = 2;
+
+ // Percentage of duration in this frequency compared to all frequencies
+ // in this gpu_id
+ optional double percentage = 3;
+ }
+
+ // Metrics for each used GPU frequency
+ repeated MetricsPerFrequency used_freqs = 5;
+ }
+
+ // GPU frequency metric for each gpu_id
+ repeated FrequencyMetric freq_metrics = 5;
+}
+
+// End of protos/perfetto/metrics/android/gpu_metric.proto
+
+// Begin of protos/perfetto/metrics/android/hwcomposer.proto
+
+message AndroidHwcomposerMetrics {
+ // Counts the number of composition total layers in the trace. (non-weighted average)
+ optional double composition_total_layers = 1;
+
+ // Counts the number of composition dpu layers in the trace. (non-weighted average)
+ optional double composition_dpu_layers = 2;
+
+ // Counts the number of composition gpu layers in the trace. (non-weighted average)
+ optional double composition_gpu_layers = 3;
+
+ // Counts the number of composition dpu cached layers in the trace. (non-weighted average)
+ optional double composition_dpu_cached_layers = 4;
+
+ // Counts the number of composition surfaceflinger cached layers in the trace.
+ // (non-weighted average)
+ optional double composition_sf_cached_layers = 5;
+
+ // Counts the number of composition rounded corner decoration layers in the trace.
+ // (non-weighted average)
+ optional double composition_rcd_layers = 15;
+
+ // Counts how many times validateDisplay is skipped.
+ optional int32 skipped_validation_count = 6;
+
+ // Counts how many times validateDisplay cannot be skipped.
+ optional int32 unskipped_validation_count = 7;
+
+ // Counts how many times validateDisplay is already separated from presentDisplay
+ // since the beginning.
+ optional int32 separated_validation_count = 8;
+
+ // Counts how many unhandled validation cases which might be caused by errors.
+ optional int32 unknown_validation_count = 9;
+
+ // the average of overall hwcomposer execution time.
+ optional double avg_all_execution_time_ms = 10;
+
+ // the average of hwcomposer execution time for skipped validation cases.
+ optional double avg_skipped_execution_time_ms = 11;
+
+ // the average of hwcomposer execution time for unskipped validation cases.
+ optional double avg_unskipped_execution_time_ms = 12;
+
+ // the average of hwcomposer execution time for separated validation cases.
+ optional double avg_separated_execution_time_ms = 13;
+
+ message DpuVoteMetrics {
+ // the thread ID that handles this track
+ optional uint32 tid = 1;
+
+ // the weighted average of DPU Vote Clock
+ optional double avg_dpu_vote_clock = 2;
+
+ // the weighted average of DPU Vote Avg Bandwidth
+ optional double avg_dpu_vote_avg_bw = 3;
+
+ // the weighted average of DPU Vote Peak Bandwidth
+ optional double avg_dpu_vote_peak_bw = 4;
+
+ // the weighted average of DPU Vote RT (Real Time) Bandwidth
+ optional double avg_dpu_vote_rt_bw = 5;
+ }
+
+ // DPU Vote Metrics for each thread track
+ repeated DpuVoteMetrics dpu_vote_metrics = 14;
+
+ message MetricsPerDisplay {
+ // Display ID in HWC
+ optional string display_id = 1;
+
+ // Counts the number of composition total layers in the trace. (non-weighted average)
+ optional double composition_total_layers = 2;
+
+ // Counts the number of composition dpu layers in the trace. (non-weighted average)
+ optional double composition_dpu_layers = 3;
+
+ // Counts the number of composition gpu layers in the trace. (non-weighted average)
+ optional double composition_gpu_layers = 4;
+
+ // Counts the number of composition dpu cached layers in the trace. (non-weighted average)
+ optional double composition_dpu_cached_layers = 5;
+
+ // Counts the number of composition surfaceflinger cached layers in the trace.
+ // (non-weighted average)
+ optional double composition_sf_cached_layers = 6;
+
+ // Counts the number of composition rounded corner decoration layers in the trace.
+ // (non-weighted average)
+ optional double composition_rcd_layers = 7;
+
+ // Counts how many times validateDisplay is skipped.
+ optional int32 skipped_validation_count = 8;
+
+ // Counts how many times validateDisplay cannot be skipped.
+ optional int32 unskipped_validation_count = 9;
+
+ // Counts how many times validateDisplay is already separated from presentDisplay
+ // since the beginning.
+ optional int32 separated_validation_count = 10;
+
+ // Counts how many unhandled validation cases which might be caused by errors.
+ optional int32 unknown_validation_count = 11;
+
+ // the average of overall hwcomposer execution time.
+ optional double avg_all_execution_time_ms = 12;
+
+ // the average of hwcomposer execution time for skipped validation cases.
+ optional double avg_skipped_execution_time_ms = 13;
+
+ // the average of hwcomposer execution time for unskipped validation cases.
+ optional double avg_unskipped_execution_time_ms = 14;
+
+ // the average of hwcomposer execution time for separated validation cases.
+ optional double avg_separated_execution_time_ms = 15;
+ }
+
+ repeated MetricsPerDisplay metrics_per_display = 16;
+}
+
+// End of protos/perfetto/metrics/android/hwcomposer.proto
+
+// Begin of protos/perfetto/metrics/android/hwui_metric.proto
+
+// Android HWUI graphics performance and graphics memory usage metrics.
+message ProcessRenderInfo {
+ // Name of the package launched
+ optional string process_name = 1;
+
+ // CPU time spent on RenderThread in milliseconds.
+ optional int64 rt_cpu_time_ms = 2;
+
+ // Number of frames drawn on RenderThread, followed by max/min/avg CPU time to draw a frame
+ // in nanoseconds.
+ optional uint32 draw_frame_count = 3;
+ optional int64 draw_frame_max = 4;
+ optional int64 draw_frame_min = 5;
+ optional double draw_frame_avg = 6;
+
+ // Number of GPU commands flushes and max/min/avg time per flush in nanoseconds.
+ optional uint32 flush_count = 7;
+ optional int64 flush_max = 8;
+ optional int64 flush_min = 9;
+ optional double flush_avg = 10;
+
+ // Number of View tree preparation counts and max/min/avg time to traverse the tree in
+ // nanoseconds.
+ optional uint32 prepare_tree_count = 11;
+ optional int64 prepare_tree_max = 12;
+ optional int64 prepare_tree_min = 13;
+ optional double prepare_tree_avg = 14;
+
+ // Number of times the GPU rendered a frame and max/min/avg time for GPU to finish rendering in
+ // in nanoseconds.
+ optional uint32 gpu_completion_count = 15;
+ optional int64 gpu_completion_max = 16;
+ optional int64 gpu_completion_min = 17;
+ optional double gpu_completion_avg = 18;
+
+ // Number of times a frame was recorded/serialized in a display list on the UI thread with
+ // max/min/avg time in nanoseconds.
+ optional uint32 ui_record_count = 19;
+ optional int64 ui_record_max = 20;
+ optional int64 ui_record_min = 21;
+ optional double ui_record_avg = 22;
+
+ // number of unique shader programs that were used to render frames, followed by total and average
+ // times to prepare a shader in nanoseconds.
+ optional uint32 shader_compile_count = 23;
+ optional int64 shader_compile_time = 24;
+ optional double shader_compile_avg = 25;
+ // number of shader programs loaded from the disk cache, followed by total time and average time
+ // to prepare a shader in nanoseconds.
+ optional uint32 cache_hit_count = 26;
+ optional int64 cache_hit_time = 27;
+ optional double cache_hit_avg = 28;
+ // number of shader programs compiled/linked, followed by total time and average time to prepare
+ // a shader in nanoseconds.
+ optional uint32 cache_miss_count = 29;
+ optional int64 cache_miss_time = 30;
+ optional double cache_miss_avg = 31;
+
+ // max/min/avg CPU memory used for graphics by HWUI at the end of a frame.
+ optional int64 graphics_cpu_mem_max = 32;
+ optional int64 graphics_cpu_mem_min = 33;
+ optional double graphics_cpu_mem_avg = 34;
+
+ // max/min/avg GPU memory used by HWUI at the end of a frame excluding textures.
+ optional int64 graphics_gpu_mem_max = 35;
+ optional int64 graphics_gpu_mem_min = 36;
+ optional double graphics_gpu_mem_avg = 37;
+
+ // max/min/avg memory used for GPU textures by HWUI at the end of a frame.
+ optional int64 texture_mem_max = 38;
+ optional int64 texture_mem_min = 39;
+ optional double texture_mem_avg = 40;
+
+ // max/min/avg memory used by HWUI at the end of a frame. This is a sum of previous 3 categories.
+ optional int64 all_mem_max = 41;
+ optional int64 all_mem_min = 42;
+ optional double all_mem_avg = 43;
+}
+
+message AndroidHwuiMetric {
+ // HWUI metrics for processes that have a RenderThread.
+ repeated ProcessRenderInfo process_info = 1;
+}
+
+// End of protos/perfetto/metrics/android/hwui_metric.proto
+
+// Begin of protos/perfetto/metrics/android/io_metric.proto
+
+// Measure Android IO stats in a trace.
+// Note: This is an aggregated metric, for unaggregated metrics look at AndroidIoUnaggregated
+// in io_unagg_metric.proto.
+message AndroidIo {
+ // Next id: 3
+ // Stats for Counters in an f2fs file system.
+ // Counters are available for various operations.
+ message F2fsCounterStats {
+ optional string name = 1;
+ optional double max = 2;
+ optional double sum = 3;
+ optional double min = 5;
+ optional int64 dur = 6;
+ optional int64 count = 7;
+ optional double avg = 8;
+ }
+ // Aggregated stats for write operations in an f2fs file system.
+ message F2fsWriteStats {
+ optional int64 total_write_count = 1;
+ optional int64 distinct_processes = 2;
+ optional int64 total_bytes_written = 3;
+ optional int64 distinct_device_count = 4;
+ optional int64 distict_inode_count = 5;
+ optional int64 distinct_thread_count = 6;
+ }
+ repeated F2fsCounterStats f2fs_counter_stats = 1;
+ repeated F2fsWriteStats f2fs_write_stats = 2;
+}
+
+// End of protos/perfetto/metrics/android/io_metric.proto
+
+// Begin of protos/perfetto/metrics/android/io_unagg_metric.proto
+
+// IO metrics on Android in unaggregated form.
+// Note: this generates a lot of data so should not be requested unless it
+// is clear that this data is necessary.
+message AndroidIoUnaggregated {
+ // Next id: 2
+ message F2fsWriteUnaggreagatedStat {
+ optional uint32 tid = 1;
+ optional string thread_name = 2;
+ optional uint32 pid = 3;
+ optional string process_name = 4;
+ optional int64 ino = 5;
+ optional int64 dev = 6;
+ }
+ // F2fs write stats which are grouped by thread and inode.
+ repeated F2fsWriteUnaggreagatedStat f2fs_write_unaggregated_stats = 1;
+}
+// End of protos/perfetto/metrics/android/io_unagg_metric.proto
+
+// Begin of protos/perfetto/metrics/android/ion_metric.proto
+
+// ion memory stats on Android.
+message AndroidIonMetric {
+ message Buffer {
+ optional string name = 1;
+ optional double avg_size_bytes = 2;
+ optional double min_size_bytes = 3;
+ optional double max_size_bytes = 4;
+
+ // Total allocation size.
+ // Essentially the sum of positive allocs (-> new buffers).
+ optional double total_alloc_size_bytes = 5;
+ }
+
+ repeated Buffer buffer = 1;
+}
+
+// End of protos/perfetto/metrics/android/ion_metric.proto
+
+// Begin of protos/perfetto/metrics/android/irq_runtime_metric.proto
+
+// measure max IRQ runtime and IRQ tasks running over threshold.
+message AndroidIrqRuntimeMetric {
+ message IrqSlice {
+ // IRQ name
+ optional string irq_name = 1;
+ // timestamp
+ optional int64 ts = 2;
+ // runtime of IRQ task
+ optional int64 dur = 3;
+ }
+ message ThresholdMetric {
+ // Threshold value
+ optional string threshold = 1;
+ // over threshold count
+ optional int64 over_threshold_count = 2;
+ // anomaly ratio (over threshold count / total count)
+ optional double anomaly_ratio= 3;
+ }
+ message IrqRuntimeMetric {
+ // max runtime of IRQ tasks
+ optional int64 max_runtime = 1;
+ // total IRQ tasks
+ optional int64 total_count = 2;
+ // over threshold metric
+ optional ThresholdMetric threshold_metric = 3;
+ // information for top 10 IRQ tasks
+ repeated IrqSlice longest_irq_slices = 4;
+ }
+
+ // metrics for hardirq and softirq
+ optional IrqRuntimeMetric hw_irq = 1;
+ optional IrqRuntimeMetric sw_irq = 2;
+}
+
+
+// End of protos/perfetto/metrics/android/irq_runtime_metric.proto
+
+// Begin of protos/perfetto/metrics/android/jank_cuj_metric.proto
+
+message AndroidJankCujMetric {
+ repeated Cuj cuj = 1;
+
+ // Next id: 12
+ message Cuj {
+ // ID of the CUJ that is unique within the trace.
+ optional int32 id = 1;
+
+ // Name of the CUJ, extracted from the CUJ trace marker.
+ // For example SHADE_EXPAND_COLLAPSE from J<SHADE_EXPAND_COLLAPSE>.
+ optional string name = 2;
+
+ // Details about the process (uid, version, etc)
+ optional AndroidProcessMetadata process = 3;
+
+ // ts of the CUJ trace marker slice.
+ optional int64 ts = 4;
+
+ // dur of the CUJ trace marker slice.
+ optional int64 dur = 5;
+
+ // Details about each of the frames within the CUJ.
+ repeated Frame frame = 6;
+
+ // Details about each of the SF frames within the CUJ.
+ repeated Frame sf_frame = 10;
+
+ // Metrics extracted from the counters output by FrameTracker
+ // Does not contain the frame_dur percentile information.
+ optional Metrics counter_metrics = 7;
+
+ // Metrics extracted from the frame timeline.
+ optional Metrics timeline_metrics = 8;
+
+ // Metrics extracted from the trace slices.
+ optional Metrics trace_metrics = 9;
+
+ // Layer name of the surface where the cuj is drawn.
+ optional string layer_name = 11;
+ }
+
+ // Next id: 10
+ message Frame {
+ // Index of the frame within the single user journey.
+ optional int64 frame_number = 1;
+
+ // VSYNC ID of the frame.
+ optional int64 vsync = 2;
+
+ optional int64 ts = 3;
+ optional int64 dur = 4;
+ optional int64 dur_expected = 7;
+
+ // Whether the app process missed the frame deadline.
+ // Only set for the App frames. Always left unset for SF frames.
+ optional bool app_missed = 5;
+
+ // Whether SF missed the frame deadline.
+ optional bool sf_missed = 6;
+
+ // Whether the SF callback missed before emitting jank metrics.
+ // SF callback is used to get the jank classification.
+ optional bool sf_callback_missed = 8;
+
+ // Whether the HWUI callback missed before emitting jank metrics.
+ // HWUI callback is used to get the frame duration.
+ optional bool hwui_callback_missed = 9;
+ }
+
+ // Next id: 18
+ message Metrics {
+ // Overall number of frames within the CUJ.
+ optional int64 total_frames = 1;
+
+ // Number of missed frames.
+ optional int64 missed_frames = 2;
+
+ // Number of frames missed due to the app missing the deadline.
+ optional int64 missed_app_frames = 3;
+
+ // Number of frames missed due to SF.
+ optional int64 missed_sf_frames = 4;
+
+ // Number of successive frames missed.
+ // Not available in timeline_metrics and trace_metrics.
+ optional int64 missed_frames_max_successive = 5;
+
+ // Max frame duration in nanoseconds.
+ optional int64 frame_dur_max = 6;
+
+ // Average frame duration in nanoseconds.
+ // Not available in counter_metrics.
+ optional int64 frame_dur_avg = 7;
+
+ // Median frame duration in nanoseconds.
+ // Not available in counter_metrics.
+ optional int64 frame_dur_p50 = 8;
+
+ // P90 frame duration in nanoseconds.
+ // Not available in counter_metrics.
+ optional int64 frame_dur_p90 = 9;
+
+ // P95 frame duration in nanoseconds.
+ // Not available in counter_metrics.
+ optional int64 frame_dur_p95 = 10;
+
+ // P99 frame duration in nanoseconds.
+ // Not available in counter_metrics.
+ optional int64 frame_dur_p99 = 11;
+
+ // Median frame duration in milliseconds.
+ // Not available in counter_metrics.
+ optional double frame_dur_ms_p50 = 12;
+
+ // P90 frame duration in milliseconds.
+ // Not available in counter_metrics.
+ optional double frame_dur_ms_p90 = 13;
+
+ // P95 frame duration in milliseconds.
+ // Not available in counter_metrics.
+ optional double frame_dur_ms_p95 = 14;
+
+ // P99 frame duration in milliseconds.
+ // Not available in counter_metrics.
+ optional double frame_dur_ms_p99 = 15;
+
+ // Number of frames with missed SF callback.
+ optional int64 sf_callback_missed_frames = 16;
+
+ // Number of frames with missed HWUI callback.
+ optional int64 hwui_callback_missed_frames = 17;
+ }
+}
+
+// End of protos/perfetto/metrics/android/jank_cuj_metric.proto
+
+// Begin of protos/perfetto/metrics/android/java_heap_histogram.proto
+
+message JavaHeapHistogram {
+ // Next id: 9
+ message TypeCount {
+ optional string type_name = 1;
+ optional string category = 4;
+
+ optional uint32 obj_count = 2;
+ optional uint32 reachable_obj_count = 3;
+
+ optional uint32 size_kb = 5;
+ optional uint32 reachable_size_kb = 6;
+ optional uint32 native_size_kb = 7;
+ optional uint32 reachable_native_size_kb = 8;
+ }
+
+ message Sample {
+ optional int64 ts = 1;
+ repeated TypeCount type_count = 2;
+ }
+
+ // Heap stats per process. One sample per dump (with continuous dump you can
+ // have more samples differentiated by ts).
+ message InstanceStats {
+ optional uint32 upid = 1;
+ optional AndroidProcessMetadata process = 2;
+ repeated Sample samples = 3;
+ }
+
+ repeated InstanceStats instance_stats = 1;
+}
+
+// End of protos/perfetto/metrics/android/java_heap_histogram.proto
+
+// Begin of protos/perfetto/metrics/android/java_heap_stats.proto
+
+message JavaHeapStats {
+ message HeapRoots {
+ optional string root_type = 1;
+ optional string type_name = 2;
+ optional int64 obj_count = 3;
+ }
+
+ // Next id: 11
+ message Sample {
+ optional int64 ts = 1;
+ // Size of the Java heap in bytes
+ optional int64 heap_size = 2;
+ // Native size of all the objects (not included in heap_size)
+ optional int64 heap_native_size = 8;
+ optional int64 obj_count = 4;
+ // Size of the reachable objects in bytes.
+ optional int64 reachable_heap_size = 3;
+ // Native size of all the reachable objects (not included in
+ // reachable_heap_size)
+ optional int64 reachable_heap_native_size = 9;
+ optional int64 reachable_obj_count = 5;
+ // Sum of anonymous RSS + swap pages in bytes.
+ optional int64 anon_rss_and_swap_size = 6;
+
+ // ART root objects
+ repeated HeapRoots roots = 7;
+ // OOM adjustment score
+ optional int64 oom_score_adj = 10;
+ }
+
+ // Heap stats per process. One sample per dump (can be > 1 if continuous
+ // dump is enabled).
+ message InstanceStats {
+ optional uint32 upid = 1;
+ optional AndroidProcessMetadata process = 2;
+ repeated Sample samples = 3;
+ }
+
+ repeated InstanceStats instance_stats = 1;
+}
+
+// End of protos/perfetto/metrics/android/java_heap_stats.proto
+
+// Begin of protos/perfetto/metrics/android/lmk_metric.proto
+
+// LMK stats on Android.
+message AndroidLmkMetric {
+ message ByOomScore {
+ optional int32 oom_score_adj = 1;
+ optional int32 count = 2;
+ }
+
+ // Total count of LMK events observed in the trace.
+ optional int32 total_count = 1;
+ repeated ByOomScore by_oom_score = 2;
+
+ // OOM reaper kills. Enabled via the oom/mark_victim point. Should never
+ // happen.
+ optional int32 oom_victim_count = 3;
+}
+
+// End of protos/perfetto/metrics/android/lmk_metric.proto
+
+// Begin of protos/perfetto/metrics/android/lmk_reason_metric.proto
+
+// Global process state at LMK time, used to identify potential culprits.
+// TODO: rename to AndroidLmkProcessState
+message AndroidLmkReasonMetric {
+ message Process {
+ optional AndroidProcessMetadata process = 1;
+
+ // OOM score adj of the process.
+ optional int32 oom_score_adj = 2;
+
+ // RSS + swap.
+ optional int64 size = 3;
+
+ optional int64 file_rss_bytes = 4;
+ optional int64 anon_rss_bytes = 5;
+ optional int64 shmem_rss_bytes = 6;
+ optional int64 swap_bytes = 7;
+ }
+ message Lmk {
+ // OOM score adj of the LMK'ed process.
+ optional int32 oom_score_adj = 1;
+
+ // Total size of the ION heap in bytes during this LMK.
+ optional int64 ion_heaps_bytes = 4;
+ // Deprecated. Prefer ion_heaps_bytes.
+ optional int64 system_ion_heap_size = 2;
+
+ // Processes present during this LMK.
+ repeated Process processes = 3;
+ }
+
+ // LMKs present in the trace, ordered on their timestamp.
+ repeated Lmk lmks = 1;
+}
+
+// End of protos/perfetto/metrics/android/lmk_reason_metric.proto
+
+// Begin of protos/perfetto/metrics/android/mem_metric.proto
+
+// Memory metrics on Android.
+message AndroidMemoryMetric {
+ message ProcessMetrics {
+ optional string process_name = 1;
+ optional ProcessMemoryCounters total_counters = 2;
+ repeated PriorityBreakdown priority_breakdown = 3;
+ }
+
+ message PriorityBreakdown {
+ optional string priority = 1;
+ optional ProcessMemoryCounters counters = 2;
+ }
+
+ message ProcessMemoryCounters {
+ optional Counter anon_rss = 1;
+ optional Counter file_rss = 2;
+ optional Counter swap = 3;
+ optional Counter anon_and_swap = 4;
+
+ // Available when ART trace events are available.
+ optional Counter java_heap = 5;
+ }
+
+ message Counter {
+ optional double min = 1;
+ optional double max = 2;
+ optional double avg = 3;
+
+ // Memory growth observed in the counter sequence. In case of multiple
+ // processes with the same name, break ties using max.
+ optional double delta = 4;
+ }
+
+ // Process metrics, grouped by process name
+ repeated ProcessMetrics process_metrics = 1;
+}
+
+// End of protos/perfetto/metrics/android/mem_metric.proto
+
+// Begin of protos/perfetto/metrics/android/mem_unagg_metric.proto
+
+// Unaggregated memory metrics on Android.
+message AndroidMemoryUnaggregatedMetric {
+ message ProcessValues {
+ optional string process_name = 1;
+ optional ProcessMemoryValues mem_values = 2;
+ }
+
+ message ProcessMemoryValues {
+ repeated Value anon_rss = 1;
+ repeated Value file_rss = 2;
+ repeated Value swap = 3;
+ repeated Value anon_and_swap = 4;
+ }
+
+ message Value {
+ optional int64 ts = 1;
+ optional int32 oom_score = 2;
+ optional double value = 3;
+ }
+
+ // Process metrics for every process instance in trace.
+ repeated ProcessValues process_values = 1;
+}
+
+// End of protos/perfetto/metrics/android/mem_unagg_metric.proto
+
+// Begin of protos/perfetto/metrics/android/monitor_contention_agg_metric.proto
+
+ // This metric provides aggregated information about monitor contention graph
+ // in a trace
+message AndroidMonitorContentionAggMetric {
+ // Next id: 2
+ // Stats for Monitor contention aggregated by process.
+ message ProcessAggregation {
+ optional string name = 1;
+ optional int64 total_contention_count = 2;
+ optional int64 total_contention_dur = 3;
+ optional int64 main_thread_contention_count = 4;
+ optional int64 main_thread_contention_dur = 5;
+ }
+ repeated ProcessAggregation process_aggregation = 1;
+}
+
+// End of protos/perfetto/metrics/android/monitor_contention_agg_metric.proto
+
+// Begin of protos/perfetto/metrics/android/monitor_contention_metric.proto
+
+// This metric provides information about the monitor contention graph in a
+// trace
+message AndroidMonitorContentionMetric {
+ // Next field id: 26
+ message Node {
+ // Global context
+ optional int64 node_parent_id = 1;
+ optional int64 node_child_id = 24;
+ optional int64 node_id = 2;
+ optional int64 ts = 3;
+ optional int64 dur = 4;
+ optional int64 monotonic_dur = 25;
+ optional string process_name = 14;
+ optional uint32 pid = 23;
+ optional uint32 waiter_count = 11;
+ repeated ThreadStateBreakdown thread_states = 19;
+ repeated BlockedFunctionBreakdown blocked_functions = 20;
+
+ // Blocking context
+ optional string blocking_method = 5;
+ optional string short_blocking_method = 7;
+ optional string blocking_src = 9;
+ optional string blocking_thread_name = 13;
+ optional bool is_blocking_thread_main = 16;
+ optional uint32 blocking_thread_tid = 22;
+
+ // Blocked context
+ optional string blocked_method = 6;
+ optional string short_blocked_method = 8;
+ optional string blocked_src = 10;
+ optional string blocked_thread_name = 12;
+ optional bool is_blocked_thread_main = 15;
+ optional uint32 blocked_thread_tid = 21;
+
+ // Binder context
+ optional int64 binder_reply_ts = 17;
+ optional uint32 binder_reply_tid = 18;
+ }
+
+ message ThreadStateBreakdown {
+ optional string thread_state = 1;
+ optional int64 thread_state_dur = 2;
+ optional int64 thread_state_count = 3;
+ }
+
+ message BlockedFunctionBreakdown {
+ optional string blocked_function = 1;
+ optional int64 blocked_function_dur = 2;
+ optional int64 blocked_function_count = 3;
+ }
+
+ repeated Node node = 1;
+}
+
+// End of protos/perfetto/metrics/android/monitor_contention_metric.proto
+
+// Begin of protos/perfetto/metrics/android/multiuser_metric.proto
+
+// Metrics for Multiuser events, such as switching users.
+message AndroidMultiuserMetric {
+
+ // Holds the data for a Multiuser event.
+ message EventData {
+ // Duration of the event (in milliseconds).
+ optional int32 duration_ms = 1;
+
+ // CPU usage of each process during the event.
+ message CpuUsage {
+ // The userId of the process (e.g. 0 or 10).
+ optional int32 user_id = 1;
+ // The name of the process.
+ optional string process_name = 2;
+ // The number of CPU cycles (in megacycles) spent by that process during the event.
+ optional int32 cpu_mcycles = 3;
+ // The ratio of this process's cycles to the total for all processes, expressed as a percentage.
+ optional float cpu_percentage = 4;
+ // General identifier for this usage source: determined from the process name, user, etc.
+ // Should be stable across multiple runs (i.e. does not print the user_id directly).
+ optional string identifier = 5;
+ }
+ repeated CpuUsage cpu_usage = 2;
+ }
+
+ // Metrics for a user switch.
+ optional EventData user_switch = 1;
+}
+// End of protos/perfetto/metrics/android/multiuser_metric.proto
+
+// Begin of protos/perfetto/metrics/android/network_metric.proto
+
+message AndroidNetworkMetric {
+ message PacketStatistic {
+ // Packet count.
+ optional int64 packets = 1;
+
+ // Packet Bytes.
+ optional int64 bytes = 2;
+
+ // Timestamp when first packet received or transmitted.
+ optional int64 first_packet_timestamp_ns = 3;
+
+ // Timestamp when last packet received or transmitted.
+ optional int64 last_packet_timestamp_ns = 4;
+
+ // Interval between first & last packet. The minimum interval is 10ms.
+ optional int64 interval_ns = 5;
+
+ // Data Speed.
+ optional double data_rate_kbps = 6;
+ }
+
+ message CorePacketStatistic {
+ optional uint32 id = 1;
+ optional PacketStatistic packet_statistic = 2;
+ }
+
+ message Rx {
+ // Total packets statistic.
+ optional PacketStatistic total = 1;
+
+ // Per core packets statistic.
+ repeated CorePacketStatistic core = 2;
+
+ // GRO aggregation ratio.
+ optional string gro_aggregation_ratio = 3;
+ }
+
+ message Tx {
+ // Total packets statistic.
+ optional PacketStatistic total = 1;
+
+ // Per core packets statistic.
+ repeated CorePacketStatistic core = 2;
+ }
+
+ message NetDevice {
+ // Network device name.
+ optional string name = 1;
+
+ // Ingress traffic statistic.
+ optional Rx rx = 2;
+
+ // Egress traffic statistic
+ optional Tx tx = 3;
+ }
+
+ message NetRxActionStatistic {
+ // SoftIrq NET_RX action count.
+ optional int64 count = 1;
+
+ // SoftIrq NET_RX action was running in millisecond.
+ optional double runtime_ms = 2;
+
+ // SoftIrq NET_RX action average running time.
+ optional double avg_runtime_ms = 3;
+
+ // CPU megacycles (i.e. cycles divided by 1e6).
+ optional int64 mcycles = 4;
+
+ // Average weighted CPU frequency by the time the NET_RX Action
+ // running at each frequency.
+ optional int64 avg_freq_khz = 5;
+ }
+
+ message NetTxActionStatistic {
+ // SoftIrq NET_TX action count.
+ optional int64 count = 1;
+
+ // SoftIrq NET_TX action was running in millisecond.
+ optional double runtime_ms = 2;
+
+ // SoftIrq NET_TX action average running time.
+ optional double avg_runtime_ms = 3;
+
+ // CPU megacycles (i.e. cycles divided by 1e6).
+ optional int64 mcycles = 4;
+
+ // Average weighted CPU frequency by the time the NET_TX Action
+ // running at each frequency.
+ optional int64 avg_freq_khz = 5;
+ }
+
+ message IpiActionStatistic {
+ // SoftIrq IPI action count.
+ optional int64 count = 1;
+
+ // SoftIrq IPI action was running in millisecond.
+ optional double runtime_ms = 2;
+
+ // SoftIrq IPI action average running time.
+ optional double avg_runtime_ms = 3;
+ }
+
+ message CoreNetRxActionStatistic {
+ optional uint32 id = 1;
+ optional NetRxActionStatistic net_rx_action_statistic = 2;
+ }
+
+ message CoreNetTxActionStatistic {
+ optional uint32 id = 1;
+ optional NetTxActionStatistic net_tx_action_statistic = 2;
+ }
+
+ message NetRxAction {
+ // Total NET_RX action statistics.
+ optional NetRxActionStatistic total = 1;
+
+ // Per core NET_RX action statistics.
+ repeated CoreNetRxActionStatistic core = 2;
+
+ // The average packet time moves through the kernel stack.
+ optional double avg_interstack_latency_ms = 3;
+ }
+
+ message NetTxAction {
+ // Total NET_TX action statistics.
+ optional NetTxActionStatistic total = 1;
+
+ // Per core NET_TX action statistics.
+ repeated CoreNetTxActionStatistic core = 2;
+ }
+
+ message IpiAction {
+ // Total IPI action statistics.
+ optional IpiActionStatistic total = 1;
+ }
+
+ // Network device metrics.
+ repeated NetDevice net_devices = 1;
+
+ // SoftIrq NET_RX action metrics.
+ optional NetRxAction net_rx_action = 2;
+
+ // Packet retransmission rate.
+ optional double retransmission_rate = 3;
+
+ // Kfree Skb rate (i.e. kfree_skb count divided by the packet count from all
+ // net devices).
+ optional double kfree_skb_rate = 4;
+
+ // SoftIrq NET_TX action metrics.
+ optional NetTxAction net_tx_action = 5;
+
+ // SoftIrq IPI action metrics.
+ optional IpiAction ipi_action = 6;
+}
+
+// End of protos/perfetto/metrics/android/network_metric.proto
+
+// Begin of protos/perfetto/metrics/android/other_traces.proto
+
+message AndroidOtherTracesMetric {
+ // Uuids of other traces being finalized while the current trace was being
+ // recorded.
+ repeated string finalized_traces_uuid = 1;
+}
+
+// End of protos/perfetto/metrics/android/other_traces.proto
+
+// Begin of protos/perfetto/metrics/android/package_list.proto
+
+message AndroidPackageList {
+ message Package {
+ optional string package_name = 1;
+ optional int64 uid = 2;
+ optional int64 version_code = 3;
+ }
+
+ repeated Package packages = 1;
+}
+
+// End of protos/perfetto/metrics/android/package_list.proto
+
+// Begin of protos/perfetto/metrics/android/powrails_metric.proto
+
+message AndroidPowerRails {
+ // Energy data per Power Rail at given ts.
+ message EnergyData {
+ // Time since device boot(CLOCK_BOTTOMTIME) in milli-seconds.
+ optional int64 timestamp_ms = 1;
+ // Accumulated energy since device boot in microwatt-seconds(uws).
+ optional double energy_uws = 2;
+ }
+
+ message PowerRails {
+ // Name of the rail.
+ optional string name = 1;
+ // Energy data for given rail and for all samples in the trace.
+ repeated EnergyData energy_data = 2;
+ // The average used power between the first and the last sampled
+ // energy data in miliwatt (mw)
+ optional double avg_used_power_mw = 3;
+ }
+
+ // Energy data per Power Rail.
+ repeated PowerRails power_rails = 1;
+
+ // The average used power between the first and last sampled rail across all
+ // the rails in milliwatts (mw).
+ optional double avg_total_used_power_mw = 2;
+}
+// End of protos/perfetto/metrics/android/powrails_metric.proto
+
+// Begin of protos/perfetto/metrics/android/profiler_smaps.proto
+
+message ProfilerSmaps {
+ message Mapping {
+ optional string path = 1;
+ optional int32 size_kb = 2;
+ optional int32 private_dirty_kb = 3;
+ optional int32 swap_kb = 4;
+ }
+
+ message Instance {
+ optional AndroidProcessMetadata process = 1;
+ repeated Mapping mappings = 2;
+ }
+
+ repeated Instance instance = 1;
+}
+
+// End of protos/perfetto/metrics/android/profiler_smaps.proto
+
+// Begin of protos/perfetto/metrics/android/rt_runtime_metric.proto
+
+// measure max RT runtime and RT tasks running over 5ms.
+message AndroidRtRuntimeMetric {
+ message RtSlice {
+ // thread name
+ optional string tname = 1;
+ // timestamp
+ optional int64 ts = 2;
+ // runtime of RT task
+ optional int64 dur = 3;
+ }
+
+ // max runtime of RT tasks
+ optional int64 max_runtime = 1;
+ // how many RT tasks are over 5ms.
+ optional int64 over_5ms_count = 2;
+ // information for top 10 RT tasks
+ repeated RtSlice longest_rt_slices = 3;
+}
+
+
+// End of protos/perfetto/metrics/android/rt_runtime_metric.proto
+
+// Begin of protos/perfetto/metrics/android/simpleperf.proto
+
+// Metric that stores information related to atrace events generated by
+// simpleperf tool
+message AndroidSimpleperfMetric {
+ optional double urgent_ratio = 1;
+
+ message PerfEventMetric {
+ // Simpleperf event name
+ optional string name = 1;
+
+ message Thread {
+ // Thread ID
+ optional int32 tid = 1;
+ // Thread name
+ optional string name = 2;
+ // CPU ID
+ optional int32 cpu = 3;
+ // Total counter value
+ optional double total = 4;
+ }
+
+ message Process {
+ // Process ID
+ optional int32 pid = 1;
+ // Process name
+ optional string name = 2;
+ // Metrics for each thread in this process.
+ repeated Thread threads = 3;
+ // Total counter value over all threads in this process
+ optional double total = 4;
+ }
+
+ // Metrics for each process
+ repeated Process processes = 2;
+
+ // Total counter value over all processes and threads
+ optional double total = 3;
+ }
+
+ repeated PerfEventMetric events = 2;
+}
+
+// End of protos/perfetto/metrics/android/simpleperf.proto
+
+// Begin of protos/perfetto/metrics/android/startup_metric.proto
+
+// Android app startup metrics.
+message AndroidStartupMetric {
+ // A simplified view of the task state durations for a thread
+ // and a span of time.
+ message TaskStateBreakdown {
+ optional int64 running_dur_ns = 1;
+ optional int64 runnable_dur_ns = 2;
+ optional int64 uninterruptible_sleep_dur_ns = 3;
+ optional int64 interruptible_sleep_dur_ns = 4;
+ optional int64 uninterruptible_io_sleep_dur_ns = 5;
+ optional int64 uninterruptible_non_io_sleep_dur_ns = 6;
+ }
+
+ message McyclesByCoreType {
+ optional int64 little = 1;
+ optional int64 big = 2;
+ optional int64 bigger = 3;
+ optional int64 unknown = 4;
+ }
+
+ message Slice {
+ optional int64 dur_ns = 1;
+ optional double dur_ms = 2;
+ }
+
+ // Timing information spanning the intent received by the
+ // activity manager to the first frame drawn.
+ // Next id: 36.
+ message ToFirstFrame {
+ // The duration between the intent received and first frame.
+ optional int64 dur_ns = 1;
+ optional double dur_ms = 17;
+
+ // Breakdown of time to first frame by task state for the main thread of
+ // the process starting up.
+ optional TaskStateBreakdown main_thread_by_task_state = 2;
+
+ // The mcycles taken by this startup across all CPUs (broken down by core
+ // type).
+ optional McyclesByCoreType mcycles_by_core_type = 26;
+
+ // In this timespan, how many processes (apart from the main activity) were
+ // spawned.
+ optional uint32 other_processes_spawned_count = 3;
+
+ // Total time spent in activity manager between the initial intent
+ // and the end of the activity starter.
+ optional Slice time_activity_manager = 4;
+
+ // The following slices follow the typical steps post-fork.
+ optional Slice time_activity_thread_main = 5;
+ optional Slice time_bind_application = 6;
+ optional Slice time_activity_start = 7;
+ optional Slice time_activity_resume = 8;
+ optional Slice time_activity_restart = 21;
+ optional Slice time_choreographer = 9;
+ optional Slice time_inflate = 22;
+ optional Slice time_get_resources = 23;
+
+ // If we are starting a new process, record the duration from the
+ // intent being received to the time we call the zygote.
+ optional Slice time_before_start_process = 10;
+
+ // The actual duration of the process start (based on the zygote slice).
+ optional Slice time_during_start_process = 11;
+
+ // The duration from launch to first running state thread of startup process.
+ optional Slice time_to_running_state = 35;
+
+ optional Slice to_post_fork = 18;
+ optional Slice to_activity_thread_main = 19;
+ optional Slice to_bind_application = 20;
+
+ optional Slice time_post_fork = 16;
+
+ // The total time spent on opening dex files.
+ optional Slice time_dex_open = 24;
+ // Total time spent verifying classes during app startup.
+ optional Slice time_verify_class = 25;
+
+ // Number of methods that were compiled by JIT during app startup.
+ optional uint32 jit_compiled_methods = 27;
+
+ // Time spent running CPU on jit thread pool.
+ optional Slice time_jit_thread_pool_on_cpu = 28;
+
+ // Time spent on garbage collection.
+ optional Slice time_gc_total = 29;
+ optional Slice time_gc_on_cpu = 30;
+
+ // Time spent in lock contention on the main thread of the process being
+ // started up. This includes *all* types of lock contention not just monitor
+ // contention.
+ optional Slice time_lock_contention_thread_main = 31;
+
+ // Time spent in monitor lock contention on the main thread of the
+ // process being started up. This will be a subset of the time counted by
+ // |time_lock_contention_thread_main|.
+ optional Slice time_monitor_contention_thread_main = 32;
+
+ // Time spent in opening dex files on the main thread of the process
+ // being started up.
+ optional Slice time_dex_open_thread_main = 33;
+
+ // Time spent in dlopening .so files on the main thread of the process
+ // being started up.
+ optional Slice time_dlopen_thread_main = 34;
+
+ // Removed: was other_process_to_activity_cpu_ratio.
+ reserved 12;
+
+ // Removed: was uint32 versions of to_post_fork, to_activity_thread_main and
+ // to_bind_application.
+ reserved 13, 14, 15;
+ }
+
+ // Metrics about startup which were developed by looking at experiments using
+ // high-speed cameras (HSC).
+ message HscMetrics {
+ // The duration of the full "startup" as defined by HSC tests.
+ optional Slice full_startup = 1;
+ }
+
+ message Activity {
+ optional string name = 1;
+ optional string method = 2;
+ optional int64 ts_method_start = 4;
+
+ // Field 3 contained Slice with a sum of durations for matching slices.
+ reserved 3;
+ }
+
+ message BinderTransaction {
+ optional Slice duration = 1;
+ optional string thread = 2;
+ optional string destination_thread = 3;
+ optional string destination_process = 4;
+ // From
+ // https://cs.android.com/android/platform/superproject/+/main:external/perfetto/protos/perfetto/trace/ftrace/binder.proto;l=15;drc=7b6a788162a30802f4c9d8d7a30a54e25edd30f1
+ optional string flags = 5;
+ // From
+ // https://cs.android.com/android/platform/superproject/+/main:external/perfetto/protos/perfetto/trace/ftrace/binder.proto;l=14;drc=7b6a788162a30802f4c9d8d7a30a54e25edd30f1
+ optional string code = 6;
+ // From
+ // https://cs.android.com/android/platform/superproject/+/main:external/perfetto/protos/perfetto/trace/ftrace/binder.proto;l=37;drc=7b6a788162a30802f4c9d8d7a30a54e25edd30f1
+ optional int64 data_size = 7;
+ }
+
+ // Metrics with information about the status of odex files and the outcome
+ // of the loading process.
+ // Multiple files might be loaded for a single startup. Platform might also
+ // decide to discard an odex file and instead load a fallback, for example
+ // in case the OS or apk were updated.
+ message OptimizationStatus {
+ optional string odex_status = 1;
+ optional string compilation_filter = 2;
+ optional string compilation_reason = 3;
+ optional string location = 4;
+ optional string summary = 5;
+ }
+
+ // Contains the name and duration of class verification occurred during
+ // the startup.
+ message VerifyClass {
+ optional string name = 1;
+ optional int64 dur_ns = 2;
+ }
+
+ // Contains timestamps of important events which occurred during the
+ // startup.
+ message EventTimestamps {
+ optional int64 intent_received = 1;
+ optional int64 first_frame = 2;
+ }
+
+ // Contains information about the state of a system during the app startup.
+ // Useful to put the startup in context.
+ message SystemState {
+ // Whether the dex2oat64 process was running concurrent to the startup.
+ // Deprecated as of 10/2022.
+ optional bool dex2oat_running = 1 [deprecated=true];
+
+ // Whether the installd process was running concurrent to the startup.
+ // Deprecated as of 10/2022.
+ optional bool installd_running = 2 [deprecated=true];
+
+ // The number of broadcasts dispatched by the system during the app
+ // launch.
+ optional int64 broadcast_dispatched_count = 3;
+
+ // The number of broadcasts received by an app or the system during the
+ // app launch. Note that multiple packages can be subscribed to the same
+ // broadcast so a single dsipatch can cause multiple packages to receive
+ // and process a broadcast.
+ optional int64 broadcast_received_count = 4;
+
+ // The most active (i.e. consuming the most mcycles) processes during the
+ // app launch excluding the process(es) being launched.
+ // Note: the exact number of returned is an implementation detail and
+ // will likely change over time.
+ repeated string most_active_non_launch_processes = 5;
+
+ // Duration the installd process was running concurrent to the startup.
+ optional int64 installd_dur_ns = 6;
+ // Duration the dex2oat64 process was running concurrent to the startup.
+ optional int64 dex2oat_dur_ns = 7;
+ }
+
+ // Contains detailed information for slow startup causes.
+ message SlowStartReasonDetailed {
+ optional string reason = 1;
+ optional string details = 2;
+ }
+
+ // Next id: 22
+ message Startup {
+ // Random id uniquely identifying an app startup in this trace.
+ optional uint32 startup_id = 1;
+
+ // Startup type (cold / warm / hot)
+ optional string startup_type = 16;
+
+ // Name of the package launched
+ optional string package_name = 2;
+
+ // Name of the process launched
+ optional string process_name = 3;
+
+ // Details about the activities launched
+ repeated Activity activities = 11;
+
+ // Details about slow binder transactions during the startup. The definition
+ // of a slow transaction is an implementation detail.
+ repeated BinderTransaction long_binder_transactions = 14;
+
+ // Did we ask the zygote for a new process
+ optional bool zygote_new_process = 4;
+
+ // Number of processes hosting the activity involved in the launch.
+ // This will usually be 1. If it is 0, it is indicative of a data / process
+ // error. If > 1, the process died during startup and the system respawned
+ // it.
+ optional uint32 activity_hosting_process_count = 6;
+
+ // Contains timestamps of important events which happened during
+ // the startup.
+ optional EventTimestamps event_timestamps = 13;
+
+ // Timing information spanning the intent received by the
+ // activity manager to the first frame drawn.
+ optional ToFirstFrame to_first_frame = 5;
+
+ // Details about the process (uid, version, etc)
+ optional AndroidProcessMetadata process = 7;
+
+ // Metrics about startup which were developed by looking at experiments
+ // using high-speed cameras (HSC).
+ optional HscMetrics hsc = 8;
+
+ // The time taken in the startup from intent received to the start time
+ // of the reportFullyDrawn slice. This should be longer than the time to
+ // first frame as the application decides this after it starts rendering.
+ optional Slice report_fully_drawn = 9;
+
+ // Contains information about the status of odex files.
+ repeated OptimizationStatus optimization_status = 12;
+
+ // Contains information about the class verification.
+ repeated VerifyClass verify_class = 19;
+
+ // Contains the dlopen file names.
+ repeated string dlopen_file = 20;
+
+ // Package name of startups running concurrent to the launch.
+ repeated string startup_concurrent_to_launch = 18;
+
+ // Contains information about the state of the rest of the system during the
+ // startup. This is useful for getting context about why a startup might
+ // be slow beyond just what the app is doing.
+ optional SystemState system_state = 15;
+
+ // A list of identified potential causes for slow startup.
+ // Optional.
+ repeated string slow_start_reason = 17;
+
+ // Same as slow_start_reason, but with more detailed information.
+ repeated SlowStartReasonDetailed slow_start_reason_detailed = 21;
+
+ reserved 10;
+ }
+
+ repeated Startup startup = 1;
+}
+
+// End of protos/perfetto/metrics/android/startup_metric.proto
+
+// Begin of protos/perfetto/metrics/android/surfaceflinger.proto
+
+message AndroidSurfaceflingerMetric {
+ // Counts the number of missed frames in the trace.
+ optional uint32 missed_frames = 1;
+
+ // Counts the number of missed HWC frames in the trace.
+ optional uint32 missed_hwc_frames = 2;
+
+ // Counts the number of missed GPU frames in the trace.
+ optional uint32 missed_gpu_frames = 3;
+
+ // Calculate the number of missed frames divided by
+ // total frames
+ optional double missed_frame_rate = 4;
+
+ // Calculate the number of missed HWC frames divided by
+ // total HWC frames
+ optional double missed_hwc_frame_rate = 5;
+
+ // Calculate the number of missed GPU frames divided by
+ // total GPU frames
+ optional double missed_gpu_frame_rate = 6;
+
+ // Count the number of times SurfaceFlinger needs to invoke GPU
+ // for rendering some layers
+ optional uint32 gpu_invocations = 7;
+
+ // Calculate the average duration of GPU request by SurfaceFlinger
+ // since it enters the FenceMonitor's queue until it gets completed
+ optional double avg_gpu_waiting_dur_ms = 8;
+
+ // Calculate the total duration when there is at least one GPU request
+ // by SurfaceFlinger that is still waiting for GPU to complete the
+ // request.
+ // This also equals to the total duration of
+ // "waiting for GPU completion <fence_num>" in SurfaceFlinger.
+ optional double total_non_empty_gpu_waiting_dur_ms = 9;
+
+ message MetricsPerDisplay {
+ // Display ID in SF
+ optional string display_id = 1;
+
+ // Counts the number of missed frames in the trace.
+ optional uint32 missed_frames = 2;
+
+ // Counts the number of missed HWC frames in the trace.
+ optional uint32 missed_hwc_frames = 3;
+
+ // Counts the number of missed GPU frames in the trace.
+ optional uint32 missed_gpu_frames = 4;
+
+ // Calculate the number of missed frames divided by
+ // total frames
+ optional double missed_frame_rate = 5;
+
+ // Calculate the number of missed HWC frames divided by
+ // total HWC frames
+ optional double missed_hwc_frame_rate = 6;
+
+ // Calculate the number of missed GPU frames divided by
+ // total GPU frames
+ optional double missed_gpu_frame_rate = 7;
+ }
+
+ repeated MetricsPerDisplay metrics_per_display = 10;
+}
+
+// End of protos/perfetto/metrics/android/surfaceflinger.proto
+
+// Begin of protos/perfetto/metrics/android/sysui_slice_performance_statistical_data.proto
+
+// Statistical performance data row for a set of slices
+message SysUiSlicePerformanceStatisticalData {
+ // Name of the Slice
+ optional string name = 1;
+ // Number of times it happened within the CUJ
+ optional int64 cnt = 2;
+ // Average duration within the CUJ
+ optional int64 avg_dur_ms = 3;
+ // Maximal duration within the CUJ
+ optional int64 max_dur_ms = 4;
+ // Average duration within the CUJ in nanoseconds
+ optional int64 avg_dur_ns = 6;
+ // Maximal duration within the CUJ in nanoseconds
+ optional int64 max_dur_ns = 7;
+}
+// End of protos/perfetto/metrics/android/sysui_slice_performance_statistical_data.proto
+
+// Begin of protos/perfetto/metrics/android/sysui_notif_shade_list_builder_metric.proto
+// System UI Notifications ShadeListBuilder.buildList slices.
+// Shows count, average duration, and max duration for each.
+message SysuiNotifShadeListBuilderMetric {
+ optional SysUiSlicePerformanceStatisticalData all_slices_performance = 1;
+ optional SysUiSlicePerformanceStatisticalData slices_with_inflation_performance = 2;
+ optional SysUiSlicePerformanceStatisticalData slices_with_modification_performance = 3;
+
+ // Data row for a single slice
+ message SliceDuration {
+ // Name of the Slice
+ optional string name = 1;
+
+ // Duration in ms
+ optional int64 dur_ms = 2;
+
+ // Duration in ns
+ optional int64 dur_ns = 3;
+ }
+ repeated SliceDuration slice = 4;
+}
+// End of protos/perfetto/metrics/android/sysui_notif_shade_list_builder_metric.proto
+
+// Begin of protos/perfetto/metrics/android/sysui_update_notif_on_ui_mode_changed_metric.proto
+
+// System UI Notifications ShadeListBuilder.buildList slices.
+// Shows count, average duration, and max duration for each.
+message SysuiUpdateNotifOnUiModeChangedMetric {
+ optional SysUiSlicePerformanceStatisticalData all_slices_performance = 1;
+ // Data row for a single slice
+ message SliceDuration {
+ // Name of the Slice
+ optional string name = 1;
+
+ // Duration in ms
+ optional int64 dur_ms = 2;
+
+ // Duration in ns
+ optional int64 dur_ns = 3;
+ }
+ repeated SliceDuration slice = 2;
+}
+// End of protos/perfetto/metrics/android/sysui_update_notif_on_ui_mode_changed_metric.proto
+
+// Begin of protos/perfetto/metrics/android/task_names.proto
+
+message AndroidTaskNames {
+ message Process {
+ optional int64 pid = 1;
+
+ // Process name.
+ optional string process_name = 2;
+
+ // Names of all threads for this process.
+ repeated string thread_name = 3;
+
+ // User id under which this process runs.
+ optional int64 uid = 4;
+
+ // Packages matching the process uid.
+ repeated string uid_package_name = 5;
+
+ // Removed, was short_lived_tasks.
+ reserved 6;
+
+ // Removed, was long_lived_tasks.
+ reserved 7;
+ }
+
+ repeated Process process = 1;
+}
+
+// End of protos/perfetto/metrics/android/task_names.proto
+
+// Begin of protos/perfetto/metrics/android/trace_quality.proto
+
+// Metric which checks the data in the trace processor tables is "reasonble"
+// (i.e. we would expect to see it from a real device).
+//
+// This is useful to reject traces which may be valid (so no stat would be
+// recorded) but a human would find the trace nonsensical.
+message AndroidTraceQualityMetric {
+ message Failure {
+ // The name of the failed check.
+ optional string name = 1;
+ }
+ repeated Failure failures = 1;
+}
+// End of protos/perfetto/metrics/android/trace_quality.proto
+
+// Begin of protos/perfetto/metrics/android/unsymbolized_frames.proto
+
+message UnsymbolizedFrames {
+ message Frame {
+ optional string module = 1;
+ optional string build_id = 2;
+ optional int64 address = 3;
+
+ // In some cases (Chrome/Webview) the ID that should be used to query
+ // symbols in Google's internal tera-scale symbolization service is !=
+ // `build_id` and requires some mangling.
+ // This field is == 'build_id` for non-chromium cases, and is the breakpad
+ // module ID (with lowercase hex digics) for chromium cases.
+ optional string google_lookup_id = 4;
+ }
+
+ repeated Frame frames = 1;
+}
+
+// End of protos/perfetto/metrics/android/unsymbolized_frames.proto
+
+// Begin of protos/perfetto/metrics/metrics.proto
+
+// Trace processor metadata
+message TraceMetadata {
+ reserved 1;
+ optional int64 trace_duration_ns = 2;
+ optional string trace_uuid = 3;
+ optional string android_build_fingerprint = 4;
+ optional int64 statsd_triggering_subscription_id = 5;
+ optional int64 trace_size_bytes = 6;
+ repeated string trace_trigger = 7;
+ optional string unique_session_name = 8;
+ optional string trace_config_pbtxt = 9;
+ optional int64 sched_duration_ns = 10;
+ optional int64 tracing_started_ns = 11;
+}
+
+// Stats counters for the trace.
+// Defined in src/trace_processor/storage/stats.h
+message TraceAnalysisStats {
+ enum Severity {
+ SEVERITY_UNKNOWN = 0;
+ SEVERITY_INFO = 1;
+ SEVERITY_DATA_LOSS = 2;
+ SEVERITY_ERROR = 3;
+ }
+
+ enum Source {
+ SOURCE_UNKNOWN = 0;
+ SOURCE_TRACE = 1;
+ SOURCE_ANALYSIS = 2;
+ }
+
+ message Stat {
+ optional string name = 1;
+ optional uint32 idx = 2;
+ optional Severity severity = 3;
+ optional Source source = 4;
+
+ optional int64 count = 5;
+ }
+
+ repeated Stat stat = 1;
+}
+
+// Root message for all Perfetto-based metrics.
+//
+// Next id: 63
+message TraceMetrics {
+ reserved 4, 10, 13, 14, 16, 19;
+
+ // Battery counters metric on Android.
+ optional AndroidBatteryMetric android_batt = 5;
+
+ // CPU usage per trace, process and thread.
+ optional AndroidCpuMetric android_cpu = 6;
+
+ // Memory metrics on Android (owned by the Android Telemetry team).
+ optional AndroidMemoryMetric android_mem = 1;
+
+ // Memory metrics on Android in unaggregated form. (owned by the Android
+ // Telemetry team).
+ // Note: this generates a lot of data so should not be requested unless it
+ // is clear that this data is necessary.
+ optional AndroidMemoryUnaggregatedMetric android_mem_unagg = 11;
+
+ // Package list.
+ optional AndroidPackageList android_package_list = 12;
+
+ // ion buffer memory metrics.
+ optional AndroidIonMetric android_ion = 9;
+
+ // fastrpc subsystem memory metrics.
+ optional AndroidFastrpcMetric android_fastrpc = 31;
+
+ // Statistics about low memory kills.
+ optional AndroidLmkMetric android_lmk = 8;
+
+ // Power Rails metrics on Android.
+ optional AndroidPowerRails android_powrails = 7;
+
+ // Startup metrics on Android (owned by the Android Telemetry team).
+ optional AndroidStartupMetric android_startup = 2;
+
+ // Trace metadata (applicable to all traces).
+ optional TraceMetadata trace_metadata = 3;
+
+ // Trace stats (applicable to all traces).
+ optional TraceAnalysisStats trace_stats = 33;
+
+ // Returns stack frames missing symbols.
+ optional UnsymbolizedFrames unsymbolized_frames = 15;
+
+ // If the trace contains a heap graph, output allocation statistics.
+ optional JavaHeapStats java_heap_stats = 17;
+
+ // If the trace contains a heap graph, output histogram.
+ optional JavaHeapHistogram java_heap_histogram = 21;
+
+ // Metrics used to find potential culprits of low-memory kills.
+ optional AndroidLmkReasonMetric android_lmk_reason = 18;
+
+ optional AndroidHwuiMetric android_hwui_metric = 20;
+
+ optional AndroidDisplayMetrics display_metrics = 22;
+
+ optional AndroidTaskNames android_task_names = 23;
+
+ // Deprecated was AndroidThreadTimeInStateMetric
+ reserved 24;
+
+ // Metric associated with surfaceflinger.
+ optional AndroidSurfaceflingerMetric android_surfaceflinger = 25;
+
+ // GPU metrics on Android.
+ optional AndroidGpuMetric android_gpu = 26;
+
+ // Deprecated AndroidSysUiCujMetrics.
+ reserved 27;
+
+ // Interaction and frame timings for CUJs (important UI transitions).
+ optional AndroidJankCujMetric android_jank_cuj = 48;
+
+ // Metric associated with hwcomposer.
+ optional AndroidHwcomposerMetrics android_hwcomposer = 28;
+
+ // Deprecated was AndroidJankMetrics;
+ reserved 29;
+
+ // G2D metrics.
+ optional G2dMetrics g2d = 30;
+
+ // Dmabuf heap metrics.
+ optional AndroidDmaHeapMetric android_dma_heap = 32;
+
+ // Metric to verify the quality of the trace.
+ optional AndroidTraceQualityMetric android_trace_quality = 34;
+
+ // Profiler smaps
+ optional ProfilerSmaps profiler_smaps = 35;
+
+ // Multiuser - metrics for switching users.
+ optional AndroidMultiuserMetric android_multiuser = 36;
+
+ // Metrics related to simpleperf tool
+ optional AndroidSimpleperfMetric android_simpleperf = 37;
+
+ // Metrics for the Camera team.
+ optional AndroidCameraMetric android_camera = 38;
+
+ // Metrics for dynamic voltage and frequency scaling.
+ optional AndroidDvfsMetric android_dvfs = 39;
+
+ // Metrics for network performance.
+ optional AndroidNetworkMetric android_netperf = 40;
+
+ // Metrics for the Camera team.
+ // Note: this generates a lot of data so should not be requested unless it
+ // is clear that this data is necessary.
+ optional AndroidCameraUnaggregatedMetric android_camera_unagg = 41;
+
+ // Metrics for RT runtime.
+ optional AndroidRtRuntimeMetric android_rt_runtime = 42;
+
+ // Metrics for IRQ runtime.
+ optional AndroidIrqRuntimeMetric android_irq_runtime = 43;
+
+ // Metrics for the Trusty team.
+ optional AndroidTrustyWorkqueues android_trusty_workqueues = 44;
+
+ // Summary of other concurrent trace recording.
+ optional AndroidOtherTracesMetric android_other_traces = 45;
+
+ // Per-process Binder transaction metrics.
+ optional AndroidBinderMetric android_binder = 46;
+
+ // Metrics for app deadline missed.
+ optional AndroidFrameTimelineMetric android_frame_timeline_metric = 47;
+
+ // Blocking calls (e.g. binder calls) for CUJs (important UI transitions).
+ optional AndroidBlockingCallsCujMetric android_blocking_calls_cuj_metric = 49;
+
+ optional AndroidMonitorContentionMetric android_monitor_contention = 50;
+
+ optional AndroidSysUINotificationsBlockingCallsMetric android_sysui_notifications_blocking_calls_metric = 51;
+
+ // Metrics to track codec framework.
+ optional AndroidCodecMetrics codec_metrics = 52;
+
+ // Metric to track Android IO.
+ optional AndroidIo android_io = 53;
+
+ // IO metrics on Android in unaggregated form.
+ // Note: this generates a lot of data so should not be requested unless it
+ // is clear that this data is necessary.
+ optional AndroidIoUnaggregated android_io_unagg = 54;
+
+ // Metrics for App Not Responding (ANR) errors.
+ optional AndroidAnrMetric android_anr = 55;
+
+ // Aggregated Android Monitor Contention metrics
+ optional AndroidMonitorContentionAggMetric android_monitor_contention_agg = 56;
+
+ optional AndroidBootMetric android_boot = 57;
+
+ // Metric for AdServices module.
+ optional AdServicesMetric ad_services_metric = 58;
+
+ optional SysuiNotifShadeListBuilderMetric sysui_notif_shade_list_builder_metric = 59;
+
+ optional SysuiUpdateNotifOnUiModeChangedMetric sysui_update_notif_on_ui_mode_changed_metric = 60;
+
+ // Metrics for Process starts.
+ optional AndroidAppProcessStartsMetric android_app_process_starts = 61;
+
+ // Android boot unaggregated metrics.
+ optional AndroidBootUnagg android_boot_unagg = 62;
+
+ // Android garbage collection metrics
+ optional AndroidGarbageCollectionUnaggMetric android_garbage_collection_unagg = 63;
+
+ // Demo extensions.
+ extensions 450 to 499;
+
+ // Vendor extensions.
+ extensions 500 to 1000;
+
+ // Chrome metrics.
+ extensions 1001 to 2000;
+
+ // WebView metrics.
+ extensions 2001 to 2500;
+}
+
+// End of protos/perfetto/metrics/metrics.proto
diff --git a/protos/perfetto/trace_processor/metatrace_categories.proto b/protos/perfetto/trace_processor/metatrace_categories.proto
new file mode 100644
index 0000000..6b9ee23
--- /dev/null
+++ b/protos/perfetto/trace_processor/metatrace_categories.proto
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+syntax = "proto2";
+
+package perfetto.protos;
+
+// Bitmask of metatrace categories which can be enabled.
+// Keep in sync with TraceProcessor::MetatraceCategories.
+enum MetatraceCategories {
+ // 1 << 0.
+ QUERY_TIMELINE = 1;
+ // 1 << 1.
+ QUERY_DETAILED = 2;
+ // 1 << 2.
+ FUNCTION_CALL = 4;
+ // 1 << 3.
+ DB = 8;
+ // 1 << 4.
+ API_TIMELINE = 16;
+
+ // Aliases for common subsets.
+ NONE = 0;
+ ALL = 31;
+}
diff --git a/protos/perfetto/trace_processor/trace_processor.proto b/protos/perfetto/trace_processor/trace_processor.proto
new file mode 100644
index 0000000..1e579ca
--- /dev/null
+++ b/protos/perfetto/trace_processor/trace_processor.proto
@@ -0,0 +1,329 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+syntax = "proto2";
+
+package perfetto.protos;
+
+import "protos/perfetto/common/descriptor.proto";
+import "protos/perfetto/trace_processor/metatrace_categories.proto";
+
+// This file defines the schema for {,un}marshalling arguments and return values
+// when interfacing to the trace processor binary interface.
+
+// The Trace Processor can be used in three modes:
+// 1. Fully native from C++ or directly using trace_processor_shell.
+// In this case, this file isn't really relevant because no binary
+// marshalling is involved. Look at include/trace_processor/trace_processor.h
+// for the public C++ API definition.
+// 2. Using WASM within the HTML ui. In this case these messages are used to
+// {,un}marshall calls made through the JS<>WASM interop in
+// src/trace_processor/rpc/wasm_bridge.cc .
+// 3. Using the HTTP+RPC interface, by running trace_processor_shell -D.
+// In this case these messages are used to {,un}marshall HTTP requests and
+// response made through src/trace_processor/rpc/httpd.cc .
+
+enum TraceProcessorApiVersion {
+ // This variable has been introduced in v15 and is used to deal with API
+ // mismatches between UI and trace_processor_shell --httpd.
+ //
+ // Prior to API version 11 this was incremented every time a new
+ // feature that the UI depended on was introduced (e.g. new tables,
+ // new SQL operators, metrics that are required by the UI, etc).
+ // This:
+ // a. Tended to be forgotten
+ // b. Still led to issues when the TP dropped *backwards*
+ // compatibility of a feature (since we checked TP >= UI
+ // TRACE_PROCESSOR_CURRENT_API_VERSION).
+ // Now the UI attempts to redirect the user to the matched version
+ // of the UI if one exists.
+ // See also StatusResult.api_version (below).
+ // Changes:
+ // 7. Introduce GUESS_CPU_SIZE
+ // 8. Add 'json' option to ComputeMetricArgs
+ // 9. Add get_thread_state_summary_for_interval.
+ // 10. Add 'slice_is_ancestor' to stdlib.
+ // 11. Removal of experimental module from stdlib.
+ // 12. Changed UI to be more aggresive about version matching.
+ // Added version_code.
+ TRACE_PROCESSOR_CURRENT_API_VERSION = 12;
+}
+
+// At lowest level, the wire-format of the RPC protocol is a linear sequence of
+// TraceProcessorRpc messages on each side of the byte pipe
+// Each message is prefixed by a tag (field = 1, type = length delimited) and a
+// varint encoding its size (this is so the whole stream can also be read /
+// written as if it was a repeated field of TraceProcessorRpcStream).
+
+message TraceProcessorRpcStream {
+ repeated TraceProcessorRpc msg = 1;
+}
+
+message TraceProcessorRpc {
+ // A monotonic counter used only for debugging purposes, to detect if the
+ // underlying stream is missing or duping data. The counter starts at 0 on
+ // each side of the pipe and is incremented on each message.
+ // Do NOT expect that a response has the same |seq| of its corresponding
+ // request: some requests (e.g., a query returning many rows) can yield more
+ // than one response message, bringing the tx and rq seq our of sync.
+ optional int64 seq = 1;
+
+ // This is returned when some unrecoverable error has been detected by the
+ // peer. The typical case is TraceProcessor detecting that the |seq| sequence
+ // is broken (e.g. when having two tabs open with the same --httpd instance).
+ optional string fatal_error = 5;
+
+ enum TraceProcessorMethod {
+ TPM_UNSPECIFIED = 0;
+ TPM_APPEND_TRACE_DATA = 1;
+ TPM_FINALIZE_TRACE_DATA = 2;
+ TPM_QUERY_STREAMING = 3;
+ // Previously: TPM_QUERY_RAW_DEPRECATED
+ reserved 4;
+ reserved "TPM_QUERY_RAW_DEPRECATED";
+ TPM_COMPUTE_METRIC = 5;
+ TPM_GET_METRIC_DESCRIPTORS = 6;
+ TPM_RESTORE_INITIAL_TABLES = 7;
+ TPM_ENABLE_METATRACE = 8;
+ TPM_DISABLE_AND_READ_METATRACE = 9;
+ TPM_GET_STATUS = 10;
+ TPM_RESET_TRACE_PROCESSOR = 11;
+ }
+
+ oneof type {
+ // Client -> TraceProcessor requests.
+ TraceProcessorMethod request = 2;
+
+ // TraceProcessor -> Client responses.
+ TraceProcessorMethod response = 3;
+
+ // This is sent back instead of filling |response| when the client sends a
+ // |request| which is not known by the TraceProcessor service. This can
+ // happen when the client is newer than the service.
+ TraceProcessorMethod invalid_request = 4;
+ }
+
+ // Request/Response arguments.
+ // Not all requests / responses require an argument.
+
+ oneof args {
+ // TraceProcessorMethod request args.
+
+ // For TPM_APPEND_TRACE_DATA.
+ bytes append_trace_data = 101;
+ // For TPM_QUERY_STREAMING.
+ QueryArgs query_args = 103;
+ // For TPM_COMPUTE_METRIC.
+ ComputeMetricArgs compute_metric_args = 105;
+ // For TPM_ENABLE_METATRACE.
+ EnableMetatraceArgs enable_metatrace_args = 106;
+ // For TPM_RESET_TRACE_PROCESSOR.
+ ResetTraceProcessorArgs reset_trace_processor_args = 107;
+
+ // TraceProcessorMethod response args.
+ // For TPM_APPEND_TRACE_DATA.
+ AppendTraceDataResult append_result = 201;
+ // For TPM_QUERY_STREAMING.
+ QueryResult query_result = 203;
+ // For TPM_COMPUTE_METRIC.
+ ComputeMetricResult metric_result = 205;
+ // For TPM_GET_METRIC_DESCRIPTORS.
+ DescriptorSet metric_descriptors = 206;
+ // For TPM_DISABLE_AND_READ_METATRACE.
+ DisableAndReadMetatraceResult metatrace = 209;
+ // For TPM_GET_STATUS.
+ StatusResult status = 210;
+ }
+
+ // Previously: RawQueryArgs for TPM_QUERY_RAW_DEPRECATED
+ reserved 104;
+ // Previously: RawQueryResult for TPM_QUERY_RAW_DEPRECATED
+ reserved 204;
+}
+
+message AppendTraceDataResult {
+ optional int64 total_bytes_parsed = 1;
+ optional string error = 2;
+}
+
+message QueryArgs {
+ optional string sql_query = 1;
+ // Was time_queued_ns
+ reserved 2;
+ // Optional string to tag this query with for performance diagnostic purposes.
+ optional string tag = 3;
+}
+
+// Output for the /query endpoint.
+// Returns a query result set, grouping cells into batches. Batching allows a
+// more efficient encoding of results, at the same time allowing to return
+// O(M) results in a pipelined fashion, without full-memory buffering.
+// Batches are split when either a large number of cells (~thousands) is reached
+// or the string/blob payload becomes too large (~hundreds of KB).
+// Data is batched in cells, scanning results by row -> column. e.g. if a query
+// returns 3 columns and 2 rows, the cells will be emitted in this order:
+// R0C0, R0C1, R0C2, R1C0, R1C1, R1C2.
+message QueryResult {
+ // This determines the number and names of columns.
+ repeated string column_names = 1;
+
+ // If non-emty the query returned an error. Note that some cells might still
+ // be present, if the error happened while iterating.
+ optional string error = 2;
+
+ // A batch contains an array of cell headers, stating the type of each cell.
+ // The payload of each cell is stored in the corresponding xxx_cells field
+ // below (unless the cell is NULL).
+ // So if |cells| contains: [VARINT, FLOAT64, VARINT, STRING], the results will
+ // be available as:
+ // [varint_cells[0], float64_cells[0], varint_cells[1], string_cells[0]].
+ message CellsBatch {
+ enum CellType {
+ CELL_INVALID = 0;
+ CELL_NULL = 1;
+ CELL_VARINT = 2;
+ CELL_FLOAT64 = 3;
+ CELL_STRING = 4;
+ CELL_BLOB = 5;
+ }
+ repeated CellType cells = 1 [packed = true];
+
+ repeated int64 varint_cells = 2 [packed = true];
+ repeated double float64_cells = 3 [packed = true];
+ repeated bytes blob_cells = 4;
+
+ // The string cells are concatenated in a single field. Each cell is
+ // NUL-terminated. This is because JS incurs into a non-negligible overhead
+ // when decoding strings and one decode + split('\0') is measurably faster
+ // than decoding N strings. See goto.google.com/postmessage-benchmark .
+ optional string string_cells = 5;
+
+ // If true this is the last batch for the query result.
+ optional bool is_last_batch = 6;
+
+ // Padding field. Used only to re-align and fill gaps in the binary format.
+ reserved 7;
+ }
+ repeated CellsBatch batch = 3;
+
+ // The number of statements in the provided SQL.
+ optional uint32 statement_count = 4;
+
+ // The number of statements which produced output rows in the provided SQL.
+ optional uint32 statement_with_output_count = 5;
+
+ // The last statement in the provided SQL.
+ optional string last_statement_sql = 6;
+}
+
+// Input for the /status endpoint.
+message StatusArgs {}
+
+// Output for the /status endpoint.
+message StatusResult {
+ // If present and not empty, a trace is already loaded already. This happens
+ // when using the HTTP+RPC mode nad passing a trace file to the shell, via
+ // trace_processor_shell -D trace_file.pftrace .
+ optional string loaded_trace_name = 1;
+
+ // Typically something like "v11.0.123", but could be just "v11" or "unknown",
+ // for binaries built from Bazel or other build configurations. This is for
+ // human presentation only, don't attempt to parse and reason on it.
+ optional string human_readable_version = 2;
+
+ // The API version is incremented every time a change that the UI depends
+ // on is introduced (e.g. adding a new table that the UI queries).
+ optional int32 api_version = 3;
+
+ // Typically something like "v42.1-deadbeef0", but could be just
+ // "v42", "v0.0", or unset for binaries built from Bazel or other
+ // build configurations. This can be compared with equality to other
+ // version codes to detect matched builds (for example to see if
+ // trace_processor_shell and the UI were built at the same revision)
+ // but you should not attempt to parse it as the format may change
+ // without warning.
+ optional string version_code = 4;
+}
+
+// Input for the /compute_metric endpoint.
+message ComputeMetricArgs {
+ enum ResultFormat {
+ BINARY_PROTOBUF = 0;
+ TEXTPROTO = 1;
+ JSON = 2;
+ }
+ repeated string metric_names = 1;
+ optional ResultFormat format = 2;
+}
+
+// Output for the /compute_metric endpoint.
+message ComputeMetricResult {
+ oneof result {
+ // This is meant to contain a perfetto.protos.TraceMetrics. We're using
+ // bytes instead of the actual type because we do not want to generate
+ // protozero code for the metrics protos. We always encode/decode metrics
+ // using a reflection based mechanism that does not require the compiled C++
+ // code. This allows us to read in new protos at runtime.
+ bytes metrics = 1;
+
+ // A perfetto.protos.TraceMetrics formatted as prototext.
+ string metrics_as_prototext = 3;
+
+ // A perfetto.protos.TraceMetrics formatted as json.
+ string metrics_as_json = 4;
+ }
+
+ optional string error = 2;
+}
+
+// Input for the /enable_metatrace endpoint.
+message EnableMetatraceArgs {
+ optional MetatraceCategories categories = 1;
+}
+
+// Output for the /enable_metatrace endpoint.
+message EnableMetatraceResult {}
+
+// Input for the /disable_and_read_metatrace endpoint.
+message DisableAndReadMetatraceArgs {}
+
+// Output for the /disable_and_read_metatrace endpoint.
+message DisableAndReadMetatraceResult {
+ // Bytes of perfetto.protos.Trace message. Stored as bytes
+ // to avoid adding a dependency on trace.proto.
+ optional bytes metatrace = 1;
+ optional string error = 2;
+}
+
+// Convenience wrapper for multiple descriptors, similar to FileDescriptorSet
+// in descriptor.proto.
+message DescriptorSet {
+ repeated DescriptorProto descriptors = 1;
+}
+
+// Input for setting Trace Processor config. This method works only in the WASM
+// mode. trace_processor_shell supports configuration through command line
+// flags.
+message ResetTraceProcessorArgs {
+ enum DropTrackEventDataBefore {
+ NO_DROP = 0;
+ TRACK_EVENT_RANGE_OF_INTEREST = 1;
+ }
+ // Mirror of the corresponding perfetto::trace_processor::Config fields.
+ optional DropTrackEventDataBefore drop_track_event_data_before = 1;
+ optional bool ingest_ftrace_in_raw_table = 2;
+ optional bool analyze_trace_proto_content = 3;
+}
diff --git a/trace_processor_shell/trace_processor_shell_aarch64 b/trace_processor_shell/trace_processor_shell_aarch64
index 6e015c0..6685960 100644
--- a/trace_processor_shell/trace_processor_shell_aarch64
+++ b/trace_processor_shell/trace_processor_shell_aarch64
Binary files differ
diff --git a/trace_processor_shell/trace_processor_shell_arm b/trace_processor_shell/trace_processor_shell_arm
index 7944c31..80bffbc 100644
--- a/trace_processor_shell/trace_processor_shell_arm
+++ b/trace_processor_shell/trace_processor_shell_arm
Binary files differ
diff --git a/trace_processor_shell/trace_processor_shell_x86 b/trace_processor_shell/trace_processor_shell_x86
index fb22a85..a2da3b1 100644
--- a/trace_processor_shell/trace_processor_shell_x86
+++ b/trace_processor_shell/trace_processor_shell_x86
Binary files differ
diff --git a/trace_processor_shell/trace_processor_shell_x86_64 b/trace_processor_shell/trace_processor_shell_x86_64
index daa3c56..a39adae 100644
--- a/trace_processor_shell/trace_processor_shell_x86_64
+++ b/trace_processor_shell/trace_processor_shell_x86_64
Binary files differ
diff --git a/tracebox/tracebox_aarch64 b/tracebox/tracebox_aarch64
index a41d4fa..b78c4b0 100644
--- a/tracebox/tracebox_aarch64
+++ b/tracebox/tracebox_aarch64
Binary files differ
diff --git a/tracebox/tracebox_arm b/tracebox/tracebox_arm
index 3568c02..5e7667c 100644
--- a/tracebox/tracebox_arm
+++ b/tracebox/tracebox_arm
Binary files differ
diff --git a/tracebox/tracebox_x86 b/tracebox/tracebox_x86
index 6381020..078610f 100644
--- a/tracebox/tracebox_x86
+++ b/tracebox/tracebox_x86
Binary files differ
diff --git a/tracebox/tracebox_x86_64 b/tracebox/tracebox_x86_64
index 41c82da..90ecc66 100644
--- a/tracebox/tracebox_x86_64
+++ b/tracebox/tracebox_x86_64
Binary files differ
