1 /* 2 * Copyright 2021 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #pragma once 18 19 #include <layerproto/LayerProtoHeader.h> 20 21 #include <atomic> 22 #include <functional> 23 #include <optional> 24 #include <ostream> 25 26 namespace android { 27 28 class TransactionTracing; 29 30 /* 31 * LayerTracing records layer states during surface flinging. Manages tracing state and 32 * configuration. 33 * 34 * The traced data can then be collected with Perfetto. 35 * 36 * The Perfetto custom data source LayerDataSource is registered with perfetto. The data source 37 * is used to listen to perfetto events (setup, start, stop, flush) and to write trace packets 38 * to perfetto. 39 * 40 * The user can configure/start/stop tracing via /system/bin/perfetto. 41 * 42 * Tracing can operate in the following modes. 43 * 44 * ACTIVE mode: 45 * A layers snapshot is taken and written to perfetto for each vsyncid commit. 46 * 47 * GENERATED mode: 48 * Listens to the perfetto 'flush' event (e.g. when a bugreport is taken). 49 * When a 'flush' event is received, the ring buffer of transactions (hold by TransactionTracing) 50 * is processed by LayerTraceGenerator, a sequence of layers snapshots is generated 51 * and written to perfetto. 52 * 53 * DUMP mode: 54 * When the 'start' event is received a single layers snapshot is taken 55 * and written to perfetto. 56 * 57 * 58 * E.g. start active mode tracing 59 * (replace mode value with MODE_DUMP, MODE_GENERATED or MODE_GENERATED_BUGREPORT_ONLY to enable 60 * different tracing modes): 61 * 62 adb shell -t perfetto \ 63 -c - --txt \ 64 -o /data/misc/perfetto-traces/trace \ 65 <<EOF 66 unique_session_name: "surfaceflinger_layers_active" 67 buffers: { 68 size_kb: 63488 69 fill_policy: RING_BUFFER 70 } 71 data_sources: { 72 config { 73 name: "android.surfaceflinger.layers" 74 surfaceflinger_layers_config: { 75 mode: MODE_ACTIVE 76 trace_flags: TRACE_FLAG_INPUT 77 trace_flags: TRACE_FLAG_COMPOSITION 78 trace_flags: TRACE_FLAG_HWC 79 trace_flags: TRACE_FLAG_BUFFERS 80 trace_flags: TRACE_FLAG_VIRTUAL_DISPLAYS 81 } 82 } 83 } 84 EOF 85 * 86 */ 87 class LayerTracing { 88 public: 89 using Mode = perfetto::protos::pbzero::SurfaceFlingerLayersConfig::Mode; 90 using OnLayersSnapshotCallback = std::function<void(perfetto::protos::LayersSnapshotProto&&)>; 91 92 enum Flag : uint32_t { 93 TRACE_INPUT = 1 << 1, 94 TRACE_COMPOSITION = 1 << 2, 95 TRACE_EXTRA = 1 << 3, 96 TRACE_HWC = 1 << 4, 97 TRACE_BUFFERS = 1 << 5, 98 TRACE_VIRTUAL_DISPLAYS = 1 << 6, 99 TRACE_ALL = TRACE_INPUT | TRACE_COMPOSITION | TRACE_EXTRA, 100 }; 101 102 LayerTracing(); 103 LayerTracing(std::ostream&); 104 ~LayerTracing(); 105 void setTakeLayersSnapshotProtoFunction( 106 const std::function<void(uint32_t, const OnLayersSnapshotCallback&)>&); 107 void setTransactionTracing(TransactionTracing&); 108 109 // Start event from perfetto data source 110 void onStart(Mode mode, uint32_t flags); 111 // Flush event from perfetto data source 112 void onFlush(Mode mode, uint32_t flags, bool isBugreport); 113 // Stop event from perfetto data source 114 void onStop(Mode mode, uint32_t flags, std::function<void()>&& deferredStopDone); 115 116 void addProtoSnapshotToOstream(perfetto::protos::LayersSnapshotProto&& snapshot, Mode mode); 117 bool isActiveTracingStarted() const; 118 uint32_t getActiveTracingFlags() const; 119 bool isActiveTracingFlagSet(Flag flag) const; 120 static perfetto::protos::LayersTraceFileProto createTraceFileProto(); 121 122 private: 123 void writeSnapshotToStream(perfetto::protos::LayersSnapshotProto&& snapshot) const; 124 void writeSnapshotToPerfetto(const perfetto::protos::LayersSnapshotProto& snapshot, Mode mode); 125 bool checkAndUpdateLastVsyncIdWrittenToPerfetto(Mode mode, std::int64_t vsyncId); 126 127 std::function<void(uint32_t, const OnLayersSnapshotCallback&)> mTakeLayersSnapshotProto; 128 TransactionTracing* mTransactionTracing; 129 130 std::atomic<bool> mIsActiveTracingStarted{false}; 131 std::atomic<uint32_t> mActiveTracingFlags{0}; 132 std::atomic<std::int64_t> mLastVsyncIdWrittenToPerfetto{-1}; 133 std::optional<std::reference_wrapper<std::ostream>> mOutStream; 134 }; 135 136 } // namespace android 137