| /* |
| * Copyright 2015 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| * |
| */ |
| |
| #include "VisualInteractiveModule.h" |
| |
| #include "ProcStats.h" |
| #include "SkApplication.h" |
| #include "SkCanvas.h" |
| #include "SkCommandLineFlags.h" |
| #include "SkForceLinking.h" |
| #include "SkGraphics.h" |
| #include "SkGr.h" |
| #include "SkImageDecoder.h" |
| #include "SkOSFile.h" |
| #include "SkStream.h" |
| #include "Stats.h" |
| #include "gl/GrGLInterface.h" |
| |
| __SK_FORCE_IMAGE_DECODER_LINKING; |
| |
| static const int kGpuFrameLag = 5; |
| static const int kFrames = 5; |
| static const double kLoopMs = 5; |
| |
| VisualInteractiveModule::VisualInteractiveModule(VisualBench* owner) |
| : fCurrentMeasurement(0) |
| , fCurrentFrame(0) |
| , fLoops(1) |
| , fState(kPreWarmLoops_State) |
| , fBenchmark(nullptr) |
| , fOwner(SkRef(owner)) { |
| fBenchmarkStream.reset(new VisualBenchmarkStream); |
| |
| memset(fMeasurements, 0, sizeof(fMeasurements)); |
| } |
| |
| inline void VisualInteractiveModule::renderFrame(SkCanvas* canvas) { |
| fBenchmark->draw(fLoops, canvas); |
| this->drawStats(canvas); |
| canvas->flush(); |
| fOwner->present(); |
| } |
| |
| void VisualInteractiveModule::drawStats(SkCanvas* canvas) { |
| static const float kPixelPerMS = 2.0f; |
| static const int kDisplayWidth = 130; |
| static const int kDisplayHeight = 100; |
| static const int kDisplayPadding = 10; |
| static const int kGraphPadding = 3; |
| static const float kBaseMS = 1000.f / 60.f; // ms/frame to hit 60 fps |
| |
| SkISize canvasSize = canvas->getDeviceSize(); |
| SkRect rect = SkRect::MakeXYWH(SkIntToScalar(canvasSize.fWidth-kDisplayWidth-kDisplayPadding), |
| SkIntToScalar(kDisplayPadding), |
| SkIntToScalar(kDisplayWidth), SkIntToScalar(kDisplayHeight)); |
| SkPaint paint; |
| canvas->clipRect(rect); |
| paint.setColor(SK_ColorBLACK); |
| canvas->drawRect(rect, paint); |
| // draw the 16ms line |
| paint.setColor(SK_ColorLTGRAY); |
| canvas->drawLine(rect.fLeft, rect.fBottom - kBaseMS*kPixelPerMS, |
| rect.fRight, rect.fBottom - kBaseMS*kPixelPerMS, paint); |
| paint.setColor(SK_ColorRED); |
| paint.setStyle(SkPaint::kStroke_Style); |
| canvas->drawRect(rect, paint); |
| |
| int x = SkScalarTruncToInt(rect.fLeft) + kGraphPadding; |
| const int xStep = 2; |
| const int startY = SkScalarTruncToInt(rect.fBottom); |
| int i = fCurrentMeasurement; |
| do { |
| int endY = startY - (int)(fMeasurements[i] * kPixelPerMS + 0.5); // round to nearest value |
| canvas->drawLine(SkIntToScalar(x), SkIntToScalar(startY), |
| SkIntToScalar(x), SkIntToScalar(endY), paint); |
| i++; |
| i &= (kMeasurementCount - 1); // fast mod |
| x += xStep; |
| } while (i != fCurrentMeasurement); |
| |
| } |
| |
| bool VisualInteractiveModule::advanceRecordIfNecessary(SkCanvas* canvas) { |
| if (fBenchmark) { |
| return true; |
| } |
| |
| fBenchmark.reset(fBenchmarkStream->next()); |
| if (!fBenchmark) { |
| return false; |
| } |
| |
| // clear both buffers |
| fOwner->clear(canvas, SK_ColorWHITE, 2); |
| |
| fBenchmark->preDraw(); |
| |
| return true; |
| } |
| |
| void VisualInteractiveModule::draw(SkCanvas* canvas) { |
| if (!this->advanceRecordIfNecessary(canvas)) { |
| SkDebugf("Exiting VisualBench successfully\n"); |
| fOwner->closeWindow(); |
| return; |
| } |
| this->renderFrame(canvas); |
| switch (fState) { |
| case kPreWarmLoopsPerCanvasPreDraw_State: { |
| this->perCanvasPreDraw(canvas, kPreWarmLoops_State); |
| break; |
| } |
| case kPreWarmLoops_State: { |
| this->preWarm(kTuneLoops_State); |
| break; |
| } |
| case kTuneLoops_State: { |
| this->tuneLoops(canvas); |
| break; |
| } |
| case kPreTiming_State: { |
| fBenchmark->perCanvasPreDraw(canvas); |
| fCurrentFrame = 0; |
| fTimer.start(); |
| fState = kTiming_State; |
| // fall to next state |
| } |
| case kTiming_State: { |
| this->timing(canvas); |
| break; |
| } |
| case kAdvance_State: { |
| this->postDraw(canvas); |
| this->nextState(kPreWarmLoopsPerCanvasPreDraw_State); |
| break; |
| } |
| } |
| } |
| |
| inline void VisualInteractiveModule::nextState(State nextState) { |
| fState = nextState; |
| } |
| |
| void VisualInteractiveModule::perCanvasPreDraw(SkCanvas* canvas, State nextState) { |
| fBenchmark->perCanvasPreDraw(canvas); |
| fCurrentFrame = 0; |
| this->nextState(nextState); |
| } |
| |
| void VisualInteractiveModule::preWarm(State nextState) { |
| if (fCurrentFrame >= kGpuFrameLag) { |
| // we currently time across all frames to make sure we capture all GPU work |
| this->nextState(nextState); |
| fCurrentFrame = 0; |
| fTimer.start(); |
| } else { |
| fCurrentFrame++; |
| } |
| } |
| |
| inline double VisualInteractiveModule::elapsed() { |
| fTimer.end(); |
| return fTimer.fWall; |
| } |
| |
| void VisualInteractiveModule::resetTimingState() { |
| fCurrentFrame = 0; |
| fTimer = WallTimer(); |
| fOwner->reset(); |
| } |
| |
| void VisualInteractiveModule::scaleLoops(double elapsedMs) { |
| // Scale back the number of loops |
| fLoops = (int)ceil(fLoops * kLoopMs / elapsedMs); |
| } |
| |
| inline void VisualInteractiveModule::tuneLoops(SkCanvas* canvas) { |
| if (1 << 30 == fLoops) { |
| // We're about to wrap. Something's wrong with the bench. |
| SkDebugf("InnerLoops wrapped\n"); |
| fLoops = 0; |
| } else { |
| double elapsedMs = this->elapsed(); |
| if (elapsedMs > kLoopMs) { |
| this->scaleLoops(elapsedMs); |
| fBenchmark->perCanvasPostDraw(canvas); |
| this->nextState(kPreTiming_State); |
| } else { |
| fLoops *= 2; |
| this->nextState(kPreWarmLoops_State); |
| } |
| this->resetTimingState(); |
| } |
| } |
| |
| void VisualInteractiveModule::recordMeasurement() { |
| double measurement = this->elapsed() / (kFrames * fLoops); |
| fMeasurements[fCurrentMeasurement++] = measurement; |
| fCurrentMeasurement &= (kMeasurementCount-1); // fast mod |
| SkASSERT(fCurrentMeasurement < kMeasurementCount); |
| } |
| |
| void VisualInteractiveModule::postDraw(SkCanvas* canvas) { |
| fBenchmark->perCanvasPostDraw(canvas); |
| fBenchmark.reset(nullptr); |
| fLoops = 1; |
| } |
| |
| inline void VisualInteractiveModule::timing(SkCanvas* canvas) { |
| if (fCurrentFrame >= kFrames) { |
| this->recordMeasurement(); |
| fTimer.start(); |
| fCurrentFrame = 0; |
| } else { |
| fCurrentFrame++; |
| } |
| } |
| |
| bool VisualInteractiveModule::onHandleChar(SkUnichar c) { |
| if (' ' == c) { |
| this->nextState(kAdvance_State); |
| } |
| |
| return true; |
| } |