#include "SkStream.h"
#include "Stats.h"
#include "VisualLightweightBenchModule.h"
+#include "VisualInteractiveModule.h"
#include "gl/GrGLInterface.h"
DEFINE_bool2(fullscreen, f, true, "Run fullscreen.");
+DEFINE_bool2(interactive, n, false, "Run in interactive mode.");
VisualBench::VisualBench(void* hwnd, int argc, char** argv)
: INHERITED(hwnd)
, fModule(new VisualLightweightBenchModule(this)) {
SkCommandLineFlags::Parse(argc, argv);
+ if (FLAGS_interactive) {
+ fModule.reset(new VisualInteractiveModule(this));
+ }
+
this->setTitle();
this->setupBackend();
}
this->inval(nullptr);
}
+void VisualBench::clear(SkCanvas* canvas, SkColor color, int frames) {
+ canvas->clear(color);
+ for (int i = 0; i < frames - 1; ++i) {
+ canvas->flush();
+ this->present();
+ canvas->clear(color);
+ }
+}
+
void VisualBench::onSizeChange() {
this->setupRenderTarget();
}
bool VisualBench::onHandleChar(SkUnichar unichar) {
- return true;
+ static const auto kEscKey = 27;
+ if (kEscKey == unichar) {
+ this->closeWindow();
+ return true;
+ }
+
+ return fModule->onHandleChar(unichar);
}
// Externally declared entry points
--- /dev/null
+/*
+ * 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;
+}
--- /dev/null
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ */
+
+#ifndef VisualInteractiveModule_DEFINED
+#define VisualInteractiveModule_DEFINED
+
+#include "VisualModule.h"
+
+#include "ResultsWriter.h"
+#include "SkPicture.h"
+#include "Timer.h"
+#include "VisualBench.h"
+#include "VisualBenchmarkStream.h"
+
+class SkCanvas;
+
+/*
+ * This module for VisualBench is designed to display stats data dynamically
+ */
+class VisualInteractiveModule : public VisualModule {
+public:
+ // TODO get rid of backpointer
+ VisualInteractiveModule(VisualBench* owner);
+
+ void draw(SkCanvas* canvas) override;
+ bool onHandleChar(SkUnichar unichar) override;
+
+private:
+ /*
+ * The heart of visual bench is an event driven timing loop.
+ * kPreWarmLoopsPerCanvasPreDraw_State: Before we begin timing, Benchmarks have a hook to
+ * access the canvas. Then we prewarm before the autotune
+ * loops step.
+ * kPreWarmLoops_State: We prewarm the gpu before auto tuning to enter a steady
+ * work state
+ * kTuneLoops_State: Then we tune the loops of the benchmark to ensure we
+ * are doing a measurable amount of work
+ * kPreTiming_State: Because reset the context after tuning loops to ensure
+ * coherent state, we need to restart before timing
+ * kTiming_State: Finally we time the benchmark. In this case we
+ * continue running and displaying benchmark data
+ * until we quit or switch to another benchmark
+ * kAdvance_State: Advance to the next benchmark in the stream
+ */
+ enum State {
+ kPreWarmLoopsPerCanvasPreDraw_State,
+ kPreWarmLoops_State,
+ kTuneLoops_State,
+ kPreTiming_State,
+ kTiming_State,
+ kAdvance_State,
+ };
+ void setTitle();
+ bool setupBackend();
+ void setupRenderTarget();
+ void drawStats(SkCanvas*);
+ bool advanceRecordIfNecessary(SkCanvas*);
+ inline void renderFrame(SkCanvas*);
+ inline void nextState(State);
+ void perCanvasPreDraw(SkCanvas*, State);
+ void preWarm(State nextState);
+ void scaleLoops(double elapsedMs);
+ inline void tuneLoops(SkCanvas*);
+ inline void timing(SkCanvas*);
+ inline double elapsed();
+ void resetTimingState();
+ void postDraw(SkCanvas*);
+ void recordMeasurement();
+
+ static const int kMeasurementCount = 64; // should be power of 2 for fast mod
+ double fMeasurements[kMeasurementCount];
+ int fCurrentMeasurement;
+
+ int fCurrentFrame;
+ int fLoops;
+ WallTimer fTimer;
+ State fState;
+ SkAutoTDelete<VisualBenchmarkStream> fBenchmarkStream;
+ SkAutoTUnref<Benchmark> fBenchmark;
+
+ // support framework
+ SkAutoTUnref<VisualBench> fOwner;
+
+ typedef VisualModule INHERITED;
+};
+
+#endif
projects / platform / upstream / libSkiaSharp.git / commitdiff