Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete MAKE_ENUM_FLAGS

Browse Source 
bug:21595702

Settle on namespace-enum for consistency. Also removes k prefix.

Change-Id: Ib89f94cb9263de40b6e4636577dca4860867d0d8
This commit is contained in:
Chris Craik
2015-06-02 17:40:58 -07:00
parent 4575acf1e7
commit 1b54fb27ac
7 changed files with 74 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
core/jni/android_view_Surface.cpp
View File

@@ -499,7 +499,7 @@ static void draw(JNIEnv* env, jclass clazz, jlong rendererPtr) {
nsecs_t vsync = systemTime(CLOCK_MONOTONIC);
UiFrameInfoBuilder(proxy->frameInfo())
.setVsync(vsync, vsync)
.addFlag(FrameInfoFlags::kSurfaceCanvas);
.addFlag(FrameInfoFlags::SurfaceCanvas);
proxy->syncAndDrawFrame();
}

75
libs/hwui/FrameInfo.h
View File

@@ -30,35 +30,36 @@ namespace uirenderer {
#define UI_THREAD_FRAME_INFO_SIZE 9
enum class FrameInfoIndex {
kFlags = 0,
kIntendedVsync,
kVsync,
kOldestInputEvent,
kNewestInputEvent,
kHandleInputStart,
kAnimationStart,
kPerformTraversalsStart,
kDrawStart,
Flags = 0,
IntendedVsync,
Vsync,
OldestInputEvent,
NewestInputEvent,
HandleInputStart,
AnimationStart,
PerformTraversalsStart,
DrawStart,
// End of UI frame info
kSyncStart,
kIssueDrawCommandsStart,
kSwapBuffers,
kFrameCompleted,
SyncStart,
IssueDrawCommandsStart,
SwapBuffers,
FrameCompleted,
// Must be the last value!
kNumIndexes
NumIndexes
};
extern const std::string FrameInfoNames[];
enum class FrameInfoFlags {
kWindowLayoutChanged = 1 << 0,
kRTAnimation = 1 << 1,
kSurfaceCanvas = 1 << 2,
kSkippedFrame = 1 << 3,
namespace FrameInfoFlags {
enum {
WindowLayoutChanged = 1 << 0,
RTAnimation = 1 << 1,
SurfaceCanvas = 1 << 2,
SkippedFrame = 1 << 3,
};
};
MAKE_FLAGS_ENUM(FrameInfoFlags)
class ANDROID_API UiFrameInfoBuilder {
public:
@@ -67,19 +68,19 @@ public:
}
UiFrameInfoBuilder& setVsync(nsecs_t vsyncTime, nsecs_t intendedVsync) {
set(FrameInfoIndex::kVsync) = vsyncTime;
set(FrameInfoIndex::kIntendedVsync) = intendedVsync;
set(FrameInfoIndex::Vsync) = vsyncTime;
set(FrameInfoIndex::IntendedVsync) = intendedVsync;
// Pretend the other fields are all at vsync, too, so that naive
// duration calculations end up being 0 instead of very large
set(FrameInfoIndex::kHandleInputStart) = vsyncTime;
set(FrameInfoIndex::kAnimationStart) = vsyncTime;
set(FrameInfoIndex::kPerformTraversalsStart) = vsyncTime;
set(FrameInfoIndex::kDrawStart) = vsyncTime;
set(FrameInfoIndex::HandleInputStart) = vsyncTime;
set(FrameInfoIndex::AnimationStart) = vsyncTime;
set(FrameInfoIndex::PerformTraversalsStart) = vsyncTime;
set(FrameInfoIndex::DrawStart) = vsyncTime;
return *this;
}
UiFrameInfoBuilder& addFlag(FrameInfoFlags flag) {
set(FrameInfoIndex::kFlags) |= static_cast<uint64_t>(flag);
UiFrameInfoBuilder& addFlag(int frameInfoFlag) {
set(FrameInfoIndex::Flags) |= static_cast<uint64_t>(frameInfoFlag);
return *this;
}
@@ -96,32 +97,32 @@ public:
void importUiThreadInfo(int64_t* info);
void markSyncStart() {
set(FrameInfoIndex::kSyncStart) = systemTime(CLOCK_MONOTONIC);
set(FrameInfoIndex::SyncStart) = systemTime(CLOCK_MONOTONIC);
}
void markIssueDrawCommandsStart() {
set(FrameInfoIndex::kIssueDrawCommandsStart) = systemTime(CLOCK_MONOTONIC);
set(FrameInfoIndex::IssueDrawCommandsStart) = systemTime(CLOCK_MONOTONIC);
}
void markSwapBuffers() {
set(FrameInfoIndex::kSwapBuffers) = systemTime(CLOCK_MONOTONIC);
set(FrameInfoIndex::SwapBuffers) = systemTime(CLOCK_MONOTONIC);
}
void markFrameCompleted() {
set(FrameInfoIndex::kFrameCompleted) = systemTime(CLOCK_MONOTONIC);
set(FrameInfoIndex::FrameCompleted) = systemTime(CLOCK_MONOTONIC);
}
void addFlag(FrameInfoFlags flag) {
set(FrameInfoIndex::kFlags) |= static_cast<uint64_t>(flag);
void addFlag(int frameInfoFlag) {
set(FrameInfoIndex::Flags) |= static_cast<uint64_t>(frameInfoFlag);
}
int64_t operator[](FrameInfoIndex index) const {
if (index == FrameInfoIndex::kNumIndexes) return 0;
if (index == FrameInfoIndex::NumIndexes) return 0;
return mFrameInfo[static_cast<int>(index)];
}
int64_t operator[](int index) const {
if (index < 0 || index >= static_cast<int>(FrameInfoIndex::kNumIndexes)) return 0;
if (index < 0 || index >= static_cast<int>(FrameInfoIndex::NumIndexes)) return 0;
return mFrameInfo[index];
}
@@ -130,7 +131,7 @@ private:
return mFrameInfo[static_cast<int>(index)];
}
int64_t mFrameInfo[static_cast<int>(FrameInfoIndex::kNumIndexes)];
int64_t mFrameInfo[static_cast<int>(FrameInfoIndex::NumIndexes)];
};
} /* namespace uirenderer */

34
libs/hwui/FrameInfoVisualizer.cpp
View File

@@ -46,15 +46,15 @@ struct BarSegment {
};
static const std::array<BarSegment,9> Bar {{
{ FrameInfoIndex::kIntendedVsync, FrameInfoIndex::kVsync, 0x00695C },
{ FrameInfoIndex::kVsync, FrameInfoIndex::kHandleInputStart, 0x00796B },
{ FrameInfoIndex::kHandleInputStart, FrameInfoIndex::kAnimationStart, 0x00897B },
{ FrameInfoIndex::kAnimationStart, FrameInfoIndex::kPerformTraversalsStart, 0x009688 },
{ FrameInfoIndex::kPerformTraversalsStart, FrameInfoIndex::kDrawStart, 0x26A69A},
{ FrameInfoIndex::kDrawStart, FrameInfoIndex::kSyncStart, 0x2196F3},
{ FrameInfoIndex::kSyncStart, FrameInfoIndex::kIssueDrawCommandsStart, 0x4FC3F7},
{ FrameInfoIndex::kIssueDrawCommandsStart, FrameInfoIndex::kSwapBuffers, 0xF44336},
{ FrameInfoIndex::kSwapBuffers, FrameInfoIndex::kFrameCompleted, 0xFF9800},
{ FrameInfoIndex::IntendedVsync, FrameInfoIndex::Vsync, 0x00695C },
{ FrameInfoIndex::Vsync, FrameInfoIndex::HandleInputStart, 0x00796B },
{ FrameInfoIndex::HandleInputStart, FrameInfoIndex::AnimationStart, 0x00897B },
{ FrameInfoIndex::AnimationStart, FrameInfoIndex::PerformTraversalsStart, 0x009688 },
{ FrameInfoIndex::PerformTraversalsStart, FrameInfoIndex::DrawStart, 0x26A69A},
{ FrameInfoIndex::DrawStart, FrameInfoIndex::SyncStart, 0x2196F3},
{ FrameInfoIndex::SyncStart, FrameInfoIndex::IssueDrawCommandsStart, 0x4FC3F7},
{ FrameInfoIndex::IssueDrawCommandsStart, FrameInfoIndex::SwapBuffers, 0xF44336},
{ FrameInfoIndex::SwapBuffers, FrameInfoIndex::FrameCompleted, 0xFF9800},
}};
static int dpToPx(int dp, float density) {
@@ -137,7 +137,7 @@ void FrameInfoVisualizer::nextBarSegment(FrameInfoIndex start, FrameInfoIndex en
for (size_t fi = 0, ri = 0; fi < mFrameSource.size(); fi++, ri += 4) {
// TODO: Skipped frames will leave little holes in the graph, but this
// is better than bogus and freaky lines, so...
if (mFrameSource[fi][FrameInfoIndex::kFlags] & FrameInfoFlags::kSkippedFrame) {
if (mFrameSource[fi][FrameInfoIndex::Flags] & FrameInfoFlags::SkippedFrame) {
continue;
}
@@ -166,7 +166,7 @@ void FrameInfoVisualizer::drawCurrentFrame(const int baseline, OpenGLRenderer* c
size_t fi = mFrameSource.size() - 1;
size_t ri = fi * 4;
float top = baseline - (mVerticalUnit * duration(fi,
FrameInfoIndex::kIntendedVsync, FrameInfoIndex::kIssueDrawCommandsStart));
FrameInfoIndex::IntendedVsync, FrameInfoIndex::IssueDrawCommandsStart));
canvas->drawRect(mRects[ri], top, mRects[ri + 2], baseline, &paint);
}
@@ -214,15 +214,15 @@ void FrameInfoVisualizer::dumpData(int fd) {
fprintf(file, "\n\tDraw\tPrepare\tProcess\tExecute\n");
for (size_t i = 0; i < mFrameSource.size(); i++) {
if (mFrameSource[i][FrameInfoIndex::kIntendedVsync] <= mLastFrameLogged) {
if (mFrameSource[i][FrameInfoIndex::IntendedVsync] <= mLastFrameLogged) {
continue;
}
mLastFrameLogged = mFrameSource[i][FrameInfoIndex::kIntendedVsync];
mLastFrameLogged = mFrameSource[i][FrameInfoIndex::IntendedVsync];
fprintf(file, "\t%3.2f\t%3.2f\t%3.2f\t%3.2f\n",
duration(i, FrameInfoIndex::kIntendedVsync, FrameInfoIndex::kSyncStart),
duration(i, FrameInfoIndex::kSyncStart, FrameInfoIndex::kIssueDrawCommandsStart),
duration(i, FrameInfoIndex::kIssueDrawCommandsStart, FrameInfoIndex::kSwapBuffers),
duration(i, FrameInfoIndex::kSwapBuffers, FrameInfoIndex::kFrameCompleted));
duration(i, FrameInfoIndex::IntendedVsync, FrameInfoIndex::SyncStart),
duration(i, FrameInfoIndex::SyncStart, FrameInfoIndex::IssueDrawCommandsStart),
duration(i, FrameInfoIndex::IssueDrawCommandsStart, FrameInfoIndex::SwapBuffers),
duration(i, FrameInfoIndex::SwapBuffers, FrameInfoIndex::FrameCompleted));
}
fflush(file);

18
libs/hwui/JankTracker.cpp
View File

@@ -40,11 +40,11 @@ struct Comparison {
};
static const Comparison COMPARISONS[] = {
{FrameInfoIndex::kIntendedVsync, FrameInfoIndex::kVsync},
{FrameInfoIndex::kOldestInputEvent, FrameInfoIndex::kVsync},
{FrameInfoIndex::kVsync, FrameInfoIndex::kSyncStart},
{FrameInfoIndex::kSyncStart, FrameInfoIndex::kIssueDrawCommandsStart},
{FrameInfoIndex::kIssueDrawCommandsStart, FrameInfoIndex::kFrameCompleted},
{FrameInfoIndex::IntendedVsync, FrameInfoIndex::Vsync},
{FrameInfoIndex::OldestInputEvent, FrameInfoIndex::Vsync},
{FrameInfoIndex::Vsync, FrameInfoIndex::SyncStart},
{FrameInfoIndex::SyncStart, FrameInfoIndex::IssueDrawCommandsStart},
{FrameInfoIndex::IssueDrawCommandsStart, FrameInfoIndex::FrameCompleted},
};
// If the event exceeds 10 seconds throw it away, this isn't a jank event
@@ -64,8 +64,8 @@ static const int64_t IGNORE_EXCEEDING = seconds_to_nanoseconds(10);
* time on the RenderThread, figure out how to attribute that as a jank-causer
*/
static const int64_t EXEMPT_FRAMES_FLAGS
= FrameInfoFlags::kWindowLayoutChanged
| FrameInfoFlags::kSurfaceCanvas;
= FrameInfoFlags::WindowLayoutChanged
| FrameInfoFlags::SurfaceCanvas;
// The bucketing algorithm controls so to speak
// If a frame is <= to this it goes in bucket 0
@@ -206,7 +206,7 @@ void JankTracker::addFrame(const FrameInfo& frame) {
mData->totalFrameCount++;
// Fast-path for jank-free frames
int64_t totalDuration =
frame[FrameInfoIndex::kFrameCompleted] - frame[FrameInfoIndex::kIntendedVsync];
frame[FrameInfoIndex::FrameCompleted] - frame[FrameInfoIndex::IntendedVsync];
uint32_t framebucket = frameCountIndexForFrameTime(
totalDuration, mData->frameCounts.size());
// Keep the fast path as fast as possible.
@@ -215,7 +215,7 @@ void JankTracker::addFrame(const FrameInfo& frame) {
return;
}
if (frame[FrameInfoIndex::kFlags] & EXEMPT_FRAMES_FLAGS) {
if (frame[FrameInfoIndex::Flags] & EXEMPT_FRAMES_FLAGS) {
return;
}

16
libs/hwui/renderthread/CanvasContext.cpp
View File

@@ -157,7 +157,7 @@ void CanvasContext::processLayerUpdate(DeferredLayerUpdater* layerUpdater) {
}
static bool wasSkipped(FrameInfo* info) {
return info && ((*info)[FrameInfoIndex::kFlags] & FrameInfoFlags::kSkippedFrame);
return info && ((*info)[FrameInfoIndex::Flags] & FrameInfoFlags::SkippedFrame);
}
void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo) {
@@ -185,7 +185,7 @@ void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo) {
}
if (CC_UNLIKELY(!mNativeWindow.get())) {
mCurrentFrameInfo->addFlag(FrameInfoFlags::kSkippedFrame);
mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
info.out.canDrawThisFrame = false;
return;
}
@@ -199,7 +199,7 @@ void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo) {
info.out.canDrawThisFrame = !runningBehind;
if (!info.out.canDrawThisFrame) {
mCurrentFrameInfo->addFlag(FrameInfoFlags::kSkippedFrame);
mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
}
if (info.out.hasAnimations || !info.out.canDrawThisFrame) {
@@ -228,7 +228,7 @@ void CanvasContext::draw() {
mDamageAccumulator.finish(&dirty);
if (dirty.isEmpty() && Properties::skipEmptyFrames) {
mCurrentFrameInfo->addFlag(FrameInfoFlags::kSkippedFrame);
mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
return;
}
@@ -288,7 +288,7 @@ void CanvasContext::doFrame() {
int64_t frameInfo[UI_THREAD_FRAME_INFO_SIZE];
UiFrameInfoBuilder(frameInfo)
.addFlag(FrameInfoFlags::kRTAnimation)
.addFlag(FrameInfoFlags::RTAnimation)
.setVsync(mRenderThread.timeLord().computeFrameTimeNanos(),
mRenderThread.timeLord().latestVsync());
@@ -400,17 +400,17 @@ void CanvasContext::setTextureAtlas(RenderThread& thread,
void CanvasContext::dumpFrames(int fd) {
FILE* file = fdopen(fd, "a");
fprintf(file, "\n\n---PROFILEDATA---\n");
for (size_t i = 0; i < static_cast<size_t>(FrameInfoIndex::kNumIndexes); i++) {
for (size_t i = 0; i < static_cast<size_t>(FrameInfoIndex::NumIndexes); i++) {
fprintf(file, "%s", FrameInfoNames[i].c_str());
fprintf(file, ",");
}
for (size_t i = 0; i < mFrames.size(); i++) {
FrameInfo& frame = mFrames[i];
if (frame[FrameInfoIndex::kSyncStart] == 0) {
if (frame[FrameInfoIndex::SyncStart] == 0) {
continue;
}
fprintf(file, "\n");
for (int i = 0; i < static_cast<int>(FrameInfoIndex::kNumIndexes); i++) {
for (int i = 0; i < static_cast<int>(FrameInfoIndex::NumIndexes); i++) {
fprintf(file, "%" PRId64 ",", frame[i]);
}
}

2
libs/hwui/renderthread/DrawFrameTask.cpp
View File

@@ -110,7 +110,7 @@ void DrawFrameTask::run() {
bool DrawFrameTask::syncFrameState(TreeInfo& info) {
ATRACE_CALL();
int64_t vsync = mFrameInfo[static_cast<int>(FrameInfoIndex::kVsync)];
int64_t vsync = mFrameInfo[static_cast<int>(FrameInfoIndex::Vsync)];
mRenderThread->timeLord().vsyncReceived(vsync);
mContext->makeCurrent();
Caches::getInstance().textureCache.resetMarkInUse();

26
libs/hwui/utils/Macros.h
View File

@@ -35,30 +35,4 @@
static_assert(std::is_standard_layout<Type>::value, \
#Type " must have standard layout")
#define MAKE_FLAGS_ENUM(enumType) \
inline void operator|=(int& lhs, enumType rhs) { \
lhs |= static_cast<int>(rhs); \
} \
inline int operator|(int lhs, enumType rhs) { \
return lhs | static_cast<int>(rhs); \
} \
inline int operator|(enumType lhs, int rhs) { \
return static_cast<int>(lhs) | rhs; \
} \
inline int operator|(enumType lhs, enumType rhs) { \
return static_cast<int>(lhs) | static_cast<int>(rhs); \
} \
inline void operator&=(int& lhs, enumType rhs) { \
lhs &= static_cast<int>(rhs); \
} \
inline int operator&(int lhs, enumType rhs) { \
return lhs & static_cast<int>(rhs); \
} \
inline int operator&(enumType lhs, int rhs) { \
return static_cast<int>(lhs) & rhs; \
} \
inline int operator&(enumType lhs, enumType rhs) { \
return static_cast<int>(lhs) & static_cast<int>(rhs); \
}
#endif /* MACROS_H */