1/*
2 * Copyright (C) 2012 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#ifndef ANDROID_FRAMETRACKER_H
18#define ANDROID_FRAMETRACKER_H
19
20#include <ui/FenceTime.h>
21
22#include <stddef.h>
23
24#include <utils/Mutex.h>
25#include <utils/Timers.h>
26#include <utils/RefBase.h>
27
28namespace android {
29
30class String8;
31
32// FrameTracker tracks information about the most recently rendered frames. It
33// uses a circular buffer of frame records, and is *NOT* thread-safe -
34// mutexing must be done at a higher level if multi-threaded access is
35// possible.
36//
37// Some of the time values tracked may be set either as a specific timestamp
38// or a fence.  When a non-NULL fence is set for a given time value, the
39// signal time of that fence is used instead of the timestamp.
40class FrameTracker {
41
42public:
43    // NUM_FRAME_RECORDS is the size of the circular buffer used to track the
44    // frame time history.
45    enum { NUM_FRAME_RECORDS = 128 };
46
47    enum { NUM_FRAME_BUCKETS = 7 };
48
49    FrameTracker();
50
51    // setDesiredPresentTime sets the time at which the current frame
52    // should be presented to the user under ideal (i.e. zero latency)
53    // conditions.
54    void setDesiredPresentTime(nsecs_t desiredPresentTime);
55
56    // setFrameReadyTime sets the time at which the current frame became ready
57    // to be presented to the user.  For example, if the frame contents is
58    // being written to memory by some asynchronous hardware, this would be
59    // the time at which those writes completed.
60    void setFrameReadyTime(nsecs_t readyTime);
61
62    // setFrameReadyFence sets the fence that is used to get the time at which
63    // the current frame became ready to be presented to the user.
64    void setFrameReadyFence(std::shared_ptr<FenceTime>&& readyFence);
65
66    // setActualPresentTime sets the timestamp at which the current frame became
67    // visible to the user.
68    void setActualPresentTime(nsecs_t displayTime);
69
70    // setActualPresentFence sets the fence that is used to get the time
71    // at which the current frame became visible to the user.
72    void setActualPresentFence(std::shared_ptr<FenceTime>&& fence);
73
74    // setDisplayRefreshPeriod sets the display refresh period in nanoseconds.
75    // This is used to compute frame presentation duration statistics relative
76    // to this period.
77    void setDisplayRefreshPeriod(nsecs_t displayPeriod);
78
79    // advanceFrame advances the frame tracker to the next frame.
80    void advanceFrame();
81
82    // clearStats clears the tracked frame stats.
83    void clearStats();
84
85    // getStats gets the tracked frame stats.
86    void getStats(FrameStats* outStats) const;
87
88    // logAndResetStats dumps the current statistics to the binary event log
89    // and then resets the accumulated statistics to their initial values.
90    void logAndResetStats(const String8& name);
91
92    // dumpStats dump appends the current frame display time history to the result string.
93    void dumpStats(String8& result) const;
94
95private:
96    struct FrameRecord {
97        FrameRecord() :
98            desiredPresentTime(0),
99            frameReadyTime(0),
100            actualPresentTime(0) {}
101        nsecs_t desiredPresentTime;
102        nsecs_t frameReadyTime;
103        nsecs_t actualPresentTime;
104        std::shared_ptr<FenceTime> frameReadyFence;
105        std::shared_ptr<FenceTime> actualPresentFence;
106    };
107
108    // processFences iterates over all the frame records that have a fence set
109    // and replaces that fence with a timestamp if the fence has signaled.  If
110    // the fence is not signaled the record's displayTime is set to INT64_MAX.
111    //
112    // This method is const because although it modifies the frame records it
113    // does so in such a way that the information represented should not
114    // change.  This allows it to be called from the dump method.
115    void processFencesLocked() const;
116
117    // updateStatsLocked updates the running statistics that are gathered
118    // about the frame times.
119    void updateStatsLocked(size_t newFrameIdx) const;
120
121    // resetFrameCounteresLocked sets all elements of the mNumFrames array to
122    // 0.
123    void resetFrameCountersLocked();
124
125    // logStatsLocked dumps the current statistics to the binary event log.
126    void logStatsLocked(const String8& name) const;
127
128    // isFrameValidLocked returns true if the data for the given frame index is
129    // valid and has all arrived (i.e. there are no oustanding fences).
130    bool isFrameValidLocked(size_t idx) const;
131
132    // mFrameRecords is the circular buffer storing the tracked data for each
133    // frame.
134    FrameRecord mFrameRecords[NUM_FRAME_RECORDS];
135
136    // mOffset is the offset into mFrameRecords of the current frame.
137    size_t mOffset;
138
139    // mNumFences is the total number of fences set in the frame records.  It
140    // is incremented each time a fence is added and decremented each time a
141    // signaled fence is removed in processFences or if advanceFrame clobbers
142    // a fence.
143    //
144    // The number of fences is tracked so that the run time of processFences
145    // doesn't grow with NUM_FRAME_RECORDS.
146    int mNumFences;
147
148    // mNumFrames keeps a count of the number of frames with a duration in a
149    // particular range of vsync periods.  Element n of the array stores the
150    // number of frames with duration in the half-inclusive range
151    // [2^n, 2^(n+1)).  The last element of the array contains the count for
152    // all frames with duration greater than 2^(NUM_FRAME_BUCKETS-1).
153    int32_t mNumFrames[NUM_FRAME_BUCKETS];
154
155    // mDisplayPeriod is the display refresh period of the display for which
156    // this FrameTracker is gathering information.
157    nsecs_t mDisplayPeriod;
158
159    // mMutex is used to protect access to all member variables.
160    mutable Mutex mMutex;
161};
162
163}
164
165#endif // ANDROID_FRAMETRACKER_H
166