1 /* 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" 23 #include <linux/futex.h> 24 #include <sys/syscall.h> 25 #include <utils/Log.h> 26 #include <utils/Trace.h> 27 #include "FastThread.h" 28 29 #define FAST_DEFAULT_NS 999999999L // ~1 sec: default time to sleep 30 #define FAST_HOT_IDLE_NS 1000000L // 1 ms: time to sleep while hot idling 31 #define MIN_WARMUP_CYCLES 2 // minimum number of loop cycles to wait for warmup 32 #define MAX_WARMUP_CYCLES 10 // maximum number of loop cycles to wait for warmup 33 34 namespace android { 35 36 FastThread::FastThread() : Thread(false /*canCallJava*/), 37 // re-initialized to &initial by subclass constructor 38 previous(NULL), current(NULL), 39 /* oldTs({0, 0}), */ 40 oldTsValid(false), 41 sleepNs(-1), 42 periodNs(0), 43 underrunNs(0), 44 overrunNs(0), 45 forceNs(0), 46 warmupNs(0), 47 // re-initialized to &dummyDumpState by subclass constructor 48 mDummyDumpState(NULL), 49 dumpState(NULL), 50 ignoreNextOverrun(true), 51 #ifdef FAST_MIXER_STATISTICS 52 // oldLoad 53 oldLoadValid(false), 54 bounds(0), 55 full(false), 56 // tcu 57 #endif 58 coldGen(0), 59 isWarm(false), 60 /* measuredWarmupTs({0, 0}), */ 61 warmupCycles(0), 62 // dummyLogWriter 63 logWriter(&dummyLogWriter), 64 timestampStatus(INVALID_OPERATION), 65 66 command(FastThreadState::INITIAL), 67 #if 0 68 frameCount(0), 69 #endif 70 attemptedWrite(false) 71 { 72 oldTs.tv_sec = 0; 73 oldTs.tv_nsec = 0; 74 measuredWarmupTs.tv_sec = 0; 75 measuredWarmupTs.tv_nsec = 0; 76 } 77 78 FastThread::~FastThread() 79 { 80 } 81 82 bool FastThread::threadLoop() 83 { 84 for (;;) { 85 86 // either nanosleep, sched_yield, or busy wait 87 if (sleepNs >= 0) { 88 if (sleepNs > 0) { 89 ALOG_ASSERT(sleepNs < 1000000000); 90 const struct timespec req = {0, sleepNs}; 91 nanosleep(&req, NULL); 92 } else { 93 sched_yield(); 94 } 95 } 96 // default to long sleep for next cycle 97 sleepNs = FAST_DEFAULT_NS; 98 99 // poll for state change 100 const FastThreadState *next = poll(); 101 if (next == NULL) { 102 // continue to use the default initial state until a real state is available 103 // FIXME &initial not available, should save address earlier 104 //ALOG_ASSERT(current == &initial && previous == &initial); 105 next = current; 106 } 107 108 command = next->mCommand; 109 if (next != current) { 110 111 // As soon as possible of learning of a new dump area, start using it 112 dumpState = next->mDumpState != NULL ? next->mDumpState : mDummyDumpState; 113 logWriter = next->mNBLogWriter != NULL ? next->mNBLogWriter : &dummyLogWriter; 114 setLog(logWriter); 115 116 // We want to always have a valid reference to the previous (non-idle) state. 117 // However, the state queue only guarantees access to current and previous states. 118 // So when there is a transition from a non-idle state into an idle state, we make a 119 // copy of the last known non-idle state so it is still available on return from idle. 120 // The possible transitions are: 121 // non-idle -> non-idle update previous from current in-place 122 // non-idle -> idle update previous from copy of current 123 // idle -> idle don't update previous 124 // idle -> non-idle don't update previous 125 if (!(current->mCommand & FastThreadState::IDLE)) { 126 if (command & FastThreadState::IDLE) { 127 onIdle(); 128 oldTsValid = false; 129 #ifdef FAST_MIXER_STATISTICS 130 oldLoadValid = false; 131 #endif 132 ignoreNextOverrun = true; 133 } 134 previous = current; 135 } 136 current = next; 137 } 138 #if !LOG_NDEBUG 139 next = NULL; // not referenced again 140 #endif 141 142 dumpState->mCommand = command; 143 144 // << current, previous, command, dumpState >> 145 146 switch (command) { 147 case FastThreadState::INITIAL: 148 case FastThreadState::HOT_IDLE: 149 sleepNs = FAST_HOT_IDLE_NS; 150 continue; 151 case FastThreadState::COLD_IDLE: 152 // only perform a cold idle command once 153 // FIXME consider checking previous state and only perform if previous != COLD_IDLE 154 if (current->mColdGen != coldGen) { 155 int32_t *coldFutexAddr = current->mColdFutexAddr; 156 ALOG_ASSERT(coldFutexAddr != NULL); 157 int32_t old = android_atomic_dec(coldFutexAddr); 158 if (old <= 0) { 159 syscall(__NR_futex, coldFutexAddr, FUTEX_WAIT_PRIVATE, old - 1, NULL); 160 } 161 int policy = sched_getscheduler(0); 162 if (!(policy == SCHED_FIFO || policy == SCHED_RR)) { 163 ALOGE("did not receive expected priority boost"); 164 } 165 // This may be overly conservative; there could be times that the normal mixer 166 // requests such a brief cold idle that it doesn't require resetting this flag. 167 isWarm = false; 168 measuredWarmupTs.tv_sec = 0; 169 measuredWarmupTs.tv_nsec = 0; 170 warmupCycles = 0; 171 sleepNs = -1; 172 coldGen = current->mColdGen; 173 #ifdef FAST_MIXER_STATISTICS 174 bounds = 0; 175 full = false; 176 #endif 177 oldTsValid = !clock_gettime(CLOCK_MONOTONIC, &oldTs); 178 timestampStatus = INVALID_OPERATION; 179 } else { 180 sleepNs = FAST_HOT_IDLE_NS; 181 } 182 continue; 183 case FastThreadState::EXIT: 184 onExit(); 185 return false; 186 default: 187 LOG_ALWAYS_FATAL_IF(!isSubClassCommand(command)); 188 break; 189 } 190 191 // there is a non-idle state available to us; did the state change? 192 if (current != previous) { 193 onStateChange(); 194 #if 1 // FIXME shouldn't need this 195 // only process state change once 196 previous = current; 197 #endif 198 } 199 200 // do work using current state here 201 attemptedWrite = false; 202 onWork(); 203 204 // To be exactly periodic, compute the next sleep time based on current time. 205 // This code doesn't have long-term stability when the sink is non-blocking. 206 // FIXME To avoid drift, use the local audio clock or watch the sink's fill status. 207 struct timespec newTs; 208 int rc = clock_gettime(CLOCK_MONOTONIC, &newTs); 209 if (rc == 0) { 210 //logWriter->logTimestamp(newTs); 211 if (oldTsValid) { 212 time_t sec = newTs.tv_sec - oldTs.tv_sec; 213 long nsec = newTs.tv_nsec - oldTs.tv_nsec; 214 ALOGE_IF(sec < 0 || (sec == 0 && nsec < 0), 215 "clock_gettime(CLOCK_MONOTONIC) failed: was %ld.%09ld but now %ld.%09ld", 216 oldTs.tv_sec, oldTs.tv_nsec, newTs.tv_sec, newTs.tv_nsec); 217 if (nsec < 0) { 218 --sec; 219 nsec += 1000000000; 220 } 221 // To avoid an initial underrun on fast tracks after exiting standby, 222 // do not start pulling data from tracks and mixing until warmup is complete. 223 // Warmup is considered complete after the earlier of: 224 // MIN_WARMUP_CYCLES write() attempts and last one blocks for at least warmupNs 225 // MAX_WARMUP_CYCLES write() attempts. 226 // This is overly conservative, but to get better accuracy requires a new HAL API. 227 if (!isWarm && attemptedWrite) { 228 measuredWarmupTs.tv_sec += sec; 229 measuredWarmupTs.tv_nsec += nsec; 230 if (measuredWarmupTs.tv_nsec >= 1000000000) { 231 measuredWarmupTs.tv_sec++; 232 measuredWarmupTs.tv_nsec -= 1000000000; 233 } 234 ++warmupCycles; 235 if ((nsec > warmupNs && warmupCycles >= MIN_WARMUP_CYCLES) || 236 (warmupCycles >= MAX_WARMUP_CYCLES)) { 237 isWarm = true; 238 dumpState->mMeasuredWarmupTs = measuredWarmupTs; 239 dumpState->mWarmupCycles = warmupCycles; 240 } 241 } 242 sleepNs = -1; 243 if (isWarm) { 244 if (sec > 0 || nsec > underrunNs) { 245 ATRACE_NAME("underrun"); 246 // FIXME only log occasionally 247 ALOGV("underrun: time since last cycle %d.%03ld sec", 248 (int) sec, nsec / 1000000L); 249 dumpState->mUnderruns++; 250 ignoreNextOverrun = true; 251 } else if (nsec < overrunNs) { 252 if (ignoreNextOverrun) { 253 ignoreNextOverrun = false; 254 } else { 255 // FIXME only log occasionally 256 ALOGV("overrun: time since last cycle %d.%03ld sec", 257 (int) sec, nsec / 1000000L); 258 dumpState->mOverruns++; 259 } 260 // This forces a minimum cycle time. It: 261 // - compensates for an audio HAL with jitter due to sample rate conversion 262 // - works with a variable buffer depth audio HAL that never pulls at a 263 // rate < than overrunNs per buffer. 264 // - recovers from overrun immediately after underrun 265 // It doesn't work with a non-blocking audio HAL. 266 sleepNs = forceNs - nsec; 267 } else { 268 ignoreNextOverrun = false; 269 } 270 } 271 #ifdef FAST_MIXER_STATISTICS 272 if (isWarm) { 273 // advance the FIFO queue bounds 274 size_t i = bounds & (dumpState->mSamplingN - 1); 275 bounds = (bounds & 0xFFFF0000) | ((bounds + 1) & 0xFFFF); 276 if (full) { 277 bounds += 0x10000; 278 } else if (!(bounds & (dumpState->mSamplingN - 1))) { 279 full = true; 280 } 281 // compute the delta value of clock_gettime(CLOCK_MONOTONIC) 282 uint32_t monotonicNs = nsec; 283 if (sec > 0 && sec < 4) { 284 monotonicNs += sec * 1000000000; 285 } 286 // compute raw CPU load = delta value of clock_gettime(CLOCK_THREAD_CPUTIME_ID) 287 uint32_t loadNs = 0; 288 struct timespec newLoad; 289 rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &newLoad); 290 if (rc == 0) { 291 if (oldLoadValid) { 292 sec = newLoad.tv_sec - oldLoad.tv_sec; 293 nsec = newLoad.tv_nsec - oldLoad.tv_nsec; 294 if (nsec < 0) { 295 --sec; 296 nsec += 1000000000; 297 } 298 loadNs = nsec; 299 if (sec > 0 && sec < 4) { 300 loadNs += sec * 1000000000; 301 } 302 } else { 303 // first time through the loop 304 oldLoadValid = true; 305 } 306 oldLoad = newLoad; 307 } 308 #ifdef CPU_FREQUENCY_STATISTICS 309 // get the absolute value of CPU clock frequency in kHz 310 int cpuNum = sched_getcpu(); 311 uint32_t kHz = tcu.getCpukHz(cpuNum); 312 kHz = (kHz << 4) | (cpuNum & 0xF); 313 #endif 314 // save values in FIFO queues for dumpsys 315 // these stores #1, #2, #3 are not atomic with respect to each other, 316 // or with respect to store #4 below 317 dumpState->mMonotonicNs[i] = monotonicNs; 318 dumpState->mLoadNs[i] = loadNs; 319 #ifdef CPU_FREQUENCY_STATISTICS 320 dumpState->mCpukHz[i] = kHz; 321 #endif 322 // this store #4 is not atomic with respect to stores #1, #2, #3 above, but 323 // the newest open & oldest closed halves are atomic with respect to each other 324 dumpState->mBounds = bounds; 325 ATRACE_INT("cycle_ms", monotonicNs / 1000000); 326 ATRACE_INT("load_us", loadNs / 1000); 327 } 328 #endif 329 } else { 330 // first time through the loop 331 oldTsValid = true; 332 sleepNs = periodNs; 333 ignoreNextOverrun = true; 334 } 335 oldTs = newTs; 336 } else { 337 // monotonic clock is broken 338 oldTsValid = false; 339 sleepNs = periodNs; 340 } 341 342 } // for (;;) 343 344 // never return 'true'; Thread::_threadLoop() locks mutex which can result in priority inversion 345 } 346 347 } // namespace android 348
