blob: e5870269d045f56056c495ca7df7129cc19008b2 [file] [log] [blame]
Glenn Kasten22340022014-04-07 12:04:41 -07001/*
2 * Copyright (C) 2014 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#define LOG_TAG "FastThread"
18//#define LOG_NDEBUG 0
19
20#define ATRACE_TAG ATRACE_TAG_AUDIO
21
22#include "Configuration.h"
Elliott Hughese348c5b2014-05-21 18:47:50 -070023#include <linux/futex.h>
24#include <sys/syscall.h>
Mathias Agopian05d19b02017-02-28 16:28:19 -080025#include <cutils/atomic.h>
Glenn Kasten22340022014-04-07 12:04:41 -070026#include <utils/Log.h>
Glenn Kasten22340022014-04-07 12:04:41 -070027#include <utils/Trace.h>
28#include "FastThread.h"
Glenn Kasten045ee7e2015-02-17 16:22:04 -080029#include "FastThreadDumpState.h"
Glenn Kasten3ab8d662017-04-03 14:35:09 -070030#include "TypedLogger.h"
Glenn Kasten22340022014-04-07 12:04:41 -070031
32#define FAST_DEFAULT_NS 999999999L // ~1 sec: default time to sleep
33#define FAST_HOT_IDLE_NS 1000000L // 1 ms: time to sleep while hot idling
Glenn Kastend2123e62015-01-29 10:02:44 -080034#define MIN_WARMUP_CYCLES 2 // minimum number of consecutive in-range loop cycles
35 // to wait for warmup
Glenn Kasten22340022014-04-07 12:04:41 -070036#define MAX_WARMUP_CYCLES 10 // maximum number of loop cycles to wait for warmup
37
38namespace android {
39
Glenn Kastenf9715e42016-07-13 14:02:03 -070040FastThread::FastThread(const char *cycleMs, const char *loadUs) : Thread(false /*canCallJava*/),
Glenn Kastene4a7ce22015-03-03 11:23:17 -080041 // re-initialized to &sInitial by subclass constructor
42 mPrevious(NULL), mCurrent(NULL),
43 /* mOldTs({0, 0}), */
44 mOldTsValid(false),
45 mSleepNs(-1),
46 mPeriodNs(0),
47 mUnderrunNs(0),
48 mOverrunNs(0),
49 mForceNs(0),
50 mWarmupNsMin(0),
51 mWarmupNsMax(LONG_MAX),
52 // re-initialized to &mDummySubclassDumpState by subclass constructor
Glenn Kasten22340022014-04-07 12:04:41 -070053 mDummyDumpState(NULL),
Glenn Kastene4a7ce22015-03-03 11:23:17 -080054 mDumpState(NULL),
55 mIgnoreNextOverrun(true),
Glenn Kasten214b4062015-03-02 14:15:47 -080056#ifdef FAST_THREAD_STATISTICS
Glenn Kastene4a7ce22015-03-03 11:23:17 -080057 // mOldLoad
58 mOldLoadValid(false),
59 mBounds(0),
60 mFull(false),
61 // mTcu
Glenn Kasten22340022014-04-07 12:04:41 -070062#endif
Glenn Kastene4a7ce22015-03-03 11:23:17 -080063 mColdGen(0),
64 mIsWarm(false),
65 /* mMeasuredWarmupTs({0, 0}), */
66 mWarmupCycles(0),
67 mWarmupConsecutiveInRangeCycles(0),
Glenn Kasten3ab8d662017-04-03 14:35:09 -070068 // mDummyNBLogWriter
69 mNBLogWriter(&mDummyNBLogWriter),
Glenn Kastene4a7ce22015-03-03 11:23:17 -080070 mTimestampStatus(INVALID_OPERATION),
Glenn Kasten22340022014-04-07 12:04:41 -070071
Glenn Kastene4a7ce22015-03-03 11:23:17 -080072 mCommand(FastThreadState::INITIAL),
Glenn Kasten22340022014-04-07 12:04:41 -070073#if 0
74 frameCount(0),
75#endif
Glenn Kastene4a7ce22015-03-03 11:23:17 -080076 mAttemptedWrite(false)
Glenn Kastenf9715e42016-07-13 14:02:03 -070077 // mCycleMs(cycleMs)
78 // mLoadUs(loadUs)
Glenn Kasten22340022014-04-07 12:04:41 -070079{
Glenn Kastene4a7ce22015-03-03 11:23:17 -080080 mOldTs.tv_sec = 0;
81 mOldTs.tv_nsec = 0;
82 mMeasuredWarmupTs.tv_sec = 0;
83 mMeasuredWarmupTs.tv_nsec = 0;
Glenn Kastenf9715e42016-07-13 14:02:03 -070084 strlcpy(mCycleMs, cycleMs, sizeof(mCycleMs));
85 strlcpy(mLoadUs, loadUs, sizeof(mLoadUs));
Glenn Kasten22340022014-04-07 12:04:41 -070086}
87
88FastThread::~FastThread()
89{
90}
91
92bool FastThread::threadLoop()
93{
Glenn Kasten388d5712017-04-07 14:38:41 -070094 // LOGT now works even if tlNBLogWriter is nullptr, but we're considering changing that,
Glenn Kasteneef598c2017-04-03 14:41:13 -070095 // so this initialization permits a future change to remove the check for nullptr.
Glenn Kasten388d5712017-04-07 14:38:41 -070096 tlNBLogWriter = &mDummyNBLogWriter;
Glenn Kasten22340022014-04-07 12:04:41 -070097 for (;;) {
98
99 // either nanosleep, sched_yield, or busy wait
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800100 if (mSleepNs >= 0) {
101 if (mSleepNs > 0) {
102 ALOG_ASSERT(mSleepNs < 1000000000);
103 const struct timespec req = {0, mSleepNs};
Glenn Kasten22340022014-04-07 12:04:41 -0700104 nanosleep(&req, NULL);
105 } else {
106 sched_yield();
107 }
108 }
109 // default to long sleep for next cycle
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800110 mSleepNs = FAST_DEFAULT_NS;
Glenn Kasten22340022014-04-07 12:04:41 -0700111
112 // poll for state change
113 const FastThreadState *next = poll();
114 if (next == NULL) {
115 // continue to use the default initial state until a real state is available
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800116 // FIXME &sInitial not available, should save address earlier
117 //ALOG_ASSERT(mCurrent == &sInitial && previous == &sInitial);
118 next = mCurrent;
Glenn Kasten22340022014-04-07 12:04:41 -0700119 }
120
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800121 mCommand = next->mCommand;
122 if (next != mCurrent) {
Glenn Kasten22340022014-04-07 12:04:41 -0700123
124 // As soon as possible of learning of a new dump area, start using it
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800125 mDumpState = next->mDumpState != NULL ? next->mDumpState : mDummyDumpState;
Glenn Kasten3ab8d662017-04-03 14:35:09 -0700126 mNBLogWriter = next->mNBLogWriter != NULL ? next->mNBLogWriter : &mDummyNBLogWriter;
127 setNBLogWriter(mNBLogWriter); // FastMixer informs its AudioMixer, FastCapture ignores
Glenn Kasten388d5712017-04-07 14:38:41 -0700128 tlNBLogWriter = mNBLogWriter;
Glenn Kasten22340022014-04-07 12:04:41 -0700129
130 // We want to always have a valid reference to the previous (non-idle) state.
131 // However, the state queue only guarantees access to current and previous states.
132 // So when there is a transition from a non-idle state into an idle state, we make a
133 // copy of the last known non-idle state so it is still available on return from idle.
134 // The possible transitions are:
135 // non-idle -> non-idle update previous from current in-place
136 // non-idle -> idle update previous from copy of current
137 // idle -> idle don't update previous
138 // idle -> non-idle don't update previous
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800139 if (!(mCurrent->mCommand & FastThreadState::IDLE)) {
140 if (mCommand & FastThreadState::IDLE) {
Glenn Kasten22340022014-04-07 12:04:41 -0700141 onIdle();
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800142 mOldTsValid = false;
Glenn Kasten214b4062015-03-02 14:15:47 -0800143#ifdef FAST_THREAD_STATISTICS
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800144 mOldLoadValid = false;
Glenn Kasten22340022014-04-07 12:04:41 -0700145#endif
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800146 mIgnoreNextOverrun = true;
Glenn Kasten22340022014-04-07 12:04:41 -0700147 }
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800148 mPrevious = mCurrent;
Glenn Kasten22340022014-04-07 12:04:41 -0700149 }
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800150 mCurrent = next;
Glenn Kasten22340022014-04-07 12:04:41 -0700151 }
152#if !LOG_NDEBUG
153 next = NULL; // not referenced again
154#endif
155
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800156 mDumpState->mCommand = mCommand;
Glenn Kasten22340022014-04-07 12:04:41 -0700157
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800158 // FIXME what does this comment mean?
Glenn Kasten22340022014-04-07 12:04:41 -0700159 // << current, previous, command, dumpState >>
160
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800161 switch (mCommand) {
Glenn Kasten22340022014-04-07 12:04:41 -0700162 case FastThreadState::INITIAL:
163 case FastThreadState::HOT_IDLE:
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800164 mSleepNs = FAST_HOT_IDLE_NS;
Glenn Kasten22340022014-04-07 12:04:41 -0700165 continue;
166 case FastThreadState::COLD_IDLE:
167 // only perform a cold idle command once
168 // FIXME consider checking previous state and only perform if previous != COLD_IDLE
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800169 if (mCurrent->mColdGen != mColdGen) {
170 int32_t *coldFutexAddr = mCurrent->mColdFutexAddr;
Glenn Kasten22340022014-04-07 12:04:41 -0700171 ALOG_ASSERT(coldFutexAddr != NULL);
172 int32_t old = android_atomic_dec(coldFutexAddr);
173 if (old <= 0) {
Elliott Hughese348c5b2014-05-21 18:47:50 -0700174 syscall(__NR_futex, coldFutexAddr, FUTEX_WAIT_PRIVATE, old - 1, NULL);
Glenn Kasten22340022014-04-07 12:04:41 -0700175 }
Glenn Kasten8255ba72016-08-23 13:54:23 -0700176 int policy = sched_getscheduler(0) & ~SCHED_RESET_ON_FORK;
Glenn Kasten22340022014-04-07 12:04:41 -0700177 if (!(policy == SCHED_FIFO || policy == SCHED_RR)) {
Glenn Kasten1bfe09a2017-02-21 13:05:56 -0800178 ALOGE("did not receive expected priority boost on time");
Glenn Kasten22340022014-04-07 12:04:41 -0700179 }
180 // This may be overly conservative; there could be times that the normal mixer
181 // requests such a brief cold idle that it doesn't require resetting this flag.
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800182 mIsWarm = false;
183 mMeasuredWarmupTs.tv_sec = 0;
184 mMeasuredWarmupTs.tv_nsec = 0;
185 mWarmupCycles = 0;
186 mWarmupConsecutiveInRangeCycles = 0;
187 mSleepNs = -1;
188 mColdGen = mCurrent->mColdGen;
Glenn Kasten214b4062015-03-02 14:15:47 -0800189#ifdef FAST_THREAD_STATISTICS
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800190 mBounds = 0;
191 mFull = false;
Glenn Kasten22340022014-04-07 12:04:41 -0700192#endif
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800193 mOldTsValid = !clock_gettime(CLOCK_MONOTONIC, &mOldTs);
194 mTimestampStatus = INVALID_OPERATION;
Glenn Kasten22340022014-04-07 12:04:41 -0700195 } else {
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800196 mSleepNs = FAST_HOT_IDLE_NS;
Glenn Kasten22340022014-04-07 12:04:41 -0700197 }
198 continue;
199 case FastThreadState::EXIT:
200 onExit();
201 return false;
202 default:
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800203 LOG_ALWAYS_FATAL_IF(!isSubClassCommand(mCommand));
Glenn Kasten22340022014-04-07 12:04:41 -0700204 break;
205 }
206
207 // there is a non-idle state available to us; did the state change?
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800208 if (mCurrent != mPrevious) {
Glenn Kasten22340022014-04-07 12:04:41 -0700209 onStateChange();
210#if 1 // FIXME shouldn't need this
211 // only process state change once
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800212 mPrevious = mCurrent;
Glenn Kasten22340022014-04-07 12:04:41 -0700213#endif
214 }
215
216 // do work using current state here
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800217 mAttemptedWrite = false;
Glenn Kasten22340022014-04-07 12:04:41 -0700218 onWork();
219
220 // To be exactly periodic, compute the next sleep time based on current time.
221 // This code doesn't have long-term stability when the sink is non-blocking.
222 // FIXME To avoid drift, use the local audio clock or watch the sink's fill status.
223 struct timespec newTs;
224 int rc = clock_gettime(CLOCK_MONOTONIC, &newTs);
225 if (rc == 0) {
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800226 if (mOldTsValid) {
227 time_t sec = newTs.tv_sec - mOldTs.tv_sec;
228 long nsec = newTs.tv_nsec - mOldTs.tv_nsec;
Glenn Kasten22340022014-04-07 12:04:41 -0700229 ALOGE_IF(sec < 0 || (sec == 0 && nsec < 0),
230 "clock_gettime(CLOCK_MONOTONIC) failed: was %ld.%09ld but now %ld.%09ld",
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800231 mOldTs.tv_sec, mOldTs.tv_nsec, newTs.tv_sec, newTs.tv_nsec);
Glenn Kasten22340022014-04-07 12:04:41 -0700232 if (nsec < 0) {
233 --sec;
234 nsec += 1000000000;
235 }
236 // To avoid an initial underrun on fast tracks after exiting standby,
237 // do not start pulling data from tracks and mixing until warmup is complete.
238 // Warmup is considered complete after the earlier of:
Glenn Kastend2123e62015-01-29 10:02:44 -0800239 // MIN_WARMUP_CYCLES consecutive in-range write() attempts,
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800240 // where "in-range" means mWarmupNsMin <= cycle time <= mWarmupNsMax
Glenn Kasten22340022014-04-07 12:04:41 -0700241 // MAX_WARMUP_CYCLES write() attempts.
242 // This is overly conservative, but to get better accuracy requires a new HAL API.
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800243 if (!mIsWarm && mAttemptedWrite) {
244 mMeasuredWarmupTs.tv_sec += sec;
245 mMeasuredWarmupTs.tv_nsec += nsec;
246 if (mMeasuredWarmupTs.tv_nsec >= 1000000000) {
247 mMeasuredWarmupTs.tv_sec++;
248 mMeasuredWarmupTs.tv_nsec -= 1000000000;
Glenn Kasten22340022014-04-07 12:04:41 -0700249 }
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800250 ++mWarmupCycles;
251 if (mWarmupNsMin <= nsec && nsec <= mWarmupNsMax) {
252 ALOGV("warmup cycle %d in range: %.03f ms", mWarmupCycles, nsec * 1e-9);
253 ++mWarmupConsecutiveInRangeCycles;
Glenn Kastend2123e62015-01-29 10:02:44 -0800254 } else {
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800255 ALOGV("warmup cycle %d out of range: %.03f ms", mWarmupCycles, nsec * 1e-9);
256 mWarmupConsecutiveInRangeCycles = 0;
Glenn Kastend2123e62015-01-29 10:02:44 -0800257 }
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800258 if ((mWarmupConsecutiveInRangeCycles >= MIN_WARMUP_CYCLES) ||
259 (mWarmupCycles >= MAX_WARMUP_CYCLES)) {
260 mIsWarm = true;
261 mDumpState->mMeasuredWarmupTs = mMeasuredWarmupTs;
262 mDumpState->mWarmupCycles = mWarmupCycles;
Glenn Kasten22340022014-04-07 12:04:41 -0700263 }
264 }
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800265 mSleepNs = -1;
266 if (mIsWarm) {
267 if (sec > 0 || nsec > mUnderrunNs) {
Glenn Kasten22340022014-04-07 12:04:41 -0700268 ATRACE_NAME("underrun");
269 // FIXME only log occasionally
270 ALOGV("underrun: time since last cycle %d.%03ld sec",
271 (int) sec, nsec / 1000000L);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800272 mDumpState->mUnderruns++;
273 mIgnoreNextOverrun = true;
274 } else if (nsec < mOverrunNs) {
275 if (mIgnoreNextOverrun) {
276 mIgnoreNextOverrun = false;
Glenn Kasten22340022014-04-07 12:04:41 -0700277 } else {
278 // FIXME only log occasionally
279 ALOGV("overrun: time since last cycle %d.%03ld sec",
280 (int) sec, nsec / 1000000L);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800281 mDumpState->mOverruns++;
Glenn Kasten22340022014-04-07 12:04:41 -0700282 }
283 // This forces a minimum cycle time. It:
284 // - compensates for an audio HAL with jitter due to sample rate conversion
285 // - works with a variable buffer depth audio HAL that never pulls at a
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800286 // rate < than mOverrunNs per buffer.
Glenn Kasten22340022014-04-07 12:04:41 -0700287 // - recovers from overrun immediately after underrun
288 // It doesn't work with a non-blocking audio HAL.
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800289 mSleepNs = mForceNs - nsec;
Glenn Kasten22340022014-04-07 12:04:41 -0700290 } else {
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800291 mIgnoreNextOverrun = false;
Glenn Kasten22340022014-04-07 12:04:41 -0700292 }
293 }
Glenn Kasten214b4062015-03-02 14:15:47 -0800294#ifdef FAST_THREAD_STATISTICS
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800295 if (mIsWarm) {
Glenn Kasten22340022014-04-07 12:04:41 -0700296 // advance the FIFO queue bounds
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800297 size_t i = mBounds & (mDumpState->mSamplingN - 1);
298 mBounds = (mBounds & 0xFFFF0000) | ((mBounds + 1) & 0xFFFF);
299 if (mFull) {
Ivan Lozano77657142018-01-02 21:01:16 +0000300 //mBounds += 0x10000;
301 __builtin_add_overflow(mBounds, 0x10000, &mBounds);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800302 } else if (!(mBounds & (mDumpState->mSamplingN - 1))) {
303 mFull = true;
Glenn Kasten22340022014-04-07 12:04:41 -0700304 }
305 // compute the delta value of clock_gettime(CLOCK_MONOTONIC)
306 uint32_t monotonicNs = nsec;
307 if (sec > 0 && sec < 4) {
308 monotonicNs += sec * 1000000000;
309 }
310 // compute raw CPU load = delta value of clock_gettime(CLOCK_THREAD_CPUTIME_ID)
311 uint32_t loadNs = 0;
312 struct timespec newLoad;
313 rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &newLoad);
314 if (rc == 0) {
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800315 if (mOldLoadValid) {
316 sec = newLoad.tv_sec - mOldLoad.tv_sec;
317 nsec = newLoad.tv_nsec - mOldLoad.tv_nsec;
Glenn Kasten22340022014-04-07 12:04:41 -0700318 if (nsec < 0) {
319 --sec;
320 nsec += 1000000000;
321 }
322 loadNs = nsec;
323 if (sec > 0 && sec < 4) {
324 loadNs += sec * 1000000000;
325 }
326 } else {
327 // first time through the loop
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800328 mOldLoadValid = true;
Glenn Kasten22340022014-04-07 12:04:41 -0700329 }
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800330 mOldLoad = newLoad;
Glenn Kasten22340022014-04-07 12:04:41 -0700331 }
332#ifdef CPU_FREQUENCY_STATISTICS
333 // get the absolute value of CPU clock frequency in kHz
334 int cpuNum = sched_getcpu();
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800335 uint32_t kHz = mTcu.getCpukHz(cpuNum);
Glenn Kasten22340022014-04-07 12:04:41 -0700336 kHz = (kHz << 4) | (cpuNum & 0xF);
337#endif
338 // save values in FIFO queues for dumpsys
339 // these stores #1, #2, #3 are not atomic with respect to each other,
340 // or with respect to store #4 below
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800341 mDumpState->mMonotonicNs[i] = monotonicNs;
Eric Tan5786e012018-08-15 09:03:47 -0700342 LOG_MONOTONIC_CYCLE_TIME(monotonicNs);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800343 mDumpState->mLoadNs[i] = loadNs;
Glenn Kasten22340022014-04-07 12:04:41 -0700344#ifdef CPU_FREQUENCY_STATISTICS
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800345 mDumpState->mCpukHz[i] = kHz;
Glenn Kasten22340022014-04-07 12:04:41 -0700346#endif
347 // this store #4 is not atomic with respect to stores #1, #2, #3 above, but
348 // the newest open & oldest closed halves are atomic with respect to each other
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800349 mDumpState->mBounds = mBounds;
Glenn Kastenf9715e42016-07-13 14:02:03 -0700350 ATRACE_INT(mCycleMs, monotonicNs / 1000000);
351 ATRACE_INT(mLoadUs, loadNs / 1000);
Glenn Kasten22340022014-04-07 12:04:41 -0700352 }
353#endif
354 } else {
355 // first time through the loop
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800356 mOldTsValid = true;
357 mSleepNs = mPeriodNs;
358 mIgnoreNextOverrun = true;
Glenn Kasten22340022014-04-07 12:04:41 -0700359 }
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800360 mOldTs = newTs;
Glenn Kasten22340022014-04-07 12:04:41 -0700361 } else {
362 // monotonic clock is broken
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800363 mOldTsValid = false;
364 mSleepNs = mPeriodNs;
Glenn Kasten22340022014-04-07 12:04:41 -0700365 }
366
367 } // for (;;)
368
369 // never return 'true'; Thread::_threadLoop() locks mutex which can result in priority inversion
370}
371
372} // namespace android