AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Expand VisualBench to a real benching tool

Browse Source 
BUG=skia:

Review URL: https://codereview.chromium.org/1159213002
This commit is contained in:
joshualitt 2015-06-01 10:03:54 -07:00 committed by Commit bot
parent 038b01c081
commit 7fe8ee4cb7
6 changed files with 152 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gyp/visualbench.gyp
View File

@ -11,6 +11,7 @@
'mac_bundle' : 1,
'include_dirs' : [
'../include/gpu',
'../src/core',
'../src/images',
],
'sources': [
@ -22,6 +23,7 @@
'flags.gyp:flags_common',
'images.gyp:images',
'skia_lib.gyp:skia_lib',
'tools.gyp:proc_stats',
'tools.gyp:timer',
'views.gyp:views',
],

5
include/views/SkOSWindow_Unix.h
View File

@ -48,6 +48,7 @@ public:
void setFullscreen(bool) override;
void setVsync(bool) override;
void closeWindow() override;
protected:
// Overridden from from SkWindow:
@ -64,7 +65,9 @@ private:
void doPaint();
void mapWindowAndWait();
void closeWindow();
// Forcefully closes the window. If a graceful shutdown is desired then call the public
// closeWindow method
void internalCloseWindow();
void initWindow(int newMSAASampleCount, AttachmentInfo* info);
SkUnixWindow fUnixWindow;

1
include/views/SkWindow.h
View File

@ -82,6 +82,7 @@ public:
virtual void setFullscreen(bool) {}
virtual void setVsync(bool) {}
virtual void closeWindow() {}
protected:
virtual bool onEvent(const SkEvent&);

27
src/views/unix/SkOSWindow_Unix.cpp
View File

