Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2016 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 | #include <gui/FrameTimestamps.h> |
| 18 | |
Brian Anderson | 8cc8b10 | 2016-10-21 12:43:09 -0700 | [diff] [blame] | 19 | #define LOG_TAG "FrameEvents" |
| 20 | |
David Stevens | 7347f0b | 2020-01-15 20:19:22 +0900 | [diff] [blame^] | 21 | #include <LibGuiProperties.sysprop.h> |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 22 | #include <android-base/stringprintf.h> |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 23 | #include <cutils/compiler.h> // For CC_[UN]LIKELY |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 24 | #include <inttypes.h> |
Brian Anderson | 175a720 | 2016-10-10 16:52:56 -0700 | [diff] [blame] | 25 | #include <utils/Log.h> |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 26 | |
| 27 | #include <algorithm> |
| 28 | #include <limits> |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 29 | #include <numeric> |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 30 | |
| 31 | namespace android { |
| 32 | |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 33 | using base::StringAppendF; |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 34 | |
| 35 | // ============================================================================ |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 36 | // FrameEvents |
| 37 | // ============================================================================ |
| 38 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 39 | bool FrameEvents::hasPostedInfo() const { |
Brian Anderson | ed816e6 | 2016-10-26 16:12:21 -0700 | [diff] [blame] | 40 | return FrameEvents::isValidTimestamp(postedTime); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 41 | } |
| 42 | |
| 43 | bool FrameEvents::hasRequestedPresentInfo() const { |
Brian Anderson | ed816e6 | 2016-10-26 16:12:21 -0700 | [diff] [blame] | 44 | return FrameEvents::isValidTimestamp(requestedPresentTime); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 45 | } |
| 46 | |
| 47 | bool FrameEvents::hasLatchInfo() const { |
Brian Anderson | ed816e6 | 2016-10-26 16:12:21 -0700 | [diff] [blame] | 48 | return FrameEvents::isValidTimestamp(latchTime); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 49 | } |
| 50 | |
| 51 | bool FrameEvents::hasFirstRefreshStartInfo() const { |
Brian Anderson | ed816e6 | 2016-10-26 16:12:21 -0700 | [diff] [blame] | 52 | return FrameEvents::isValidTimestamp(firstRefreshStartTime); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 53 | } |
| 54 | |
| 55 | bool FrameEvents::hasLastRefreshStartInfo() const { |
| 56 | // The last refresh start time may continue to update until a new frame |
Brian Anderson | 4e606e3 | 2017-03-16 15:34:57 -0700 | [diff] [blame] | 57 | // is latched. We know we have the final value once the release info is set. |
| 58 | return addReleaseCalled; |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 59 | } |
| 60 | |
Brian Anderson | f638686 | 2016-10-31 16:34:13 -0700 | [diff] [blame] | 61 | bool FrameEvents::hasDequeueReadyInfo() const { |
Brian Anderson | ed816e6 | 2016-10-26 16:12:21 -0700 | [diff] [blame] | 62 | return FrameEvents::isValidTimestamp(dequeueReadyTime); |
Brian Anderson | f638686 | 2016-10-31 16:34:13 -0700 | [diff] [blame] | 63 | } |
| 64 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 65 | bool FrameEvents::hasAcquireInfo() const { |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 66 | return acquireFence->isValid(); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 67 | } |
| 68 | |
| 69 | bool FrameEvents::hasGpuCompositionDoneInfo() const { |
| 70 | // We may not get a gpuCompositionDone in addPostComposite if |
| 71 | // client/gles compositing isn't needed. |
| 72 | return addPostCompositeCalled; |
| 73 | } |
| 74 | |
| 75 | bool FrameEvents::hasDisplayPresentInfo() const { |
| 76 | // We may not get a displayPresent in addPostComposite for HWC1. |
| 77 | return addPostCompositeCalled; |
| 78 | } |
| 79 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 80 | bool FrameEvents::hasReleaseInfo() const { |
| 81 | return addReleaseCalled; |
| 82 | } |
| 83 | |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 84 | void FrameEvents::checkFencesForCompletion() { |
| 85 | acquireFence->getSignalTime(); |
| 86 | gpuCompositionDoneFence->getSignalTime(); |
| 87 | displayPresentFence->getSignalTime(); |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 88 | releaseFence->getSignalTime(); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 89 | } |
| 90 | |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 91 | static void dumpFenceTime(std::string& outString, const char* name, bool pending, |
| 92 | const FenceTime& fenceTime) { |
| 93 | StringAppendF(&outString, "--- %s", name); |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 94 | nsecs_t signalTime = fenceTime.getCachedSignalTime(); |
| 95 | if (Fence::isValidTimestamp(signalTime)) { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 96 | StringAppendF(&outString, "%" PRId64 "\n", signalTime); |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 97 | } else if (pending || signalTime == Fence::SIGNAL_TIME_PENDING) { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 98 | outString.append("Pending\n"); |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 99 | } else if (&fenceTime == FenceTime::NO_FENCE.get()){ |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 100 | outString.append("N/A\n"); |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 101 | } else { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 102 | outString.append("Error\n"); |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 103 | } |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 104 | } |
| 105 | |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 106 | void FrameEvents::dump(std::string& outString) const { |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 107 | if (!valid) { |
| 108 | return; |
| 109 | } |
| 110 | |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 111 | StringAppendF(&outString, "-- Frame %" PRIu64 "\n", frameNumber); |
| 112 | StringAppendF(&outString, "--- Posted \t%" PRId64 "\n", postedTime); |
| 113 | StringAppendF(&outString, "--- Req. Present\t%" PRId64 "\n", requestedPresentTime); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 114 | |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 115 | outString.append("--- Latched \t"); |
Brian Anderson | ed816e6 | 2016-10-26 16:12:21 -0700 | [diff] [blame] | 116 | if (FrameEvents::isValidTimestamp(latchTime)) { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 117 | StringAppendF(&outString, "%" PRId64 "\n", latchTime); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 118 | } else { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 119 | outString.append("Pending\n"); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 120 | } |
| 121 | |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 122 | outString.append("--- Refresh (First)\t"); |
Brian Anderson | ed816e6 | 2016-10-26 16:12:21 -0700 | [diff] [blame] | 123 | if (FrameEvents::isValidTimestamp(firstRefreshStartTime)) { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 124 | StringAppendF(&outString, "%" PRId64 "\n", firstRefreshStartTime); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 125 | } else { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 126 | outString.append("Pending\n"); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 127 | } |
| 128 | |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 129 | outString.append("--- Refresh (Last)\t"); |
Brian Anderson | ed816e6 | 2016-10-26 16:12:21 -0700 | [diff] [blame] | 130 | if (FrameEvents::isValidTimestamp(lastRefreshStartTime)) { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 131 | StringAppendF(&outString, "%" PRId64 "\n", lastRefreshStartTime); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 132 | } else { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 133 | outString.append("Pending\n"); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 134 | } |
| 135 | |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 136 | dumpFenceTime(outString, "Acquire \t", |
| 137 | true, *acquireFence); |
| 138 | dumpFenceTime(outString, "GPU Composite Done\t", |
| 139 | !addPostCompositeCalled, *gpuCompositionDoneFence); |
| 140 | dumpFenceTime(outString, "Display Present \t", |
| 141 | !addPostCompositeCalled, *displayPresentFence); |
Brian Anderson | f638686 | 2016-10-31 16:34:13 -0700 | [diff] [blame] | 142 | |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 143 | outString.append("--- DequeueReady \t"); |
Brian Anderson | ed816e6 | 2016-10-26 16:12:21 -0700 | [diff] [blame] | 144 | if (FrameEvents::isValidTimestamp(dequeueReadyTime)) { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 145 | StringAppendF(&outString, "%" PRId64 "\n", dequeueReadyTime); |
Brian Anderson | f638686 | 2016-10-31 16:34:13 -0700 | [diff] [blame] | 146 | } else { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 147 | outString.append("Pending\n"); |
Brian Anderson | f638686 | 2016-10-31 16:34:13 -0700 | [diff] [blame] | 148 | } |
| 149 | |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 150 | dumpFenceTime(outString, "Release \t", |
| 151 | true, *releaseFence); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 152 | } |
| 153 | |
| 154 | |
| 155 | // ============================================================================ |
| 156 | // FrameEventHistory |
| 157 | // ============================================================================ |
| 158 | |
| 159 | namespace { |
| 160 | |
| 161 | struct FrameNumberEqual { |
Chih-Hung Hsieh | aaf6216 | 2018-12-20 15:45:04 -0800 | [diff] [blame] | 162 | explicit FrameNumberEqual(uint64_t frameNumber) : mFrameNumber(frameNumber) {} |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 163 | bool operator()(const FrameEvents& frame) { |
| 164 | return frame.valid && mFrameNumber == frame.frameNumber; |
| 165 | } |
| 166 | const uint64_t mFrameNumber; |
| 167 | }; |
| 168 | |
| 169 | } // namespace |
| 170 | |
David Stevens | 7347f0b | 2020-01-15 20:19:22 +0900 | [diff] [blame^] | 171 | const size_t FrameEventHistory::MAX_FRAME_HISTORY = |
| 172 | sysprop::LibGuiProperties::frame_event_history_size().value_or(8); |
| 173 | |
| 174 | FrameEventHistory::FrameEventHistory() : mFrames(std::vector<FrameEvents>(MAX_FRAME_HISTORY)) {} |
| 175 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 176 | FrameEventHistory::~FrameEventHistory() = default; |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 177 | |
| 178 | FrameEvents* FrameEventHistory::getFrame(uint64_t frameNumber) { |
| 179 | auto frame = std::find_if( |
| 180 | mFrames.begin(), mFrames.end(), FrameNumberEqual(frameNumber)); |
| 181 | return frame == mFrames.end() ? nullptr : &(*frame); |
| 182 | } |
| 183 | |
| 184 | FrameEvents* FrameEventHistory::getFrame(uint64_t frameNumber, size_t* iHint) { |
| 185 | *iHint = std::min(*iHint, mFrames.size()); |
| 186 | auto hint = mFrames.begin() + *iHint; |
| 187 | auto frame = std::find_if( |
| 188 | hint, mFrames.end(), FrameNumberEqual(frameNumber)); |
| 189 | if (frame == mFrames.end()) { |
| 190 | frame = std::find_if( |
| 191 | mFrames.begin(), hint, FrameNumberEqual(frameNumber)); |
| 192 | if (frame == hint) { |
| 193 | return nullptr; |
| 194 | } |
| 195 | } |
| 196 | *iHint = static_cast<size_t>(std::distance(mFrames.begin(), frame)); |
| 197 | return &(*frame); |
| 198 | } |
| 199 | |
| 200 | void FrameEventHistory::checkFencesForCompletion() { |
| 201 | for (auto& frame : mFrames) { |
| 202 | frame.checkFencesForCompletion(); |
| 203 | } |
| 204 | } |
| 205 | |
| 206 | // Uses !|valid| as the MSB. |
| 207 | static bool FrameNumberLessThan( |
| 208 | const FrameEvents& lhs, const FrameEvents& rhs) { |
| 209 | if (lhs.valid == rhs.valid) { |
| 210 | return lhs.frameNumber < rhs.frameNumber; |
| 211 | } |
| 212 | return lhs.valid; |
| 213 | } |
| 214 | |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 215 | void FrameEventHistory::dump(std::string& outString) const { |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 216 | auto earliestFrame = std::min_element( |
| 217 | mFrames.begin(), mFrames.end(), &FrameNumberLessThan); |
| 218 | if (!earliestFrame->valid) { |
Yiwei Zhang | 5434a78 | 2018-12-05 18:06:32 -0800 | [diff] [blame] | 219 | outString.append("-- N/A\n"); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 220 | return; |
| 221 | } |
| 222 | for (auto frame = earliestFrame; frame != mFrames.end(); ++frame) { |
| 223 | frame->dump(outString); |
| 224 | } |
| 225 | for (auto frame = mFrames.begin(); frame != earliestFrame; ++frame) { |
| 226 | frame->dump(outString); |
| 227 | } |
| 228 | } |
| 229 | |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 230 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 231 | // ============================================================================ |
| 232 | // ProducerFrameEventHistory |
| 233 | // ============================================================================ |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 234 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 235 | ProducerFrameEventHistory::~ProducerFrameEventHistory() = default; |
| 236 | |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 237 | nsecs_t ProducerFrameEventHistory::snapToNextTick( |
| 238 | nsecs_t timestamp, nsecs_t tickPhase, nsecs_t tickInterval) { |
| 239 | nsecs_t tickOffset = (tickPhase - timestamp) % tickInterval; |
| 240 | // Integer modulo rounds towards 0 and not -inf before taking the remainder, |
| 241 | // so adjust the offset if it is negative. |
| 242 | if (tickOffset < 0) { |
| 243 | tickOffset += tickInterval; |
| 244 | } |
| 245 | return timestamp + tickOffset; |
| 246 | } |
| 247 | |
| 248 | nsecs_t ProducerFrameEventHistory::getNextCompositeDeadline( |
| 249 | const nsecs_t now) const{ |
| 250 | return snapToNextTick( |
| 251 | now, mCompositorTiming.deadline, mCompositorTiming.interval); |
| 252 | } |
| 253 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 254 | void ProducerFrameEventHistory::updateAcquireFence( |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 255 | uint64_t frameNumber, std::shared_ptr<FenceTime>&& acquire) { |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 256 | FrameEvents* frame = getFrame(frameNumber, &mAcquireOffset); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 257 | if (frame == nullptr) { |
Brian Anderson | 8cc8b10 | 2016-10-21 12:43:09 -0700 | [diff] [blame] | 258 | ALOGE("updateAcquireFence: Did not find frame."); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 259 | return; |
| 260 | } |
| 261 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 262 | if (acquire->isValid()) { |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 263 | mAcquireTimeline.push(acquire); |
| 264 | frame->acquireFence = std::move(acquire); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 265 | } else { |
| 266 | // If there isn't an acquire fence, assume that buffer was |
| 267 | // ready for the consumer when posted. |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 268 | frame->acquireFence = std::make_shared<FenceTime>(frame->postedTime); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 269 | } |
| 270 | } |
| 271 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 272 | void ProducerFrameEventHistory::applyDelta( |
| 273 | const FrameEventHistoryDelta& delta) { |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 274 | mCompositorTiming = delta.mCompositorTiming; |
| 275 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 276 | for (auto& d : delta.mDeltas) { |
| 277 | // Avoid out-of-bounds access. |
Brian Anderson | 8cc8b10 | 2016-10-21 12:43:09 -0700 | [diff] [blame] | 278 | if (CC_UNLIKELY(d.mIndex >= mFrames.size())) { |
| 279 | ALOGE("applyDelta: Bad index."); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 280 | return; |
| 281 | } |
| 282 | |
| 283 | FrameEvents& frame = mFrames[d.mIndex]; |
| 284 | |
| 285 | frame.addPostCompositeCalled = d.mAddPostCompositeCalled != 0; |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 286 | frame.addReleaseCalled = d.mAddReleaseCalled != 0; |
| 287 | |
| 288 | frame.postedTime = d.mPostedTime; |
| 289 | frame.requestedPresentTime = d.mRequestedPresentTime; |
| 290 | frame.latchTime = d.mLatchTime; |
| 291 | frame.firstRefreshStartTime = d.mFirstRefreshStartTime; |
| 292 | frame.lastRefreshStartTime = d.mLastRefreshStartTime; |
Brian Anderson | f638686 | 2016-10-31 16:34:13 -0700 | [diff] [blame] | 293 | frame.dequeueReadyTime = d.mDequeueReadyTime; |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 294 | |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 295 | if (frame.frameNumber != d.mFrameNumber) { |
| 296 | // We got a new frame. Initialize some of the fields. |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 297 | frame.frameNumber = d.mFrameNumber; |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 298 | frame.acquireFence = FenceTime::NO_FENCE; |
| 299 | frame.gpuCompositionDoneFence = FenceTime::NO_FENCE; |
| 300 | frame.displayPresentFence = FenceTime::NO_FENCE; |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 301 | frame.releaseFence = FenceTime::NO_FENCE; |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 302 | // The consumer only sends valid frames. |
| 303 | frame.valid = true; |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 304 | } |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 305 | |
| 306 | applyFenceDelta(&mGpuCompositionDoneTimeline, |
| 307 | &frame.gpuCompositionDoneFence, d.mGpuCompositionDoneFence); |
| 308 | applyFenceDelta(&mPresentTimeline, |
| 309 | &frame.displayPresentFence, d.mDisplayPresentFence); |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 310 | applyFenceDelta(&mReleaseTimeline, |
| 311 | &frame.releaseFence, d.mReleaseFence); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 312 | } |
| 313 | } |
| 314 | |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 315 | void ProducerFrameEventHistory::updateSignalTimes() { |
| 316 | mAcquireTimeline.updateSignalTimes(); |
| 317 | mGpuCompositionDoneTimeline.updateSignalTimes(); |
| 318 | mPresentTimeline.updateSignalTimes(); |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 319 | mReleaseTimeline.updateSignalTimes(); |
| 320 | } |
| 321 | |
Brian Anderson | 3da8d27 | 2016-07-28 16:20:47 -0700 | [diff] [blame] | 322 | void ProducerFrameEventHistory::applyFenceDelta(FenceTimeline* timeline, |
| 323 | std::shared_ptr<FenceTime>* dst, const FenceTime::Snapshot& src) const { |
Brian Anderson | 5ea5e59 | 2016-12-01 16:54:33 -0800 | [diff] [blame] | 324 | if (CC_UNLIKELY(dst == nullptr || dst->get() == nullptr)) { |
Brian Anderson | 3da8d27 | 2016-07-28 16:20:47 -0700 | [diff] [blame] | 325 | ALOGE("applyFenceDelta: dst is null."); |
| 326 | return; |
| 327 | } |
| 328 | |
| 329 | switch (src.state) { |
| 330 | case FenceTime::Snapshot::State::EMPTY: |
| 331 | return; |
| 332 | case FenceTime::Snapshot::State::FENCE: |
Brian Anderson | 8cc8b10 | 2016-10-21 12:43:09 -0700 | [diff] [blame] | 333 | ALOGE_IF((*dst)->isValid(), "applyFenceDelta: Unexpected fence."); |
Brian Anderson | 3da8d27 | 2016-07-28 16:20:47 -0700 | [diff] [blame] | 334 | *dst = createFenceTime(src.fence); |
| 335 | timeline->push(*dst); |
| 336 | return; |
| 337 | case FenceTime::Snapshot::State::SIGNAL_TIME: |
| 338 | if ((*dst)->isValid()) { |
| 339 | (*dst)->applyTrustedSnapshot(src); |
| 340 | } else { |
| 341 | *dst = std::make_shared<FenceTime>(src.signalTime); |
| 342 | } |
| 343 | return; |
| 344 | } |
| 345 | } |
| 346 | |
| 347 | std::shared_ptr<FenceTime> ProducerFrameEventHistory::createFenceTime( |
| 348 | const sp<Fence>& fence) const { |
| 349 | return std::make_shared<FenceTime>(fence); |
| 350 | } |
| 351 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 352 | |
| 353 | // ============================================================================ |
| 354 | // ConsumerFrameEventHistory |
| 355 | // ============================================================================ |
| 356 | |
David Stevens | 7347f0b | 2020-01-15 20:19:22 +0900 | [diff] [blame^] | 357 | ConsumerFrameEventHistory::ConsumerFrameEventHistory() |
| 358 | : mFramesDirty(std::vector<FrameEventDirtyFields>(MAX_FRAME_HISTORY)) {} |
| 359 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 360 | ConsumerFrameEventHistory::~ConsumerFrameEventHistory() = default; |
| 361 | |
Brian Anderson | 5ea5e59 | 2016-12-01 16:54:33 -0800 | [diff] [blame] | 362 | void ConsumerFrameEventHistory::onDisconnect() { |
| 363 | mCurrentConnectId++; |
| 364 | mProducerWantsEvents = false; |
| 365 | } |
| 366 | |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 367 | void ConsumerFrameEventHistory::initializeCompositorTiming( |
| 368 | const CompositorTiming& compositorTiming) { |
| 369 | mCompositorTiming = compositorTiming; |
| 370 | } |
| 371 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 372 | void ConsumerFrameEventHistory::addQueue(const NewFrameEventsEntry& newEntry) { |
| 373 | // Overwrite all fields of the frame with default values unless set here. |
| 374 | FrameEvents newTimestamps; |
Brian Anderson | 5ea5e59 | 2016-12-01 16:54:33 -0800 | [diff] [blame] | 375 | newTimestamps.connectId = mCurrentConnectId; |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 376 | newTimestamps.frameNumber = newEntry.frameNumber; |
| 377 | newTimestamps.postedTime = newEntry.postedTime; |
| 378 | newTimestamps.requestedPresentTime = newEntry.requestedPresentTime; |
| 379 | newTimestamps.acquireFence = newEntry.acquireFence; |
| 380 | newTimestamps.valid = true; |
| 381 | mFrames[mQueueOffset] = newTimestamps; |
Brian Anderson | 7c3ba8a | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 382 | |
| 383 | // Note: We avoid sending the acquire fence back to the caller since |
| 384 | // they have the original one already, so there is no need to set the |
| 385 | // acquire dirty bit. |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 386 | mFramesDirty[mQueueOffset].setDirty<FrameEvent::POSTED>(); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 387 | |
| 388 | mQueueOffset = (mQueueOffset + 1) % mFrames.size(); |
| 389 | } |
| 390 | |
| 391 | void ConsumerFrameEventHistory::addLatch( |
| 392 | uint64_t frameNumber, nsecs_t latchTime) { |
| 393 | FrameEvents* frame = getFrame(frameNumber, &mCompositionOffset); |
| 394 | if (frame == nullptr) { |
Brian Anderson | 4565daa | 2016-12-13 15:41:28 -0800 | [diff] [blame] | 395 | ALOGE_IF(mProducerWantsEvents, "addLatch: Did not find frame."); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 396 | return; |
| 397 | } |
| 398 | frame->latchTime = latchTime; |
| 399 | mFramesDirty[mCompositionOffset].setDirty<FrameEvent::LATCH>(); |
| 400 | } |
| 401 | |
| 402 | void ConsumerFrameEventHistory::addPreComposition( |
| 403 | uint64_t frameNumber, nsecs_t refreshStartTime) { |
| 404 | FrameEvents* frame = getFrame(frameNumber, &mCompositionOffset); |
| 405 | if (frame == nullptr) { |
Brian Anderson | 4565daa | 2016-12-13 15:41:28 -0800 | [diff] [blame] | 406 | ALOGE_IF(mProducerWantsEvents, |
| 407 | "addPreComposition: Did not find frame."); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 408 | return; |
| 409 | } |
| 410 | frame->lastRefreshStartTime = refreshStartTime; |
| 411 | mFramesDirty[mCompositionOffset].setDirty<FrameEvent::LAST_REFRESH_START>(); |
Brian Anderson | ed816e6 | 2016-10-26 16:12:21 -0700 | [diff] [blame] | 412 | if (!FrameEvents::isValidTimestamp(frame->firstRefreshStartTime)) { |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 413 | frame->firstRefreshStartTime = refreshStartTime; |
| 414 | mFramesDirty[mCompositionOffset].setDirty<FrameEvent::FIRST_REFRESH_START>(); |
| 415 | } |
| 416 | } |
| 417 | |
| 418 | void ConsumerFrameEventHistory::addPostComposition(uint64_t frameNumber, |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 419 | const std::shared_ptr<FenceTime>& gpuCompositionDone, |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 420 | const std::shared_ptr<FenceTime>& displayPresent, |
| 421 | const CompositorTiming& compositorTiming) { |
| 422 | mCompositorTiming = compositorTiming; |
| 423 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 424 | FrameEvents* frame = getFrame(frameNumber, &mCompositionOffset); |
| 425 | if (frame == nullptr) { |
Brian Anderson | 4565daa | 2016-12-13 15:41:28 -0800 | [diff] [blame] | 426 | ALOGE_IF(mProducerWantsEvents, |
| 427 | "addPostComposition: Did not find frame."); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 428 | return; |
| 429 | } |
| 430 | // Only get GPU and present info for the first composite. |
| 431 | if (!frame->addPostCompositeCalled) { |
| 432 | frame->addPostCompositeCalled = true; |
| 433 | frame->gpuCompositionDoneFence = gpuCompositionDone; |
Brian Anderson | b04c6f0 | 2016-10-21 12:57:46 -0700 | [diff] [blame] | 434 | mFramesDirty[mCompositionOffset].setDirty<FrameEvent::GPU_COMPOSITION_DONE>(); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 435 | if (!frame->displayPresentFence->isValid()) { |
| 436 | frame->displayPresentFence = displayPresent; |
| 437 | mFramesDirty[mCompositionOffset].setDirty<FrameEvent::DISPLAY_PRESENT>(); |
| 438 | } |
| 439 | } |
| 440 | } |
| 441 | |
Brian Anderson | f638686 | 2016-10-31 16:34:13 -0700 | [diff] [blame] | 442 | void ConsumerFrameEventHistory::addRelease(uint64_t frameNumber, |
| 443 | nsecs_t dequeueReadyTime, std::shared_ptr<FenceTime>&& release) { |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 444 | FrameEvents* frame = getFrame(frameNumber, &mReleaseOffset); |
Brian Anderson | 5ea5e59 | 2016-12-01 16:54:33 -0800 | [diff] [blame] | 445 | if (frame == nullptr) { |
| 446 | ALOGE_IF(mProducerWantsEvents, "addRelease: Did not find frame."); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 447 | return; |
| 448 | } |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 449 | frame->addReleaseCalled = true; |
Brian Anderson | f638686 | 2016-10-31 16:34:13 -0700 | [diff] [blame] | 450 | frame->dequeueReadyTime = dequeueReadyTime; |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 451 | frame->releaseFence = std::move(release); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 452 | mFramesDirty[mReleaseOffset].setDirty<FrameEvent::RELEASE>(); |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 453 | } |
| 454 | |
David Stevens | 7347f0b | 2020-01-15 20:19:22 +0900 | [diff] [blame^] | 455 | void ConsumerFrameEventHistory::getFrameDelta(FrameEventHistoryDelta* delta, |
| 456 | const std::vector<FrameEvents>::iterator& frame) { |
Brian Anderson | 4565daa | 2016-12-13 15:41:28 -0800 | [diff] [blame] | 457 | mProducerWantsEvents = true; |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 458 | size_t i = static_cast<size_t>(std::distance(mFrames.begin(), frame)); |
| 459 | if (mFramesDirty[i].anyDirty()) { |
Brian Anderson | 5ea5e59 | 2016-12-01 16:54:33 -0800 | [diff] [blame] | 460 | // Make sure only to send back deltas for the current connection |
| 461 | // since the producer won't have the correct state to apply a delta |
| 462 | // from a previous connection. |
| 463 | if (mFrames[i].connectId == mCurrentConnectId) { |
| 464 | delta->mDeltas.emplace_back(i, *frame, mFramesDirty[i]); |
| 465 | } |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 466 | mFramesDirty[i].reset(); |
| 467 | } |
| 468 | } |
| 469 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 470 | void ConsumerFrameEventHistory::getAndResetDelta( |
| 471 | FrameEventHistoryDelta* delta) { |
Brian Anderson | 5ea5e59 | 2016-12-01 16:54:33 -0800 | [diff] [blame] | 472 | mProducerWantsEvents = true; |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 473 | delta->mCompositorTiming = mCompositorTiming; |
| 474 | |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 475 | // Write these in order of frame number so that it is easy to |
| 476 | // add them to a FenceTimeline in the proper order producer side. |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 477 | delta->mDeltas.reserve(mFramesDirty.size()); |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 478 | auto earliestFrame = std::min_element( |
| 479 | mFrames.begin(), mFrames.end(), &FrameNumberLessThan); |
| 480 | for (auto frame = earliestFrame; frame != mFrames.end(); ++frame) { |
| 481 | getFrameDelta(delta, frame); |
| 482 | } |
| 483 | for (auto frame = mFrames.begin(); frame != earliestFrame; ++frame) { |
| 484 | getFrameDelta(delta, frame); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 485 | } |
| 486 | } |
| 487 | |
| 488 | |
| 489 | // ============================================================================ |
| 490 | // FrameEventsDelta |
| 491 | // ============================================================================ |
| 492 | |
| 493 | FrameEventsDelta::FrameEventsDelta( |
| 494 | size_t index, |
| 495 | const FrameEvents& frameTimestamps, |
| 496 | const FrameEventDirtyFields& dirtyFields) |
| 497 | : mIndex(index), |
| 498 | mFrameNumber(frameTimestamps.frameNumber), |
| 499 | mAddPostCompositeCalled(frameTimestamps.addPostCompositeCalled), |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 500 | mAddReleaseCalled(frameTimestamps.addReleaseCalled), |
| 501 | mPostedTime(frameTimestamps.postedTime), |
| 502 | mRequestedPresentTime(frameTimestamps.requestedPresentTime), |
| 503 | mLatchTime(frameTimestamps.latchTime), |
| 504 | mFirstRefreshStartTime(frameTimestamps.firstRefreshStartTime), |
Brian Anderson | f638686 | 2016-10-31 16:34:13 -0700 | [diff] [blame] | 505 | mLastRefreshStartTime(frameTimestamps.lastRefreshStartTime), |
| 506 | mDequeueReadyTime(frameTimestamps.dequeueReadyTime) { |
Brian Anderson | b04c6f0 | 2016-10-21 12:57:46 -0700 | [diff] [blame] | 507 | if (dirtyFields.isDirty<FrameEvent::GPU_COMPOSITION_DONE>()) { |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 508 | mGpuCompositionDoneFence = |
| 509 | frameTimestamps.gpuCompositionDoneFence->getSnapshot(); |
| 510 | } |
| 511 | if (dirtyFields.isDirty<FrameEvent::DISPLAY_PRESENT>()) { |
| 512 | mDisplayPresentFence = |
| 513 | frameTimestamps.displayPresentFence->getSnapshot(); |
| 514 | } |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 515 | if (dirtyFields.isDirty<FrameEvent::RELEASE>()) { |
| 516 | mReleaseFence = frameTimestamps.releaseFence->getSnapshot(); |
| 517 | } |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 518 | } |
| 519 | |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 520 | constexpr size_t FrameEventsDelta::minFlattenedSize() { |
| 521 | return sizeof(FrameEventsDelta::mFrameNumber) + |
Brian Anderson | 4e606e3 | 2017-03-16 15:34:57 -0700 | [diff] [blame] | 522 | sizeof(uint16_t) + // mIndex |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 523 | sizeof(uint8_t) + // mAddPostCompositeCalled |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 524 | sizeof(uint8_t) + // mAddReleaseCalled |
| 525 | sizeof(FrameEventsDelta::mPostedTime) + |
| 526 | sizeof(FrameEventsDelta::mRequestedPresentTime) + |
| 527 | sizeof(FrameEventsDelta::mLatchTime) + |
| 528 | sizeof(FrameEventsDelta::mFirstRefreshStartTime) + |
Brian Anderson | f638686 | 2016-10-31 16:34:13 -0700 | [diff] [blame] | 529 | sizeof(FrameEventsDelta::mLastRefreshStartTime) + |
| 530 | sizeof(FrameEventsDelta::mDequeueReadyTime); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 531 | } |
| 532 | |
| 533 | // Flattenable implementation |
| 534 | size_t FrameEventsDelta::getFlattenedSize() const { |
| 535 | auto fences = allFences(this); |
| 536 | return minFlattenedSize() + |
| 537 | std::accumulate(fences.begin(), fences.end(), size_t(0), |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 538 | [](size_t a, const FenceTime::Snapshot* fence) { |
| 539 | return a + fence->getFlattenedSize(); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 540 | }); |
| 541 | } |
| 542 | |
| 543 | size_t FrameEventsDelta::getFdCount() const { |
| 544 | auto fences = allFences(this); |
| 545 | return std::accumulate(fences.begin(), fences.end(), size_t(0), |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 546 | [](size_t a, const FenceTime::Snapshot* fence) { |
| 547 | return a + fence->getFdCount(); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 548 | }); |
| 549 | } |
| 550 | |
| 551 | status_t FrameEventsDelta::flatten(void*& buffer, size_t& size, int*& fds, |
| 552 | size_t& count) const { |
| 553 | if (size < getFlattenedSize() || count < getFdCount()) { |
| 554 | return NO_MEMORY; |
| 555 | } |
| 556 | |
| 557 | if (mIndex >= FrameEventHistory::MAX_FRAME_HISTORY || |
Brian Anderson | 4e606e3 | 2017-03-16 15:34:57 -0700 | [diff] [blame] | 558 | mIndex > std::numeric_limits<uint16_t>::max()) { |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 559 | return BAD_VALUE; |
| 560 | } |
| 561 | |
| 562 | FlattenableUtils::write(buffer, size, mFrameNumber); |
| 563 | |
Brian Anderson | 4e606e3 | 2017-03-16 15:34:57 -0700 | [diff] [blame] | 564 | // These are static_cast to uint16_t/uint8_t for alignment. |
| 565 | FlattenableUtils::write(buffer, size, static_cast<uint16_t>(mIndex)); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 566 | FlattenableUtils::write( |
| 567 | buffer, size, static_cast<uint8_t>(mAddPostCompositeCalled)); |
| 568 | FlattenableUtils::write( |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 569 | buffer, size, static_cast<uint8_t>(mAddReleaseCalled)); |
| 570 | |
| 571 | FlattenableUtils::write(buffer, size, mPostedTime); |
| 572 | FlattenableUtils::write(buffer, size, mRequestedPresentTime); |
| 573 | FlattenableUtils::write(buffer, size, mLatchTime); |
| 574 | FlattenableUtils::write(buffer, size, mFirstRefreshStartTime); |
| 575 | FlattenableUtils::write(buffer, size, mLastRefreshStartTime); |
Brian Anderson | f638686 | 2016-10-31 16:34:13 -0700 | [diff] [blame] | 576 | FlattenableUtils::write(buffer, size, mDequeueReadyTime); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 577 | |
| 578 | // Fences |
| 579 | for (auto fence : allFences(this)) { |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 580 | status_t status = fence->flatten(buffer, size, fds, count); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 581 | if (status != NO_ERROR) { |
| 582 | return status; |
| 583 | } |
| 584 | } |
| 585 | return NO_ERROR; |
| 586 | } |
| 587 | |
| 588 | status_t FrameEventsDelta::unflatten(void const*& buffer, size_t& size, |
| 589 | int const*& fds, size_t& count) { |
| 590 | if (size < minFlattenedSize()) { |
| 591 | return NO_MEMORY; |
| 592 | } |
| 593 | |
| 594 | FlattenableUtils::read(buffer, size, mFrameNumber); |
| 595 | |
Brian Anderson | 4e606e3 | 2017-03-16 15:34:57 -0700 | [diff] [blame] | 596 | // These were written as uint16_t/uint8_t for alignment. |
| 597 | uint16_t temp16 = 0; |
| 598 | FlattenableUtils::read(buffer, size, temp16); |
| 599 | mIndex = temp16; |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 600 | if (mIndex >= FrameEventHistory::MAX_FRAME_HISTORY) { |
| 601 | return BAD_VALUE; |
| 602 | } |
Brian Anderson | 4e606e3 | 2017-03-16 15:34:57 -0700 | [diff] [blame] | 603 | uint8_t temp8 = 0; |
| 604 | FlattenableUtils::read(buffer, size, temp8); |
| 605 | mAddPostCompositeCalled = static_cast<bool>(temp8); |
| 606 | FlattenableUtils::read(buffer, size, temp8); |
| 607 | mAddReleaseCalled = static_cast<bool>(temp8); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 608 | |
| 609 | FlattenableUtils::read(buffer, size, mPostedTime); |
| 610 | FlattenableUtils::read(buffer, size, mRequestedPresentTime); |
| 611 | FlattenableUtils::read(buffer, size, mLatchTime); |
| 612 | FlattenableUtils::read(buffer, size, mFirstRefreshStartTime); |
| 613 | FlattenableUtils::read(buffer, size, mLastRefreshStartTime); |
Brian Anderson | f638686 | 2016-10-31 16:34:13 -0700 | [diff] [blame] | 614 | FlattenableUtils::read(buffer, size, mDequeueReadyTime); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 615 | |
| 616 | // Fences |
| 617 | for (auto fence : allFences(this)) { |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 618 | status_t status = fence->unflatten(buffer, size, fds, count); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 619 | if (status != NO_ERROR) { |
| 620 | return status; |
| 621 | } |
| 622 | } |
| 623 | return NO_ERROR; |
| 624 | } |
| 625 | |
| 626 | |
| 627 | // ============================================================================ |
| 628 | // FrameEventHistoryDelta |
| 629 | // ============================================================================ |
| 630 | |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 631 | FrameEventHistoryDelta& FrameEventHistoryDelta::operator=( |
Chih-Hung Hsieh | 5bc849f | 2018-09-25 14:21:50 -0700 | [diff] [blame] | 632 | FrameEventHistoryDelta&& src) noexcept { |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 633 | mCompositorTiming = src.mCompositorTiming; |
| 634 | |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 635 | if (CC_UNLIKELY(!mDeltas.empty())) { |
Brian Anderson | 8cc8b10 | 2016-10-21 12:43:09 -0700 | [diff] [blame] | 636 | ALOGE("FrameEventHistoryDelta assign clobbering history."); |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 637 | } |
| 638 | mDeltas = std::move(src.mDeltas); |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 639 | return *this; |
| 640 | } |
| 641 | |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 642 | constexpr size_t FrameEventHistoryDelta::minFlattenedSize() { |
| 643 | return sizeof(uint32_t) + // mDeltas.size() |
| 644 | sizeof(mCompositorTiming); |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 645 | } |
| 646 | |
| 647 | size_t FrameEventHistoryDelta::getFlattenedSize() const { |
| 648 | return minFlattenedSize() + |
| 649 | std::accumulate(mDeltas.begin(), mDeltas.end(), size_t(0), |
| 650 | [](size_t a, const FrameEventsDelta& delta) { |
| 651 | return a + delta.getFlattenedSize(); |
| 652 | }); |
| 653 | } |
| 654 | |
| 655 | size_t FrameEventHistoryDelta::getFdCount() const { |
| 656 | return std::accumulate(mDeltas.begin(), mDeltas.end(), size_t(0), |
| 657 | [](size_t a, const FrameEventsDelta& delta) { |
| 658 | return a + delta.getFdCount(); |
| 659 | }); |
| 660 | } |
| 661 | |
| 662 | status_t FrameEventHistoryDelta::flatten( |
| 663 | void*& buffer, size_t& size, int*& fds, size_t& count) const { |
| 664 | if (mDeltas.size() > FrameEventHistory::MAX_FRAME_HISTORY) { |
| 665 | return BAD_VALUE; |
| 666 | } |
| 667 | if (size < getFlattenedSize()) { |
| 668 | return NO_MEMORY; |
| 669 | } |
| 670 | |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 671 | FlattenableUtils::write(buffer, size, mCompositorTiming); |
| 672 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 673 | FlattenableUtils::write( |
| 674 | buffer, size, static_cast<uint32_t>(mDeltas.size())); |
| 675 | for (auto& d : mDeltas) { |
| 676 | status_t status = d.flatten(buffer, size, fds, count); |
| 677 | if (status != NO_ERROR) { |
| 678 | return status; |
| 679 | } |
| 680 | } |
| 681 | return NO_ERROR; |
| 682 | } |
| 683 | |
| 684 | status_t FrameEventHistoryDelta::unflatten( |
| 685 | void const*& buffer, size_t& size, int const*& fds, size_t& count) { |
| 686 | if (size < minFlattenedSize()) { |
| 687 | return NO_MEMORY; |
| 688 | } |
| 689 | |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 690 | FlattenableUtils::read(buffer, size, mCompositorTiming); |
| 691 | |
Brian Anderson | 3890c39 | 2016-07-25 12:48:08 -0700 | [diff] [blame] | 692 | uint32_t deltaCount = 0; |
| 693 | FlattenableUtils::read(buffer, size, deltaCount); |
| 694 | if (deltaCount > FrameEventHistory::MAX_FRAME_HISTORY) { |
| 695 | return BAD_VALUE; |
| 696 | } |
| 697 | mDeltas.resize(deltaCount); |
| 698 | for (auto& d : mDeltas) { |
| 699 | status_t status = d.unflatten(buffer, size, fds, count); |
| 700 | if (status != NO_ERROR) { |
| 701 | return status; |
| 702 | } |
| 703 | } |
| 704 | return NO_ERROR; |
| 705 | } |
| 706 | |
| 707 | |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 708 | } // namespace android |