blob: e1f348fdbaddff0a12c9632271f7de2ff210bf92 [file] [log] [blame]
Robert Carr9a803c32021-01-14 16:57:58 -08001/*
2 * Copyright 2018 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// TODO(b/129481165): remove the #pragma below and fix conversion issues
18#pragma clang diagnostic push
19#pragma clang diagnostic ignored "-Wconversion"
20
21//#define LOG_NDEBUG 0
22#undef LOG_TAG
23#define LOG_TAG "TransactionCallbackInvoker"
24#define ATRACE_TAG ATRACE_TAG_GRAPHICS
25
26#include "TransactionCallbackInvoker.h"
Vishnu Nair34eb9ca2021-11-18 15:23:23 -080027#include "BackgroundExecutor.h"
Robert Carr9a803c32021-01-14 16:57:58 -080028
29#include <cinttypes>
30
31#include <binder/IInterface.h>
32#include <utils/RefBase.h>
33
34namespace android {
35
36// Returns 0 if they are equal
37// <0 if the first id that doesn't match is lower in c2 or all ids match but c2 is shorter
38// >0 if the first id that doesn't match is greater in c2 or all ids match but c2 is longer
39//
Vishnu Nairfc46c1e2021-04-21 08:31:32 -070040// See CallbackIdsHash for a explanation of why this works
Robert Carr9a803c32021-01-14 16:57:58 -080041static int compareCallbackIds(const std::vector<CallbackId>& c1,
42 const std::vector<CallbackId>& c2) {
43 if (c1.empty()) {
44 return !c2.empty();
45 }
Vishnu Nairfc46c1e2021-04-21 08:31:32 -070046 return c1.front().id - c2.front().id;
47}
48
49static bool containsOnCommitCallbacks(const std::vector<CallbackId>& callbacks) {
50 return !callbacks.empty() && callbacks.front().type == CallbackId::Type::ON_COMMIT;
Robert Carr9a803c32021-01-14 16:57:58 -080051}
52
Jiakai Zhanga5505cb2021-11-09 11:46:30 +000053void TransactionCallbackInvoker::addEmptyTransaction(const ListenerCallbacks& listenerCallbacks) {
Robert Carr9a803c32021-01-14 16:57:58 -080054 auto& [listener, callbackIds] = listenerCallbacks;
Jiakai Zhanga5505cb2021-11-09 11:46:30 +000055 auto& transactionStatsDeque = mCompletedTransactions[listener];
56 transactionStatsDeque.emplace_back(callbackIds);
Robert Carr9a803c32021-01-14 16:57:58 -080057}
58
Robert Carr3d1047b2021-09-20 18:22:32 -070059status_t TransactionCallbackInvoker::addOnCommitCallbackHandles(
Vishnu Nairfc46c1e2021-04-21 08:31:32 -070060 const std::deque<sp<CallbackHandle>>& handles,
61 std::deque<sp<CallbackHandle>>& outRemainingHandles) {
62 if (handles.empty()) {
63 return NO_ERROR;
64 }
Vishnu Nairfc46c1e2021-04-21 08:31:32 -070065 const std::vector<JankData>& jankData = std::vector<JankData>();
66 for (const auto& handle : handles) {
67 if (!containsOnCommitCallbacks(handle->callbackIds)) {
68 outRemainingHandles.push_back(handle);
69 continue;
70 }
Robert Carr3d1047b2021-09-20 18:22:32 -070071 status_t err = addCallbackHandle(handle, jankData);
Vishnu Nairfc46c1e2021-04-21 08:31:32 -070072 if (err != NO_ERROR) {
73 return err;
74 }
75 }
76
77 return NO_ERROR;
78}
79
Robert Carr3d1047b2021-09-20 18:22:32 -070080status_t TransactionCallbackInvoker::addCallbackHandles(
Robert Carr9a803c32021-01-14 16:57:58 -080081 const std::deque<sp<CallbackHandle>>& handles, const std::vector<JankData>& jankData) {
82 if (handles.empty()) {
83 return NO_ERROR;
84 }
Robert Carr9a803c32021-01-14 16:57:58 -080085 for (const auto& handle : handles) {
Robert Carr3d1047b2021-09-20 18:22:32 -070086 status_t err = addCallbackHandle(handle, jankData);
Robert Carr9a803c32021-01-14 16:57:58 -080087 if (err != NO_ERROR) {
Robert Carr9a803c32021-01-14 16:57:58 -080088 return err;
89 }
90 }
91
92 return NO_ERROR;
93}
94
Jiakai Zhanga5505cb2021-11-09 11:46:30 +000095status_t TransactionCallbackInvoker::registerUnpresentedCallbackHandle(
Robert Carr9a803c32021-01-14 16:57:58 -080096 const sp<CallbackHandle>& handle) {
Robert Carr9a803c32021-01-14 16:57:58 -080097 return addCallbackHandle(handle, std::vector<JankData>());
98}
99
Vishnu Naircd52e2d2021-10-18 08:42:46 -0700100status_t TransactionCallbackInvoker::findOrCreateTransactionStats(
Robert Carr9a803c32021-01-14 16:57:58 -0800101 const sp<IBinder>& listener, const std::vector<CallbackId>& callbackIds,
102 TransactionStats** outTransactionStats) {
103 auto& transactionStatsDeque = mCompletedTransactions[listener];
104
105 // Search back to front because the most recent transactions are at the back of the deque
106 auto itr = transactionStatsDeque.rbegin();
107 for (; itr != transactionStatsDeque.rend(); itr++) {
108 if (compareCallbackIds(itr->callbackIds, callbackIds) == 0) {
109 *outTransactionStats = &(*itr);
110 return NO_ERROR;
111 }
112 }
Robert Carr3d1047b2021-09-20 18:22:32 -0700113 *outTransactionStats = &transactionStatsDeque.emplace_back(callbackIds);
114 return NO_ERROR;
Robert Carr9a803c32021-01-14 16:57:58 -0800115}
116
117status_t TransactionCallbackInvoker::addCallbackHandle(const sp<CallbackHandle>& handle,
118 const std::vector<JankData>& jankData) {
119 // If we can't find the transaction stats something has gone wrong. The client should call
120 // startRegistration before trying to add a callback handle.
121 TransactionStats* transactionStats;
Vishnu Naircd52e2d2021-10-18 08:42:46 -0700122 status_t err =
123 findOrCreateTransactionStats(handle->listener, handle->callbackIds, &transactionStats);
Robert Carr9a803c32021-01-14 16:57:58 -0800124 if (err != NO_ERROR) {
125 return err;
126 }
127
128 transactionStats->latchTime = handle->latchTime;
129 // If the layer has already been destroyed, don't add the SurfaceControl to the callback.
130 // The client side keeps a sp<> to the SurfaceControl so if the SurfaceControl has been
131 // destroyed the client side is dead and there won't be anyone to send the callback to.
132 sp<IBinder> surfaceControl = handle->surfaceControl.promote();
133 if (surfaceControl) {
Sally Qi59a9f502021-10-12 18:53:23 +0000134 sp<Fence> prevFence = nullptr;
135
136 for (const auto& futureStruct : handle->previousReleaseFences) {
137 sp<Fence> currentFence = sp<Fence>::make(dup(futureStruct.get().drawFence));
138 if (prevFence == nullptr && currentFence->getStatus() != Fence::Status::Invalid) {
139 prevFence = currentFence;
140 handle->previousReleaseFence = prevFence;
141 } else if (prevFence != nullptr) {
142 // If both fences are signaled or both are unsignaled, we need to merge
143 // them to get an accurate timestamp.
144 if (prevFence->getStatus() != Fence::Status::Invalid &&
145 prevFence->getStatus() == currentFence->getStatus()) {
146 char fenceName[32] = {};
147 snprintf(fenceName, 32, "%.28s", handle->name.c_str());
148 sp<Fence> mergedFence = Fence::merge(fenceName, prevFence, currentFence);
149 if (mergedFence->isValid()) {
150 handle->previousReleaseFence = mergedFence;
151 prevFence = handle->previousReleaseFence;
152 }
153 } else if (currentFence->getStatus() == Fence::Status::Unsignaled) {
154 // If one fence has signaled and the other hasn't, the unsignaled
155 // fence will approximately correspond with the correct timestamp.
156 // There's a small race if both fences signal at about the same time
157 // and their statuses are retrieved with unfortunate timing. However,
158 // by this point, they will have both signaled and only the timestamp
159 // will be slightly off; any dependencies after this point will
160 // already have been met.
161 handle->previousReleaseFence = currentFence;
162 }
163 }
164 }
165 handle->previousReleaseFences = {};
Robert Carr9a803c32021-01-14 16:57:58 -0800166 FrameEventHistoryStats eventStats(handle->frameNumber,
167 handle->gpuCompositionDoneFence->getSnapshot().fence,
168 handle->compositorTiming, handle->refreshStartTime,
169 handle->dequeueReadyTime);
Ady Abraham461296a2022-01-21 11:11:31 -0800170 transactionStats->surfaceStats.emplace_back(surfaceControl, handle->acquireTimeOrFence,
Robert Carr9a803c32021-01-14 16:57:58 -0800171 handle->previousReleaseFence,
Ady Abraham899dcdb2021-06-15 16:56:21 -0700172 handle->transformHint,
173 handle->currentMaxAcquiredBufferCount,
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700174 eventStats, jankData,
175 handle->previousReleaseCallbackId);
Robert Carr9a803c32021-01-14 16:57:58 -0800176 }
177 return NO_ERROR;
178}
179
180void TransactionCallbackInvoker::addPresentFence(const sp<Fence>& presentFence) {
Robert Carr9a803c32021-01-14 16:57:58 -0800181 mPresentFence = presentFence;
182}
183
Vishnu Naircd52e2d2021-10-18 08:42:46 -0700184void TransactionCallbackInvoker::sendCallbacks(bool onCommitOnly) {
Robert Carr9a803c32021-01-14 16:57:58 -0800185 // For each listener
186 auto completedTransactionsItr = mCompletedTransactions.begin();
187 while (completedTransactionsItr != mCompletedTransactions.end()) {
188 auto& [listener, transactionStatsDeque] = *completedTransactionsItr;
189 ListenerStats listenerStats;
190 listenerStats.listener = listener;
191
192 // For each transaction
193 auto transactionStatsItr = transactionStatsDeque.begin();
194 while (transactionStatsItr != transactionStatsDeque.end()) {
195 auto& transactionStats = *transactionStatsItr;
Vishnu Naircd52e2d2021-10-18 08:42:46 -0700196 if (onCommitOnly && !containsOnCommitCallbacks(transactionStats.callbackIds)) {
197 transactionStatsItr++;
198 continue;
199 }
Robert Carr9a803c32021-01-14 16:57:58 -0800200
Robert Carr9a803c32021-01-14 16:57:58 -0800201 // If the transaction has been latched
Vishnu Nairfc46c1e2021-04-21 08:31:32 -0700202 if (transactionStats.latchTime >= 0 &&
203 !containsOnCommitCallbacks(transactionStats.callbackIds)) {
Robert Carr9a803c32021-01-14 16:57:58 -0800204 transactionStats.presentFence = mPresentFence;
205 }
206
207 // Remove the transaction from completed to the callback
208 listenerStats.transactionStats.push_back(std::move(transactionStats));
209 transactionStatsItr = transactionStatsDeque.erase(transactionStatsItr);
210 }
211 // If the listener has completed transactions
212 if (!listenerStats.transactionStats.empty()) {
213 // If the listener is still alive
214 if (listener->isBinderAlive()) {
215 // Send callback. The listener stored in listenerStats
216 // comes from the cross-process setTransactionState call to
217 // SF. This MUST be an ITransactionCompletedListener. We
218 // keep it as an IBinder due to consistency reasons: if we
219 // interface_cast at the IPC boundary when reading a Parcel,
220 // we get pointers that compare unequal in the SF process.
Vishnu Nair34eb9ca2021-11-18 15:23:23 -0800221 BackgroundExecutor::getInstance().execute([stats = std::move(listenerStats)]() {
222 interface_cast<ITransactionCompletedListener>(stats.listener)
223 ->onTransactionCompleted(stats);
224 });
Robert Carr9a803c32021-01-14 16:57:58 -0800225 }
Robert Carr9a803c32021-01-14 16:57:58 -0800226 }
Robert Carr3d1047b2021-09-20 18:22:32 -0700227 completedTransactionsItr++;
Robert Carr9a803c32021-01-14 16:57:58 -0800228 }
229
230 if (mPresentFence) {
231 mPresentFence.clear();
232 }
233}
234
235// -----------------------------------------------------------------------
236
237CallbackHandle::CallbackHandle(const sp<IBinder>& transactionListener,
238 const std::vector<CallbackId>& ids, const sp<IBinder>& sc)
239 : listener(transactionListener), callbackIds(ids), surfaceControl(sc) {}
240
241} // namespace android
242
243// TODO(b/129481165): remove the #pragma below and fix conversion issues
244#pragma clang diagnostic pop // ignored "-Wconversion"