blob: 84890eefd1fda94bb0725e1f3f0ff706ecf7a7ac [file] [log] [blame]
Vishnu Nair00b90132021-11-05 14:03:40 -07001/*
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#undef LOG_TAG
18#define LOG_TAG "LayerTracing"
19#define ATRACE_TAG ATRACE_TAG_GRAPHICS
20
21#include <SurfaceFlinger.h>
22#include <android-base/stringprintf.h>
23#include <log/log.h>
24#include <utils/SystemClock.h>
25#include <utils/Trace.h>
26
27#include "LayerTracing.h"
28#include "RingBuffer.h"
29
30namespace android {
31
32LayerTracing::LayerTracing(SurfaceFlinger& flinger) : mFlinger(flinger) {
33 mBuffer = std::make_unique<RingBuffer<LayersTraceFileProto, LayersTraceProto>>();
34}
35
36LayerTracing::~LayerTracing() = default;
37
38bool LayerTracing::enable() {
39 std::scoped_lock lock(mTraceLock);
40 if (mEnabled) {
41 return false;
42 }
43 mBuffer->setSize(mBufferSizeInBytes);
44 mEnabled = true;
45 return true;
46}
47
48bool LayerTracing::disable() {
49 std::scoped_lock lock(mTraceLock);
50 if (!mEnabled) {
51 return false;
52 }
53 mEnabled = false;
54 LayersTraceFileProto fileProto = createTraceFileProto();
55 mBuffer->writeToFile(fileProto, FILE_NAME);
56 return true;
57}
58
59bool LayerTracing::isEnabled() const {
60 std::scoped_lock lock(mTraceLock);
61 return mEnabled;
62}
63
64status_t LayerTracing::writeToFile() {
65 std::scoped_lock lock(mTraceLock);
66 if (!mEnabled) {
67 return STATUS_OK;
68 }
69 LayersTraceFileProto fileProto = createTraceFileProto();
70 return mBuffer->writeToFile(fileProto, FILE_NAME);
71}
72
73void LayerTracing::setTraceFlags(uint32_t flags) {
74 std::scoped_lock lock(mTraceLock);
75 mFlags = flags;
76}
77
78void LayerTracing::setBufferSize(size_t bufferSizeInBytes) {
79 std::scoped_lock lock(mTraceLock);
80 mBufferSizeInBytes = bufferSizeInBytes;
81}
82
83bool LayerTracing::flagIsSet(uint32_t flags) const {
84 return (mFlags & flags) == flags;
85}
86
87LayersTraceFileProto LayerTracing::createTraceFileProto() const {
88 LayersTraceFileProto fileProto;
89 fileProto.set_magic_number(uint64_t(LayersTraceFileProto_MagicNumber_MAGIC_NUMBER_H) << 32 |
90 LayersTraceFileProto_MagicNumber_MAGIC_NUMBER_L);
91 return fileProto;
92}
93
94void LayerTracing::dump(std::string& result) const {
95 std::scoped_lock lock(mTraceLock);
96 base::StringAppendF(&result, "Tracing state: %s\n", mEnabled ? "enabled" : "disabled");
97 mBuffer->dump(result);
98}
99
100void LayerTracing::notify(const char* where) {
101 ATRACE_CALL();
102 std::scoped_lock lock(mTraceLock);
103 if (!mEnabled) {
104 return;
105 }
106
107 ATRACE_CALL();
108 LayersTraceProto entry;
109 entry.set_elapsed_realtime_nanos(elapsedRealtimeNano());
110 entry.set_where(where);
111 LayersProto layers(mFlinger.dumpDrawingStateProto(mFlags));
112
113 if (flagIsSet(LayerTracing::TRACE_EXTRA)) {
114 mFlinger.dumpOffscreenLayersProto(layers);
115 }
116 entry.mutable_layers()->Swap(&layers);
117
118 if (flagIsSet(LayerTracing::TRACE_HWC)) {
119 std::string hwcDump;
120 mFlinger.dumpHwc(hwcDump);
121 entry.set_hwc_blob(hwcDump);
122 }
123 if (!flagIsSet(LayerTracing::TRACE_COMPOSITION)) {
124 entry.set_excludes_composition_state(true);
125 }
126 mFlinger.dumpDisplayProto(entry);
127 mBuffer->emplace(std::move(entry));
128}
129
130} // namespace android