Merge "ui: Fix thread and process names being null"
diff --git a/Android.bp b/Android.bp
index 391cbec..6a66249 100644
--- a/Android.bp
+++ b/Android.bp
@@ -3730,6 +3730,7 @@
"protos/perfetto/metrics/chrome/blink_gc_metric.proto",
"protos/perfetto/metrics/chrome/dropped_frames.proto",
"protos/perfetto/metrics/chrome/frame_times.proto",
+ "protos/perfetto/metrics/chrome/long_latency.proto",
"protos/perfetto/metrics/chrome/media_metric.proto",
"protos/perfetto/metrics/chrome/reported_by_page.proto",
"protos/perfetto/metrics/chrome/scroll_jank.proto",
@@ -8145,6 +8146,7 @@
name: "perfetto_src_trace_processor_importers_common_common",
srcs: [
"src/trace_processor/importers/common/args_tracker.cc",
+ "src/trace_processor/importers/common/args_translation_table.cc",
"src/trace_processor/importers/common/clock_tracker.cc",
"src/trace_processor/importers/common/event_tracker.cc",
"src/trace_processor/importers/common/flow_tracker.cc",
@@ -8160,6 +8162,7 @@
filegroup {
name: "perfetto_src_trace_processor_importers_common_unittests",
srcs: [
+ "src/trace_processor/importers/common/args_translation_table_unittest.cc",
"src/trace_processor/importers/common/clock_tracker_unittest.cc",
"src/trace_processor/importers/common/event_tracker_unittest.cc",
"src/trace_processor/importers/common/flow_tracker_unittest.cc",
@@ -8390,6 +8393,7 @@
"src/trace_processor/metrics/sql/chrome/touch_jank.sql",
"src/trace_processor/metrics/sql/experimental/blink_gc_metric.sql",
"src/trace_processor/metrics/sql/experimental/chrome_dropped_frames.sql",
+ "src/trace_processor/metrics/sql/experimental/chrome_long_latency.sql",
"src/trace_processor/metrics/sql/experimental/frame_times.sql",
"src/trace_processor/metrics/sql/experimental/media_metric.sql",
"src/trace_processor/metrics/sql/experimental/reported_by_page.sql",
@@ -8541,6 +8545,7 @@
"src/trace_processor/importers/proto/track_event_parser.cc",
"src/trace_processor/importers/proto/track_event_tokenizer.cc",
"src/trace_processor/importers/proto/track_event_tracker.cc",
+ "src/trace_processor/importers/proto/translation_table_module.cc",
"src/trace_processor/trace_blob.cc",
"src/trace_processor/trace_processor_context.cc",
"src/trace_processor/trace_processor_storage.cc",
diff --git a/BUILD b/BUILD
index dcdc2fc..3260a6e 100644
--- a/BUILD
+++ b/BUILD
@@ -971,6 +971,8 @@
srcs = [
"src/trace_processor/importers/common/args_tracker.cc",
"src/trace_processor/importers/common/args_tracker.h",
+ "src/trace_processor/importers/common/args_translation_table.cc",
+ "src/trace_processor/importers/common/args_translation_table.h",
"src/trace_processor/importers/common/chunked_trace_reader.h",
"src/trace_processor/importers/common/clock_tracker.cc",
"src/trace_processor/importers/common/clock_tracker.h",
@@ -1130,6 +1132,7 @@
"src/trace_processor/metrics/sql/chrome/touch_jank.sql",
"src/trace_processor/metrics/sql/experimental/blink_gc_metric.sql",
"src/trace_processor/metrics/sql/experimental/chrome_dropped_frames.sql",
+ "src/trace_processor/metrics/sql/experimental/chrome_long_latency.sql",
"src/trace_processor/metrics/sql/experimental/frame_times.sql",
"src/trace_processor/metrics/sql/experimental/media_metric.sql",
"src/trace_processor/metrics/sql/experimental/reported_by_page.sql",
@@ -1529,6 +1532,8 @@
"src/trace_processor/importers/proto/track_event_tokenizer.h",
"src/trace_processor/importers/proto/track_event_tracker.cc",
"src/trace_processor/importers/proto/track_event_tracker.h",
+ "src/trace_processor/importers/proto/translation_table_module.cc",
+ "src/trace_processor/importers/proto/translation_table_module.h",
"src/trace_processor/importers/syscalls/syscall_tracker.h",
"src/trace_processor/importers/systrace/systrace_line.h",
"src/trace_processor/timestamped_trace_piece.h",
@@ -2716,6 +2721,7 @@
"protos/perfetto/metrics/chrome/blink_gc_metric.proto",
"protos/perfetto/metrics/chrome/dropped_frames.proto",
"protos/perfetto/metrics/chrome/frame_times.proto",
+ "protos/perfetto/metrics/chrome/long_latency.proto",
"protos/perfetto/metrics/chrome/media_metric.proto",
"protos/perfetto/metrics/chrome/reported_by_page.proto",
"protos/perfetto/metrics/chrome/scroll_jank.proto",
diff --git a/include/perfetto/tracing/track.h b/include/perfetto/tracing/track.h
index f288e81..3a84364 100644
--- a/include/perfetto/tracing/track.h
+++ b/include/perfetto/tracing/track.h
@@ -115,6 +115,15 @@
parent);
}
+ // Construct a track using |ptr| as identifier within thread-scope.
+ // Shorthand for `Track::FromPointer(ptr, ThreadTrack::Current())`
+ // Usage: TRACE_EVENT_BEGIN("...", "...", perfetto::Track::ThreadScoped(this))
+ static Track ThreadScoped(
+ const void* ptr,
+ Track parent = MakeThreadTrack(base::GetThreadId())) {
+ return Track::FromPointer(ptr, parent);
+ }
+
protected:
constexpr Track(uint64_t uuid_, uint64_t parent_uuid_)
: uuid(uuid_), parent_uuid(parent_uuid_) {}
diff --git a/protos/perfetto/metrics/chrome/BUILD.gn b/protos/perfetto/metrics/chrome/BUILD.gn
index e686114..9e88247 100644
--- a/protos/perfetto/metrics/chrome/BUILD.gn
+++ b/protos/perfetto/metrics/chrome/BUILD.gn
@@ -25,6 +25,7 @@
"blink_gc_metric.proto",
"dropped_frames.proto",
"frame_times.proto",
+ "long_latency.proto",
"media_metric.proto",
"reported_by_page.proto",
"scroll_jank.proto",
diff --git a/protos/perfetto/metrics/chrome/all_chrome_metrics.proto b/protos/perfetto/metrics/chrome/all_chrome_metrics.proto
index 2632405..4a24580 100644
--- a/protos/perfetto/metrics/chrome/all_chrome_metrics.proto
+++ b/protos/perfetto/metrics/chrome/all_chrome_metrics.proto
@@ -22,6 +22,7 @@
import "protos/perfetto/metrics/chrome/blink_gc_metric.proto";
import "protos/perfetto/metrics/chrome/dropped_frames.proto";
import "protos/perfetto/metrics/chrome/frame_times.proto";
+import "protos/perfetto/metrics/chrome/long_latency.proto";
import "protos/perfetto/metrics/chrome/media_metric.proto";
import "protos/perfetto/metrics/chrome/reported_by_page.proto";
import "protos/perfetto/metrics/chrome/scroll_jank.proto";
@@ -38,4 +39,5 @@
optional MediaMetric media_metric = 1006;
optional TouchJank touch_jank = 1007;
optional ChromeDroppedFrames chrome_dropped_frames = 1008;
+ optional ChromeLongLatency chrome_long_latency = 1009;
}
diff --git a/protos/perfetto/metrics/chrome/long_latency.proto b/protos/perfetto/metrics/chrome/long_latency.proto
new file mode 100644
index 0000000..2c5fbaf
--- /dev/null
+++ b/protos/perfetto/metrics/chrome/long_latency.proto
@@ -0,0 +1,40 @@
+/*
+ * 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;
+
+// Information of a frame associated with long latency input events.
+// The latency info is extracted from EventLatency slices.
+message ChromeLongLatency {
+ message LongLatency {
+ // The ending timestamp of the input event, i.e. the presentation time of
+ // the frame that contains updates triggered by the input event.
+ optional int64 ts = 1;
+
+ // The type of the input event as reported in the EventLatency slice,
+ // e.g. 'GestureScrollUpdate'.
+ optional string event_type = 2;
+
+ // The name and pid of the process where the EventLatency slice
+ // originates from.
+ optional string process_name = 3;
+ optional int64 pid = 4;
+ }
+
+ repeated LongLatency long_latency = 1;
+}
\ No newline at end of file
diff --git a/src/protozero/test/example_proto/test_messages.proto b/src/protozero/test/example_proto/test_messages.proto
index 8e710b4..ba3e5d3 100644
--- a/src/protozero/test/example_proto/test_messages.proto
+++ b/src/protozero/test/example_proto/test_messages.proto
@@ -101,8 +101,26 @@
message PackedRepeatedFields {
repeated int32 field_int32 = 1 [packed = true];
+ repeated int64 field_int64 = 4 [packed = true];
+ repeated uint32 field_uint32 = 5 [packed = true];
+ repeated uint64 field_uint64 = 6 [packed = true];
+ // Repeated packed Zig-zag fields are currently unsupported by our protoc
+ // plugin.
+ // repeated sint32 field_sint32 = 7 [packed = true];
+ // repeated sint64 field_sint64 = 8 [packed = true];
repeated fixed32 field_fixed32 = 2 [packed = true];
+ repeated fixed64 field_fixed64 = 9 [packed = true];
+ repeated sfixed32 field_sfixed32 = 10 [packed = true];
repeated sfixed64 field_sfixed64 = 3 [packed = true];
+ repeated float field_float = 11 [packed = true];
+ repeated double field_double = 12 [packed = true];
+ // Repeated (even non-packed) bool fields are currently unsupported by our
+ // protoc plugin.
+ // repeated bool field_bool = 13 [packed = true];
+ // Repeated packed enum fields are currently unsupported by our protoc plugin.
+ // repeated SmallEnum small_enum = 51 [packed = true];
+ // repeated SignedEnum signed_enum = 52 [packed = true];
+ // repeated BigEnum big_enum = 53 [packed = true];
}
// The following two messages are for testing that unknown fields being
diff --git a/src/trace_processor/BUILD.gn b/src/trace_processor/BUILD.gn
index 3cbfca5..45e9774 100644
--- a/src/trace_processor/BUILD.gn
+++ b/src/trace_processor/BUILD.gn
@@ -131,6 +131,8 @@
"importers/proto/track_event_tokenizer.h",
"importers/proto/track_event_tracker.cc",
"importers/proto/track_event_tracker.h",
+ "importers/proto/translation_table_module.cc",
+ "importers/proto/translation_table_module.h",
"importers/syscalls/syscall_tracker.h",
"importers/systrace/systrace_line.h",
"timestamped_trace_piece.h",
@@ -177,6 +179,7 @@
"../../protos/perfetto/trace/sys_stats:zero",
"../../protos/perfetto/trace/system_info:zero",
"../../protos/perfetto/trace/track_event:zero",
+ "../../protos/perfetto/trace/translation:zero",
]
# json_utils optionally depends on jsoncpp.
diff --git a/src/trace_processor/importers/additional_modules.cc b/src/trace_processor/importers/additional_modules.cc
index 1627893..5368ed9 100644
--- a/src/trace_processor/importers/additional_modules.cc
+++ b/src/trace_processor/importers/additional_modules.cc
@@ -20,6 +20,7 @@
#include "src/trace_processor/importers/proto/graphics_event_module.h"
#include "src/trace_processor/importers/proto/heap_graph_module.h"
#include "src/trace_processor/importers/proto/system_probes_module.h"
+#include "src/trace_processor/importers/proto/translation_table_module.h"
namespace perfetto {
namespace trace_processor {
@@ -29,6 +30,7 @@
context->modules.emplace_back(new GraphicsEventModule(context));
context->modules.emplace_back(new HeapGraphModule(context));
context->modules.emplace_back(new SystemProbesModule(context));
+ context->modules.emplace_back(new TranslationTableModule(context));
context->modules.emplace_back(new FtraceModuleImpl(context));
// Ftrace module is special, because it has one extra method for parsing
// ftrace packets. So we need to store a pointer to it separately.
diff --git a/src/trace_processor/importers/common/BUILD.gn b/src/trace_processor/importers/common/BUILD.gn
index aa7f57c..534c2bb 100644
--- a/src/trace_processor/importers/common/BUILD.gn
+++ b/src/trace_processor/importers/common/BUILD.gn
@@ -18,6 +18,8 @@
sources = [
"args_tracker.cc",
"args_tracker.h",
+ "args_translation_table.cc",
+ "args_translation_table.h",
"chunked_trace_reader.h",
"clock_tracker.cc",
"clock_tracker.h",
@@ -56,6 +58,7 @@
source_set("unittests") {
sources = [
+ "args_translation_table_unittest.cc",
"clock_tracker_unittest.cc",
"event_tracker_unittest.cc",
"flow_tracker_unittest.cc",
diff --git a/src/trace_processor/importers/common/args_translation_table.cc b/src/trace_processor/importers/common/args_translation_table.cc
new file mode 100644
index 0000000..ee91b30
--- /dev/null
+++ b/src/trace_processor/importers/common/args_translation_table.cc
@@ -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.
+ */
+
+#include "src/trace_processor/importers/common/args_translation_table.h"
+
+namespace perfetto {
+namespace trace_processor {
+
+base::Optional<base::StringView>
+ArgsTranslationTable::TranslateChromeHistogramHash(uint64_t hash) const {
+ auto* value = chrome_histogram_hash_to_name_.Find(hash);
+ if (!value) {
+ return base::nullopt;
+ }
+ return base::StringView(*value);
+}
+
+void ArgsTranslationTable::AddChromeHistogramTranslationRule(
+ uint64_t hash,
+ base::StringView name) {
+ chrome_histogram_hash_to_name_.Insert(hash, name.ToStdString());
+}
+
+} // namespace trace_processor
+} // namespace perfetto
diff --git a/src/trace_processor/importers/common/args_translation_table.h b/src/trace_processor/importers/common/args_translation_table.h
new file mode 100644
index 0000000..0e34e2c
--- /dev/null
+++ b/src/trace_processor/importers/common/args_translation_table.h
@@ -0,0 +1,50 @@
+/*
+ * 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.
+ */
+
+#ifndef SRC_TRACE_PROCESSOR_IMPORTERS_COMMON_ARGS_TRANSLATION_TABLE_H_
+#define SRC_TRACE_PROCESSOR_IMPORTERS_COMMON_ARGS_TRANSLATION_TABLE_H_
+
+#include <cstdint>
+
+#include "perfetto/ext/base/flat_hash_map.h"
+#include "perfetto/ext/base/optional.h"
+#include "perfetto/ext/base/string_view.h"
+
+namespace perfetto {
+namespace trace_processor {
+
+// Tracks and stores args translation rules. It allows Trace Processor
+// to map for example hashes to their names.
+class ArgsTranslationTable {
+ public:
+ static constexpr char kChromeHistogramHashKey[] =
+ "chrome_histogram_sample.name_hash";
+ static constexpr char kChromeHistogramNameKey[] =
+ "chrome_histogram_sample.name";
+
+ base::Optional<base::StringView> TranslateChromeHistogramHash(
+ uint64_t hash) const;
+
+ void AddChromeHistogramTranslationRule(uint64_t hash, base::StringView name);
+
+ private:
+ base::FlatHashMap<uint64_t, std::string> chrome_histogram_hash_to_name_;
+};
+
+} // namespace trace_processor
+} // namespace perfetto
+
+#endif // SRC_TRACE_PROCESSOR_IMPORTERS_COMMON_ARGS_TRANSLATION_TABLE_H_
diff --git a/src/trace_processor/importers/common/args_translation_table_unittest.cc b/src/trace_processor/importers/common/args_translation_table_unittest.cc
new file mode 100644
index 0000000..15dddff
--- /dev/null
+++ b/src/trace_processor/importers/common/args_translation_table_unittest.cc
@@ -0,0 +1,42 @@
+/*
+ * 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.
+ */
+
+#include "src/trace_processor/importers/common/args_translation_table.h"
+#include "test/gtest_and_gmock.h"
+
+namespace perfetto {
+namespace trace_processor {
+namespace {
+
+TEST(ArgsTranslationTable, EmptyTableByDefault) {
+ ArgsTranslationTable table;
+ EXPECT_EQ(table.TranslateChromeHistogramHash(1), base::nullopt);
+}
+
+TEST(ArgsTranslationTable, TranslatesHashes) {
+ ArgsTranslationTable table;
+ table.AddChromeHistogramTranslationRule(1, "hash1");
+ table.AddChromeHistogramTranslationRule(10, "hash2");
+ EXPECT_EQ(table.TranslateChromeHistogramHash(1),
+ base::Optional<base::StringView>("hash1"));
+ EXPECT_EQ(table.TranslateChromeHistogramHash(10),
+ base::Optional<base::StringView>("hash2"));
+ EXPECT_EQ(table.TranslateChromeHistogramHash(2), base::nullopt);
+}
+
+} // namespace
+} // namespace trace_processor
+} // namespace perfetto
diff --git a/src/trace_processor/importers/proto/translation_table_module.cc b/src/trace_processor/importers/proto/translation_table_module.cc
new file mode 100644
index 0000000..cf523d9
--- /dev/null
+++ b/src/trace_processor/importers/proto/translation_table_module.cc
@@ -0,0 +1,61 @@
+/*
+ * 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.
+ */
+#include "src/trace_processor/importers/proto/translation_table_module.h"
+
+#include "src/trace_processor/importers/common/args_translation_table.h"
+
+#include "protos/perfetto/trace/trace_packet.pbzero.h"
+#include "protos/perfetto/trace/translation/translation_table.pbzero.h"
+
+namespace perfetto {
+namespace trace_processor {
+
+using perfetto::protos::pbzero::TracePacket;
+
+TranslationTableModule::TranslationTableModule(TraceProcessorContext* context)
+ : context_(context) {
+ RegisterForField(TracePacket::kTranslationTableFieldNumber, context);
+}
+
+TranslationTableModule::~TranslationTableModule() = default;
+
+void TranslationTableModule::ParsePacket(const TracePacket::Decoder& decoder,
+ const TimestampedTracePiece& /*ttp*/,
+ uint32_t field_id) {
+ if (field_id != TracePacket::kTranslationTableFieldNumber) {
+ return;
+ }
+ const auto translation_table =
+ protos::pbzero::TranslationTable::Decoder(decoder.translation_table());
+ if (translation_table.has_chrome_histogram()) {
+ ParseChromeHistogramRules(translation_table.chrome_histogram());
+ }
+}
+
+void TranslationTableModule::ParseChromeHistogramRules(
+ protozero::ConstBytes bytes) {
+ const auto chrome_histogram =
+ protos::pbzero::ChromeHistorgramTranslationTable::Decoder(bytes);
+ for (auto it = chrome_histogram.hash_to_name(); it; ++it) {
+ protos::pbzero::ChromeHistorgramTranslationTable::HashToNameEntry::Decoder
+ entry(*it);
+ context_->args_translation_table->AddChromeHistogramTranslationRule(
+ entry.key(), entry.value());
+ }
+}
+
+} // namespace trace_processor
+} // namespace perfetto
diff --git a/src/trace_processor/importers/proto/translation_table_module.h b/src/trace_processor/importers/proto/translation_table_module.h
new file mode 100644
index 0000000..c6c61a6
--- /dev/null
+++ b/src/trace_processor/importers/proto/translation_table_module.h
@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+
+#ifndef SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_TRANSLATION_TABLE_MODULE_H_
+#define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_TRANSLATION_TABLE_MODULE_H_
+
+#include <cstdint>
+
+#include "perfetto/ext/base/optional.h"
+#include "protos/perfetto/trace/trace_packet.pbzero.h"
+#include "src/trace_processor/importers/proto/proto_importer_module.h"
+#include "src/trace_processor/types/trace_processor_context.h"
+
+namespace perfetto {
+namespace trace_processor {
+
+class TranslationTableModule : public ProtoImporterModule {
+ public:
+ explicit TranslationTableModule(TraceProcessorContext* context);
+
+ ~TranslationTableModule() override;
+
+ void ParsePacket(const protos::pbzero::TracePacket::Decoder& decoder,
+ const TimestampedTracePiece& ttp,
+ uint32_t field_id) override;
+
+ private:
+ void ParseChromeHistogramRules(protozero::ConstBytes bytes);
+
+ TraceProcessorContext* context_;
+};
+
+} // namespace trace_processor
+} // namespace perfetto
+
+#endif // SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_TRANSLATION_TABLE_MODULE_H_
diff --git a/src/trace_processor/metrics/sql/BUILD.gn b/src/trace_processor/metrics/sql/BUILD.gn
index f8de2ad..fbbb41c 100644
--- a/src/trace_processor/metrics/sql/BUILD.gn
+++ b/src/trace_processor/metrics/sql/BUILD.gn
@@ -110,6 +110,7 @@
"chrome/touch_jank.sql",
"experimental/blink_gc_metric.sql",
"experimental/chrome_dropped_frames.sql",
+ "experimental/chrome_long_latency.sql",
"experimental/frame_times.sql",
"experimental/media_metric.sql",
"experimental/reported_by_page.sql",
diff --git a/src/trace_processor/metrics/sql/experimental/chrome_long_latency.sql b/src/trace_processor/metrics/sql/experimental/chrome_long_latency.sql
new file mode 100644
index 0000000..26fc2b5
--- /dev/null
+++ b/src/trace_processor/metrics/sql/experimental/chrome_long_latency.sql
@@ -0,0 +1,104 @@
+--
+-- Copyright 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
+--
+-- https://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.
+
+-- Find all long EventLatency slices > 100ms and also get the
+-- type of the event stored as 'debug.event' argument.
+-- In order to group all events
+-- Note that a long latency event is represented by the the ending time
+-- of an EventLatency slice, i.e. the timestamp of the frame presentation
+-- that reflects the event.
+DROP VIEW IF EXISTS long_eventlatency_slice;
+CREATE VIEW long_eventlatency_slice AS
+SELECT
+ ts + dur AS ts,
+ dur,
+ id,
+ track_id,
+ EXTRACT_ARG(arg_set_id, 'debug.event') AS event_type
+FROM slice WHERE name = 'EventLatency' AND dur > 100000000;
+
+-- Find the upid of the proccesses where the long latency occur.
+DROP VIEW IF EXISTS long_latency_with_upid;
+CREATE VIEW long_latency_with_upid AS
+SELECT
+ long_eventlatency_slice.ts,
+ long_eventlatency_slice.event_type,
+ process_track.upid
+FROM long_eventlatency_slice
+INNER JOIN process_track
+ON long_eventlatency_slice.track_id = process_track.id;
+
+-- Find the name and pid of the processes.
+-- Long latency events with the same timestamp and from the same process
+-- are considered one single long latency occurrence.
+DROP VIEW IF EXISTS long_latency_with_process_info;
+CREATE VIEW long_latency_with_process_info AS
+SELECT
+ long_latency_with_upid.ts,
+ long_latency_with_upid.event_type,
+ process.name AS process_name,
+ process.pid AS process_id
+FROM long_latency_with_upid
+INNER JOIN process
+ON long_latency_with_upid.upid = process.upid
+GROUP BY ts, process.pid;
+
+-- Create the derived event track for long latency.
+-- All tracks generated from chrome_long_latency_event are
+-- placed under a track group named 'Long Latency', whose summary
+-- track is the first track ('All Processes') in chrome_long_latency_event.
+-- Note that the 'All Processes' track is generated only when there are more
+-- than one source of long latency events.
+DROP VIEW IF EXISTS chrome_long_latency_event;
+CREATE VIEW chrome_long_latency_event AS
+SELECT
+ 'slice' AS track_type,
+ 'All Processes' AS track_name,
+ ts,
+ 0 AS dur,
+ event_type AS slice_name,
+ 'Long Latency' AS group_name
+FROM long_latency_with_process_info
+WHERE (SELECT COUNT(DISTINCT process_id)
+ FROM long_latency_with_process_info) > 1
+GROUP BY ts
+UNION ALL
+SELECT
+ 'slice' AS track_type,
+ process_name || ' ' || process_id AS track_name,
+ ts,
+ 0 AS dur,
+ event_type AS slice_name,
+ 'Long Latency' AS group_name
+FROM long_latency_with_process_info
+GROUP BY ts;
+
+-- Create the long latency metric output.
+DROP VIEW IF EXISTS chrome_long_latency_output;
+CREATE VIEW chrome_long_latency_output AS
+SELECT ChromeLongLatency(
+ 'long_latency', (
+ SELECT RepeatedField(
+ ChromeLongLatency_LongLatency(
+ 'ts', ts,
+ 'event_type', event_type,
+ 'process_name', process_name,
+ 'pid', process_id
+ )
+ )
+ FROM long_latency_with_process_info
+ ORDER BY ts
+ )
+);
\ No newline at end of file
diff --git a/src/trace_processor/trace_processor_context.cc b/src/trace_processor/trace_processor_context.cc
index 412b63a..75800f3 100644
--- a/src/trace_processor/trace_processor_context.cc
+++ b/src/trace_processor/trace_processor_context.cc
@@ -18,6 +18,7 @@
#include "src/trace_processor/forwarding_trace_parser.h"
#include "src/trace_processor/importers/common/args_tracker.h"
+#include "src/trace_processor/importers/common/args_translation_table.h"
#include "src/trace_processor/importers/common/chunked_trace_reader.h"
#include "src/trace_processor/importers/common/clock_tracker.h"
#include "src/trace_processor/importers/common/event_tracker.h"
diff --git a/src/trace_processor/trace_processor_storage_impl.cc b/src/trace_processor/trace_processor_storage_impl.cc
index 53bc802..cdd671e 100644
--- a/src/trace_processor/trace_processor_storage_impl.cc
+++ b/src/trace_processor/trace_processor_storage_impl.cc
@@ -21,6 +21,7 @@
#include "src/trace_processor/forwarding_trace_parser.h"
#include "src/trace_processor/importers/chrome_track_event.descriptor.h"
#include "src/trace_processor/importers/common/args_tracker.h"
+#include "src/trace_processor/importers/common/args_translation_table.h"
#include "src/trace_processor/importers/common/clock_tracker.h"
#include "src/trace_processor/importers/common/event_tracker.h"
#include "src/trace_processor/importers/common/flow_tracker.h"
@@ -49,6 +50,7 @@
context_.track_tracker.reset(new TrackTracker(&context_));
context_.async_track_set_tracker.reset(new AsyncTrackSetTracker(&context_));
context_.args_tracker.reset(new ArgsTracker(&context_));
+ context_.args_translation_table.reset(new ArgsTranslationTable());
context_.slice_tracker.reset(new SliceTracker(&context_));
context_.flow_tracker.reset(new FlowTracker(&context_));
context_.event_tracker.reset(new EventTracker(&context_));
diff --git a/src/trace_processor/types/trace_processor_context.h b/src/trace_processor/types/trace_processor_context.h
index 4bc0e2b..221c62b 100644
--- a/src/trace_processor/types/trace_processor_context.h
+++ b/src/trace_processor/types/trace_processor_context.h
@@ -27,6 +27,7 @@
namespace trace_processor {
class ArgsTracker;
+class ArgsTranslationTable;
class AsyncTrackSetTracker;
class AndroidProbesTracker;
class ChunkedTraceReader;
@@ -67,6 +68,7 @@
// trackers, as they may own ArgsTrackers themselves.
std::unique_ptr<GlobalArgsTracker> global_args_tracker;
std::unique_ptr<ArgsTracker> args_tracker;
+ std::unique_ptr<ArgsTranslationTable> args_translation_table;
std::unique_ptr<TrackTracker> track_tracker;
std::unique_ptr<AsyncTrackSetTracker> async_track_set_tracker;
diff --git a/src/trace_processor/util/protozero_to_text.cc b/src/trace_processor/util/protozero_to_text.cc
index cdb60d1..274f504 100644
--- a/src/trace_processor/util/protozero_to_text.cc
+++ b/src/trace_processor/util/protozero_to_text.cc
@@ -16,19 +16,8 @@
namespace {
-std::string BytesToHexEncodedString(const std::string& bytes) {
- // Each byte becomes four chars 'A' -> "\x41" + 1 for trailing null.
- std::string value(4 * bytes.size() + 1, 'Z');
- for (size_t i = 0; i < bytes.size(); ++i) {
- // snprintf prints 5 characters: '\x', then two hex digits, and finally a
- // null byte. As we write left to right, we keep overwriting the null
- // byte, except for the last call to snprintf.
- snprintf(&(value[4 * i]), 5, "\\x%02hhx", bytes[i]);
- }
- // Trim trailing null.
- value.resize(4 * bytes.size());
- return value;
-}
+using protozero::proto_utils::ProtoWireType;
+using FieldDescriptorProto = protos::pbzero::FieldDescriptorProto;
// This function matches the implementation of TextFormatEscaper.escapeBytes
// from the Java protobuf library.
@@ -87,118 +76,16 @@
return '"' + ret + '"';
}
-// Recursively determine the size of all the string like things passed in the
-// parameter pack |rest|.
-size_t SizeOfStr() {
- return 0;
-}
-template <typename T, typename... Rest>
-size_t SizeOfStr(const T& first, Rest... rest) {
- return base::StringView(first).size() + SizeOfStr(rest...);
-}
-
-// Append |to_add| which is something string like to |out|.
-template <typename T>
-void StrAppendInternal(std::string* out, const T& to_add) {
- out->append(to_add);
-}
-
-template <typename T, typename... strings>
-void StrAppendInternal(std::string* out, const T& first, strings... values) {
- StrAppendInternal(out, first);
- StrAppendInternal(out, values...);
-}
-
// Append |to_add| which is something string like to |out|.
template <typename T>
void StrAppend(std::string* out, const T& to_add) {
- out->reserve(out->size() + base::StringView(to_add).size());
out->append(to_add);
}
template <typename T, typename... strings>
void StrAppend(std::string* out, const T& first, strings... values) {
- out->reserve(out->size() + SizeOfStr(values...));
- StrAppendInternal(out, first);
- StrAppendInternal(out, values...);
-}
-
-void ConvertProtoTypeToFieldAndValueString(const FieldDescriptor& fd,
- const protozero::Field& field,
- const std::string& separator,
- const std::string& indent,
- const DescriptorPool& pool,
- std::string* out) {
- using FieldDescriptorProto = protos::pbzero::FieldDescriptorProto;
- switch (fd.type()) {
- case FieldDescriptorProto::TYPE_INT32:
- case FieldDescriptorProto::TYPE_SFIXED32:
- case FieldDescriptorProto::TYPE_FIXED32:
- StrAppend(out, separator, indent, fd.name(), ": ",
- std::to_string(field.as_int32()));
- return;
- case FieldDescriptorProto::TYPE_SINT32:
- StrAppend(out, separator, indent, fd.name(), ": ",
- std::to_string(field.as_sint32()));
- return;
- case FieldDescriptorProto::TYPE_INT64:
- case FieldDescriptorProto::TYPE_SFIXED64:
- case FieldDescriptorProto::TYPE_FIXED64:
- StrAppend(out, separator, indent, fd.name(), ": ",
- std::to_string(field.as_int64()));
- return;
- case FieldDescriptorProto::TYPE_SINT64:
- StrAppend(out, separator, indent, fd.name(), ": ",
- std::to_string(field.as_sint64()));
- return;
- case FieldDescriptorProto::TYPE_UINT32:
- StrAppend(out, separator, indent, fd.name(), ": ",
- std::to_string(field.as_uint32()));
- return;
- case FieldDescriptorProto::TYPE_UINT64:
- StrAppend(out, separator, indent, fd.name(), ": ",
- std::to_string(field.as_uint64()));
- return;
- case FieldDescriptorProto::TYPE_BOOL:
- StrAppend(out, separator, indent, fd.name(), ": ",
- field.as_bool() ? "true" : "false");
- return;
- case FieldDescriptorProto::TYPE_DOUBLE:
- StrAppend(out, separator, indent, fd.name(), ": ",
- std::to_string(field.as_double()));
- return;
- case FieldDescriptorProto::TYPE_FLOAT:
- StrAppend(out, separator, indent, fd.name(), ": ",
- std::to_string(field.as_float()));
- return;
- case FieldDescriptorProto::TYPE_STRING: {
- auto s = QuoteAndEscapeTextProtoString(field.as_std_string());
- StrAppend(out, separator, indent, fd.name(), ": ", s);
- return;
- }
- case FieldDescriptorProto::TYPE_BYTES: {
- std::string value = BytesToHexEncodedString(field.as_std_string());
- StrAppend(out, separator, indent, fd.name(), ": \"", value, "\"");
- return;
- }
- case FieldDescriptorProto::TYPE_ENUM: {
- auto opt_enum_descriptor_idx =
- pool.FindDescriptorIdx(fd.resolved_type_name());
- PERFETTO_DCHECK(opt_enum_descriptor_idx);
- auto opt_enum_string =
- pool.descriptors()[*opt_enum_descriptor_idx].FindEnumString(
- field.as_int32());
- PERFETTO_DCHECK(opt_enum_string);
- StrAppend(out, separator, indent, fd.name(), ": ", *opt_enum_string);
- return;
- }
- default: {
- PERFETTO_FATAL(
- "Tried to write value of type field %s (in proto type "
- "%s) which has type enum %d",
- fd.name().c_str(), fd.resolved_type_name().c_str(), fd.type());
- }
- }
+ StrAppend(out, first);
+ StrAppend(out, values...);
}
void IncreaseIndents(std::string* out) {
@@ -224,9 +111,232 @@
}
}
+void PrintVarIntField(const FieldDescriptor* fd,
+ const protozero::Field& field,
+ const DescriptorPool& pool,
+ std::string* out) {
+ uint32_t type = fd ? fd->type() : 0;
+ switch (type) {
+ case FieldDescriptorProto::TYPE_INT32:
+ StrAppend(out, fd->name(), ": ", std::to_string(field.as_int32()));
+ return;
+ case FieldDescriptorProto::TYPE_SINT32:
+ StrAppend(out, fd->name(), ": ", std::to_string(field.as_sint32()));
+ return;
+ case FieldDescriptorProto::TYPE_UINT32:
+ StrAppend(out, fd->name(), ": ", std::to_string(field.as_uint32()));
+ return;
+ case FieldDescriptorProto::TYPE_INT64:
+ StrAppend(out, fd->name(), ": ", std::to_string(field.as_int64()));
+ return;
+ case FieldDescriptorProto::TYPE_SINT64:
+ StrAppend(out, fd->name(), ": ", std::to_string(field.as_sint64()));
+ return;
+ case FieldDescriptorProto::TYPE_UINT64:
+ StrAppend(out, fd->name(), ": ", std::to_string(field.as_uint64()));
+ return;
+ case FieldDescriptorProto::TYPE_BOOL:
+ StrAppend(out, fd->name(), ": ", field.as_bool() ? "true" : "false");
+ return;
+ case FieldDescriptorProto::TYPE_ENUM: {
+ // If the enum value is unknown, treat it like a completely unknown field.
+ auto opt_enum_descriptor_idx =
+ pool.FindDescriptorIdx(fd->resolved_type_name());
+ if (!opt_enum_descriptor_idx)
+ break;
+ auto opt_enum_string =
+ pool.descriptors()[*opt_enum_descriptor_idx].FindEnumString(
+ field.as_int32());
+ if (!opt_enum_string)
+ break;
+ StrAppend(out, fd->name(), ": ", *opt_enum_string);
+ return;
+ }
+ case 0:
+ default:
+ break;
+ }
+ StrAppend(out, std::to_string(field.id()), ": ",
+ std::to_string(field.as_uint64()));
+}
+
+void PrintFixed32Field(const FieldDescriptor* fd,
+ const protozero::Field& field,
+ std::string* out) {
+ uint32_t type = fd ? fd->type() : 0;
+ switch (type) {
+ case FieldDescriptorProto::TYPE_SFIXED32:
+ StrAppend(out, fd->name(), ": ", std::to_string(field.as_int32()));
+ break;
+ case FieldDescriptorProto::TYPE_FIXED32:
+ StrAppend(out, fd->name(), ": ", std::to_string(field.as_uint32()));
+ break;
+ case FieldDescriptorProto::TYPE_FLOAT:
+ StrAppend(out, fd->name(), ": ", std::to_string(field.as_float()));
+ break;
+ case 0:
+ default:
+ base::StackString<12> padded_hex("0x%08" PRIx32, field.as_uint32());
+ StrAppend(out, std::to_string(field.id()), ": ", padded_hex.c_str());
+ break;
+ }
+}
+
+void PrintFixed64Field(const FieldDescriptor* fd,
+ const protozero::Field& field,
+ std::string* out) {
+ uint32_t type = fd ? fd->type() : 0;
+ switch (type) {
+ case FieldDescriptorProto::TYPE_SFIXED64:
+ StrAppend(out, fd->name(), ": ", std::to_string(field.as_int64()));
+ break;
+ case FieldDescriptorProto::TYPE_FIXED64:
+ StrAppend(out, fd->name(), ": ", std::to_string(field.as_uint64()));
+ break;
+ case FieldDescriptorProto::TYPE_DOUBLE:
+ StrAppend(out, fd->name(), ": ", std::to_string(field.as_double()));
+ break;
+ case 0:
+ default:
+ base::StackString<20> padded_hex("0x%016" PRIx64, field.as_uint64());
+ StrAppend(out, std::to_string(field.id()), ": ", padded_hex.c_str());
+ break;
+ }
+}
+
+void ProtozeroToTextInternal(const std::string& type,
+ protozero::ConstBytes protobytes,
+ NewLinesMode new_lines_mode,
+ const DescriptorPool& pool,
+ std::string* indents,
+ std::string* output);
+
+template <protozero::proto_utils::ProtoWireType wire_type, typename T>
+void PrintPackedField(const FieldDescriptor& fd,
+ const protozero::Field& field,
+ NewLinesMode new_lines_mode,
+ const std::string& indents,
+ std::string* out) {
+ const bool include_new_lines = new_lines_mode == kIncludeNewLines;
+ bool err = false;
+ bool first_output = true;
+ for (protozero::PackedRepeatedFieldIterator<wire_type, T> it(
+ field.data(), field.size(), &err);
+ it; it++) {
+ T value = *it;
+ if (!first_output) {
+ if (include_new_lines) {
+ StrAppend(out, "\n", indents);
+ } else {
+ StrAppend(out, " ");
+ }
+ }
+ StrAppend(out, fd.name(), ": ", std::to_string(value));
+ first_output = false;
+ }
+
+ if (err) {
+ if (!first_output) {
+ if (include_new_lines) {
+ StrAppend(out, "\n", indents);
+ } else {
+ StrAppend(out, " ");
+ }
+ }
+ StrAppend(out, "# Packed decoding failure for field ", fd.name(), "\n");
+ }
+}
+
+void PrintLengthDelimitedField(const FieldDescriptor* fd,
+ const protozero::Field& field,
+ NewLinesMode new_lines_mode,
+ std::string* indents,
+ const DescriptorPool& pool,
+ std::string* out) {
+ const bool include_new_lines = new_lines_mode == kIncludeNewLines;
+ uint32_t type = fd ? fd->type() : 0;
+ switch (type) {
+ case FieldDescriptorProto::TYPE_BYTES:
+ case FieldDescriptorProto::TYPE_STRING: {
+ std::string value = QuoteAndEscapeTextProtoString(field.as_std_string());
+ StrAppend(out, fd->name(), ": ", value);
+ return;
+ }
+ case FieldDescriptorProto::TYPE_MESSAGE:
+ StrAppend(out, FormattedFieldDescriptorName(*fd), ": {");
+ if (include_new_lines) {
+ IncreaseIndents(indents);
+ }
+ ProtozeroToTextInternal(fd->resolved_type_name(), field.as_bytes(),
+ new_lines_mode, pool, indents, out);
+ if (include_new_lines) {
+ DecreaseIndents(indents);
+ StrAppend(out, "\n", *indents, "}");
+ } else {
+ StrAppend(out, " }");
+ }
+ return;
+ case FieldDescriptorProto::TYPE_DOUBLE:
+ PrintPackedField<protozero::proto_utils::ProtoWireType::kFixed64, double>(
+ *fd, field, new_lines_mode, *indents, out);
+ return;
+ case FieldDescriptorProto::TYPE_FLOAT:
+ PrintPackedField<protozero::proto_utils::ProtoWireType::kFixed32, float>(
+ *fd, field, new_lines_mode, *indents, out);
+ return;
+ case FieldDescriptorProto::TYPE_INT64:
+ PrintPackedField<protozero::proto_utils::ProtoWireType::kVarInt, int64_t>(
+ *fd, field, new_lines_mode, *indents, out);
+ return;
+ case FieldDescriptorProto::TYPE_UINT64:
+ PrintPackedField<protozero::proto_utils::ProtoWireType::kVarInt,
+ uint64_t>(*fd, field, new_lines_mode, *indents, out);
+ return;
+ case FieldDescriptorProto::TYPE_INT32:
+ PrintPackedField<protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(
+ *fd, field, new_lines_mode, *indents, out);
+ return;
+ case FieldDescriptorProto::TYPE_FIXED64:
+ PrintPackedField<protozero::proto_utils::ProtoWireType::kFixed64,
+ uint64_t>(*fd, field, new_lines_mode, *indents, out);
+ return;
+ case FieldDescriptorProto::TYPE_FIXED32:
+ PrintPackedField<protozero::proto_utils::ProtoWireType::kFixed32,
+ uint32_t>(*fd, field, new_lines_mode, *indents, out);
+ return;
+ case FieldDescriptorProto::TYPE_UINT32:
+ PrintPackedField<protozero::proto_utils::ProtoWireType::kVarInt,
+ uint32_t>(*fd, field, new_lines_mode, *indents, out);
+ return;
+ case FieldDescriptorProto::TYPE_SFIXED32:
+ PrintPackedField<protozero::proto_utils::ProtoWireType::kFixed32,
+ int32_t>(*fd, field, new_lines_mode, *indents, out);
+ return;
+ case FieldDescriptorProto::TYPE_SFIXED64:
+ PrintPackedField<protozero::proto_utils::ProtoWireType::kFixed64,
+ int64_t>(*fd, field, new_lines_mode, *indents, out);
+ return;
+ // Our protoc plugin cannot generate code for packed repeated fields with
+ // these types. Output a comment and then fall back to the raw field_id:
+ // string representation.
+ case FieldDescriptorProto::TYPE_BOOL:
+ case FieldDescriptorProto::TYPE_ENUM:
+ case FieldDescriptorProto::TYPE_SINT32:
+ case FieldDescriptorProto::TYPE_SINT64:
+ StrAppend(out, "# Packed type ", std::to_string(type),
+ " not supported. Printing raw string.", "\n", *indents);
+ break;
+ case 0:
+ default:
+ break;
+ }
+ std::string value = QuoteAndEscapeTextProtoString(field.as_std_string());
+ StrAppend(out, std::to_string(field.id()), ": ", value);
+}
+
// Recursive case function, Will parse |protobytes| assuming it is a proto of
// |type| and will use |pool| to look up the |type|. All output will be placed
-// in |output| and between fields |separator| will be placed. When called for
+// in |output|, using |new_lines_mode| to separate fields. When called for
// |indents| will be increased by 2 spaces to improve readability.
void ProtozeroToTextInternal(const std::string& type,
protozero::ConstBytes protobytes,
@@ -237,44 +347,35 @@
auto opt_proto_descriptor_idx = pool.FindDescriptorIdx(type);
PERFETTO_DCHECK(opt_proto_descriptor_idx);
auto& proto_descriptor = pool.descriptors()[*opt_proto_descriptor_idx];
- bool include_new_lines = new_lines_mode == kIncludeNewLines;
+ const bool include_new_lines = new_lines_mode == kIncludeNewLines;
protozero::ProtoDecoder decoder(protobytes.data, protobytes.size);
for (auto field = decoder.ReadField(); field.valid();
field = decoder.ReadField()) {
- auto opt_field_descriptor = proto_descriptor.FindFieldByTag(field.id());
- if (!opt_field_descriptor) {
- StrAppend(
- output, output->empty() ? "" : "\n", *indents,
- "# Ignoring unknown field with id: ", std::to_string(field.id()));
- continue;
- }
- const auto& field_descriptor = *opt_field_descriptor;
-
- if (field_descriptor.type() ==
- protos::pbzero::FieldDescriptorProto::TYPE_MESSAGE) {
+ if (!output->empty()) {
if (include_new_lines) {
- StrAppend(output, output->empty() ? "" : "\n", *indents,
- FormattedFieldDescriptorName(field_descriptor), ": {");
- IncreaseIndents(indents);
+ StrAppend(output, "\n", *indents);
} else {
- StrAppend(output, output->empty() ? "" : " ",
- FormattedFieldDescriptorName(field_descriptor), ": {");
- }
- ProtozeroToTextInternal(field_descriptor.resolved_type_name(),
- field.as_bytes(), new_lines_mode, pool, indents,
- output);
- if (include_new_lines) {
- DecreaseIndents(indents);
- StrAppend(output, "\n", *indents, "}");
- } else {
- StrAppend(output, " }");
+ StrAppend(output, " ", *indents);
}
} else {
- ConvertProtoTypeToFieldAndValueString(
- field_descriptor, field,
- output->empty() ? "" : include_new_lines ? "\n" : " ", *indents, pool,
- output);
+ StrAppend(output, *indents);
+ }
+ auto* opt_field_descriptor = proto_descriptor.FindFieldByTag(field.id());
+ switch (field.type()) {
+ case ProtoWireType::kVarInt:
+ PrintVarIntField(opt_field_descriptor, field, pool, output);
+ break;
+ case ProtoWireType::kLengthDelimited:
+ PrintLengthDelimitedField(opt_field_descriptor, field, new_lines_mode,
+ indents, pool, output);
+ break;
+ case ProtoWireType::kFixed32:
+ PrintFixed32Field(opt_field_descriptor, field, output);
+ break;
+ case ProtoWireType::kFixed64:
+ PrintFixed64Field(opt_field_descriptor, field, output);
+ break;
}
}
PERFETTO_DCHECK(decoder.bytes_left() == 0);
@@ -341,10 +442,6 @@
new_lines_mode);
}
-std::string BytesToHexEncodedStringForTesting(const std::string& s) {
- return BytesToHexEncodedString(s);
-}
-
} // namespace protozero_to_text
} // namespace trace_processor
} // namespace perfetto
diff --git a/src/trace_processor/util/protozero_to_text.h b/src/trace_processor/util/protozero_to_text.h
index c7b793b..9a0acf1 100644
--- a/src/trace_processor/util/protozero_to_text.h
+++ b/src/trace_processor/util/protozero_to_text.h
@@ -71,8 +71,6 @@
return ProtozeroEnumToText(type, static_cast<int32_t>(enum_value));
}
-std::string BytesToHexEncodedStringForTesting(const std::string&);
-
} // namespace protozero_to_text
} // namespace trace_processor
} // namespace perfetto
diff --git a/src/trace_processor/util/protozero_to_text_unittests.cc b/src/trace_processor/util/protozero_to_text_unittests.cc
index bd92298..6b664cd 100644
--- a/src/trace_processor/util/protozero_to_text_unittests.cc
+++ b/src/trace_processor/util/protozero_to_text_unittests.cc
@@ -180,10 +180,6 @@
TrackEvent::TYPE_SLICE_END));
}
-TEST(ProtozeroToTextTest, BytesToHexEncodedString) {
- EXPECT_EQ(BytesToHexEncodedStringForTesting("abc"), R"(\x61\x62\x63)");
-}
-
// Sets up a descriptor pool with all the messages from
// "src/protozero/test/example_proto/test_messages.proto"
class ProtozeroToTextTestMessageTest : public testing::Test {
@@ -278,8 +274,7 @@
"big_enum: END");
}
-// TODO(b/224800278): Fix ProtozeroToText() crash and reenable.
-TEST_F(ProtozeroToTextTestMessageTest, DISABLED_FieldVarIntEnumUnknown) {
+TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntEnumUnknown) {
protozero::HeapBuffered<EveryField> msg;
msg->AppendVarInt(EveryField::kSmallEnumFieldNumber, 42);
ASSERT_EQ(EveryField::kSmallEnumFieldNumber, 51);
@@ -293,15 +288,12 @@
protozero::HeapBuffered<EveryField> msg;
msg->AppendVarInt(/*field_id=*/9999, /*value=*/42);
- // TODO(b/224800278): "protoc --decode" also prints the varint value, which is
- // more useful.
EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField",
msg.SerializeAsArray(), kIncludeNewLines),
- "# Ignoring unknown field with id: 9999");
+ "9999: 42");
}
-// TODO(b/224800278): Fix ProtozeroToText() crash and reenable.
-TEST_F(ProtozeroToTextTestMessageTest, DISABLED_FieldVarIntMismatch) {
+TEST_F(ProtozeroToTextTestMessageTest, FieldVarIntMismatch) {
protozero::HeapBuffered<EveryField> msg;
ASSERT_EQ(EveryField::kFieldStringFieldNumber, 500);
msg->AppendVarInt(EveryField::kFieldStringFieldNumber, 42);
@@ -336,11 +328,9 @@
protozero::HeapBuffered<EveryField> msg;
msg->set_field_fixed32(3000000000);
- // TODO(b/224800278): This is a bug. fixed32 is supposed to be unsigned, but
- // the code prints it as signed.
EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField",
msg.SerializeAsArray(), kIncludeNewLines),
- "field_fixed32: -1294967296");
+ "field_fixed32: 3000000000");
}
TEST_F(ProtozeroToTextTestMessageTest, FieldFixed32Float) {
@@ -356,15 +346,12 @@
protozero::HeapBuffered<EveryField> msg;
msg->AppendFixed<uint32_t>(/*field_id=*/9999, /*value=*/0x1);
- // TODO(b/224800278): "protoc --decode" also prints the 32-bit value, which is
- // more useful.
EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField",
msg.SerializeAsArray(), kIncludeNewLines),
- "# Ignoring unknown field with id: 9999");
+ "9999: 0x00000001");
}
-// TODO(b/224800278): Fix ProtozeroToText() crash and reenable.
-TEST_F(ProtozeroToTextTestMessageTest, DISABLED_FieldFixed32Mismatch) {
+TEST_F(ProtozeroToTextTestMessageTest, FieldFixed32Mismatch) {
protozero::HeapBuffered<EveryField> msg;
ASSERT_EQ(EveryField::kFieldStringFieldNumber, 500);
msg->AppendFixed<uint32_t>(EveryField::kFieldStringFieldNumber, 0x1);
@@ -405,15 +392,12 @@
protozero::HeapBuffered<EveryField> msg;
msg->AppendFixed<uint64_t>(/*field_id=*/9999, /*value=*/0x1);
- // TODO(b/224800278): "protoc --decode" also prints the 64-bit value, which is
- // more useful.
EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField",
msg.SerializeAsArray(), kIncludeNewLines),
- "# Ignoring unknown field with id: 9999");
+ "9999: 0x0000000000000001");
}
-// TODO(b/224800278): Fix ProtozeroToText() crash and reenable.
-TEST_F(ProtozeroToTextTestMessageTest, DISABLED_FieldFixed64Mismatch) {
+TEST_F(ProtozeroToTextTestMessageTest, FieldFixed64Mismatch) {
protozero::HeapBuffered<EveryField> msg;
ASSERT_EQ(EveryField::kFieldStringFieldNumber, 500);
msg->AppendFixed<uint64_t>(EveryField::kFieldStringFieldNumber, 0x1);
@@ -436,35 +420,257 @@
protozero::HeapBuffered<EveryField> msg;
msg->set_field_bytes("Hello");
- // TODO(b/224800278): "protoc --decode" always tries to print the value as
- // ASCII.
EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField",
msg.SerializeAsArray(), kIncludeNewLines),
- R"(field_bytes: "\x48\x65\x6c\x6c\x6f")");
+ R"(field_bytes: "Hello")");
}
TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedUnknown) {
protozero::HeapBuffered<EveryField> msg;
msg->AppendString(9999, "Hello");
- // TODO(b/224800278): "protoc --decode" also prints the string value, which is
- // more useful.
EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField",
msg.SerializeAsArray(), kIncludeNewLines),
- "# Ignoring unknown field with id: 9999");
+ R"(9999: "Hello")");
}
-// TODO(b/224800278): Fix ProtozeroToText() crash and reenable.
-TEST_F(ProtozeroToTextTestMessageTest, DISABLED_FieldLengthLimitedMismatch) {
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedMismatch) {
protozero::HeapBuffered<EveryField> msg;
ASSERT_EQ(EveryField::kFieldBoolFieldNumber, 13);
msg->AppendString(EveryField::kFieldBoolFieldNumber, "Hello");
EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField",
msg.SerializeAsArray(), kIncludeNewLines),
+ "# Packed type 8 not supported. Printing raw string.\n"
R"(13: "Hello")");
}
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedForNonPacked) {
+ // Even though repeated_int32 doesn't have [packed = true], it still accepts a
+ // packed representation.
+ protozero::HeapBuffered<EveryField> msg;
+ protozero::PackedVarInt buf;
+ buf.Append<int32_t>(-42);
+ buf.Append<int32_t>(2147483647);
+ msg->AppendBytes(EveryField::kRepeatedInt32FieldNumber, buf.data(),
+ buf.size());
+
+ EXPECT_EQ(ProtozeroToText(pool_, ".protozero.test.protos.EveryField",
+ msg.SerializeAsArray(), kIncludeNewLines),
+ "repeated_int32: -42\nrepeated_int32: 2147483647");
+}
+
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedVarIntInt32) {
+ protozero::HeapBuffered<PackedRepeatedFields> msg;
+ protozero::PackedVarInt buf;
+ buf.Append<int32_t>(-42);
+ buf.Append<int32_t>(2147483647);
+ msg->set_field_int32(buf);
+
+ EXPECT_EQ(
+ ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields",
+ msg.SerializeAsArray(), kIncludeNewLines),
+ "field_int32: -42\nfield_int32: 2147483647");
+}
+
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedVarIntInt64) {
+ protozero::HeapBuffered<PackedRepeatedFields> msg;
+ protozero::PackedVarInt buf;
+ buf.Append<int64_t>(-42);
+ buf.Append<int64_t>(3000000000);
+ msg->set_field_int64(buf);
+
+ EXPECT_EQ(
+ ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields",
+ msg.SerializeAsArray(), kIncludeNewLines),
+ "field_int64: -42\nfield_int64: 3000000000");
+}
+
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedVarIntUint32) {
+ protozero::HeapBuffered<PackedRepeatedFields> msg;
+ protozero::PackedVarInt buf;
+ buf.Append<uint32_t>(42);
+ buf.Append<uint32_t>(3000000000);
+ msg->set_field_uint32(buf);
+
+ EXPECT_EQ(
+ ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields",
+ msg.SerializeAsArray(), kIncludeNewLines),
+ "field_uint32: 42\nfield_uint32: 3000000000");
+}
+
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedVarIntUint64) {
+ protozero::HeapBuffered<PackedRepeatedFields> msg;
+ protozero::PackedVarInt buf;
+ buf.Append<uint64_t>(42);
+ buf.Append<uint64_t>(3000000000000);
+ msg->set_field_uint64(buf);
+
+ EXPECT_EQ(
+ ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields",
+ msg.SerializeAsArray(), kIncludeNewLines),
+ "field_uint64: 42\nfield_uint64: 3000000000000");
+}
+
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixed32Uint32) {
+ protozero::HeapBuffered<PackedRepeatedFields> msg;
+ protozero::PackedFixedSizeInt<uint32_t> buf;
+ buf.Append(42);
+ buf.Append(3000000000);
+ msg->set_field_fixed32(buf);
+
+ EXPECT_EQ(
+ ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields",
+ msg.SerializeAsArray(), kIncludeNewLines),
+ "field_fixed32: 42\nfield_fixed32: 3000000000");
+}
+
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixed32Int32) {
+ protozero::HeapBuffered<PackedRepeatedFields> msg;
+ protozero::PackedFixedSizeInt<int32_t> buf;
+ buf.Append(-42);
+ buf.Append(42);
+ msg->set_field_sfixed32(buf);
+
+ EXPECT_EQ(
+ ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields",
+ msg.SerializeAsArray(), kIncludeNewLines),
+ "field_sfixed32: -42\nfield_sfixed32: 42");
+}
+
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixed32Float) {
+ protozero::HeapBuffered<PackedRepeatedFields> msg;
+ protozero::PackedFixedSizeInt<float> buf;
+ buf.Append(-42);
+ buf.Append(42.125);
+ msg->set_field_float(buf);
+
+ std::string output =
+ ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields",
+ msg.SerializeAsArray(), kIncludeNewLines);
+
+ EXPECT_THAT(base::SplitString(output, "\n"),
+ ElementsAre(StartsWith("field_float: -42"),
+ StartsWith("field_float: 42.125")));
+}
+
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixed64Uint64) {
+ protozero::HeapBuffered<PackedRepeatedFields> msg;
+ protozero::PackedFixedSizeInt<uint64_t> buf;
+ buf.Append(42);
+ buf.Append(3000000000000);
+ msg->set_field_fixed64(buf);
+
+ EXPECT_EQ(
+ ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields",
+ msg.SerializeAsArray(), kIncludeNewLines),
+ "field_fixed64: 42\nfield_fixed64: 3000000000000");
+}
+
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixed64Int64) {
+ protozero::HeapBuffered<PackedRepeatedFields> msg;
+ protozero::PackedFixedSizeInt<int64_t> buf;
+ buf.Append(-42);
+ buf.Append(3000000000000);
+ msg->set_field_sfixed64(buf);
+
+ EXPECT_EQ(
+ ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields",
+ msg.SerializeAsArray(), kIncludeNewLines),
+ "field_sfixed64: -42\nfield_sfixed64: 3000000000000");
+}
+
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixed64Double) {
+ protozero::HeapBuffered<PackedRepeatedFields> msg;
+ protozero::PackedFixedSizeInt<double> buf;
+ buf.Append(-42);
+ buf.Append(42.125);
+ msg->set_field_double(buf);
+
+ EXPECT_THAT(
+ base::SplitString(
+ ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields",
+ msg.SerializeAsArray(), kIncludeNewLines),
+ "\n"),
+ ElementsAre(StartsWith("field_double: -42"),
+ StartsWith("field_double: 42.125")));
+}
+
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixedErrShort) {
+ protozero::HeapBuffered<PackedRepeatedFields> msg;
+ std::string buf;
+ buf = "\x01";
+ // buf does not contain enough data for a fixed 64
+ msg->AppendBytes(PackedRepeatedFields::kFieldFixed64FieldNumber, buf.data(),
+ buf.size());
+
+ // "protoc --decode", instead, returns an error on stderr and doesn't output
+ // anything at all.
+ EXPECT_EQ(
+ ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields",
+ msg.SerializeAsArray(), kIncludeNewLines),
+ "# Packed decoding failure for field field_fixed64\n");
+}
+
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedFixedGarbage) {
+ protozero::HeapBuffered<PackedRepeatedFields> msg;
+ protozero::PackedFixedSizeInt<uint64_t> buf;
+ buf.Append(42);
+ buf.Append(3000000000000);
+ std::string buf_and_garbage(reinterpret_cast<const char*>(buf.data()),
+ buf.size());
+ buf_and_garbage += "\x01";
+ // buf contains extra garbage
+ msg->AppendBytes(PackedRepeatedFields::kFieldFixed64FieldNumber,
+ buf_and_garbage.data(), buf_and_garbage.size());
+
+ // "protoc --decode", instead, returns an error on stderr and doesn't output
+ // anything at all.
+ EXPECT_EQ(
+ ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields",
+ msg.SerializeAsArray(), kIncludeNewLines),
+ "# Packed decoding failure for field field_fixed64\n");
+}
+
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedVarIntShort) {
+ protozero::HeapBuffered<PackedRepeatedFields> msg;
+ std::string buf;
+ buf = "\xFF";
+ // for the varint to be valid, buf should contain another byte.
+ msg->AppendBytes(PackedRepeatedFields::kFieldInt32FieldNumber, buf.data(),
+ buf.size());
+
+ // "protoc --decode", instead, returns an error on stderr and doesn't output
+ // anything at all.
+ EXPECT_EQ(
+ ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields",
+ msg.SerializeAsArray(), kIncludeNewLines),
+ "# Packed decoding failure for field field_int32\n");
+}
+
+TEST_F(ProtozeroToTextTestMessageTest, FieldLengthLimitedPackedVarIntGarbage) {
+ protozero::HeapBuffered<PackedRepeatedFields> msg;
+ protozero::PackedVarInt buf;
+ buf.Append(42);
+ buf.Append(105);
+ std::string buf_and_garbage(reinterpret_cast<const char*>(buf.data()),
+ buf.size());
+ buf_and_garbage += "\xFF";
+ // buf contains extra garbage
+ msg->AppendBytes(PackedRepeatedFields::kFieldInt32FieldNumber,
+ buf_and_garbage.data(), buf_and_garbage.size());
+
+ // "protoc --decode", instead:
+ // * doesn't output anything.
+ // * returns an error on stderr.
+ EXPECT_EQ(
+ ProtozeroToText(pool_, ".protozero.test.protos.PackedRepeatedFields",
+ msg.SerializeAsArray(), kIncludeNewLines),
+ "field_int32: 42\n"
+ "field_int32: 105\n"
+ "# Packed decoding failure for field field_int32\n");
+}
+
} // namespace
} // namespace protozero_to_text
} // namespace trace_processor
diff --git a/src/traced/probes/android_log/android_log_data_source.cc b/src/traced/probes/android_log/android_log_data_source.cc
index 4d8d309..2d4d264 100644
--- a/src/traced/probes/android_log/android_log_data_source.cc
+++ b/src/traced/probes/android_log/android_log_data_source.cc
@@ -368,8 +368,6 @@
if (!ReadAndAdvance(&buf, end, &eid))
return false;
- // TODO test events with 0 arguments. DNS.
-
const EventFormat* fmt = GetEventFormat(eid);
if (!fmt) {
// We got an event which doesn't have a corresponding entry in
diff --git a/src/traced/probes/ps/process_stats_data_source.cc b/src/traced/probes/ps/process_stats_data_source.cc
index d61e41c..665a350 100644
--- a/src/traced/probes/ps/process_stats_data_source.cc
+++ b/src/traced/probes/ps/process_stats_data_source.cc
@@ -23,7 +23,6 @@
#include "perfetto/base/task_runner.h"
#include "perfetto/base/time.h"
-#include "perfetto/ext/base/crash_keys.h"
#include "perfetto/ext/base/file_utils.h"
#include "perfetto/ext/base/hash.h"
#include "perfetto/ext/base/metatrace.h"
@@ -55,10 +54,6 @@
// was provided in the config. The cache is trimmed if it exceeds this size.
const size_t kThreadTimeInStateCacheSize = 10000;
-// TODO(b/189749310): For debugging of b/189749310. Remove by Jan 2022.
-base::CrashKey g_crash_key_proc_file("proc_file");
-base::CrashKey g_crash_key_proc_count("proc_count");
-
int32_t ReadNextNumericDir(DIR* dirp) {
while (struct dirent* dir_ent = readdir(dirp)) {
if (dir_ent->d_type != DT_DIR)
@@ -344,8 +339,6 @@
std::string ProcessStatsDataSource::ReadProcPidFile(int32_t pid,
const std::string& file) {
base::StackString<128> path("/proc/%" PRId32 "/%s", pid, file.c_str());
- auto scoped_key = g_crash_key_proc_file.SetScoped(path.string_view());
- g_crash_key_proc_count.Set(g_crash_key_proc_count.int_value() + 1);
std::string contents;
contents.reserve(4096);
if (!base::ReadFile(path.c_str(), &contents))
@@ -433,7 +426,6 @@
base::WeakPtr<ProcessStatsDataSource> weak_this) {
if (!weak_this)
return;
- g_crash_key_proc_count.Clear();
ProcessStatsDataSource& thiz = *weak_this;
uint32_t period_ms = thiz.poll_period_ms_;
uint32_t delay_ms =
diff --git a/src/tracing/core/tracing_service_impl.cc b/src/tracing/core/tracing_service_impl.cc
index 18f6e69..f9da779 100644
--- a/src/tracing/core/tracing_service_impl.cc
+++ b/src/tracing/core/tracing_service_impl.cc
@@ -53,7 +53,6 @@
#include "perfetto/base/status.h"
#include "perfetto/base/task_runner.h"
#include "perfetto/ext/base/android_utils.h"
-#include "perfetto/ext/base/crash_keys.h"
#include "perfetto/ext/base/file_utils.h"
#include "perfetto/ext/base/metatrace.h"
#include "perfetto/ext/base/string_utils.h"
diff --git a/src/tracing/test/api_integrationtest.cc b/src/tracing/test/api_integrationtest.cc
index 4a16b42..97a94f4 100644
--- a/src/tracing/test/api_integrationtest.cc
+++ b/src/tracing/test/api_integrationtest.cc
@@ -24,6 +24,7 @@
#include <mutex>
#include <regex>
#include <thread>
+#include <unordered_set>
#include <vector>
// We also want to test legacy trace events.
@@ -2805,6 +2806,56 @@
"]I:test.Event"));
}
+TEST_P(PerfettoApiTest, TrackEventTrackFromThreadScopedPointer) {
+ // Create a new trace session.
+ auto* tracing_session = NewTraceWithCategories({"test"});
+ tracing_session->get()->StartBlocking();
+
+ int num = 2;
+ TRACE_EVENT_INSTANT("test", "Event0.1");
+ TRACE_EVENT_INSTANT("test", "Event0.2");
+ TRACE_EVENT_INSTANT("test", "Event1.1", perfetto::Track::ThreadScoped(&num));
+ TRACE_EVENT_INSTANT("test", "Event1.2", perfetto::Track::ThreadScoped(&num));
+ std::thread t1([&]() {
+ TRACE_EVENT_INSTANT("test", "Event2.1",
+ perfetto::Track::ThreadScoped(&num));
+ TRACE_EVENT_INSTANT("test", "Event2.2",
+ perfetto::Track::ThreadScoped(&num));
+ });
+ t1.join();
+ std::thread t2([&]() {
+ TRACE_EVENT_INSTANT("test", "Event3.1",
+ perfetto::Track::ThreadScoped(&num));
+ TRACE_EVENT_INSTANT("test", "Event3.2",
+ perfetto::Track::ThreadScoped(&num));
+ });
+ t2.join();
+ perfetto::TrackEvent::Flush();
+ tracing_session->get()->StopBlocking();
+ std::vector<char> raw_trace = tracing_session->get()->ReadTraceBlocking();
+ perfetto::protos::gen::Trace parsed_trace;
+ ASSERT_TRUE(parsed_trace.ParseFromArray(raw_trace.data(), raw_trace.size()));
+
+ std::unordered_map<std::string, uint64_t> track_uuid_map;
+ for (auto packet : parsed_trace.packet()) {
+ if (packet.has_interned_data()) {
+ for (auto& ename : packet.interned_data().event_names()) {
+ track_uuid_map.emplace(ename.name(), packet.track_event().track_uuid());
+ }
+ }
+ }
+ EXPECT_EQ(track_uuid_map.at("Event0.1"), track_uuid_map.at("Event0.2"));
+ EXPECT_EQ(track_uuid_map.at("Event1.1"), track_uuid_map.at("Event1.2"));
+ EXPECT_EQ(track_uuid_map.at("Event2.1"), track_uuid_map.at("Event2.2"));
+ EXPECT_EQ(track_uuid_map.at("Event3.1"), track_uuid_map.at("Event3.2"));
+
+ EXPECT_EQ(4u,
+ (std::unordered_set<uint64_t>{
+ track_uuid_map.at("Event0.1"), track_uuid_map.at("Event1.1"),
+ track_uuid_map.at("Event2.1"), track_uuid_map.at("Event3.1")})
+ .size());
+}
+
TEST_P(PerfettoApiTest, TrackEventDebugAnnotations) {
// Create a new trace session.
auto* tracing_session = NewTraceWithCategories({"test"});
diff --git a/test/trace_processor/chrome/chrome_long_latency_metric.out b/test/trace_processor/chrome/chrome_long_latency_metric.out
new file mode 100644
index 0000000..9779ed9
--- /dev/null
+++ b/test/trace_processor/chrome/chrome_long_latency_metric.out
@@ -0,0 +1,5 @@
+
+"ts","event_type","process_name","process_id"
+200111000,"GestureScrollUpdate","Renderer",1001
+200111000,"GestureScrollUpdate","Renderer",1002
+280111001,"GestureScrollUpdate","Renderer",1001
diff --git a/test/trace_processor/chrome/chrome_long_latency_metric.sql b/test/trace_processor/chrome/chrome_long_latency_metric.sql
new file mode 100644
index 0000000..13db1ff
--- /dev/null
+++ b/test/trace_processor/chrome/chrome_long_latency_metric.sql
@@ -0,0 +1,18 @@
+--
+-- Copyright 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
+--
+-- https://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.
+
+SELECT RUN_METRIC('experimental/chrome_long_latency.sql') AS suppress_query_output;
+
+SELECT * FROM long_latency_with_process_info;
\ No newline at end of file
diff --git a/test/trace_processor/chrome/index b/test/trace_processor/chrome/index
index 019067a..7e6856c 100644
--- a/test/trace_processor/chrome/index
+++ b/test/trace_processor/chrome/index
@@ -17,6 +17,7 @@
../track_event/track_event_counters.textproto chrome_thread_slice_repeated.sql chrome_thread_slice_repeated.out
../../data/chrome_rendering_desktop.pftrace frame_times frame_times_metric.out
../../data/chrome_rendering_desktop.pftrace chrome_dropped_frames chrome_dropped_frames_metric.out
+../chrome/long_event_latency.textproto chrome_long_latency_metric.sql chrome_long_latency_metric.out
scroll_jank_mojo_simple_watcher.py scroll_jank_mojo_simple_watcher.sql scroll_jank_mojo_simple_watcher.out
scroll_jank_gpu_check.py scroll_jank_gpu_check.sql scroll_jank_gpu_check.out
diff --git a/test/trace_processor/chrome/long_event_latency.textproto b/test/trace_processor/chrome/long_event_latency.textproto
new file mode 100644
index 0000000..8b6fa8b
--- /dev/null
+++ b/test/trace_processor/chrome/long_event_latency.textproto
@@ -0,0 +1,212 @@
+# Long latency events from two renderer processes
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 0
+ track_descriptor {
+ uuid: 10
+ process {
+ pid: 1001
+ process_name: "Renderer"
+ }
+ }
+}
+
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 0
+ track_descriptor {
+ uuid: 20
+ process {
+ pid: 1002
+ process_name: "Renderer"
+ }
+ }
+}
+
+# EventLatency 1: 200ms duration
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 0
+ track_descriptor {
+ uuid: 101
+ parent_uuid: 10
+ name: "EventLatency"
+ }
+}
+
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 111000
+ track_event {
+ track_uuid: 101
+ categories: "cat"
+ debug_annotations: {
+ name: "event"
+ string_value: "GestureScrollUpdate"
+ }
+ name: "EventLatency"
+ type: 1
+ }
+}
+
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 200111000
+ track_event {
+ track_uuid: 101
+ categories: "cat"
+ name: "EventLatency"
+ type: 2
+ }
+}
+
+# EventLatency 2: 110ms ending at the same timestamp as EventLatency 1.
+# EventLatency 1 and 2 are reported as one occurrence of long latency.
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 0
+ track_descriptor {
+ uuid: 102
+ parent_uuid: 10
+ name: "EventLatency"
+ }
+}
+
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 90111000
+ track_event {
+ track_uuid: 102
+ categories: "cat"
+ debug_annotations: {
+ name: "event"
+ string_value: "GestureScrollUpdate"
+ }
+ name: "EventLatency"
+ type: 1
+ }
+}
+
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 200111000
+ track_event {
+ track_uuid: 102
+ categories: "cat"
+ name: "EventLatency"
+ type: 2
+ }
+}
+
+# EventLatency 3: a long latency slightly above the 100ms threshold
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 0
+ track_descriptor {
+ uuid: 103
+ parent_uuid: 10
+ name: "EventLatency"
+ }
+}
+
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 180111000
+ track_event {
+ track_uuid: 103
+ categories: "cat"
+ debug_annotations: {
+ name: "event"
+ string_value: "GestureScrollUpdate"
+ }
+ name: "EventLatency"
+ type: 1
+ }
+}
+
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 280111001
+ track_event {
+ track_uuid: 103
+ categories: "cat"
+ name: "EventLatency"
+ type: 2
+ }
+}
+
+# EventLatency 4: below the 100ms threshold; not a long latency
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 0
+ track_descriptor {
+ uuid: 104
+ parent_uuid: 10
+ name: "EventLatency"
+ }
+}
+
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 250111001
+ track_event {
+ track_uuid: 104
+ categories: "cat"
+ debug_annotations: {
+ name: "event"
+ string_value: "GestureScrollUpdate"
+ }
+ name: "EventLatency"
+ type: 1
+ }
+}
+
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 350111000
+ track_event {
+ track_uuid: 104
+ categories: "cat"
+ name: "EventLatency"
+ type: 2
+ }
+}
+
+# EventLatency 5: long latency from the second renderer process;
+# should be reported as a standalone long latency occurrence despite having
+# the same end time as EventLatency 1.
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 0
+ track_descriptor {
+ uuid: 201
+ parent_uuid: 20
+ name: "EventLatency"
+ }
+}
+
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 111000
+ track_event {
+ track_uuid: 201
+ categories: "cat"
+ debug_annotations: {
+ name: "event"
+ string_value: "GestureScrollUpdate"
+ }
+ name: "EventLatency"
+ type: 1
+ }
+}
+
+packet {
+ trusted_packet_sequence_id: 1
+ timestamp: 200111000
+ track_event {
+ track_uuid: 201
+ categories: "cat"
+ name: "EventLatency"
+ type: 2
+ }
+}
\ No newline at end of file
diff --git a/ui/src/common/state.ts b/ui/src/common/state.ts
index 18df6ce..da6809b 100644
--- a/ui/src/common/state.ts
+++ b/ui/src/common/state.ts
@@ -155,7 +155,10 @@
labels?: string[];
trackKindPriority: TrackKindPriority;
trackGroup?: string;
- config: {};
+ config: {
+ trackId?: number;
+ trackIds?: number[];
+ };
}
export interface TrackGroupState {
diff --git a/ui/src/controller/search_controller.ts b/ui/src/controller/search_controller.ts
index d38e64f..6bf5326 100644
--- a/ui/src/controller/search_controller.ts
+++ b/ui/src/controller/search_controller.ts
@@ -217,13 +217,12 @@
cpuToTrackId.set((track.config as {cpu: number}).cpu, track.id);
continue;
}
- if (track.kind === 'ChromeSliceTrack') {
- const config = (track.config as {trackId: number});
+ const config = track.config || {};
+ if (config.trackId !== undefined) {
engineTrackIdToTrackId.set(config.trackId, track.id);
continue;
}
- if (track.kind === 'AsyncSliceTrack') {
- const config = (track.config as {trackIds: number[]});
+ if (config.trackIds !== undefined) {
for (const trackId of config.trackIds) {
engineTrackIdToTrackId.set(trackId, track.id);
}
diff --git a/ui/src/controller/selection_controller.ts b/ui/src/controller/selection_controller.ts
index 66c55a0..a940716 100644
--- a/ui/src/controller/selection_controller.ts
+++ b/ui/src/controller/selection_controller.ts
@@ -50,7 +50,7 @@
processName?: string;
uid?: number;
packageName?: string;
- versionCode?: string;
+ versionCode?: number;
}
// This class queries the TP for the details on a specific slice that has
@@ -539,7 +539,7 @@
// check if the result has returned any rows.
if (packageResult.numRows() > 0) {
const packageDetails =
- packageResult.firstRow({package_name: STR, version_code: STR});
+ packageResult.firstRow({package_name: STR, version_code: NUM});
details.packageName = packageDetails.package_name;
details.versionCode = packageDetails.version_code;
}
diff --git a/ui/src/frontend/globals.ts b/ui/src/frontend/globals.ts
index dd5b51b..e5fa7ad 100644
--- a/ui/src/frontend/globals.ts
+++ b/ui/src/frontend/globals.ts
@@ -63,7 +63,7 @@
processName?: string;
uid?: number;
packageName?: string;
- versionCode?: string;
+ versionCode?: number;
args?: Args;
argsTree?: ArgsTree;
description?: Description;
diff --git a/ui/src/frontend/keyboard_event_handler.ts b/ui/src/frontend/keyboard_event_handler.ts
index 204fcb2..0bbb98e 100644
--- a/ui/src/frontend/keyboard_event_handler.ts
+++ b/ui/src/frontend/keyboard_event_handler.ts
@@ -42,8 +42,10 @@
const selection = globals.state.currentSelection;
const noModifiers = !(e.ctrlKey || e.metaKey || e.altKey || e.shiftKey);
const ctrlOrMeta = (e.ctrlKey || e.metaKey) && !(e.altKey || e.shiftKey);
+ // No other modifiers other than possibly Shift.
+ const maybeShift = !(e.ctrlKey || e.metaKey || e.altKey);
- if (down && 'm' === key && noModifiers) {
+ if (down && 'm' === key && maybeShift) {
if (selection && selection.kind === 'AREA') {
globals.dispatch(Actions.toggleMarkCurrentArea({persistent: e.shiftKey}));
} else if (selection) {
@@ -56,10 +58,10 @@
if (down && 'b' === key && ctrlOrMeta) {
globals.dispatch(Actions.toggleSidebar({}));
}
- if (down && '?' === key && noModifiers) {
+ if (down && '?' === key && maybeShift) {
toggleHelp();
}
- if (down && 'enter' === key && noModifiers) {
+ if (down && 'enter' === key && maybeShift) {
e.preventDefault();
executeSearch(e.shiftKey);
}
diff --git a/ui/src/frontend/slice_panel.ts b/ui/src/frontend/slice_panel.ts
index 85dbff1..a1b3428 100644
--- a/ui/src/frontend/slice_panel.ts
+++ b/ui/src/frontend/slice_panel.ts
@@ -32,7 +32,10 @@
['Process name', sliceInfo.processName],
['User ID', sliceInfo.uid ? String(sliceInfo.uid) : undefined],
['Package name', sliceInfo.packageName],
- ['Version code', sliceInfo.versionCode]
+ [
+ 'Version code',
+ sliceInfo.versionCode ? String(sliceInfo.versionCode) : undefined
+ ]
]);
}
}
\ No newline at end of file
