Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1b54fb27 authored by Chris Craik's avatar Chris Craik
Browse files

Delete MAKE_ENUM_FLAGS 

bug:21595702

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

Change-Id: Ib89f94cb9263de40b6e4636577dca4860867d0d8
parent 4575acf1

core/jni/android_view_Surface.cpp

+1 −1
Original line number Diff line number Diff line
@@ -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();

}

libs/hwui/FrameInfo.h

+38 −37
Original line number Diff line number Diff line
@@ -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 */

libs/hwui/FrameInfoVisualizer.cpp

+17 −17
Original line number Diff line number Diff line
@@ -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);

libs/hwui/JankTracker.cpp

+9 −9
Original line number Diff line number Diff line
@@ -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;

    }

libs/hwui/renderthread/CanvasContext.cpp

+8 −8
Original line number Diff line number Diff line
@@ -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]);

        }

    }