ChangeLog

2012-02-01  Alex Nicolaou  <anicolao@chromium.org>

        [chromium] When rendering goes idle, do not count that time against frame rate

        https://bugs.webkit.org/show_bug.cgi?id=73454

        The FPS counter had a few issues with its reporting. The first

        3 swapbuffers are non-blocking and create FPS rates that are

        unrealistically high, throwing off the moving averages and

        introducing false spikes into the FPS graph. There was also no

        way to monitor the smoothness of the animation, or to focus in

        on a particular animation or transition.

        This patch updates the FPS counter code so that bad data points

        are trimmed and not graphed; so that the graph itself is taller

        and more legible; so that there is a clear boundary between 40FPS

        and better; so that outlier data points are labelled with their

        frame rate so that you can see how slow the frame is that is

        causing the jank; and to keep statistics on frame rate between

        pauses in the activity in the UI so that you can trigger a

        transition and read off the average and standard deviation for

        that transition to judge it smooth enough or not.

        Reviewed by NOBODY (OOPS!).

        HUD is not testable in webkit.

        * platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:

        (WebCore::CCHeadsUpDisplay::CCHeadsUpDisplay):

        (WebCore::CCHeadsUpDisplay::onFrameBegin):

        (WebCore::CCHeadsUpDisplay::drawHudContents):

        (WebCore::CCHeadsUpDisplay::drawFPSCounter):

        * platform/graphics/chromium/cc/CCHeadsUpDisplay.h:

2012-01-31  Adam Klein  <adamk@chromium.org>

        ProcessingInstruction should not be a ContainerNode

Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp

@@using namespace std;

CCHeadsUpDisplay::CCHeadsUpDisplay(LayerRendererChromium* owner)

    : m_currentFrameNumber(1)

52 , m_filteredFrameTime(0)

    , m_averageFPS(0)

    , m_averageFPSCount(0)

    , m_varianceNumerator(0)

    , m_layerRenderer(owner)

    , m_useMapSubForUploads(owner->contextSupportsMapSub())

{

@@CCHeadsUpDisplay::CCHeadsUpDisplay(LayerRendererChromium* owner)

    FontDescription mediumFontDesc;

    mediumFontDesc.setGenericFamily(FontDescription::MonospaceFamily);

63 mediumFontDesc.setComputedSize(20);

65 mediumFontDesc.setComputedSize(12);

    m_mediumFont = adoptPtr(new Font(mediumFontDesc, 0, 0));

    m_mediumFont->update(0);

@@CCHeadsUpDisplay::~CCHeadsUpDisplay()

{

}

// SAFE_MOD works on -1, returning m-1 in that case.

#define SAFE_MOD(n, m) (((n) + (m)) % (m))

#define FRAME_INDEX(frame) SAFE_MOD(frame, kBeginFrameHistorySize)

8086void CCHeadsUpDisplay::onFrameBegin(double timestamp)

8187{

82 m_beginTimeHistoryInSec[m_currentFrameNumber ~~% kBeginFrameHistorySize~~] = timestamp;

88 m_beginTimeHistoryInSec[FRAME_INDEX(m_currentFrameNumber)] = timestamp;

}

void CCHeadsUpDisplay::onSwapBuffers()

@@void CCHeadsUpDisplay::draw()

    m_hudTexture->unreserve();

}

bool CCHeadsUpDisplay::isBadFrame(int frameNumber) const

{

    double delta = m_beginTimeHistoryInSec[FRAME_INDEX(frameNumber)] -

                   m_beginTimeHistoryInSec[FRAME_INDEX(frameNumber - 1)];

    bool tooSlow = delta > kFrameTooSlow;

    bool bSchedulerAllowsDoubleFrames = !CCProxy::hasImplThread();

    return (bSchedulerAllowsDoubleFrames && delta < kFrameTooFast) || tooSlow;

}

void CCHeadsUpDisplay::drawHudContents(GraphicsContext* ctx, const IntSize& hudSize)

