skia2/bench/benchmain.cpp
robertphillips@google.com 91ee3a11ed Added second "truncated" cpu/wall timer to bench
http://codereview.appspot.com/6476064/

This CL will increase the bench baselines across the board



git-svn-id: http://skia.googlecode.com/svn/trunk@5305 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-08-28 12:18:40 +00:00

999 lines
34 KiB
C++

/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "BenchTimer.h"
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrRenderTarget.h"
#if SK_ANGLE
#include "gl/SkANGLEGLContext.h"
#endif // SK_ANGLE
#include "gl/SkNativeGLContext.h"
#include "gl/SkNullGLContext.h"
#include "gl/SkDebugGLContext.h"
#include "SkGpuDevice.h"
#endif // SK_SUPPORT_GPU
#include "SkBenchmark.h"
#include "SkCanvas.h"
#include "SkDeferredCanvas.h"
#include "SkDevice.h"
#include "SkColorPriv.h"
#include "SkGraphics.h"
#include "SkImageEncoder.h"
#include "SkNWayCanvas.h"
#include "SkPicture.h"
#include "SkStream.h"
#include "SkString.h"
template <typename T> const T& Min(const T& a, const T& b) {
return (a < b) ? a : b;
}
class SkBenchLogger {
public:
SkBenchLogger() : fFileStream(NULL) {}
~SkBenchLogger() {
if (fFileStream)
SkDELETE(fFileStream);
}
bool SetLogFile(const char file[]) {
fFileStream = SkNEW_ARGS(SkFILEWStream, (file));
return fFileStream->isValid();
}
void logError(const char msg[]) { nativeLogError(msg); }
void logError(const SkString& str) { nativeLogError(str.c_str()); }
void logProgress(const char msg[]) {
nativeLogProgress(msg);
fileWrite(msg, strlen(msg));
}
void logProgress(const SkString& str) {
nativeLogProgress(str.c_str());
fileWrite(str.c_str(), str.size());
}
private:
#ifdef SK_BUILD_FOR_ANDROID
void nativeLogError(const char msg[]) { SkDebugf("%s", msg); }
void nativeLogProgress(const char msg[]) { SkDebugf("%s", msg); }
#else
void nativeLogError(const char msg[]) { fprintf(stderr, "%s", msg); }
void nativeLogProgress(const char msg[]) { printf("%s", msg); }
#endif
void fileWrite(const char msg[], size_t size) {
if (fFileStream && fFileStream->isValid())
fFileStream->write(msg, size);
}
SkFILEWStream* fFileStream;
} logger;
///////////////////////////////////////////////////////////////////////////////
enum benchModes {
kNormal_benchModes,
kDeferred_benchModes,
kRecord_benchModes,
kPictureRecord_benchModes
};
///////////////////////////////////////////////////////////////////////////////
static void erase(SkBitmap& bm) {
if (bm.config() == SkBitmap::kA8_Config) {
bm.eraseColor(0);
} else {
bm.eraseColor(SK_ColorWHITE);
}
}
#if 0
static bool equal(const SkBitmap& bm1, const SkBitmap& bm2) {
if (bm1.width() != bm2.width() ||
bm1.height() != bm2.height() ||
bm1.config() != bm2.config()) {
return false;
}
size_t pixelBytes = bm1.width() * bm1.bytesPerPixel();
for (int y = 0; y < bm1.height(); y++) {
if (memcmp(bm1.getAddr(0, y), bm2.getAddr(0, y), pixelBytes)) {
return false;
}
}
return true;
}
#endif
class Iter {
public:
Iter(void* param) {
fBench = BenchRegistry::Head();
fParam = param;
}
SkBenchmark* next() {
if (fBench) {
BenchRegistry::Factory f = fBench->factory();
fBench = fBench->next();
return f(fParam);
}
return NULL;
}
private:
const BenchRegistry* fBench;
void* fParam;
};
class AutoPrePostDraw {
public:
AutoPrePostDraw(SkBenchmark* bench) : fBench(bench) {
fBench->preDraw();
}
~AutoPrePostDraw() {
fBench->postDraw();
}
private:
SkBenchmark* fBench;
};
static void make_filename(const char name[], SkString* path) {
path->set(name);
for (int i = 0; name[i]; i++) {
switch (name[i]) {
case '/':
case '\\':
case ' ':
case ':':
path->writable_str()[i] = '-';
break;
default:
break;
}
}
}
static void saveFile(const char name[], const char config[], const char dir[],
const SkBitmap& bm) {
SkBitmap copy;
if (!bm.copyTo(&copy, SkBitmap::kARGB_8888_Config)) {
return;
}
if (bm.config() == SkBitmap::kA8_Config) {
// turn alpha into gray-scale
size_t size = copy.getSize() >> 2;
SkPMColor* p = copy.getAddr32(0, 0);
for (size_t i = 0; i < size; i++) {
int c = (*p >> SK_A32_SHIFT) & 0xFF;
c = 255 - c;
c |= (c << 24) | (c << 16) | (c << 8);
*p++ = c | (SK_A32_MASK << SK_A32_SHIFT);
}
}
SkString str;
make_filename(name, &str);
str.appendf("_%s.png", config);
str.prepend(dir);
::remove(str.c_str());
SkImageEncoder::EncodeFile(str.c_str(), copy, SkImageEncoder::kPNG_Type,
100);
}
static void performClip(SkCanvas* canvas, int w, int h) {
SkRect r;
r.set(SkIntToScalar(10), SkIntToScalar(10),
SkIntToScalar(w*2/3), SkIntToScalar(h*2/3));
canvas->clipRect(r, SkRegion::kIntersect_Op);
r.set(SkIntToScalar(w/3), SkIntToScalar(h/3),
SkIntToScalar(w-10), SkIntToScalar(h-10));
canvas->clipRect(r, SkRegion::kXOR_Op);
}
static void performRotate(SkCanvas* canvas, int w, int h) {
const SkScalar x = SkIntToScalar(w) / 2;
const SkScalar y = SkIntToScalar(h) / 2;
canvas->translate(x, y);
canvas->rotate(SkIntToScalar(35));
canvas->translate(-x, -y);
}
static void performScale(SkCanvas* canvas, int w, int h) {
const SkScalar x = SkIntToScalar(w) / 2;
const SkScalar y = SkIntToScalar(h) / 2;
canvas->translate(x, y);
// just enough so we can't take the sprite case
canvas->scale(SK_Scalar1 * 99/100, SK_Scalar1 * 99/100);
canvas->translate(-x, -y);
}
static bool parse_bool_arg(char * const* argv, char* const* stop, bool* var) {
if (argv < stop) {
*var = atoi(*argv) != 0;
return true;
}
return false;
}
enum Backend {
kRaster_Backend,
kGPU_Backend,
kPDF_Backend,
};
#if SK_SUPPORT_GPU
class GLHelper {
public:
GLHelper() {
}
bool init(SkGLContext* glCtx, int width, int height) {
GrContext* grCtx;
if (!glCtx->init(width, height)) {
return false;
}
GrPlatform3DContext ctx =
reinterpret_cast<GrPlatform3DContext>(glCtx->gl());
grCtx = GrContext::Create(kOpenGL_Shaders_GrEngine, ctx);
if (NULL != grCtx) {
GrPlatformRenderTargetDesc desc;
desc.fConfig = kSkia8888_PM_GrPixelConfig;
desc.fWidth = width;
desc.fHeight = height;
desc.fStencilBits = 8;
desc.fRenderTargetHandle = glCtx->getFBOID();
GrRenderTarget* rt = grCtx->createPlatformRenderTarget(desc);
if (NULL == rt) {
grCtx->unref();
return false;
}
glCtx->ref();
fGLContext.reset(glCtx);
fGrContext.reset(grCtx);
fRenderTarget.reset(rt);
}
return true;
}
void cleanup() {
fGLContext.reset(NULL);
fGrContext.reset(NULL);
fRenderTarget.reset(NULL);
}
bool isValid() {
return NULL != fGLContext.get();
}
SkGLContext* glContext() {
return fGLContext.get();
}
GrRenderTarget* renderTarget() {
return fRenderTarget.get();
}
GrContext* grContext() {
return fGrContext.get();
}
private:
SkAutoTUnref<SkGLContext> fGLContext;
SkAutoTUnref<GrContext> fGrContext;
SkAutoTUnref<GrRenderTarget> fRenderTarget;
};
static GLHelper gRealGLHelper;
static GLHelper gNullGLHelper;
static GLHelper gDebugGLHelper;
#if SK_ANGLE
static GLHelper gANGLEGLHelper;
#endif // SK_ANGLE
#else // !SK_SUPPORT_GPU
class GLHelper;
class SkGLContext;
#endif // !SK_SUPPORT_GPU
static SkDevice* make_device(SkBitmap::Config config, const SkIPoint& size,
Backend backend, GLHelper* glHelper) {
SkDevice* device = NULL;
SkBitmap bitmap;
bitmap.setConfig(config, size.fX, size.fY);
switch (backend) {
case kRaster_Backend:
bitmap.allocPixels();
erase(bitmap);
device = new SkDevice(bitmap);
break;
#if SK_SUPPORT_GPU
case kGPU_Backend:
device = new SkGpuDevice(glHelper->grContext(),
glHelper->renderTarget());
break;
#endif
case kPDF_Backend:
default:
SkASSERT(!"unsupported");
}
return device;
}
static const struct {
SkBitmap::Config fConfig;
const char* fName;
Backend fBackend;
GLHelper* fGLHelper;
} gConfigs[] = {
{ SkBitmap::kARGB_8888_Config, "8888", kRaster_Backend, NULL },
{ SkBitmap::kRGB_565_Config, "565", kRaster_Backend, NULL },
#if SK_SUPPORT_GPU
{ SkBitmap::kARGB_8888_Config, "GPU", kGPU_Backend, &gRealGLHelper },
#if SK_ANGLE
{ SkBitmap::kARGB_8888_Config, "ANGLE", kGPU_Backend, &gANGLEGLHelper },
#endif // SK_ANGLE
#ifdef SK_DEBUG
{ SkBitmap::kARGB_8888_Config, "Debug", kGPU_Backend, &gDebugGLHelper },
#endif // SK_DEBUG
{ SkBitmap::kARGB_8888_Config, "NULLGPU", kGPU_Backend, &gNullGLHelper },
#endif // SK_SUPPORT_GPU
};
static int findConfig(const char config[]) {
for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); i++) {
if (!strcmp(config, gConfigs[i].fName)) {
return i;
}
}
return -1;
}
static void determine_gpu_context_size(SkTDict<const char*>& defineDict,
int* contextWidth,
int* contextHeight) {
Iter iter(&defineDict);
SkBenchmark* bench;
while ((bench = iter.next()) != NULL) {
SkIPoint dim = bench->getSize();
if (*contextWidth < dim.fX) {
*contextWidth = dim.fX;
}
if (*contextHeight < dim.fY) {
*contextHeight = dim.fY;
}
bench->unref();
}
}
static bool skip_name(const SkTDArray<const char*> array, const char name[]) {
if (0 == array.count()) {
// no names, so don't skip anything
return false;
}
for (int i = 0; i < array.count(); ++i) {
if (strstr(name, array[i])) {
// found the name, so don't skip
return false;
}
}
return true;
}
static void help() {
SkDebugf("Usage: bench [-o outDir] [-repeat nr] [-logPerIter 1|0] "
"[-timers [wcgWC]*] [-rotate]\n"
" [-scale] [-clip] [-min] [-forceAA 1|0] [-forceFilter 1|0]\n"
" [-forceDither 1|0] [-forceBlend 1|0] [-strokeWidth width]\n"
" [-match name] [-mode normal|deferred|record|picturerecord]\n"
" [-config 8888|565|GPU|ANGLE|NULLGPU] [-Dfoo bar]\n"
" [-h|--help]");
SkDebugf("\n\n");
SkDebugf(" -o outDir : Image of each bench will be put in outDir.\n");
SkDebugf(" -repeat nr : Each bench repeats for nr times.\n");
SkDebugf(" -logPerIter 1|0 : "
"Log each repeat timer instead of mean, default is disabled.\n");
SkDebugf(" -timers [wcgWC]* : "
"Display wall, cpu, gpu, truncated wall or truncated cpu time for each bench.\n");
SkDebugf(" -rotate : Rotate before each bench runs.\n");
SkDebugf(" -scale : Scale before each bench runs.\n");
SkDebugf(" -clip : Clip before each bench runs.\n");
SkDebugf(" -min : Print the minimum times (instead of average).\n");
SkDebugf(" -forceAA 1|0 : "
"Enable/disable anti-aliased, default is enabled.\n");
SkDebugf(" -forceFilter 1|0 : "
"Enable/disable bitmap filtering, default is disabled.\n");
SkDebugf(" -forceDither 1|0 : "
"Enable/disable dithering, default is disabled.\n");
SkDebugf(" -forceBlend 1|0 : "
"Enable/disable dithering, default is disabled.\n");
SkDebugf(" -strokeWidth width : The width for path stroke.\n");
SkDebugf(" -match name : Only run bench whose name is matched.\n");
SkDebugf(" -mode normal|deferred|record|picturerecord : Run in the corresponding mode\n"
" normal, Use a normal canvas to draw to;\n"
" deferred, Use a deferrred canvas when drawing;\n"
" record, Benchmark the time to record to an SkPicture;\n"
" picturerecord, Benchmark the time to do record from a \n"
" SkPicture to a SkPicture.\n");
SkDebugf(" -logFile : destination for writing log output, in addition to stdout.\n");
#if SK_SUPPORT_GPU
SkDebugf(" -config 8888|565|GPU|ANGLE|NULLGPU : "
"Run bench in corresponding config mode.\n");
#else
SkDebugf(" -config 8888|565: "
"Run bench in corresponding config mode.\n");
#endif
SkDebugf(" -Dfoo bar : Add extra definition to bench.\n");
SkDebugf(" -h|--help : Show this help message.\n");
}
int main (int argc, char * const argv[]) {
#ifdef SK_ENABLE_INST_COUNT
gPrintInstCount = true;
#endif
SkAutoGraphics ag;
SkTDict<const char*> defineDict(1024);
int repeatDraw = 1;
bool logPerIter = false;
int forceAlpha = 0xFF;
bool forceAA = true;
bool forceFilter = false;
SkTriState::State forceDither = SkTriState::kDefault;
bool timerWall = false;
bool truncatedTimerWall = false;
bool timerCpu = true;
bool truncatedTimerCpu = false;
bool timerGpu = true;
bool doScale = false;
bool doRotate = false;
bool doClip = false;
bool printMin = false;
bool hasStrokeWidth = false;
float strokeWidth;
SkTDArray<const char*> fMatches;
benchModes benchMode = kNormal_benchModes;
SkString perIterTimeformat("%.2f");
SkString normalTimeFormat("%6.2f");
SkString outDir;
SkBitmap::Config outConfig = SkBitmap::kNo_Config;
GLHelper* glHelper = NULL;
const char* configName = "";
Backend backend = kRaster_Backend; // for warning
SkTDArray<int> configs;
bool userConfig = false;
char* const* stop = argv + argc;
for (++argv; argv < stop; ++argv) {
if (strcmp(*argv, "-o") == 0) {
argv++;
if (argv < stop && **argv) {
outDir.set(*argv);
if (outDir.c_str()[outDir.size() - 1] != '/') {
outDir.append("/");
}
}
} else if (strcmp(*argv, "-repeat") == 0) {
argv++;
if (argv < stop) {
repeatDraw = atoi(*argv);
if (repeatDraw < 1) {
repeatDraw = 1;
}
} else {
logger.logError("missing arg for -repeat\n");
help();
return -1;
}
} else if (strcmp(*argv, "-logPerIter") == 0) {
if (!parse_bool_arg(++argv, stop, &logPerIter)) {
logger.logError("missing arg for -logPerIter\n");
help();
return -1;
}
} else if (strcmp(*argv, "-timers") == 0) {
argv++;
if (argv < stop) {
timerWall = false;
truncatedTimerWall = false;
timerCpu = false;
truncatedTimerCpu = false;
timerGpu = false;
for (char* t = *argv; *t; ++t) {
switch (*t) {
case 'w': timerWall = true; break;
case 'c': timerCpu = true; break;
case 'W': truncatedTimerWall = true; break;
case 'C': truncatedTimerCpu = true; break;
case 'g': timerGpu = true; break;
}
}
} else {
logger.logError("missing arg for -timers\n");
help();
return -1;
}
} else if (!strcmp(*argv, "-rotate")) {
doRotate = true;
} else if (!strcmp(*argv, "-scale")) {
doScale = true;
} else if (!strcmp(*argv, "-clip")) {
doClip = true;
} else if (!strcmp(*argv, "-min")) {
printMin = true;
} else if (strcmp(*argv, "-forceAA") == 0) {
if (!parse_bool_arg(++argv, stop, &forceAA)) {
logger.logError("missing arg for -forceAA\n");
help();
return -1;
}
} else if (strcmp(*argv, "-forceFilter") == 0) {
if (!parse_bool_arg(++argv, stop, &forceFilter)) {
logger.logError("missing arg for -forceFilter\n");
help();
return -1;
}
} else if (strcmp(*argv, "-forceDither") == 0) {
bool tmp;
if (!parse_bool_arg(++argv, stop, &tmp)) {
logger.logError("missing arg for -forceDither\n");
help();
return -1;
}
forceDither = tmp ? SkTriState::kTrue : SkTriState::kFalse;
} else if (strcmp(*argv, "-forceBlend") == 0) {
bool wantAlpha = false;
if (!parse_bool_arg(++argv, stop, &wantAlpha)) {
logger.logError("missing arg for -forceBlend\n");
help();
return -1;
}
forceAlpha = wantAlpha ? 0x80 : 0xFF;
} else if (strcmp(*argv, "-mode") == 0) {
argv++;
if (argv < stop) {
if (strcmp(*argv, "normal") == 0) {
benchMode = kNormal_benchModes;
} else if (strcmp(*argv, "deferred") == 0) {
benchMode = kDeferred_benchModes;
} else if (strcmp(*argv, "record") == 0) {
benchMode = kRecord_benchModes;
} else if (strcmp(*argv, "picturerecord") == 0) {
benchMode = kPictureRecord_benchModes;
} else {
logger.logError("bad arg for -mode\n");
help();
return -1;
}
} else {
logger.logError("missing arg for -mode\n");
help();
return -1;
}
} else if (strcmp(*argv, "-strokeWidth") == 0) {
argv++;
if (argv < stop) {
const char *strokeWidthStr = *argv;
if (sscanf(strokeWidthStr, "%f", &strokeWidth) != 1) {
logger.logError("bad arg for -strokeWidth\n");
help();
return -1;
}
hasStrokeWidth = true;
} else {
logger.logError("missing arg for -strokeWidth\n");
help();
return -1;
}
} else if (strcmp(*argv, "-match") == 0) {
argv++;
if (argv < stop) {
*fMatches.append() = *argv;
} else {
logger.logError("missing arg for -match\n");
help();
return -1;
}
} else if (strcmp(*argv, "-config") == 0) {
argv++;
if (argv < stop) {
int index = findConfig(*argv);
if (index >= 0) {
*configs.append() = index;
userConfig = true;
} else {
SkString str;
str.printf("unrecognized config %s\n", *argv);
logger.logError(str);
help();
return -1;
}
} else {
logger.logError("missing arg for -config\n");
help();
return -1;
}
} else if (strcmp(*argv, "-logFile") == 0) {
argv++;
if (argv < stop) {
if (!logger.SetLogFile(*argv)) {
SkString str;
str.printf("Could not open %s for writing.", *argv);
return -1;
}
} else {
logger.logError("missing arg for -logFile\n");
help();
return -1;
}
} else if (strlen(*argv) > 2 && strncmp(*argv, "-D", 2) == 0) {
argv++;
if (argv < stop) {
defineDict.set(argv[-1] + 2, *argv);
} else {
logger.logError("incomplete '-Dfoo bar' definition\n");
help();
return -1;
}
} else if (strcmp(*argv, "--help") == 0 || strcmp(*argv, "-h") == 0) {
help();
return 0;
} else {
SkString str;
str.printf("unrecognized arg %s\n", *argv);
logger.logError(str);
help();
return -1;
}
}
if ((benchMode == kRecord_benchModes || benchMode == kPictureRecord_benchModes)
&& !outDir.isEmpty()) {
logger.logError("'-mode record' and '-mode picturerecord' are not"
" compatible with -o.\n");
return -1;
}
if ((benchMode == kRecord_benchModes || benchMode == kPictureRecord_benchModes)) {
perIterTimeformat.set("%.4f");
normalTimeFormat.set("%6.4f");
}
if (!userConfig) {
// if no config is specified by user, we add them all.
for (unsigned int i = 0; i < SK_ARRAY_COUNT(gConfigs); ++i) {
*configs.append() = i;
}
}
// report our current settings
{
SkString str;
str.printf("skia bench: alpha=0x%02X antialias=%d filter=%d "
"deferred=%d logperiter=%d",
forceAlpha, forceAA, forceFilter, benchMode == kDeferred_benchModes,
logPerIter);
str.appendf(" rotate=%d scale=%d clip=%d min=%d",
doRotate, doScale, doClip, printMin);
str.appendf(" record=%d picturerecord=%d",
benchMode == kRecord_benchModes,
benchMode == kPictureRecord_benchModes);
const char * ditherName;
switch (forceDither) {
case SkTriState::kDefault: ditherName = "default"; break;
case SkTriState::kTrue: ditherName = "true"; break;
case SkTriState::kFalse: ditherName = "false"; break;
default: ditherName = "<invalid>"; break;
}
str.appendf(" dither=%s", ditherName);
if (hasStrokeWidth) {
str.appendf(" strokeWidth=%f", strokeWidth);
} else {
str.append(" strokeWidth=none");
}
#if defined(SK_SCALAR_IS_FLOAT)
str.append(" scalar=float");
#elif defined(SK_SCALAR_IS_FIXED)
str.append(" scalar=fixed");
#endif
#if defined(SK_BUILD_FOR_WIN32)
str.append(" system=WIN32");
#elif defined(SK_BUILD_FOR_MAC)
str.append(" system=MAC");
#elif defined(SK_BUILD_FOR_ANDROID)
str.append(" system=ANDROID");
#elif defined(SK_BUILD_FOR_UNIX)
str.append(" system=UNIX");
#else
str.append(" system=other");
#endif
#if defined(SK_DEBUG)
str.append(" DEBUG");
#endif
str.append("\n");
logger.logProgress(str);
}
SkGLContext* timerCtx = NULL;
//Don't do GL when fixed.
#if !defined(SK_SCALAR_IS_FIXED) && SK_SUPPORT_GPU
int contextWidth = 1024;
int contextHeight = 1024;
determine_gpu_context_size(defineDict, &contextWidth, &contextHeight);
SkAutoTUnref<SkGLContext> realGLCtx(new SkNativeGLContext);
SkAutoTUnref<SkGLContext> nullGLCtx(new SkNullGLContext);
SkAutoTUnref<SkGLContext> debugGLCtx(new SkDebugGLContext);
gRealGLHelper.init(realGLCtx.get(), contextWidth, contextHeight);
gNullGLHelper.init(nullGLCtx.get(), contextWidth, contextHeight);
gDebugGLHelper.init(debugGLCtx.get(), contextWidth, contextHeight);
#if SK_ANGLE
SkAutoTUnref<SkGLContext> angleGLCtx(new SkANGLEGLContext);
gANGLEGLHelper.init(angleGLCtx.get(), contextWidth, contextHeight);
#endif // SK_ANGLE
timerCtx = gRealGLHelper.glContext();
#endif // !defined(SK_SCALAR_IS_FIXED) && SK_SUPPORT_GPU
BenchTimer timer = BenchTimer(timerCtx);
Iter iter(&defineDict);
SkBenchmark* bench;
while ((bench = iter.next()) != NULL) {
SkAutoTUnref<SkBenchmark> benchUnref(bench);
SkIPoint dim = bench->getSize();
if (dim.fX <= 0 || dim.fY <= 0) {
continue;
}
bench->setForceAlpha(forceAlpha);
bench->setForceAA(forceAA);
bench->setForceFilter(forceFilter);
bench->setDither(forceDither);
if (hasStrokeWidth) {
bench->setStrokeWidth(strokeWidth);
}
// only run benchmarks if their name contains matchStr
if (skip_name(fMatches, bench->getName())) {
continue;
}
{
SkString str;
str.printf("running bench [%d %d] %28s", dim.fX, dim.fY,
bench->getName());
logger.logProgress(str);
}
AutoPrePostDraw appd(bench);
for (int x = 0; x < configs.count(); ++x) {
int configIndex = configs[x];
outConfig = gConfigs[configIndex].fConfig;
configName = gConfigs[configIndex].fName;
backend = gConfigs[configIndex].fBackend;
glHelper = gConfigs[configIndex].fGLHelper;
#if SK_SUPPORT_GPU
if (kGPU_Backend == backend &&
(NULL == glHelper || !glHelper->isValid())) {
continue;
}
#endif
SkDevice* device = make_device(outConfig, dim, backend, glHelper);
SkCanvas* canvas = NULL;
SkPicture pictureRecordFrom;
SkPicture pictureRecordTo;
switch(benchMode) {
case kDeferred_benchModes:
canvas = new SkDeferredCanvas(device);
break;
case kRecord_benchModes:
canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY);
canvas->ref();
break;
case kPictureRecord_benchModes: {
// This sets up picture-to-picture recording.
// The C++ drawing calls for the benchmark are recorded into
// pictureRecordFrom. As the benchmark, we will time how
// long it takes to playback pictureRecordFrom into
// pictureRecordTo.
SkCanvas* tempCanvas = pictureRecordFrom.beginRecording(dim.fX, dim.fY);
bench->draw(tempCanvas);
pictureRecordFrom.endRecording();
canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY);
canvas->ref();
break;
}
case kNormal_benchModes:
canvas = new SkCanvas(device);
break;
default:
SkASSERT(0);
}
device->unref();
SkAutoUnref canvasUnref(canvas);
if (doClip) {
performClip(canvas, dim.fX, dim.fY);
}
if (doScale) {
performScale(canvas, dim.fX, dim.fY);
}
if (doRotate) {
performRotate(canvas, dim.fX, dim.fY);
}
// warm up caches if needed
if (repeatDraw > 1) {
#if SK_SUPPORT_GPU
if (glHelper) {
// purge the GPU resources to reduce variance
glHelper->grContext()->freeGpuResources();
}
#endif
SkAutoCanvasRestore acr(canvas, true);
if (benchMode == kPictureRecord_benchModes) {
pictureRecordFrom.draw(canvas);
} else {
bench->draw(canvas);
}
canvas->flush();
#if SK_SUPPORT_GPU
if (glHelper) {
glHelper->grContext()->flush();
SK_GL(*glHelper->glContext(), Finish());
}
#endif
}
// record timer values for each repeat, and their sum
SkString fWallStr(" msecs = ");
SkString fTruncatedWallStr(" Wmsecs = ");
SkString fCpuStr(" cmsecs = ");
SkString fTruncatedCpuStr(" Cmsecs = ");
SkString fGpuStr(" gmsecs = ");
double fWallSum = 0.0, fWallMin;
double fTruncatedWallSum = 0.0, fTruncatedWallMin;
double fCpuSum = 0.0, fCpuMin;
double fTruncatedCpuSum = 0.0, fTruncatedCpuMin;
double fGpuSum = 0.0, fGpuMin;
for (int i = 0; i < repeatDraw; i++) {
if ((benchMode == kRecord_benchModes
|| benchMode == kPictureRecord_benchModes)) {
// This will clear the recorded commands so that they do not
// acculmulate.
canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY);
}
timer.start();
SkAutoCanvasRestore acr(canvas, true);
if (benchMode == kPictureRecord_benchModes) {
pictureRecordFrom.draw(canvas);
} else {
bench->draw(canvas);
}
canvas->flush();
// stop the truncated timer after the last canvas call but
// don't wait for all the GL calls to complete
timer.truncatedEnd();
#if SK_SUPPORT_GPU
if (glHelper) {
glHelper->grContext()->flush();
SK_GL(*glHelper->glContext(), Finish());
}
#endif
// stop the inclusive and gpu timers once all the GL calls
// have completed
timer.end();
if (i == repeatDraw - 1) {
// no comma after the last value
fWallStr.appendf(perIterTimeformat.c_str(), timer.fWall);
fCpuStr.appendf(perIterTimeformat.c_str(), timer.fCpu);
fTruncatedWallStr.appendf(perIterTimeformat.c_str(), timer.fTruncatedWall);
fTruncatedCpuStr.appendf(perIterTimeformat.c_str(), timer.fTruncatedCpu);
fGpuStr.appendf(perIterTimeformat.c_str(), timer.fGpu);
} else {
fWallStr.appendf(perIterTimeformat.c_str(), timer.fWall);
fWallStr.appendf(",");
fCpuStr.appendf(perIterTimeformat.c_str(), timer.fCpu);
fCpuStr.appendf(",");
fTruncatedWallStr.appendf(perIterTimeformat.c_str(), timer.fTruncatedWall);
fTruncatedWallStr.appendf(",");
fTruncatedCpuStr.appendf(perIterTimeformat.c_str(), timer.fTruncatedCpu);
fTruncatedCpuStr.appendf(",");
fGpuStr.appendf(perIterTimeformat.c_str(), timer.fGpu);
fGpuStr.appendf(",");
}
if (0 == i) {
fWallMin = timer.fWall;
fCpuMin = timer.fCpu;
fTruncatedWallMin = timer.fTruncatedWall;
fTruncatedCpuMin = timer.fTruncatedCpu;
fGpuMin = timer.fGpu;
} else {
fWallMin = Min(fWallMin, timer.fWall);
fCpuMin = Min(fCpuMin, timer.fCpu);
fTruncatedWallMin = Min(fTruncatedWallMin, timer.fTruncatedWall);
fTruncatedCpuMin = Min(fTruncatedCpuMin, timer.fTruncatedCpu);
fGpuMin = Min(fGpuMin, timer.fGpu);
}
fWallSum += timer.fWall;
fCpuSum += timer.fCpu;
fTruncatedWallSum += timer.fTruncatedWall;
fTruncatedCpuSum += timer.fTruncatedCpu;
fGpuSum += timer.fGpu;
}
if (repeatDraw > 1) {
// output each repeat (no average) if logPerIter is set,
// otherwise output only the average
if (!logPerIter) {
fWallStr.set(" msecs = ");
fWallStr.appendf(normalTimeFormat.c_str(),
printMin ? fWallMin : fWallSum / repeatDraw);
fCpuStr.set(" cmsecs = ");
fCpuStr.appendf(normalTimeFormat.c_str(),
printMin ? fCpuMin : fCpuSum / repeatDraw);
fTruncatedWallStr.set(" Wmsecs = ");
fTruncatedWallStr.appendf(normalTimeFormat.c_str(),
printMin ? fTruncatedWallMin : fTruncatedWallSum / repeatDraw);
fTruncatedCpuStr.set(" Cmsecs = ");
fTruncatedCpuStr.appendf(normalTimeFormat.c_str(),
printMin ? fTruncatedCpuMin : fTruncatedCpuSum / repeatDraw);
fGpuStr.set(" gmsecs = ");
fGpuStr.appendf(normalTimeFormat.c_str(),
printMin ? fGpuMin : fGpuSum / repeatDraw);
}
SkString str;
str.printf(" %4s:", configName);
if (timerWall) {
str += fWallStr;
}
if (truncatedTimerWall) {
str += fTruncatedWallStr;
}
if (timerCpu) {
str += fCpuStr;
}
if (truncatedTimerCpu) {
str += fTruncatedCpuStr;
}
if (timerGpu && glHelper && fGpuSum > 0) {
str += fGpuStr;
}
logger.logProgress(str);
}
if (outDir.size() > 0) {
saveFile(bench->getName(), configName, outDir.c_str(),
device->accessBitmap(false));
}
}
logger.logProgress(SkString("\n"));
}
#if SK_SUPPORT_GPU
// need to clean up here rather than post-main to allow leak detection to work
gDebugGLHelper.cleanup();
#endif
return 0;
}