@ -42,10 +42,10 @@ SkOSWindow::SkOSWindow(void*)
}
SkOSWindow::~SkOSWindow() {
this->closeWindow();
this->internalCloseWindow();
}
void SkOSWindow::closeWindow() {
void SkOSWindow::internalCloseWindow() {
if (fUnixWindow.fDisplay) {
this->detach();
SkASSERT(fUnixWindow.fGc);
@ -61,7 +61,7 @@ void SkOSWindow::closeWindow() {
void SkOSWindow::initWindow(int requestedMSAASampleCount, AttachmentInfo* info) {
if (fMSAASampleCount != requestedMSAASampleCount) {
this->closeWindow();
this->internalCloseWindow();
}
// presence of fDisplay means we already have a window
if (fUnixWindow.fDisplay) {
@ -461,7 +461,6 @@ void SkOSWindow::setFullscreen(bool setFullscreen) {
if (NULL == dsp) {
return;
}
Window win = fUnixWindow.fWin;
// Full screen
Atom wm_state = XInternAtom(dsp, "_NET_WM_STATE", False);
@ -470,7 +469,7 @@ void SkOSWindow::setFullscreen(bool setFullscreen) {
XEvent evt;
sk_bzero(&evt, sizeof(evt));
evt.type = ClientMessage;
evt.xclient.window = win;
evt.xclient.window = fUnixWindow.fWin;
evt.xclient.message_type = wm_state;
evt.xclient.format = 32;
evt.xclient.data.l[0] = setFullscreen ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
@ -488,6 +487,24 @@ void SkOSWindow::setVsync(bool vsync) {
}
}
void SkOSWindow::closeWindow() {
Display* dsp = fUnixWindow.fDisplay;
if (NULL == dsp) {
return;
}
XEvent evt;
sk_bzero(&evt, sizeof(evt));
evt.type = ClientMessage;
evt.xclient.message_type = XInternAtom(dsp, "WM_PROTOCOLS", true);
evt.xclient.window = fUnixWindow.fWin;
evt.xclient.format = 32;
evt.xclient.data.l[0] = XInternAtom(dsp, "WM_DELETE_WINDOW", false);
evt.xclient.data.l[1] = CurrentTime;
XSendEvent(dsp, fUnixWindow.fWin, false, NoEventMask, &evt);
}
///////////////////////////////////////////////////////////////////////////////
void SkEvent::SignalNonEmptyQueue() {

122
tools/VisualBench.cpp
View File

@ -8,6 +8,7 @@
#include "VisualBench.h"
#include "ProcStats.h"
#include "SkApplication.h"
#include "SkCanvas.h"
#include "SkCommandLineFlags.h"
@ -18,35 +19,49 @@
#include "SkImageDecoder.h"
#include "SkOSFile.h"
#include "SkStream.h"
#include "Timer.h"
#include "Stats.h"
#include "gl/GrGLInterface.h"
__SK_FORCE_IMAGE_DECODER_LINKING;
DEFINE_int32(gpuFrameLag, 5, "Overestimate of maximum number of frames GPU allows to lag.");
DEFINE_int32(samples, 10, "Number of times to render each skp.");
DEFINE_int32(loops, 5, "Number of times to time.");
DEFINE_int32(msaa, 0, "Number of msaa samples.");
static SkString humanize(double ms) {
if (FLAGS_verbose) {
return SkStringPrintf("%llu", (uint64_t)(ms*1e6));
}
return HumanizeMs(ms);
}
#define HUMANIZE(time) humanize(time).c_str()
VisualBench::VisualBench(void* hwnd, int argc, char** argv)
: INHERITED(hwnd)
, fCurrentLoops(1)
, fLoop(0)
, fCurrentPicture(0)
, fCurrentFrame(0) {
, fCurrentSample(0)
, fState(kPreWarm_State) {
SkCommandLineFlags::Parse(argc, argv);
// load all SKPs
SkTArray<SkString> skps;
for (int i = 0; i < FLAGS_skps.count(); i++) {
if (SkStrEndsWith(FLAGS_skps[i], ".skp")) {
skps.push_back() = FLAGS_skps[i];
fTimings.push_back().fName = FLAGS_skps[i];
} else {
SkOSFile::Iter it(FLAGS_skps[i], ".skp");
SkString path;
while (it.next(&path)) {
skps.push_back() = SkOSPath::Join(FLAGS_skps[0], path.c_str());
fTimings.push_back().fName = path.c_str();
}
}
}
this->setTitle();
this->setupBackend();
// Load picture for playback
for (int i = 0; i < skps.count(); i++) {
SkFILEStream stream(skps[i].c_str());
if (stream.isValid()) {
@ -55,6 +70,13 @@ VisualBench::VisualBench(void* hwnd, int argc, char** argv)
SkDebugf("couldn't load picture at \"path\"\n", skps[i].c_str());
}
}
if (fPictures.empty()) {
SkDebugf("no valid skps found\n");
}
this->setTitle();
this->setupBackend();
}
VisualBench::~VisualBench() {
@ -79,7 +101,7 @@ bool VisualBench::setupBackend() {
this->setVisibleP(true);
this->setClipToBounds(false);
if (!this->attach(kNativeGL_BackEndType, 0 /*msaa*/, &fAttachmentInfo)) {
if (!this->attach(kNativeGL_BackEndType, FLAGS_msaa, &fAttachmentInfo)) {
SkDebugf("Not possible to create backend.\n");
INHERITED::detach();
return false;
@ -87,7 +109,11 @@ bool VisualBench::setupBackend() {
this->setFullscreen(true);
this->setVsync(false);
this->resetContext();
return true;
}
void VisualBench::resetContext() {
fInterface.reset(GrGLCreateNativeInterface());
SkASSERT(fInterface);
@ -97,26 +123,84 @@ bool VisualBench::setupBackend() {
// setup rendertargets
this->setupRenderTarget();
return true;
}
void VisualBench::setupRenderTarget() {
fRenderTarget.reset(this->renderTarget(fAttachmentInfo, fInterface, fContext));
}
void VisualBench::draw(SkCanvas* canvas) {
fCurrentFrame++;
WallTimer timer;
timer.start();
for (int i = 0; i < fCurrentLoops; i++) {
canvas->drawPicture(fPictures[fCurrentPicture]);
}
// in case we have queued drawing calls
inline void VisualBench::renderFrame(SkCanvas* canvas) {
canvas->drawPicture(fPictures[fCurrentPicture]);
fContext->flush();
INHERITED::present();
timer.end();
}
SkDebugf("%s\n", HumanizeMs(timer.fWall).c_str());
void VisualBench::printStats() {
const SkTArray<double>& measurements = fTimings[fCurrentPicture].fMeasurements;
if (FLAGS_verbose) {
for (int i = 0; i < measurements.count(); i++) {
SkDebugf("%s ", HUMANIZE(measurements[i]));
}
SkDebugf("%s\n", fTimings[fCurrentPicture].fName.c_str());
} else {
SkASSERT(measurements.count());
Stats stats(measurements.begin(), measurements.count());
const double stdDevPercent = 100 * sqrt(stats.var) / stats.mean;
SkDebugf("%4d/%-4dMB\t%s\t%s\t%s\t%s\t%.0f%%\t%s\n",
sk_tools::getCurrResidentSetSizeMB(),
sk_tools::getMaxResidentSetSizeMB(),
HUMANIZE(stats.min),
HUMANIZE(stats.median),
HUMANIZE(stats.mean),
HUMANIZE(stats.max),
stdDevPercent,
fTimings[fCurrentPicture].fName.c_str());
}
}
void VisualBench::timePicture(SkCanvas* canvas) {
this->renderFrame(canvas);
switch (fState) {
case kPreWarm_State: {
if (fCurrentSample >= FLAGS_gpuFrameLag) {
// TODO we currently time across all frames to make sure we capture all GPU work
// We should also rendering an empty SKP to get a baseline to subtract from
// our timing
fState = kTiming_State;
fCurrentSample -= FLAGS_gpuFrameLag;
fTimer.start();
} else {
fCurrentSample++;
}
break;
}
case kTiming_State: {
if (fCurrentSample >= FLAGS_samples) {
fTimer.end();
fTimings[fCurrentPicture].fMeasurements.push_back(fTimer.fWall / FLAGS_samples);
this->resetContext();
fTimer = WallTimer();
fState = kPreWarm_State;
fCurrentSample = 0;
if (fLoop++ > FLAGS_loops) {
this->printStats();
fCurrentPicture++;
fLoop = 0;
}
} else {
fCurrentSample++;
}
break;
}
}
}
void VisualBench::draw(SkCanvas* canvas) {
if (fCurrentPicture < fPictures.count()) {
this->timePicture(canvas);
} else {
this->closeWindow();
}
// Invalidate the window to force a redraw. Poor man's animation mechanism.
this->inval(NULL);

22
tools/VisualBench.h
View File

@ -13,6 +13,7 @@
#include "SkPicture.h"
#include "SkSurface.h"
#include "Timer.h"
#include "gl/SkGLContext.h"
class GrContext;
@ -38,13 +39,30 @@ protected:
private:
void setTitle();
bool setupBackend();
void resetContext();
void setupRenderTarget();
bool onHandleChar(SkUnichar unichar) override;
void printStats();
inline void timePicture(SkCanvas*);
inline void renderFrame(SkCanvas*);
int fCurrentLoops;
struct Timing {
SkString fName;
SkTArray<double> fMeasurements;
};
enum State {
kPreWarm_State,
kTiming_State,
};
int fLoop;
int fCurrentPicture;
int fCurrentFrame;
int fCurrentSample;
SkTArray<Timing> fTimings;
SkTArray<SkPicture*> fPictures;
WallTimer fTimer;
State fState;
// support framework
SkAutoTUnref<SkSurface> fSurface;