{

    FontCachePurgePreventer fontCachePurgePreventer;

@@void CCHeadsUpDisplay::drawHudContents(GraphicsContext* ctx, const IntSize& hudS

        ctx->fillRect(FloatRect(0, 0, hudSize.width(), hudSize.height()));

    }

173 int fpsCounterHeight = m_mediumFont->fontMetrics().floatHeight() + 2;

188 int fpsCounterHeight = m_mediumFont->fontMetrics().floatHeight() + 40;

    int fpsCounterTop = 2;

    int platformLayerTreeTop;

    if (settings().showFPSCounter)

177 platformLayerTreeTop = fpsCounterTop + fpsCounterHeight ~~+ 2~~;

192 platformLayerTreeTop = fpsCounterTop + fpsCounterHeight;

    else

        platformLayerTreeTop = 0;

@@void CCHeadsUpDisplay::drawFPSCounter(GraphicsContext* ctx, int top, int height)

{

    // Note that since we haven't finished the current frame, the FPS counter

    // actually reports the last frame's time.

    double secForLastFrame = m_beginTimeHistoryInSec[(m_currentFrameNumber + kBeginFrameHistorySize - 1) % kBeginFrameHistorySize] -

                             m_beginTimeHistoryInSec[(m_currentFrameNumber + kBeginFrameHistorySize - 2) % kBeginFrameHistorySize];

    // Filter the frame times to avoid spikes.

    const float alpha = 0.1;

    if (!m_filteredFrameTime) {

        if (m_currentFrameNumber == 2)

            m_filteredFrameTime = secForLastFrame;

    } else

        m_filteredFrameTime = ((1.0 - alpha) * m_filteredFrameTime) + (alpha * secForLastFrame);

    double secForLastFrame = m_beginTimeHistoryInSec[FRAME_INDEX(m_currentFrameNumber - 1)] -

                             m_beginTimeHistoryInSec[FRAME_INDEX(m_currentFrameNumber - 2)];

    double secForThirdLastFrame = m_beginTimeHistoryInSec[FRAME_INDEX(m_currentFrameNumber - 3)] -

                                  m_beginTimeHistoryInSec[FRAME_INDEX(m_currentFrameNumber - 4)];

    // Filter the frame times to avoid spikes. Specifically, keep a running

    // average frame rate and a running variance while ignoring bad frames

    // which are either too slow or too fast. Slow frames occur just because

    // the user is inactive, and should be ignored. Fast frames are ignored if

    // the scheduler is not active in order to represent the true frame rate in

    // spite of the fact that the first few swapbuffers happen instantly which

    // skews the statistics too much for short lived animations.

    if (secForThirdLastFrame > kIdleSecondsTriggersReset || m_averageFPSCount > kLongAnimationTriggersReset) {

        // restart the frame statistics

        m_averageFPS = 0;

        m_averageFPSCount = 0;

        m_varianceNumerator = 0;

    } else if (!isBadFrame(m_currentFrameNumber - 1)) {

        m_averageFPSCount++;

        double x = 1.0 / secForLastFrame;

        double deltaFromAverage = x - m_averageFPS;

        // Change with caution - numerics. http://en.wikipedia.org/wiki/Standard_deviation

        m_averageFPS = m_averageFPS + deltaFromAverage / m_averageFPSCount;

        m_varianceNumerator = m_varianceNumerator + deltaFromAverage * (x - m_averageFPS);

    }

202232

203233 // Create & measure FPS text.

    String text(String::format("FPS: %5.1f", 1.0 / m_filteredFrameTime));

    TextRun run(text);

    float textWidth = m_mediumFont->width(run) + 2.0f;

    double stdDeviation = sqrt(m_varianceNumerator / m_averageFPSCount);

    String fps(String::format("FPS: %4.1f +/-%3.1f", m_averageFPS, stdDeviation));

    TextRun text(fps);

    float textWidth = m_mediumFont->width(text) + 2.0f;

    float graphWidth = kBeginFrameHistorySize;

    // Draw background.

    ctx->setFillColor(Color(0, 0, 0, 255), ColorSpaceDeviceRGB);

211 ctx->fillRect(FloatRect(2, top, textWidth + graphWidth, height));

    double fontHeight = m_mediumFont->fontMetrics().floatHeight() + 2;

    ctx->fillRect(FloatRect(2, top, textWidth, fontHeight));

    ctx->fillRect(FloatRect(2 + textWidth, top, graphWidth, height));

212245

213246 // Draw FPS text.

    if (m_filteredFrameTime) {

        ctx->setFillColor(Color(255, 0, 0), ColorSpaceDeviceRGB);

        ctx->drawText(*m_mediumFont, run, IntPoint(3, top + height - 6));

    }

247 ctx->setFillColor(Color(200, 200, 200), ColorSpaceDeviceRGB);

248 ctx->drawText(*m_mediumFont, text, IntPoint(3, top + fontHeight - 4));

    // Draw FPS graph.

    const double loFPS = 0.0;

221 const double hiFPS = 120.0;

252 const double hiFPS = 80.0;

222253 ctx->setStrokeStyle(SolidStroke);

    ctx->setFillColor(Color(154, 205, 50), ColorSpaceDeviceRGB);

    ctx->fillRect(FloatRect(2 + textWidth, top, graphWidth, height / 2));

    ctx->setFillColor(Color(255, 250, 205), ColorSpaceDeviceRGB);

    ctx->fillRect(FloatRect(2 + textWidth, top + height / 2, graphWidth, height / 2));

223258 ctx->setStrokeColor(Color(255, 0, 0), ColorSpaceDeviceRGB);

259 ctx->setFillColor(Color(255, 0, 0), ColorSpaceDeviceRGB);

    int graphLeft = static_cast<int>(textWidth + 3);

    IntPoint prev(-1, 0);

    int x = 0;

@@void CCHeadsUpDisplay::drawFPSCounter(GraphicsContext* ctx, int top, int height)

    for (int i = m_currentFrameNumber % kBeginFrameHistorySize; i != (m_currentFrameNumber - 1) % kBeginFrameHistorySize; i = (i + 1) % kBeginFrameHistorySize) {

        int j = (i + 1) % kBeginFrameHistorySize;

        double fps = 1.0 / (m_beginTimeHistoryInSec[j] - m_beginTimeHistoryInSec[i]);

        double p = 1 - ((fps - loFPS) / (hiFPS - loFPS));

        if (p < 0)

            p = 0;

        if (p > 1)

            p = 1;

        IntPoint cur(graphLeft + x, 1 + top + p*h);

        if (prev.x() != -1)

            ctx->drawLine(prev, cur);

        prev = cur;

        if (!isBadFrame(j)) {

            double p = 1 - ((fps - loFPS) / (hiFPS - loFPS));

            if (p < 0)

                p = 0;

            if (p > 1)

                p = 1;

            IntPoint cur(graphLeft + x, 1 + top + p*h);

            if (prev.x() != -1)

                ctx->drawLine(prev, cur);

            prev = cur;

        }

        x += 1;

    }

}

Source/WebCore/ChangeLog

Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp

Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.h