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