diff options
Diffstat (limited to 'bench')
40 files changed, 3116 insertions, 571 deletions
diff --git a/bench/AAClipBench.cpp b/bench/AAClipBench.cpp new file mode 100644 index 0000000..39088c1 --- /dev/null +++ b/bench/AAClipBench.cpp @@ -0,0 +1,104 @@ +/* + * 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 "SkBenchmark.h" +#include "SkAAClip.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkString.h" + +class AAClipBuilderBench : public SkBenchmark { + SkString fName; + SkPath fPath; + SkRect fRect; + SkRegion fRegion; + bool fDoPath; + bool fDoAA; + + enum { + N = SkBENCHLOOP(200), + }; + +public: + AAClipBuilderBench(void* param, bool doPath, bool doAA) : INHERITED(param) { + fDoPath = doPath; + fDoAA = doAA; + + fName.printf("aaclip_build_%s_%s", doPath ? "path" : "rect", + doAA ? "AA" : "BW"); + + fRegion.setRect(0, 0, 640, 480); + fRect.set(fRegion.getBounds()); + fRect.inset(SK_Scalar1/4, SK_Scalar1/4); + fPath.addRoundRect(fRect, SkIntToScalar(20), SkIntToScalar(20)); + } + +protected: + virtual const char* onGetName() { return fName.c_str(); } + virtual void onDraw(SkCanvas* canvas) { + SkPaint paint; + this->setupPaint(&paint); + + for (int i = 0; i < N; ++i) { + SkAAClip clip; + if (fDoPath) { + clip.setPath(fPath, &fRegion, fDoAA); + } else { + clip.setRect(fRect, fDoAA); + } + } + } +private: + typedef SkBenchmark INHERITED; +}; + +class AAClipRegionBench : public SkBenchmark { +public: + AAClipRegionBench(void* param) : INHERITED(param) { + SkPath path; + // test conversion of a complex clip to a aaclip + path.addCircle(0, 0, SkIntToScalar(200)); + path.addCircle(0, 0, SkIntToScalar(180)); + // evenodd means we've constructed basically a stroked circle + path.setFillType(SkPath::kEvenOdd_FillType); + + SkIRect bounds; + path.getBounds().roundOut(&bounds); + fRegion.setPath(path, SkRegion(bounds)); + } + +protected: + virtual const char* onGetName() { return "aaclip_setregion"; } + virtual void onDraw(SkCanvas* canvas) { + for (int i = 0; i < N; ++i) { + SkAAClip clip; + clip.setRegion(fRegion); + } + } + +private: + enum { + N = SkBENCHLOOP(400), + }; + SkRegion fRegion; + typedef SkBenchmark INHERITED; +}; + +/////////////////////////////////////////////////////////////////////////////// + +static SkBenchmark* Fact0(void* p) { return SkNEW_ARGS(AAClipBuilderBench, (p, false, false)); } +static SkBenchmark* Fact1(void* p) { return SkNEW_ARGS(AAClipBuilderBench, (p, false, true)); } +static SkBenchmark* Fact2(void* p) { return SkNEW_ARGS(AAClipBuilderBench, (p, true, false)); } +static SkBenchmark* Fact3(void* p) { return SkNEW_ARGS(AAClipBuilderBench, (p, true, true)); } + +static BenchRegistry gReg0(Fact0); +static BenchRegistry gReg1(Fact1); +static BenchRegistry gReg2(Fact2); +static BenchRegistry gReg3(Fact3); + +static SkBenchmark* Fact01(void* p) { return SkNEW_ARGS(AAClipRegionBench, (p)); } +static BenchRegistry gReg01(Fact01); diff --git a/bench/Android.mk b/bench/Android.mk index a0fe86c..ab2e588 100644 --- a/bench/Android.mk +++ b/bench/Android.mk @@ -3,36 +3,42 @@ LOCAL_PATH:= $(call my-dir) include $(CLEAR_VARS) LOCAL_SRC_FILES := \ - BenchGpuTimer_none.cpp \ - BenchSysTimer_posix.cpp \ + benchmain.cpp \ BenchTimer.cpp \ + BenchSysTimer_posix.cpp \ + BenchGpuTimer_gl.cpp \ + SkBenchmark.cpp + +LOCAL_SRC_FILES += \ + AAClipBench.cpp \ BitmapBench.cpp \ + BlurBench.cpp \ + ChromeBench.cpp \ DecodeBench.cpp \ - FPSBench.cpp \ + FontScalerBench.cpp \ GradientBench.cpp \ + MathBench.cpp \ MatrixBench.cpp \ + MutexBench.cpp \ PathBench.cpp \ RectBench.cpp \ RepeatTileBench.cpp \ + ScalarBench.cpp \ + ShaderMaskBench.cpp \ TextBench.cpp \ - SkBenchmark.cpp \ - benchmain.cpp - -# additional optional class for this tool -LOCAL_SRC_FILES += \ - ../src/utils/SkNWayCanvas.cpp \ - ../src/utils/SkParse.cpp + VertBench.cpp -LOCAL_SHARED_LIBRARIES := libcutils libskia libGLESv2 +LOCAL_SHARED_LIBRARIES := libcutils libskia libGLESv2 libEGL LOCAL_STATIC_LIBRARIES := libskiagpu LOCAL_C_INCLUDES := \ - external/skia/include/config \ external/skia/include/core \ + external/skia/include/config \ + external/skia/include/effects \ + external/skia/include/gpu \ external/skia/include/images \ external/skia/include/utils \ - external/skia/include/effects \ - external/skia/gpu/include \ - external/skia/include/gpu + external/skia/src/core \ + external/skia/src/gpu #LOCAL_CFLAGS := diff --git a/bench/BenchGpuTimer_gl.cpp b/bench/BenchGpuTimer_gl.cpp index ec2145d..885f7b2 100644 --- a/bench/BenchGpuTimer_gl.cpp +++ b/bench/BenchGpuTimer_gl.cpp @@ -1,159 +1,41 @@ -#include "BenchGpuTimer_gl.h" -#include <string.h> - -//GL -#define BENCH_GL_FUNCTION_TYPE -#if defined(SK_MESA) - #include <GL/osmesa.h> - #define SK_BENCH_CONTEXT_CHECK (NULL != OSMesaGetCurrentContext()) - - #define SK_GL_GET_PROC(F) gBenchGL.f ## F = (BenchGL ## F ## Proc) \ - OSMesaGetProcAddress("gl" #F); - #define SK_GL_GET_PROC_SUFFIX(F, S) gBenchGL.f ## F = (BenchGL##F##Proc)\ - OSMesaGetProcAddress("gl" #F #S); - -#elif defined(SK_BUILD_FOR_WIN32) - #define WIN32_LEAN_AND_MEAN 1 - #include <Windows.h> - #include <GL/GL.h> - #define SK_BENCH_CONTEXT_CHECK (NULL != wglGetCurrentContext()) - - #undef BENCH_GL_FUNCTION_TYPE - #define BENCH_GL_FUNCTION_TYPE __stdcall - #define SK_GL_GET_PROC(F) gBenchGL.f ## F = (BenchGL ## F ## Proc) \ - wglGetProcAddress("gl" #F); - #define SK_GL_GET_PROC_SUFFIX(F, S) gBenchGL.f ## F = (BenchGL##F##Proc)\ - wglGetProcAddress("gl" #F #S); - -#elif defined(SK_BUILD_FOR_MAC) - #include <OpenGL/gl.h> - #include <OpenGL/CGLCurrent.h> - #define SK_BENCH_CONTEXT_CHECK (NULL != CGLGetCurrentContext()) - -#elif defined(SK_BUILD_FOR_UNIX) - #include <GL/gl.h> - #include <GL/glx.h> - #define SK_BENCH_CONTEXT_CHECK (NULL != glXGetCurrentContext()) +/* + * 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 "BenchGpuTimer_gl.h" +#include "SkGLContext.h" + +BenchGpuTimer::BenchGpuTimer(const SkGLContext* glctx) { + fContext = glctx; + glctx->ref(); + glctx->makeCurrent(); + fStarted = false; + fSupported = GrGLGetVersion(glctx->gl()) > GR_GL_VER(3,3) || + GrGLHasExtension(glctx->gl(), "GL_ARB_timer_query") || + GrGLHasExtension(glctx->gl(), "GL_EXT_timer_query"); - #define SK_GL_GET_PROC(F) gBenchGL.f ## F = (BenchGL ## F ## Proc) \ - glXGetProcAddressARB(reinterpret_cast<const GLubyte*>("gl" #F)); - #define SK_GL_GET_PROC_SUFFIX(F, S) gBenchGL.f ## F = (BenchGL##F##Proc)\ - glXGetProcAddressARB(reinterpret_cast<const GLubyte*>("gl" #F #S)); -#else - #error unsupported platform -#endif - -#define BenchGL_TIME_ELAPSED 0x88BF -#define BenchGL_QUERY_RESULT 0x8866 -#define BenchGL_QUERY_RESULT_AVAILABLE 0x8867 - -#if defined(SK_BUILD_FOR_WIN32) -typedef UINT64 BenchGLuint64; -#else -#include <stdint.h> -typedef uint64_t BenchGLuint64; -#endif - -typedef void (BENCH_GL_FUNCTION_TYPE *BenchGLGenQueriesProc) (GLsizei n, GLuint *ids); -typedef void (BENCH_GL_FUNCTION_TYPE *BenchGLBeginQueryProc) (GLenum target, GLuint id); -typedef void (BENCH_GL_FUNCTION_TYPE *BenchGLEndQueryProc) (GLenum target); -typedef void (BENCH_GL_FUNCTION_TYPE *BenchGLDeleteQueriesProc) (GLsizei n, const GLuint *ids); -typedef void (BENCH_GL_FUNCTION_TYPE *BenchGLGetQueryObjectivProc) (GLuint id, GLenum pname, GLint *params); -typedef void (BENCH_GL_FUNCTION_TYPE *BenchGLGetQueryObjectui64vProc) (GLuint id, GLenum pname, BenchGLuint64 *params); - -struct BenchGLInterface { - bool fHasTimer; - BenchGLGenQueriesProc fGenQueries; - BenchGLBeginQueryProc fBeginQuery; - BenchGLEndQueryProc fEndQuery; - BenchGLDeleteQueriesProc fDeleteQueries; - BenchGLGetQueryObjectivProc fGetQueryObjectiv; - BenchGLGetQueryObjectui64vProc fGetQueryObjectui64v; -}; - -static bool BenchGLCheckExtension(const char* ext, - const char* extensionString) { - int extLength = strlen(ext); - - while (true) { - int n = strcspn(extensionString, " "); - if (n == extLength && 0 == strncmp(ext, extensionString, n)) { - return true; - } - if (0 == extensionString[n]) { - return false; - } - extensionString += n+1; - } - - return false; -} - -static BenchGLInterface gBenchGL; -static bool gBenchGLInterfaceInit = false; - -static void BenchGLSetDefaultGLInterface() { - gBenchGL.fHasTimer = false; - if (gBenchGLInterfaceInit || !SK_BENCH_CONTEXT_CHECK) return; - - const char* glExts = - reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)); - const GLboolean ext = - BenchGLCheckExtension("GL_EXT_timer_query", glExts); - const GLboolean arb = - BenchGLCheckExtension("GL_ARB_timer_query", glExts); - if (ext || arb) { -#if defined(SK_BUILD_FOR_MAC) - #if GL_EXT_timer_query || GL_ARB_timer_query - gBenchGL.fHasTimer = true; - gBenchGL.fGenQueries = glGenQueries; - gBenchGL.fBeginQuery = glBeginQuery; - gBenchGL.fEndQuery = glEndQuery; - gBenchGL.fDeleteQueries = glDeleteQueries; - gBenchGL.fGetQueryObjectiv = glGetQueryObjectiv; - #endif - #if GL_ARB_timer_query - gBenchGL.fGetQueryObjectui64v = glGetQueryObjectui64v; - #elif GL_EXT_timer_query - gBenchGL.fGetQueryObjectui64v = glGetQueryObjectui64vEXT; - #endif -#else - gBenchGL.fHasTimer = true; - SK_GL_GET_PROC(GenQueries) - SK_GL_GET_PROC(BeginQuery) - SK_GL_GET_PROC(EndQuery) - SK_GL_GET_PROC(DeleteQueries) - - SK_GL_GET_PROC(GetQueryObjectiv) - if (arb) { - SK_GL_GET_PROC(GetQueryObjectui64v) - } else { - SK_GL_GET_PROC_SUFFIX(GetQueryObjectui64v, EXT) - } -#endif - } - gBenchGLInterfaceInit = true; -} - -BenchGpuTimer::BenchGpuTimer() { - BenchGLSetDefaultGLInterface(); - if (gBenchGL.fHasTimer) { - gBenchGL.fGenQueries(1, &this->fQuery); + if (fSupported) { + SK_GL(*glctx, GenQueries(1, &fQuery)); } } BenchGpuTimer::~BenchGpuTimer() { - if (gBenchGL.fHasTimer) { - gBenchGL.fDeleteQueries(1, &this->fQuery); + if (fSupported) { + fContext->makeCurrent(); + SK_GL(*fContext, DeleteQueries(1, &fQuery)); } + fContext->unref(); } void BenchGpuTimer::startGpu() { - if (!gBenchGL.fHasTimer) return; - - this->fStarted = true; - gBenchGL.fBeginQuery(BenchGL_TIME_ELAPSED, this->fQuery); + if (fSupported) { + fContext->makeCurrent(); + fStarted = true; + SK_GL(*fContext, BeginQuery(GR_GL_TIME_ELAPSED, fQuery)); + } } /** @@ -161,21 +43,24 @@ void BenchGpuTimer::startGpu() { * as this will cpu wait for the gpu to finish. */ double BenchGpuTimer::endGpu() { - if (!gBenchGL.fHasTimer) return 0; - - this->fStarted = false; - gBenchGL.fEndQuery(BenchGL_TIME_ELAPSED); - - GLint available = 0; - while (!available) { - gBenchGL.fGetQueryObjectiv(this->fQuery - , BenchGL_QUERY_RESULT_AVAILABLE - , &available); + if (fSupported) { + fStarted = false; + fContext->makeCurrent(); + SK_GL(*fContext, EndQuery(GR_GL_TIME_ELAPSED)); + + GrGLint available = 0; + while (!available) { + SK_GL(*fContext, GetQueryObjectiv(fQuery, + GR_GL_QUERY_RESULT_AVAILABLE, + &available)); + } + GrGLuint64 totalGPUTimeElapsed = 0; + SK_GL(*fContext, GetQueryObjectui64v(fQuery, + GR_GL_QUERY_RESULT, + &totalGPUTimeElapsed)); + + return totalGPUTimeElapsed / 1000000.0; + } else { + return 0; } - BenchGLuint64 totalGPUTimeElapsed = 0; - gBenchGL.fGetQueryObjectui64v(this->fQuery - , BenchGL_QUERY_RESULT - , &totalGPUTimeElapsed); - - return totalGPUTimeElapsed / 1000000.0; } diff --git a/bench/BenchGpuTimer_gl.h b/bench/BenchGpuTimer_gl.h index ac23482..7c7b5c2 100644 --- a/bench/BenchGpuTimer_gl.h +++ b/bench/BenchGpuTimer_gl.h @@ -1,33 +1,26 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ #ifndef SkBenchGpuTimer_DEFINED #define SkBenchGpuTimer_DEFINED -#if defined(SK_MESA) - #include <GL/osmesa.h> - -#elif defined(SK_BUILD_FOR_WIN32) - #define WIN32_LEAN_AND_MEAN 1 - #include <Windows.h> - #include <GL/GL.h> - -#elif defined(SK_BUILD_FOR_MAC) - #include <OpenGL/gl.h> - -#elif defined(SK_BUILD_FOR_UNIX) - #include <GL/gl.h> - -#else - #error unsupported platform -#endif +class SkGLContext; class BenchGpuTimer { public: - BenchGpuTimer(); + BenchGpuTimer(const SkGLContext* glctx); ~BenchGpuTimer(); void startGpu(); double endGpu(); private: - GLuint fQuery; + unsigned fQuery; int fStarted; + const SkGLContext* fContext; + bool fSupported; }; #endif diff --git a/bench/BenchGpuTimer_none.cpp b/bench/BenchGpuTimer_none.cpp deleted file mode 100644 index 0dba6d7..0000000 --- a/bench/BenchGpuTimer_none.cpp +++ /dev/null @@ -1,14 +0,0 @@ -#include "BenchGpuTimer_none.h" - -BenchGpuTimer::BenchGpuTimer() { -} - -BenchGpuTimer::~BenchGpuTimer() { -} - -void BenchGpuTimer::startGpu() { -} - -double BenchGpuTimer::endGpu() { - return -1.0; -} diff --git a/bench/BenchGpuTimer_none.h b/bench/BenchGpuTimer_none.h deleted file mode 100644 index 7069ca4..0000000 --- a/bench/BenchGpuTimer_none.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifndef SkBenchGpuTimer_DEFINED -#define SkBenchGpuTimer_DEFINED - -class BenchGpuTimer { -public: - BenchGpuTimer(); - ~BenchGpuTimer(); - void startGpu(); - double endGpu(); -}; - -#endif diff --git a/bench/BenchSysTimer_c.cpp b/bench/BenchSysTimer_c.cpp index fc0850b..f4cbd39 100644 --- a/bench/BenchSysTimer_c.cpp +++ b/bench/BenchSysTimer_c.cpp @@ -1,3 +1,10 @@ + +/* + * 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 "BenchSysTimer_c.h" //Time diff --git a/bench/BenchSysTimer_c.h b/bench/BenchSysTimer_c.h index c598f30..2ddc83d 100644 --- a/bench/BenchSysTimer_c.h +++ b/bench/BenchSysTimer_c.h @@ -1,3 +1,10 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ #ifndef SkBenchSysTimer_DEFINED #define SkBenchSysTimer_DEFINED diff --git a/bench/BenchSysTimer_mach.cpp b/bench/BenchSysTimer_mach.cpp index b23897c..c837ca3 100644 --- a/bench/BenchSysTimer_mach.cpp +++ b/bench/BenchSysTimer_mach.cpp @@ -1,3 +1,10 @@ + +/* + * 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 "BenchSysTimer_mach.h" //Time diff --git a/bench/BenchSysTimer_mach.h b/bench/BenchSysTimer_mach.h index da4fff0..44d0e5e 100644 --- a/bench/BenchSysTimer_mach.h +++ b/bench/BenchSysTimer_mach.h @@ -1,3 +1,10 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ #ifndef SkBenchSysTimer_DEFINED #define SkBenchSysTimer_DEFINED diff --git a/bench/BenchSysTimer_posix.cpp b/bench/BenchSysTimer_posix.cpp index 5d28f40..e6767e5 100644 --- a/bench/BenchSysTimer_posix.cpp +++ b/bench/BenchSysTimer_posix.cpp @@ -1,3 +1,10 @@ + +/* + * 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 "BenchSysTimer_posix.h" //Time diff --git a/bench/BenchSysTimer_posix.h b/bench/BenchSysTimer_posix.h index 09dfb0e..de793f3 100644 --- a/bench/BenchSysTimer_posix.h +++ b/bench/BenchSysTimer_posix.h @@ -1,3 +1,10 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ #ifndef SkBenchSysTimer_DEFINED #define SkBenchSysTimer_DEFINED diff --git a/bench/BenchSysTimer_windows.cpp b/bench/BenchSysTimer_windows.cpp index 923754c..3635ec5 100644 --- a/bench/BenchSysTimer_windows.cpp +++ b/bench/BenchSysTimer_windows.cpp @@ -1,3 +1,10 @@ + +/* + * 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 "BenchSysTimer_windows.h" //Time @@ -35,7 +42,7 @@ void BenchSysTimer::startCpu() { double BenchSysTimer::endCpu() { ULONGLONG end_cpu = winCpuTime(); - return (end_cpu - this->fStartCpu) / 10000; + return static_cast<double>((end_cpu - this->fStartCpu)) / 10000.0L; } double BenchSysTimer::endWall() { LARGE_INTEGER end_wall; @@ -48,8 +55,10 @@ double BenchSysTimer::endWall() { LARGE_INTEGER frequency; if (0 == ::QueryPerformanceFrequency(&frequency)) { - return 0; + return 0.0L; } else { - return (double)ticks_elapsed.QuadPart / frequency.QuadPart * 1000; + return static_cast<double>(ticks_elapsed.QuadPart) + / static_cast<double>(frequency.QuadPart) + * 1000.0L; } } diff --git a/bench/BenchSysTimer_windows.h b/bench/BenchSysTimer_windows.h index 72a3fb2..c3d0c9b 100644 --- a/bench/BenchSysTimer_windows.h +++ b/bench/BenchSysTimer_windows.h @@ -1,3 +1,10 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ #ifndef SkBenchSysTimer_DEFINED #define SkBenchSysTimer_DEFINED @@ -5,7 +12,7 @@ #define WIN32_LEAN_AND_MEAN 1 #include <Windows.h> -struct BenchSysTimer { +class BenchSysTimer { public: void startWall(); void startCpu(); diff --git a/bench/BenchTimer.cpp b/bench/BenchTimer.cpp index e7b0068..c3a1190 100644 --- a/bench/BenchTimer.cpp +++ b/bench/BenchTimer.cpp @@ -1,48 +1,55 @@ + +/* + * 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 defined(SK_BUILD_FOR_WIN32) #include "BenchSysTimer_windows.h" #elif defined(SK_BUILD_FOR_MAC) #include "BenchSysTimer_mach.h" -#elif defined(SK_BUILD_FOR_UNIX) +#elif defined(SK_BUILD_FOR_UNIX) || defined(SK_BUILD_FOR_ANDROID) #include "BenchSysTimer_posix.h" #else #include "BenchSysTimer_c.h" #endif -#if defined(SK_MESA) || \ - defined(SK_BUILD_FOR_WIN32) || \ - defined(SK_BUILD_FOR_MAC) || \ - defined(SK_BUILD_FOR_UNIX) - #include "BenchGpuTimer_gl.h" - -#else - #include "BenchGpuTimer_none.h" -#endif +#include "BenchGpuTimer_gl.h" -BenchTimer::BenchTimer() +BenchTimer::BenchTimer(SkGLContext* gl) : fCpu(-1.0) , fWall(-1.0) , fGpu(-1.0) { - this->fSysTimer = new BenchSysTimer(); - this->fGpuTimer = new BenchGpuTimer(); + fSysTimer = new BenchSysTimer(); + if (gl) { + fGpuTimer = new BenchGpuTimer(gl); + } else { + fGpuTimer = NULL; + } } BenchTimer::~BenchTimer() { - delete this->fSysTimer; - delete this->fGpuTimer; + delete fSysTimer; + delete fGpuTimer; } void BenchTimer::start() { - this->fSysTimer->startWall(); - this->fGpuTimer->startGpu(); - this->fSysTimer->startCpu(); + fSysTimer->startWall(); + if (fGpuTimer) { + fGpuTimer->startGpu(); + } + fSysTimer->startCpu(); } void BenchTimer::end() { - this->fCpu = this->fSysTimer->endCpu(); + fCpu = fSysTimer->endCpu(); //It is important to stop the cpu clocks first, //as the following will cpu wait for the gpu to finish. - this->fGpu = this->fGpuTimer->endGpu(); - this->fWall = this->fSysTimer->endWall(); + if (fGpuTimer) { + fGpu = fGpuTimer->endGpu(); + } + fWall = fSysTimer->endWall(); } diff --git a/bench/BenchTimer.h b/bench/BenchTimer.h index eae82d5..080bc6d 100644 --- a/bench/BenchTimer.h +++ b/bench/BenchTimer.h @@ -1,9 +1,21 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ #ifndef SkBenchTimer_DEFINED #define SkBenchTimer_DEFINED +#include <SkTypes.h> + + class BenchSysTimer; class BenchGpuTimer; +class SkGLContext; + /** * SysTimers and GpuTimers are implemented orthogonally. * This class combines a SysTimer and a GpuTimer into one single, @@ -11,7 +23,7 @@ class BenchGpuTimer; */ class BenchTimer { public: - BenchTimer(); + BenchTimer(SkGLContext* gl = NULL); ~BenchTimer(); void start(); void end(); diff --git a/bench/BitmapBench.cpp b/bench/BitmapBench.cpp index 77e7ade..3b16925 100644 --- a/bench/BitmapBench.cpp +++ b/bench/BitmapBench.cpp @@ -1,3 +1,10 @@ + +/* + * 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 "SkBenchmark.h" #include "SkBitmap.h" #include "SkPaint.h" @@ -93,13 +100,15 @@ class BitmapBench : public SkBenchmark { SkBitmap fBitmap; SkPaint fPaint; bool fIsOpaque; + bool fForceUpdate; //bitmap marked as dirty before each draw. forces bitmap to be updated on device cache int fTileX, fTileY; // -1 means don't use shader SkString fName; - enum { N = 300 }; + enum { N = SkBENCHLOOP(300) }; public: BitmapBench(void* param, bool isOpaque, SkBitmap::Config c, + bool forceUpdate = false, bool bitmapVolatile = false, int tx = -1, int ty = -1) - : INHERITED(param), fIsOpaque(isOpaque), fTileX(tx), fTileY(ty) { + : INHERITED(param), fIsOpaque(isOpaque), fForceUpdate(forceUpdate), fTileX(tx), fTileY(ty) { const int w = 128; const int h = 128; SkBitmap bm; @@ -124,6 +133,7 @@ public: fBitmap.getColorTable()->setIsOpaque(isOpaque); } fBitmap.setIsOpaque(isOpaque); + fBitmap.setIsVolatile(bitmapVolatile); } protected: @@ -137,6 +147,11 @@ protected: } fName.appendf("_%s%s", gConfigName[fBitmap.config()], fIsOpaque ? "" : "_A"); + if (fForceUpdate) + fName.append("_update"); + if (fBitmap.isVolatile()) + fName.append("_volatile"); + return fName.c_str(); } @@ -154,6 +169,10 @@ protected: for (int i = 0; i < N; i++) { SkScalar x = x0 + rand.nextUScalar1() * dim.fX; SkScalar y = y0 + rand.nextUScalar1() * dim.fY; + + if (fForceUpdate) + bitmap.notifyPixelsChanged(); + canvas->drawBitmap(bitmap, x, y, &paint); } } @@ -169,6 +188,8 @@ static SkBenchmark* Fact3(void* p) { return new BitmapBench(p, false, SkBitmap:: static SkBenchmark* Fact4(void* p) { return new BitmapBench(p, true, SkBitmap::kARGB_4444_Config); } static SkBenchmark* Fact5(void* p) { return new BitmapBench(p, false, SkBitmap::kIndex8_Config); } static SkBenchmark* Fact6(void* p) { return new BitmapBench(p, true, SkBitmap::kIndex8_Config); } +static SkBenchmark* Fact7(void* p) { return new BitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, true); } +static SkBenchmark* Fact8(void* p) { return new BitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, false); } static BenchRegistry gReg0(Fact0); static BenchRegistry gReg1(Fact1); @@ -177,3 +198,5 @@ static BenchRegistry gReg3(Fact3); static BenchRegistry gReg4(Fact4); static BenchRegistry gReg5(Fact5); static BenchRegistry gReg6(Fact6); +static BenchRegistry gReg7(Fact7); +static BenchRegistry gReg8(Fact8); diff --git a/bench/BlurBench.cpp b/bench/BlurBench.cpp new file mode 100644 index 0000000..de78fe1 --- /dev/null +++ b/bench/BlurBench.cpp @@ -0,0 +1,106 @@ + +/* + * 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 "SkBenchmark.h" +#include "SkCanvas.h" +#include "SkPaint.h" +#include "SkRandom.h" +#include "SkShader.h" +#include "SkString.h" +#include "SkBlurMaskFilter.h" + +#define SMALL SkIntToScalar(2) +#define REAL SkFloatToScalar(1.5f) +#define BIG SkIntToScalar(10) + +static const char* gStyleName[] = { + "normal", + "solid", + "outer", + "inner" +}; + +class BlurBench : public SkBenchmark { + SkScalar fRadius; + SkBlurMaskFilter::BlurStyle fStyle; + SkString fName; + +public: + BlurBench(void* param, SkScalar rad, SkBlurMaskFilter::BlurStyle bs) : INHERITED(param) { + fRadius = rad; + fStyle = bs; + const char* name = rad > 0 ? gStyleName[bs] : "none"; + if (SkScalarFraction(rad) != 0) { + fName.printf("blur_%.2f_%s", SkScalarToFloat(rad), name); + } else { + fName.printf("blur_%d_%s", SkScalarRound(rad), name); + } + } + +protected: + virtual const char* onGetName() { + return fName.c_str(); + } + + virtual void onDraw(SkCanvas* canvas) { + SkPaint paint; + this->setupPaint(&paint); + + paint.setAntiAlias(true); + + SkRandom rand; + for (int i = 0; i < SkBENCHLOOP(10); i++) { + SkRect r = SkRect::MakeWH(rand.nextUScalar1() * 400, + rand.nextUScalar1() * 400); + r.offset(fRadius, fRadius); + + if (fRadius > 0) { + SkMaskFilter* mf = SkBlurMaskFilter::Create(fRadius, fStyle, 0); + paint.setMaskFilter(mf)->unref(); + } + canvas->drawOval(r, paint); + } + } + +private: + typedef SkBenchmark INHERITED; +}; + +static SkBenchmark* Fact00(void* p) { return new BlurBench(p, SMALL, SkBlurMaskFilter::kNormal_BlurStyle); } +static SkBenchmark* Fact01(void* p) { return new BlurBench(p, SMALL, SkBlurMaskFilter::kSolid_BlurStyle); } +static SkBenchmark* Fact02(void* p) { return new BlurBench(p, SMALL, SkBlurMaskFilter::kOuter_BlurStyle); } +static SkBenchmark* Fact03(void* p) { return new BlurBench(p, SMALL, SkBlurMaskFilter::kInner_BlurStyle); } + +static SkBenchmark* Fact10(void* p) { return new BlurBench(p, BIG, SkBlurMaskFilter::kNormal_BlurStyle); } +static SkBenchmark* Fact11(void* p) { return new BlurBench(p, BIG, SkBlurMaskFilter::kSolid_BlurStyle); } +static SkBenchmark* Fact12(void* p) { return new BlurBench(p, BIG, SkBlurMaskFilter::kOuter_BlurStyle); } +static SkBenchmark* Fact13(void* p) { return new BlurBench(p, BIG, SkBlurMaskFilter::kInner_BlurStyle); } + +static SkBenchmark* Fact20(void* p) { return new BlurBench(p, REAL, SkBlurMaskFilter::kNormal_BlurStyle); } +static SkBenchmark* Fact21(void* p) { return new BlurBench(p, REAL, SkBlurMaskFilter::kSolid_BlurStyle); } +static SkBenchmark* Fact22(void* p) { return new BlurBench(p, REAL, SkBlurMaskFilter::kOuter_BlurStyle); } +static SkBenchmark* Fact23(void* p) { return new BlurBench(p, REAL, SkBlurMaskFilter::kInner_BlurStyle); } + +static SkBenchmark* FactNone(void* p) { return new BlurBench(p, 0, SkBlurMaskFilter::kNormal_BlurStyle); } + +static BenchRegistry gReg00(Fact00); +static BenchRegistry gReg01(Fact01); +static BenchRegistry gReg02(Fact02); +static BenchRegistry gReg03(Fact03); + +static BenchRegistry gReg10(Fact10); +static BenchRegistry gReg11(Fact11); +static BenchRegistry gReg12(Fact12); +static BenchRegistry gReg13(Fact13); + +static BenchRegistry gReg20(Fact20); +static BenchRegistry gReg21(Fact21); +static BenchRegistry gReg22(Fact22); +static BenchRegistry gReg23(Fact23); + +static BenchRegistry gRegNone(FactNone); + diff --git a/bench/ChromeBench.cpp b/bench/ChromeBench.cpp new file mode 100644 index 0000000..fc73d53 --- /dev/null +++ b/bench/ChromeBench.cpp @@ -0,0 +1,498 @@ +/* + * 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 "SkBenchmark.h" +#include "SkCanvas.h" +#include "SkPaint.h" +#include "SkString.h" + +/** + Benchmarks that try to emulate a particular Skia call pattern observed in Chrome. +*/ + +/// blitRect() calls emitted by Chrome while scrolling through gmail: count, width, height. +int gmailScrollingRectSpec [431*3] = { + 1, 1254, 1160, + 1, 64, 112, + 1, 1034, 261, + 1, 1166, 1, + 1, 1166, 20, + 1, 1254, 40, + 1, 140, 20, + 1, 22, 30, + 1, 22, 39, + 1, 294, 29, + 1, 336, 25, + 1, 336, 5, + 1, 37, 3, + 1, 37, 4, + 1, 37, 5, + 1, 41, 29, + 1, 57, 15, + 1, 72, 5, + 1, 72, 8, + 1, 76, 29, + 1, 981, 88, + 1, 990, 2, + 1, 990, 6, + 2, 220, 88, + 2, 294, 1, + 2, 37, 6, + 2, 391, 55, + 2, 57, 11, + 2, 57, 14, + 2, 57, 7, + 2, 981, 30, + 2, 990, 15, + 2, 990, 19, + 3, 114, 16, + 3, 1166, 39, + 3, 1254, 154, + 3, 12, 12, + 3, 162, 7, + 3, 164, 479, + 3, 167, 449, + 3, 16, 24, + 3, 204, 497, + 3, 205, 434, + 3, 220, 1127, + 3, 220, 1132, + 3, 220, 931, + 3, 220, 933, + 3, 220, 934, + 3, 297, 8, + 3, 72, 25, + 3, 87, 30, + 3, 981, 1, + 3, 981, 126, + 3, 990, 27, + 3, 990, 36, + 3, 991, 29, + 4, 1254, 306, + 4, 1254, 36, + 4, 1, 1, + 4, 1, 14, + 4, 1, 19, + 4, 1, 7, + 4, 21, 21, + 4, 220, 30, + 4, 46, 949, + 4, 509, 30, + 4, 57, 2, + 4, 57, 6, + 4, 990, 11, + 5, 13, 8, + 5, 198, 24, + 5, 24, 24, + 5, 25, 24, + 5, 2, 24, + 5, 37, 33, + 5, 57, 4, + 5, 599, 24, + 5, 90, 24, + 5, 981, 19, + 5, 990, 23, + 5, 990, 8, + 6, 101, 29, + 6, 117, 29, + 6, 1254, 88, + 6, 139, 29, + 6, 13, 12, + 6, 15, 15, + 6, 164, 25, + 6, 16, 16, + 6, 198, 7, + 6, 1, 12, + 6, 1, 15, + 6, 1, 27, + 6, 220, 936, + 6, 24, 7, + 6, 25, 7, + 6, 2, 7, + 6, 326, 29, + 6, 336, 29, + 6, 599, 7, + 6, 86, 29, + 6, 90, 7, + 6, 96, 29, + 6, 991, 31, + 7, 198, 12, + 7, 198, 20, + 7, 198, 33, + 7, 198, 35, + 7, 24, 12, + 7, 24, 20, + 7, 24, 33, + 7, 24, 35, + 7, 25, 12, + 7, 25, 20, + 7, 25, 33, + 7, 25, 35, + 7, 2, 12, + 7, 2, 20, + 7, 2, 33, + 7, 2, 35, + 7, 304, 1, + 7, 38, 29, + 7, 51, 29, + 7, 599, 12, + 7, 599, 20, + 7, 599, 33, + 7, 599, 35, + 7, 90, 12, + 7, 90, 20, + 7, 90, 33, + 7, 90, 35, + 8, 13, 5, + 8, 198, 13, + 8, 198, 23, + 8, 220, 1, + 8, 24, 13, + 8, 24, 23, + 8, 25, 13, + 8, 25, 23, + 8, 2, 13, + 8, 2, 23, + 8, 329, 28, + 8, 57, 10, + 8, 599, 13, + 8, 599, 23, + 8, 90, 13, + 8, 90, 23, + 9, 198, 17, + 9, 198, 19, + 9, 198, 37, + 9, 198, 5, + 9, 198, 8, + 9, 24, 17, + 9, 24, 19, + 9, 24, 37, + 9, 24, 5, + 9, 24, 8, + 9, 25, 17, + 9, 25, 19, + 9, 25, 37, + 9, 25, 5, + 9, 25, 8, + 9, 2, 17, + 9, 2, 19, + 9, 2, 37, + 9, 2, 5, + 9, 2, 8, + 9, 599, 17, + 9, 599, 19, + 9, 599, 37, + 9, 599, 5, + 9, 599, 8, + 9, 72, 29, + 9, 90, 17, + 9, 90, 19, + 9, 90, 37, + 9, 90, 5, + 9, 90, 8, + 10, 13, 11, + 10, 13, 9, + 10, 198, 26, + 10, 198, 28, + 10, 1, 23, + 10, 1, 4, + 10, 1, 6, + 10, 24, 26, + 10, 24, 28, + 10, 25, 26, + 10, 25, 28, + 10, 26, 24, + 10, 2, 26, + 10, 2, 28, + 10, 599, 26, + 10, 599, 28, + 10, 90, 26, + 10, 90, 28, + 11, 198, 27, + 11, 24, 27, + 11, 25, 27, + 11, 2, 27, + 11, 599, 27, + 11, 90, 27, + 12, 198, 14, + 12, 198, 21, + 12, 198, 3, + 12, 1, 11, + 12, 1, 2, + 12, 1, 8, + 12, 24, 14, + 12, 24, 21, + 12, 24, 3, + 12, 25, 14, + 12, 25, 21, + 12, 25, 3, + 12, 26, 7, + 12, 2, 14, + 12, 2, 21, + 12, 2, 3, + 12, 329, 14, + 12, 38, 2, + 12, 599, 14, + 12, 599, 21, + 12, 599, 3, + 12, 90, 14, + 12, 90, 21, + 12, 90, 3, + 13, 198, 11, + 13, 198, 15, + 13, 198, 31, + 13, 24, 11, + 13, 24, 15, + 13, 24, 31, + 13, 25, 11, + 13, 25, 15, + 13, 25, 31, + 13, 2, 11, + 13, 2, 15, + 13, 2, 31, + 13, 57, 13, + 13, 599, 11, + 13, 599, 15, + 13, 599, 31, + 13, 71, 29, + 13, 90, 11, + 13, 90, 15, + 13, 90, 31, + 14, 13, 2, + 14, 198, 10, + 14, 24, 10, + 14, 25, 10, + 14, 26, 12, + 14, 26, 20, + 14, 26, 33, + 14, 26, 35, + 14, 2, 10, + 14, 336, 1, + 14, 45, 29, + 14, 599, 10, + 14, 63, 29, + 14, 90, 10, + 15, 13, 3, + 15, 198, 2, + 15, 198, 29, + 15, 198, 34, + 15, 24, 2, + 15, 24, 29, + 15, 24, 34, + 15, 25, 2, + 15, 25, 29, + 15, 25, 34, + 15, 2, 2, + 15, 2, 29, + 15, 2, 34, + 15, 599, 2, + 15, 599, 29, + 15, 599, 34, + 15, 90, 2, + 15, 90, 29, + 15, 90, 34, + 16, 13, 4, + 16, 13, 6, + 16, 198, 16, + 16, 198, 9, + 16, 1, 10, + 16, 24, 16, + 16, 24, 9, + 16, 25, 16, + 16, 25, 9, + 16, 26, 13, + 16, 26, 23, + 16, 2, 16, + 16, 2, 9, + 16, 599, 16, + 16, 599, 9, + 16, 90, 16, + 16, 90, 9, + 17, 13, 7, + 17, 198, 18, + 17, 24, 18, + 17, 25, 18, + 17, 2, 18, + 17, 599, 18, + 17, 90, 18, + 18, 198, 22, + 18, 198, 32, + 18, 198, 36, + 18, 198, 4, + 18, 24, 22, + 18, 24, 32, + 18, 24, 36, + 18, 24, 4, + 18, 25, 22, + 18, 25, 32, + 18, 25, 36, + 18, 25, 4, + 18, 26, 17, + 18, 26, 19, + 18, 26, 37, + 18, 26, 5, + 18, 26, 8, + 18, 2, 22, + 18, 2, 32, + 18, 2, 36, + 18, 2, 4, + 18, 599, 22, + 18, 599, 32, + 18, 599, 36, + 18, 599, 4, + 18, 90, 22, + 18, 90, 32, + 18, 90, 36, + 18, 90, 4, + 19, 13, 10, + 20, 1254, 30, + 20, 16, 1007, + 20, 26, 26, + 20, 26, 28, + 21, 198, 6, + 21, 24, 6, + 21, 25, 6, + 21, 2, 6, + 21, 599, 6, + 21, 90, 6, + 22, 198, 38, + 22, 22, 40, + 22, 24, 38, + 22, 25, 38, + 22, 26, 27, + 22, 2, 38, + 22, 599, 38, + 22, 90, 38, + 23, 1254, 1160, + 24, 220, 930, + 24, 26, 14, + 24, 26, 21, + 24, 26, 3, + 26, 11, 11, + 26, 1, 13, + 26, 26, 11, + 26, 26, 15, + 26, 26, 31, + 28, 26, 10, + 30, 176, 60, + 30, 26, 2, + 30, 26, 29, + 30, 26, 34, + 32, 26, 16, + 32, 26, 9, + 34, 26, 18, + 36, 26, 22, + 36, 26, 32, + 36, 26, 36, + 36, 26, 4, + 36, 37, 26, + 42, 26, 6, + 43, 115, 29, + 44, 198, 25, + 44, 24, 25, + 44, 25, 25, + 44, 26, 38, + 44, 2, 25, + 44, 599, 25, + 44, 90, 25, + 46, 22, 1, + 47, 198, 30, + 47, 25, 30, + 47, 2, 30, + 47, 599, 30, + 47, 90, 30, + 48, 24, 30, + 52, 176, 30, + 58, 140, 24, + 58, 4, 30, + 63, 990, 29, + 64, 1254, 1, + 88, 26, 25, + 92, 198, 39, + 92, 25, 39, + 92, 2, 39, + 92, 599, 39, + 92, 90, 39, + 93, 24, 39, + 94, 26, 30, + 108, 1254, 1051, + 117, 140, 1, + 119, 160, 1, + 126, 1, 29, + 132, 135, 16, + 147, 72, 16, + 184, 26, 39, + 238, 990, 1, + 376, 11, 1007, + 380, 11, 487, + 1389, 1034, 1007, + 1870, 57, 16, + 4034, 1, 16, + 8521, 198, 40, + 8521, 25, 40, + 8521, 2, 40, + 8521, 599, 40, + 8521, 90, 40, + 8543, 24, 40, + 8883, 13, 13, + 17042, 26, 40, + 17664, 198, 1, + 17664, 25, 1, + 17664, 2, 1, + 17664, 599, 1, + 17664, 90, 1, + 17710, 24, 1, + 35328, 26, 1, +}; + +/// Emulates the mix of rects blitted by gmail during scrolling +class ScrollGmailBench : public SkBenchmark { + enum { + W = 1254, + H = 1160, + N = 431 + }; +public: + ScrollGmailBench(void* param) : INHERITED(param) { } + +protected: + + virtual const char* onGetName() { return "chrome_scrollGmail"; } + virtual void onDraw(SkCanvas* canvas) { + SkDEBUGCODE(this->validateBounds(canvas)); + SkPaint paint; + this->setupPaint(&paint); + for (int i = 0; i < N; i++) { + SkRect current; + setRectangle(current, i); + for (int j = 0; j < SkBENCHLOOP(gmailScrollingRectSpec[i*3]); j++) { + canvas->drawRect(current, paint); + } + } + } + virtual SkIPoint onGetSize() { return SkIPoint::Make(W, H); } + + void setRectangle(SkRect& current, int i) { + current.set(0, 0, + SkIntToScalar(gmailScrollingRectSpec[i*3+1]), SkIntToScalar(gmailScrollingRectSpec[i*3+2])); + } + void validateBounds(SkCanvas* canvas) { + SkIRect bounds; + canvas->getClipDeviceBounds(&bounds); + SkASSERT(bounds.right()-bounds.left() >= W); + SkASSERT(bounds.bottom()-bounds.top() >= H); + } + + +private: + typedef SkBenchmark INHERITED; +}; + +static SkBenchmark* ScrollGmailFactory(void* p) { + return SkNEW_ARGS(ScrollGmailBench, (p)); +} + +static BenchRegistry gScrollGmailReg(ScrollGmailFactory); diff --git a/bench/DecodeBench.cpp b/bench/DecodeBench.cpp index ac11089..6761690 100644 --- a/bench/DecodeBench.cpp +++ b/bench/DecodeBench.cpp @@ -1,3 +1,10 @@ + +/* + * 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 "SkBenchmark.h" #include "SkBitmap.h" #include "SkImageDecoder.h" @@ -11,7 +18,7 @@ class DecodeBench : public SkBenchmark { const char* fFilename; SkBitmap::Config fPrefConfig; SkString fName; - enum { N = 10 }; + enum { N = SkBENCHLOOP(10) }; public: DecodeBench(void* param, SkBitmap::Config c) : SkBenchmark(param) { fFilename = this->findDefine("decode-filename"); diff --git a/bench/FPSBench.cpp b/bench/FPSBench.cpp deleted file mode 100644 index 28668fe..0000000 --- a/bench/FPSBench.cpp +++ /dev/null @@ -1,108 +0,0 @@ -#include "SkBenchmark.h" -#include "SkCanvas.h" -#include "SkPaint.h" -#include "SkRandom.h" -#include "SkString.h" - -class FPSBench : public SkBenchmark { - int32_t fWidth; - int32_t fHeight; -public: - FPSBench(void* p) : INHERITED(p) { - fWidth = 640; - (void)this->findDefine32("width", &fWidth); - fHeight = 480; - (void)this->findDefine32("height", &fHeight); - } - - int width() const { return fWidth; } - int height() const { return fHeight; } - -protected: - virtual SkIPoint onGetSize() { return SkIPoint::Make(fWidth, fHeight); } - -private: - typedef SkBenchmark INHERITED; -}; - -/////////////////////////////////////////////////////////////////////////////// - -class Color_FPSBench : public FPSBench { -public: - Color_FPSBench(void* p, SkColor c, const char name[]) : INHERITED(p) { - fColor = c; - fName = name; - } - -protected: - virtual const char* onGetName() { return fName; } - virtual void onDraw(SkCanvas* canvas) { - canvas->drawColor(fColor); - } - -private: - const char* fName; - SkColor fColor; - - typedef FPSBench INHERITED; -}; - -class Bitmap_FPSBench : public FPSBench { -public: - Bitmap_FPSBench(void* p, SkBitmap::Config config, bool doOpaque, bool doScale) : INHERITED(p) { - fBitmap.setConfig(config, this->width(), this->height()); - fBitmap.allocPixels(); - fBitmap.eraseColor(0xFFFF0000); - if (doOpaque) { - fBitmap.setIsOpaque(true); - } - - const char* configStr = "565"; - if (config == SkBitmap::kARGB_8888_Config) { - if (doOpaque) { - configStr = "X888"; - } else { - configStr = "8888"; - } - } - fName.printf("fps_bitmap_%s_%s", configStr, - doScale ? "scale" : "noscale"); - - fMatrix.reset(); - if (doScale) { - fMatrix.setScale(SkIntToScalar(3)/2, SkIntToScalar(3)/2); - } - } - -protected: - virtual const char* onGetName() { return fName.c_str(); } - virtual void onDraw(SkCanvas* canvas) { - canvas->drawBitmapMatrix(fBitmap, fMatrix); - } - -private: - SkBitmap fBitmap; - SkMatrix fMatrix; - SkString fName; - - typedef FPSBench INHERITED; -}; - -static SkBenchmark* FillFactory(void* p) { return SkNEW_ARGS(Color_FPSBench, (p, 0xFFFF0000, "fps_fill")); } -static SkBenchmark* BlendFactory(void* p) { return SkNEW_ARGS(Color_FPSBench, (p, 0x80FF0000, "fps_blend")); } -static SkBenchmark* BMFactory0(void* p) { return SkNEW_ARGS(Bitmap_FPSBench, (p, SkBitmap::kARGB_8888_Config, false, false)); } -static SkBenchmark* BMFactory1(void* p) { return SkNEW_ARGS(Bitmap_FPSBench, (p, SkBitmap::kARGB_8888_Config, false, true)); } -static SkBenchmark* BMFactory2(void* p) { return SkNEW_ARGS(Bitmap_FPSBench, (p, SkBitmap::kARGB_8888_Config, true, false)); } -static SkBenchmark* BMFactory3(void* p) { return SkNEW_ARGS(Bitmap_FPSBench, (p, SkBitmap::kARGB_8888_Config, true, true)); } -static SkBenchmark* BMFactory4(void* p) { return SkNEW_ARGS(Bitmap_FPSBench, (p, SkBitmap::kRGB_565_Config, false, false)); } -static SkBenchmark* BMFactory5(void* p) { return SkNEW_ARGS(Bitmap_FPSBench, (p, SkBitmap::kRGB_565_Config, false, true)); } - -static BenchRegistry gFillReg(FillFactory); -static BenchRegistry gBlendReg(BlendFactory); -static BenchRegistry gBMReg0(BMFactory0); -static BenchRegistry gBMReg1(BMFactory1); -static BenchRegistry gBMReg2(BMFactory2); -static BenchRegistry gBMReg3(BMFactory3); -static BenchRegistry gBMReg4(BMFactory4); -static BenchRegistry gBMReg5(BMFactory5); - diff --git a/bench/FontScalerBench.cpp b/bench/FontScalerBench.cpp new file mode 100644 index 0000000..4ac6a35 --- /dev/null +++ b/bench/FontScalerBench.cpp @@ -0,0 +1,60 @@ +/* + * 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 "SkBenchmark.h" +#include "SkCanvas.h" +#include "SkGraphics.h" +#include "SkPaint.h" +#include "SkRandom.h" +#include "SkString.h" + +extern bool gSkSuppressFontCachePurgeSpew; + +class FontScalerBench : public SkBenchmark { + SkString fName; + SkString fText; + bool fDoLCD; +public: + FontScalerBench(void* param, bool doLCD) : INHERITED(param) { + fName.printf("fontscaler_%s", doLCD ? "lcd" : "aa"); + fText.set("abcdefghijklmnopqrstuvwxyz01234567890"); + fDoLCD = doLCD; + } + +protected: + virtual const char* onGetName() { return fName.c_str(); } + virtual void onDraw(SkCanvas* canvas) { + SkPaint paint; + this->setupPaint(&paint); + paint.setLCDRenderText(fDoLCD); + + bool prev = gSkSuppressFontCachePurgeSpew; + gSkSuppressFontCachePurgeSpew = true; + + // this is critical - we want to time the creation process, so we + // explicitly flush our cache before each run + SkGraphics::PurgeFontCache(); + + for (int ps = 9; ps <= 24; ps += 2) { + paint.setTextSize(SkIntToScalar(ps)); + canvas->drawText(fText.c_str(), fText.size(), + 0, SkIntToScalar(20), paint); + } + + gSkSuppressFontCachePurgeSpew = prev; + } +private: + typedef SkBenchmark INHERITED; +}; + +/////////////////////////////////////////////////////////////////////////////// + +static SkBenchmark* Fact0(void* p) { return SkNEW_ARGS(FontScalerBench, (p, false)); } +static SkBenchmark* Fact1(void* p) { return SkNEW_ARGS(FontScalerBench, (p, true)); } + +static BenchRegistry gReg0(Fact0); +static BenchRegistry gReg1(Fact1); diff --git a/bench/GradientBench.cpp b/bench/GradientBench.cpp index 5ecca6b..a5032ea 100644 --- a/bench/GradientBench.cpp +++ b/bench/GradientBench.cpp @@ -1,3 +1,10 @@ + +/* + * 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 "SkBenchmark.h" #include "SkBitmap.h" #include "SkCanvas.h" @@ -31,23 +38,29 @@ static const GradData gGradData[] = { { 5, gColors, gPos2 } }; +/// Ignores scale static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data, - SkShader::TileMode tm, SkUnitMapper* mapper) { + SkShader::TileMode tm, SkUnitMapper* mapper, + float scale) { return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos, data.fCount, tm, mapper); } static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data, - SkShader::TileMode tm, SkUnitMapper* mapper) { + SkShader::TileMode tm, SkUnitMapper* mapper, + float scale) { SkPoint center; center.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); - return SkGradientShader::CreateRadial(center, center.fX, data.fColors, + return SkGradientShader::CreateRadial(center, center.fX * scale, + data.fColors, data.fPos, data.fCount, tm, mapper); } +/// Ignores scale static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, - SkShader::TileMode tm, SkUnitMapper* mapper) { + SkShader::TileMode tm, SkUnitMapper* mapper, + float scale) { SkPoint center; center.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); @@ -55,21 +68,24 @@ static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, data.fPos, data.fCount, mapper); } +/// Ignores scale static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, - SkShader::TileMode tm, SkUnitMapper* mapper) { + SkShader::TileMode tm, SkUnitMapper* mapper, + float scale) { SkPoint center0, center1; center0.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5), SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4)); return SkGradientShader::CreateTwoPointRadial( - center1, (pts[1].fX - pts[0].fX) / 7, - center0, (pts[1].fX - pts[0].fX) / 2, - data.fColors, data.fPos, data.fCount, tm, mapper); + center1, (pts[1].fX - pts[0].fX) / 7, + center0, (pts[1].fX - pts[0].fX) / 2, + data.fColors, data.fPos, data.fCount, tm, mapper); } typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, - SkShader::TileMode tm, SkUnitMapper* mapper); + SkShader::TileMode tm, SkUnitMapper* mapper, + float scale); static const struct { GradMaker fMaker; @@ -89,6 +105,37 @@ enum GradType { // these must match the order in gGrads kRadial2_GradType }; +enum GeomType { + kRect_GeomType, + kOval_GeomType +}; + +static const char* tilemodename(SkShader::TileMode tm) { + switch (tm) { + case SkShader::kClamp_TileMode: + return "clamp"; + case SkShader::kRepeat_TileMode: + return "repeat"; + case SkShader::kMirror_TileMode: + return "mirror"; + default: + SkASSERT(!"unknown tilemode"); + return "error"; + } +} + +static const char* geomtypename(GeomType gt) { + switch (gt) { + case kRect_GeomType: + return "rectangle"; + case kOval_GeomType: + return "oval"; + default: + SkASSERT(!"unknown geometry type"); + return "error"; + } +} + /////////////////////////////////////////////////////////////////////////////// class GradientBench : public SkBenchmark { @@ -101,17 +148,26 @@ class GradientBench : public SkBenchmark { N = 1 }; public: - GradientBench(void* param, GradType gt) : INHERITED(param) { - fName.printf("gradient_%s", gGrads[gt].fName); + GradientBench(void* param, GradType gradType, + SkShader::TileMode tm = SkShader::kClamp_TileMode, + GeomType geomType = kRect_GeomType, + float scale = 1.0f) + : INHERITED(param) { + fName.printf("gradient_%s_%s", gGrads[gradType].fName, + tilemodename(tm)); + if (geomType != kRect_GeomType) { + fName.append("_"); + fName.append(geomtypename(geomType)); + } const SkPoint pts[2] = { { 0, 0 }, { SkIntToScalar(W), SkIntToScalar(H) } }; - fCount = N * gGrads[gt].fRepeat; - fShader = gGrads[gt].fMaker(pts, gGradData[0], - SkShader::kClamp_TileMode, NULL); + fCount = SkBENCHLOOP(N * gGrads[gradType].fRepeat); + fShader = gGrads[gradType].fMaker(pts, gGradData[0], tm, NULL, scale); + fGeomType = geomType; } virtual ~GradientBench() { @@ -131,21 +187,86 @@ protected: SkRect r = { 0, 0, SkIntToScalar(W), SkIntToScalar(H) }; for (int i = 0; i < fCount; i++) { - canvas->drawRect(r, paint); + switch (fGeomType) { + case kRect_GeomType: + canvas->drawRect(r, paint); + break; + case kOval_GeomType: + canvas->drawOval(r, paint); + break; + } } } private: typedef SkBenchmark INHERITED; + + GeomType fGeomType; +}; + +class Gradient2Bench : public SkBenchmark { +public: + Gradient2Bench(void* param) : INHERITED(param) {} + +protected: + virtual const char* onGetName() { + return "gradient_create"; + } + + virtual void onDraw(SkCanvas* canvas) { + SkPaint paint; + this->setupPaint(&paint); + + const SkRect r = { 0, 0, SkIntToScalar(4), SkIntToScalar(4) }; + const SkPoint pts[] = { + { 0, 0 }, + { SkIntToScalar(100), SkIntToScalar(100) }, + }; + + for (int i = 0; i < SkBENCHLOOP(1000); i++) { + const int a = i % 256; + SkColor colors[] = { + SK_ColorBLACK, + SkColorSetARGB(a, a, a, a), + SK_ColorWHITE }; + SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, + SK_ARRAY_COUNT(colors), + SkShader::kClamp_TileMode); + paint.setShader(s)->unref(); + canvas->drawRect(r, paint); + } + } + +private: + typedef SkBenchmark INHERITED; }; static SkBenchmark* Fact0(void* p) { return new GradientBench(p, kLinear_GradType); } -static SkBenchmark* Fact1(void* p) { return new GradientBench(p, kRadial_GradType); } +static SkBenchmark* Fact01(void* p) { return new GradientBench(p, kLinear_GradType, SkShader::kMirror_TileMode); } + +// Draw a radial gradient of radius 1/2 on a rectangle; half the lines should +// be completely pinned, the other half should pe partially pinned +static SkBenchmark* Fact1(void* p) { return new GradientBench(p, kRadial_GradType, SkShader::kClamp_TileMode, kRect_GeomType, 0.5f); } + +// Draw a radial gradient on a circle of equal size; all the lines should +// hit the unpinned fast path (so long as GradientBench.W == H) +static SkBenchmark* Fact1o(void* p) { return new GradientBench(p, kRadial_GradType, SkShader::kClamp_TileMode, kOval_GeomType); } + +static SkBenchmark* Fact11(void* p) { return new GradientBench(p, kRadial_GradType, SkShader::kMirror_TileMode); } static SkBenchmark* Fact2(void* p) { return new GradientBench(p, kSweep_GradType); } static SkBenchmark* Fact3(void* p) { return new GradientBench(p, kRadial2_GradType); } +static SkBenchmark* Fact31(void* p) { return new GradientBench(p, kRadial2_GradType, SkShader::kMirror_TileMode); } + +static SkBenchmark* Fact4(void* p) { return new Gradient2Bench(p); } static BenchRegistry gReg0(Fact0); +static BenchRegistry gReg01(Fact01); static BenchRegistry gReg1(Fact1); +static BenchRegistry gReg1o(Fact1o); +static BenchRegistry gReg11(Fact11); static BenchRegistry gReg2(Fact2); static BenchRegistry gReg3(Fact3); +static BenchRegistry gReg31(Fact31); + +static BenchRegistry gReg4(Fact4); diff --git a/bench/Makefile.am b/bench/Makefile.am deleted file mode 100644 index 2b67862..0000000 --- a/bench/Makefile.am +++ /dev/null @@ -1,20 +0,0 @@ -AM_CPPFLAGS = -I$(top_builddir)/include/core -I$(top_builddir)/include/images -AM_LDFLAGS = -lpng -lpthread - -bin_PROGRAMS = Bench -Bench_SOURCES = RectBench.cpp \ - FPSBench.cpp \ - SkBenchmark.cpp \ - BenchTool/main.cpp \ - $(top_builddir)/src/images/SkImageDecoder.cpp \ - $(top_builddir)/src/images/SkImageDecoder_libpng.cpp \ - $(top_builddir)/src/images/SkScaledBitmapSampler.cpp \ - $(top_builddir)/src/ports/SkGlobals_global.cpp \ - $(top_builddir)/src/ports/SkOSFile_stdio.cpp \ - $(top_builddir)/src/ports/SkThread_pthread.cpp \ - $(top_builddir)/src/ports/SkTime_Unix.cpp \ - $(top_builddir)/src/ports/SkFontHost_none.cpp - - -Bench_LDADD = $(top_builddir)/src/core/libskia.a - diff --git a/bench/MathBench.cpp b/bench/MathBench.cpp new file mode 100644 index 0000000..9feb5af --- /dev/null +++ b/bench/MathBench.cpp @@ -0,0 +1,316 @@ +#include "SkBenchmark.h" +#include "SkColorPriv.h" +#include "SkMatrix.h" +#include "SkRandom.h" +#include "SkString.h" +#include "SkPaint.h" + +class MathBench : public SkBenchmark { + enum { + kBuffer = 100, + kLoop = 10000 + }; + SkString fName; + float fSrc[kBuffer], fDst[kBuffer]; +public: + MathBench(void* param, const char name[]) : INHERITED(param) { + fName.printf("math_%s", name); + + SkRandom rand; + for (int i = 0; i < kBuffer; ++i) { + fSrc[i] = rand.nextSScalar1(); + } + } + + virtual void performTest(float dst[], const float src[], int count) = 0; + +protected: + virtual int mulLoopCount() const { return 1; } + + virtual const char* onGetName() { + return fName.c_str(); + } + + virtual void onDraw(SkCanvas* canvas) { + int n = SkBENCHLOOP(kLoop * this->mulLoopCount()); + for (int i = 0; i < n; i++) { + this->performTest(fDst, fSrc, kBuffer); + } + } + +private: + typedef SkBenchmark INHERITED; +}; + +class MathBenchU32 : public MathBench { +public: + MathBenchU32(void* param, const char name[]) : INHERITED(param, name) {} + +protected: + virtual void performITest(uint32_t* dst, const uint32_t* src, int count) = 0; + + virtual void performTest(float* SK_RESTRICT dst, const float* SK_RESTRICT src, + int count) SK_OVERRIDE { + uint32_t* d = SkTCast<uint32_t*>(dst); + const uint32_t* s = SkTCast<const uint32_t*>(src); + this->performITest(d, s, count); + } +private: + typedef MathBench INHERITED; +}; + +/////////////////////////////////////////////////////////////////////////////// + +class NoOpMathBench : public MathBench { +public: + NoOpMathBench(void* param) : INHERITED(param, "noOp") {} +protected: + virtual void performTest(float dst[], const float src[], int count) { + for (int i = 0; i < count; ++i) { + dst[i] = src[i] + 1; + } + } +private: + typedef MathBench INHERITED; +}; + +class SlowISqrtMathBench : public MathBench { +public: + SlowISqrtMathBench(void* param) : INHERITED(param, "slowIsqrt") {} +protected: + virtual void performTest(float dst[], const float src[], int count) { + for (int i = 0; i < count; ++i) { + dst[i] = 1.0f / sk_float_sqrt(src[i]); + } + } +private: + typedef MathBench INHERITED; +}; + +static inline float SkFastInvSqrt(float x) { + float xhalf = 0.5f*x; + int i = *(int*)&x; + i = 0x5f3759df - (i>>1); + x = *(float*)&i; + x = x*(1.5f-xhalf*x*x); +// x = x*(1.5f-xhalf*x*x); // this line takes err from 10^-3 to 10^-6 + return x; +} + +class FastISqrtMathBench : public MathBench { +public: + FastISqrtMathBench(void* param) : INHERITED(param, "fastIsqrt") {} +protected: + virtual void performTest(float dst[], const float src[], int count) { + for (int i = 0; i < count; ++i) { + dst[i] = SkFastInvSqrt(src[i]); + } + } +private: + typedef MathBench INHERITED; +}; + +static inline uint32_t QMul64(uint32_t value, U8CPU alpha) { + SkASSERT((uint8_t)alpha == alpha); + const uint32_t mask = 0xFF00FF; + + uint64_t tmp = value; + tmp = (tmp & mask) | ((tmp & ~mask) << 24); + tmp *= alpha; + return ((tmp >> 8) & mask) | ((tmp >> 32) & ~mask); +} + +class QMul64Bench : public MathBenchU32 { +public: + QMul64Bench(void* param) : INHERITED(param, "qmul64") {} +protected: + virtual void performITest(uint32_t* SK_RESTRICT dst, + const uint32_t* SK_RESTRICT src, + int count) SK_OVERRIDE { + for (int i = 0; i < count; ++i) { + dst[i] = QMul64(src[i], (uint8_t)i); + } + } +private: + typedef MathBenchU32 INHERITED; +}; + +class QMul32Bench : public MathBenchU32 { +public: + QMul32Bench(void* param) : INHERITED(param, "qmul32") {} +protected: + virtual void performITest(uint32_t* SK_RESTRICT dst, + const uint32_t* SK_RESTRICT src, + int count) SK_OVERRIDE { + for (int i = 0; i < count; ++i) { + dst[i] = SkAlphaMulQ(src[i], (uint8_t)i); + } + } +private: + typedef MathBenchU32 INHERITED; +}; + +/////////////////////////////////////////////////////////////////////////////// + +static bool isFinite_int(float x) { + uint32_t bits = SkFloat2Bits(x); // need unsigned for our shifts + int exponent = bits << 1 >> 24; + return exponent != 0xFF; +} + +static bool isFinite_float(float x) { + return sk_float_isfinite(x); +} + +static bool isFinite_mulzero(float x) { + float y = x * 0; + return y == y; +} + +static bool isfinite_and_int(const float data[4]) { + return isFinite_int(data[0]) && isFinite_int(data[1]) && isFinite_int(data[2]) && isFinite_int(data[3]); +} + +static bool isfinite_and_float(const float data[4]) { + return isFinite_float(data[0]) && isFinite_float(data[1]) && isFinite_float(data[2]) && isFinite_float(data[3]); +} + +static bool isfinite_and_mulzero(const float data[4]) { + return isFinite_mulzero(data[0]) && isFinite_mulzero(data[1]) && isFinite_mulzero(data[2]) && isFinite_mulzero(data[3]); +} + +#define mulzeroadd(data) (data[0]*0 + data[1]*0 + data[2]*0 + data[3]*0) + +static bool isfinite_plus_int(const float data[4]) { + return isFinite_int(mulzeroadd(data)); +} + +static bool isfinite_plus_float(const float data[4]) { + return !sk_float_isnan(mulzeroadd(data)); +} + +static bool isfinite_plus_mulzero(const float data[4]) { + float x = mulzeroadd(data); + return x == x; +} + +typedef bool (*IsFiniteProc)(const float[]); + +#define MAKEREC(name) { name, #name } + +static const struct { + IsFiniteProc fProc; + const char* fName; +} gRec[] = { + MAKEREC(isfinite_and_int), + MAKEREC(isfinite_and_float), + MAKEREC(isfinite_and_mulzero), + MAKEREC(isfinite_plus_int), + MAKEREC(isfinite_plus_float), + MAKEREC(isfinite_plus_mulzero), +}; + +#undef MAKEREC + +static bool isFinite(const SkRect& r) { + // x * 0 will be NaN iff x is infinity or NaN. + // a + b will be NaN iff either a or b is NaN. + float value = r.fLeft * 0 + r.fTop * 0 + r.fRight * 0 + r.fBottom * 0; + + // value is either NaN or it is finite (zero). + // value==value will be true iff value is not NaN + return value == value; +} + +class IsFiniteBench : public SkBenchmark { + enum { + N = SkBENCHLOOP(1000), + NN = SkBENCHLOOP(1000), + }; + float fData[N]; +public: + + IsFiniteBench(void* param, int index) : INHERITED(param) { + SkRandom rand; + + for (int i = 0; i < N; ++i) { + fData[i] = rand.nextSScalar1(); + } + + if (index < 0) { + fProc = NULL; + fName = "isfinite_rect"; + } else { + fProc = gRec[index].fProc; + fName = gRec[index].fName; + } + } + +protected: + virtual void onDraw(SkCanvas* canvas) { + IsFiniteProc proc = fProc; + const float* data = fData; + // do this so the compiler won't throw away the function call + int counter = 0; + + if (proc) { + for (int j = 0; j < NN; ++j) { + for (int i = 0; i < N - 4; ++i) { + counter += proc(&data[i]); + } + } + } else { + for (int j = 0; j < NN; ++j) { + for (int i = 0; i < N - 4; ++i) { + const SkRect* r = reinterpret_cast<const SkRect*>(&data[i]); + counter += r->isFinite(); + } + } + } + + SkPaint paint; + if (paint.getAlpha() == 0) { + SkDebugf("%d\n", counter); + } + } + + virtual const char* onGetName() { + return fName; + } + +private: + IsFiniteProc fProc; + const char* fName; + + typedef SkBenchmark INHERITED; +}; + +/////////////////////////////////////////////////////////////////////////////// + +static SkBenchmark* M0(void* p) { return new NoOpMathBench(p); } +static SkBenchmark* M1(void* p) { return new SlowISqrtMathBench(p); } +static SkBenchmark* M2(void* p) { return new FastISqrtMathBench(p); } +static SkBenchmark* M3(void* p) { return new QMul64Bench(p); } +static SkBenchmark* M4(void* p) { return new QMul32Bench(p); } + +static SkBenchmark* M5neg1(void* p) { return new IsFiniteBench(p, -1); } +static SkBenchmark* M50(void* p) { return new IsFiniteBench(p, 0); } +static SkBenchmark* M51(void* p) { return new IsFiniteBench(p, 1); } +static SkBenchmark* M52(void* p) { return new IsFiniteBench(p, 2); } +static SkBenchmark* M53(void* p) { return new IsFiniteBench(p, 3); } +static SkBenchmark* M54(void* p) { return new IsFiniteBench(p, 4); } +static SkBenchmark* M55(void* p) { return new IsFiniteBench(p, 5); } + +static BenchRegistry gReg0(M0); +static BenchRegistry gReg1(M1); +static BenchRegistry gReg2(M2); +static BenchRegistry gReg3(M3); +static BenchRegistry gReg4(M4); + +static BenchRegistry gReg5neg1(M5neg1); +static BenchRegistry gReg50(M50); +static BenchRegistry gReg51(M51); +static BenchRegistry gReg52(M52); +static BenchRegistry gReg53(M53); +static BenchRegistry gReg54(M54); +static BenchRegistry gReg55(M55); diff --git a/bench/MatrixBench.cpp b/bench/MatrixBench.cpp index dce0358..a2e459a 100644 --- a/bench/MatrixBench.cpp +++ b/bench/MatrixBench.cpp @@ -1,3 +1,10 @@ + +/* + * 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 "SkBenchmark.h" #include "SkMatrix.h" #include "SkRandom.h" @@ -21,7 +28,7 @@ protected: } virtual void onDraw(SkCanvas* canvas) { - int n = N * this->mulLoopCount(); + int n = SkBENCHLOOP(N * this->mulLoopCount()); for (int i = 0; i < n; i++) { this->performTest(); } @@ -56,9 +63,6 @@ protected: always_do(m0 == m1); always_do(m1 == m2); always_do(m2 == m0); - always_do(m0.getType()); - always_do(m1.getType()); - always_do(m2.getType()); } private: typedef MatrixBench INHERITED; @@ -214,26 +218,71 @@ private: typedef MatrixBench INHERITED; }; +class GetTypeMatrixBench : public MatrixBench { +public: + GetTypeMatrixBench(void* param) + : INHERITED(param, "gettype") { + fArray[0] = (float) fRnd.nextS(); + fArray[1] = (float) fRnd.nextS(); + fArray[2] = (float) fRnd.nextS(); + fArray[3] = (float) fRnd.nextS(); + fArray[4] = (float) fRnd.nextS(); + fArray[5] = (float) fRnd.nextS(); + fArray[6] = (float) fRnd.nextS(); + fArray[7] = (float) fRnd.nextS(); + fArray[8] = (float) fRnd.nextS(); + } +protected: + // Putting random generation of the matrix inside performTest() + // would help us avoid anomalous runs, but takes up 25% or + // more of the function time. + virtual void performTest() { + fMatrix.setAll(fArray[0], fArray[1], fArray[2], + fArray[3], fArray[4], fArray[5], + fArray[6], fArray[7], fArray[8]); + always_do(fMatrix.getType()); + fMatrix.dirtyMatrixTypeCache(); + always_do(fMatrix.getType()); + fMatrix.dirtyMatrixTypeCache(); + always_do(fMatrix.getType()); + fMatrix.dirtyMatrixTypeCache(); + always_do(fMatrix.getType()); + fMatrix.dirtyMatrixTypeCache(); + always_do(fMatrix.getType()); + fMatrix.dirtyMatrixTypeCache(); + always_do(fMatrix.getType()); + fMatrix.dirtyMatrixTypeCache(); + always_do(fMatrix.getType()); + fMatrix.dirtyMatrixTypeCache(); + always_do(fMatrix.getType()); + } +private: + SkMatrix fMatrix; + float fArray[9]; + SkRandom fRnd; + typedef MatrixBench INHERITED; +}; + #ifdef SK_SCALAR_IS_FLOAT class ScaleTransMixedMatrixBench : public MatrixBench { public: ScaleTransMixedMatrixBench(void* p) : INHERITED(p, "scaletrans_mixed"), fCount (16) { - fMatrix.setAll(fRandom.nextS(), fRandom.nextS(), fRandom.nextS(), - fRandom.nextS(), fRandom.nextS(), fRandom.nextS(), - fRandom.nextS(), fRandom.nextS(), fRandom.nextS()); + fMatrix.setAll(fRandom.nextSScalar1(), fRandom.nextSScalar1(), fRandom.nextSScalar1(), + fRandom.nextSScalar1(), fRandom.nextSScalar1(), fRandom.nextSScalar1(), + fRandom.nextSScalar1(), fRandom.nextSScalar1(), fRandom.nextSScalar1()); int i; - for (i = 0; i < fCount; i++) { - fSrc[i].fX = fRandom.nextS(); - fSrc[i].fY = fRandom.nextS(); - fDst[i].fX = fRandom.nextS(); - fDst[i].fY = fRandom.nextS(); + for (i = 0; i < SkBENCHLOOP(fCount); i++) { + fSrc[i].fX = fRandom.nextSScalar1(); + fSrc[i].fY = fRandom.nextSScalar1(); + fDst[i].fX = fRandom.nextSScalar1(); + fDst[i].fY = fRandom.nextSScalar1(); } } protected: virtual void performTest() { SkPoint* dst = fDst; const SkPoint* src = fSrc; - int count = fCount; + int count = SkBENCHLOOP(fCount); float mx = fMatrix[SkMatrix::kMScaleX]; float my = fMatrix[SkMatrix::kMScaleY]; float tx = fMatrix[SkMatrix::kMTransX]; @@ -254,29 +303,28 @@ class ScaleTransMixedMatrixBench : public MatrixBench { typedef MatrixBench INHERITED; }; - class ScaleTransDoubleMatrixBench : public MatrixBench { public: ScaleTransDoubleMatrixBench(void* p) : INHERITED(p, "scaletrans_double"), fCount (16) { init9(fMatrix); int i; - for (i = 0; i < fCount; i++) { - fSrc[i].fX = fRandom.nextS(); - fSrc[i].fY = fRandom.nextS(); - fDst[i].fX = fRandom.nextS(); - fDst[i].fY = fRandom.nextS(); + for (i = 0; i < SkBENCHLOOP(fCount); i++) { + fSrc[i].fX = fRandom.nextSScalar1(); + fSrc[i].fY = fRandom.nextSScalar1(); + fDst[i].fX = fRandom.nextSScalar1(); + fDst[i].fY = fRandom.nextSScalar1(); } } protected: virtual void performTest() { SkPoint* dst = fDst; const SkPoint* src = fSrc; - int count = fCount; + int count = SkBENCHLOOP(fCount); // As doubles, on Z600 Linux systems this is 2.5x as expensive as mixed mode - float mx = fMatrix[SkMatrix::kMScaleX]; - float my = fMatrix[SkMatrix::kMScaleY]; - float tx = fMatrix[SkMatrix::kMTransX]; - float ty = fMatrix[SkMatrix::kMTransY]; + float mx = (float) fMatrix[SkMatrix::kMScaleX]; + float my = (float) fMatrix[SkMatrix::kMScaleY]; + float tx = (float) fMatrix[SkMatrix::kMTransX]; + float ty = (float) fMatrix[SkMatrix::kMTransY]; do { dst->fY = src->fY * my + ty; dst->fX = src->fX * mx + tx; @@ -303,12 +351,14 @@ static SkBenchmark* M1(void* p) { return new ScaleMatrixBench(p); } static SkBenchmark* M2(void* p) { return new FloatConcatMatrixBench(p); } static SkBenchmark* M3(void* p) { return new FloatDoubleConcatMatrixBench(p); } static SkBenchmark* M4(void* p) { return new DoubleConcatMatrixBench(p); } +static SkBenchmark* M5(void* p) { return new GetTypeMatrixBench(p); } static BenchRegistry gReg0(M0); static BenchRegistry gReg1(M1); static BenchRegistry gReg2(M2); static BenchRegistry gReg3(M3); static BenchRegistry gReg4(M4); +static BenchRegistry gReg5(M5); #ifdef SK_SCALAR_IS_FLOAT static SkBenchmark* FlM0(void* p) { return new ScaleTransMixedMatrixBench(p); } diff --git a/bench/MutexBench.cpp b/bench/MutexBench.cpp new file mode 100644 index 0000000..d9b427b --- /dev/null +++ b/bench/MutexBench.cpp @@ -0,0 +1,43 @@ +/* + * 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 "SkBenchmark.h" +#include "SkThread.h" + +class MutexBench : public SkBenchmark { + enum { + N = SkBENCHLOOP(80), + M = SkBENCHLOOP(200) + }; +public: + MutexBench(void* param) : INHERITED(param) { + + } +protected: + virtual const char* onGetName() { + return "mutex"; + } + + virtual void onDraw(SkCanvas* canvas) { + for (int i = 0; i < N; i++) { + SkMutex mu; + for (int j = 0; j < M; j++) { + mu.acquire(); + mu.release(); + } + } + } + +private: + typedef SkBenchmark INHERITED; +}; + +/////////////////////////////////////////////////////////////////////////////// + +static SkBenchmark* Fact(void* p) { return new MutexBench(p); } + +static BenchRegistry gReg01(Fact); + diff --git a/bench/PathBench.cpp b/bench/PathBench.cpp index 19e3aae..d3e01b7 100644 --- a/bench/PathBench.cpp +++ b/bench/PathBench.cpp @@ -1,8 +1,16 @@ + +/* + * 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 "SkBenchmark.h" #include "SkBitmap.h" #include "SkCanvas.h" #include "SkColorPriv.h" #include "SkPaint.h" +#include "SkRandom.h" #include "SkShader.h" #include "SkString.h" @@ -20,7 +28,7 @@ class PathBench : public SkBenchmark { SkPaint fPaint; SkString fName; Flags fFlags; - enum { N = 1000 }; + enum { N = SkBENCHLOOP(1000) }; public: PathBench(void* param, Flags flags) : INHERITED(param), fFlags(flags) { fPaint.setStyle(flags & kStroke_Flag ? SkPaint::kStroke_Style : @@ -31,7 +39,7 @@ public: virtual void appendName(SkString*) = 0; virtual void makePath(SkPath*) = 0; - virtual bool iscomplex() { return false; } + virtual int complexity() { return 0; } protected: virtual const char* onGetName() { @@ -58,9 +66,7 @@ protected: if (fFlags & kBig_Flag) { count >>= 2; } - if (this->iscomplex()) { - count >>= 3; - } + count >>= (3 * complexity()); for (int i = 0; i < count; i++) { canvas->drawPath(path, paint); @@ -146,11 +152,38 @@ public: path->lineTo(x0, y + 2 * dy); path->close(); } - virtual bool iscomplex() { return true; } + virtual int complexity() { return 1; } private: typedef PathBench INHERITED; }; +class LongCurvedPathBench : public PathBench { +public: + LongCurvedPathBench(void * param, Flags flags) + : INHERITED(param, flags) { + } + + virtual void appendName(SkString* name) { + name->append("long_curved"); + } + virtual void makePath(SkPath* path) { + SkRandom rand (12); + int i; + for (i = 0; i < 100; i++) { + path->quadTo(SkScalarMul(rand.nextUScalar1(), SkIntToScalar(640)), + SkScalarMul(rand.nextUScalar1(), SkIntToScalar(480)), + SkScalarMul(rand.nextUScalar1(), SkIntToScalar(640)), + SkScalarMul(rand.nextUScalar1(), SkIntToScalar(480))); + } + path->close(); + } + virtual int complexity() { return 2; } +private: + typedef PathBench INHERITED; +}; + + + static SkBenchmark* FactT00(void* p) { return new TrianglePathBench(p, FLAGS00); } static SkBenchmark* FactT01(void* p) { return new TrianglePathBench(p, FLAGS01); } static SkBenchmark* FactT10(void* p) { return new TrianglePathBench(p, FLAGS10); } @@ -169,6 +202,13 @@ static SkBenchmark* FactO11(void* p) { return new OvalPathBench(p, FLAGS11); } static SkBenchmark* FactS00(void* p) { return new SawToothPathBench(p, FLAGS00); } static SkBenchmark* FactS01(void* p) { return new SawToothPathBench(p, FLAGS01); } +static SkBenchmark* FactLC00(void* p) { + return new LongCurvedPathBench(p, FLAGS00); +} +static SkBenchmark* FactLC01(void* p) { + return new LongCurvedPathBench(p, FLAGS01); +} + static BenchRegistry gRegT00(FactT00); static BenchRegistry gRegT01(FactT01); static BenchRegistry gRegT10(FactT10); @@ -187,3 +227,6 @@ static BenchRegistry gRegO11(FactO11); static BenchRegistry gRegS00(FactS00); static BenchRegistry gRegS01(FactS01); +static BenchRegistry gRegLC00(FactLC00); +static BenchRegistry gRegLC01(FactLC01); + diff --git a/bench/RectBench.cpp b/bench/RectBench.cpp index fb54640..cef2e22 100644 --- a/bench/RectBench.cpp +++ b/bench/RectBench.cpp @@ -1,3 +1,10 @@ + +/* + * 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 "SkBenchmark.h" #include "SkCanvas.h" #include "SkPaint.h" @@ -11,7 +18,7 @@ public: enum { W = 640, H = 480, - N = 300 + N = SkBENCHLOOP(300) }; SkRect fRects[N]; SkColor fColors[N]; diff --git a/bench/RepeatTileBench.cpp b/bench/RepeatTileBench.cpp index 97bbeb8..8470bed 100644 --- a/bench/RepeatTileBench.cpp +++ b/bench/RepeatTileBench.cpp @@ -1,3 +1,10 @@ + +/* + * 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 "SkBenchmark.h" #include "SkBitmap.h" #include "SkCanvas.h" @@ -79,7 +86,7 @@ static void convertToIndex666(const SkBitmap& src, SkBitmap* dst) { class RepeatTileBench : public SkBenchmark { SkPaint fPaint; SkString fName; - enum { N = 20 }; + enum { N = SkBENCHLOOP(20) }; public: RepeatTileBench(void* param, SkBitmap::Config c) : INHERITED(param) { const int w = 50; diff --git a/bench/ScalarBench.cpp b/bench/ScalarBench.cpp index 29fe5c4..8bedfbd 100644 --- a/bench/ScalarBench.cpp +++ b/bench/ScalarBench.cpp @@ -1,3 +1,10 @@ + +/* + * 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 "SkBenchmark.h" #include "SkFloatBits.h" #include "SkRandom.h" @@ -21,7 +28,7 @@ protected: } virtual void onDraw(SkCanvas* canvas) { - int n = N * this->mulLoopCount(); + int n = SkBENCHLOOP(N * this->mulLoopCount()); for (int i = 0; i < n; i++) { this->performTest(); } diff --git a/bench/ShaderMaskBench.cpp b/bench/ShaderMaskBench.cpp new file mode 100644 index 0000000..62be6c5 --- /dev/null +++ b/bench/ShaderMaskBench.cpp @@ -0,0 +1,109 @@ + +/* + * 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 "SkBenchmark.h" +#include "SkCanvas.h" +#include "SkColorShader.h" +#include "SkFontHost.h" +#include "SkPaint.h" +#include "SkRandom.h" +#include "SkSfntUtils.h" +#include "SkString.h" +#include "SkTemplates.h" + +#define STR "Hamburgefons" + +enum FontQuality { + kBW, + kAA, + kLCD +}; + +static const char* fontQualityName(const SkPaint& paint) { + if (!paint.isAntiAlias()) { + return "BW"; + } + if (paint.isLCDRenderText()) { + return "LCD"; + } + return "AA"; +} + +class ShaderMaskBench : public SkBenchmark { + SkPaint fPaint; + SkString fText; + SkString fName; + FontQuality fFQ; + enum { N = SkBENCHLOOP(500) }; +public: + ShaderMaskBench(void* param, bool isOpaque, FontQuality fq) : INHERITED(param) { + fFQ = fq; + fText.set(STR); + + fPaint.setAntiAlias(kBW != fq); + fPaint.setLCDRenderText(kLCD == fq); + fPaint.setAlpha(isOpaque ? 0xFF : 0x80); + fPaint.setShader(new SkColorShader)->unref(); + } + +protected: + virtual const char* onGetName() { + fName.printf("shadermask", SkScalarToFloat(fPaint.getTextSize())); + fName.appendf("_%s", fontQualityName(fPaint)); + fName.appendf("_%02X", fPaint.getAlpha()); + return fName.c_str(); + } + + virtual void onDraw(SkCanvas* canvas) { + const SkIPoint dim = this->getSize(); + SkRandom rand; + + SkPaint paint(fPaint); + this->setupPaint(&paint); + // explicitly need these + paint.setAlpha(fPaint.getAlpha()); + paint.setAntiAlias(kBW != fFQ); + paint.setLCDRenderText(kLCD == fFQ); + + const SkScalar x0 = SkIntToScalar(-10); + const SkScalar y0 = SkIntToScalar(-10); + + paint.setTextSize(SkIntToScalar(12)); + for (int i = 0; i < N; i++) { + SkScalar x = x0 + rand.nextUScalar1() * dim.fX; + SkScalar y = y0 + rand.nextUScalar1() * dim.fY; + canvas->drawText(fText.c_str(), fText.size(), x, y, paint); + } + + paint.setTextSize(SkIntToScalar(48)); + for (int i = 0; i < N/4; i++) { + SkScalar x = x0 + rand.nextUScalar1() * dim.fX; + SkScalar y = y0 + rand.nextUScalar1() * dim.fY; + canvas->drawText(fText.c_str(), fText.size(), x, y, paint); + } + } + +private: + typedef SkBenchmark INHERITED; +}; + +/////////////////////////////////////////////////////////////////////////////// + +static SkBenchmark* Fact00(void* p) { return new ShaderMaskBench(p, true, kBW); } +static SkBenchmark* Fact01(void* p) { return new ShaderMaskBench(p, false, kBW); } +static SkBenchmark* Fact10(void* p) { return new ShaderMaskBench(p, true, kAA); } +static SkBenchmark* Fact11(void* p) { return new ShaderMaskBench(p, false, kAA); } +static SkBenchmark* Fact20(void* p) { return new ShaderMaskBench(p, true, kLCD); } +static SkBenchmark* Fact21(void* p) { return new ShaderMaskBench(p, false, kLCD); } + +static BenchRegistry gReg00(Fact00); +static BenchRegistry gReg01(Fact01); +static BenchRegistry gReg10(Fact10); +static BenchRegistry gReg11(Fact11); +static BenchRegistry gReg20(Fact20); +static BenchRegistry gReg21(Fact21); + diff --git a/bench/SkBenchmark.cpp b/bench/SkBenchmark.cpp index 230a7af..a69402b 100644 --- a/bench/SkBenchmark.cpp +++ b/bench/SkBenchmark.cpp @@ -1,3 +1,10 @@ + +/* + * 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 "SkBenchmark.h" #include "SkPaint.h" #include "SkParse.h" diff --git a/bench/SkBenchmark.h b/bench/SkBenchmark.h index 945db80..5019b23 100644 --- a/bench/SkBenchmark.h +++ b/bench/SkBenchmark.h @@ -1,3 +1,10 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ #ifndef SkBenchmark_DEFINED #define SkBenchmark_DEFINED @@ -6,6 +13,12 @@ #include "SkTDict.h" #include "SkTRegistry.h" +#ifdef SK_DEBUG + #define SkBENCHLOOP(n) 1 +#else + #define SkBENCHLOOP(n) n +#endif + class SkCanvas; class SkPaint; diff --git a/bench/TextBench.cpp b/bench/TextBench.cpp index f2b9604..63a7167 100644 --- a/bench/TextBench.cpp +++ b/bench/TextBench.cpp @@ -1,3 +1,10 @@ + +/* + * 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 "SkBenchmark.h" #include "SkCanvas.h" #include "SkFontHost.h" @@ -7,6 +14,22 @@ #include "SkString.h" #include "SkTemplates.h" +enum FontQuality { + kBW, + kAA, + kLCD +}; + +static const char* fontQualityName(const SkPaint& paint) { + if (!paint.isAntiAlias()) { + return "BW"; + } + if (paint.isLCDRenderText()) { + return "LCD"; + } + return "AA"; +} + /* Some considerations for performance: short -vs- long strings (measuring overhead) tiny -vs- large pointsize (measure blit -vs- overhead) @@ -18,34 +41,35 @@ */ class TextBench : public SkBenchmark { SkPaint fPaint; - int fCount; - SkPoint* fPos; SkString fText; SkString fName; - enum { N = 600 }; + FontQuality fFQ; + bool fDoPos; + SkPoint* fPos; + enum { N = SkBENCHLOOP(800) }; public: - TextBench(void* param, const char text[], int ps, bool linearText, - bool posText, SkColor color = SK_ColorBLACK) : INHERITED(param) { + TextBench(void* param, const char text[], int ps, + SkColor color, FontQuality fq, bool doPos = false) : INHERITED(param) { + fFQ = fq; + fDoPos = doPos; fText.set(text); - fPaint.setAntiAlias(true); + fPaint.setAntiAlias(kBW != fq); + fPaint.setLCDRenderText(kLCD == fq); fPaint.setTextSize(SkIntToScalar(ps)); - fPaint.setLinearText(linearText); fPaint.setColor(color); - if (posText) { - SkAutoTArray<SkScalar> storage(fText.size()); - SkScalar* widths = storage.get(); - fCount = fPaint.getTextWidths(fText.c_str(), fText.size(), widths); - fPos = new SkPoint[fCount]; + if (doPos) { + size_t len = strlen(text); + SkScalar* adv = new SkScalar[len]; + fPaint.getTextWidths(text, len, adv); + fPos = new SkPoint[len]; SkScalar x = 0; - for (int i = 0; i < fCount; i++) { - fPos[i].set(x, 0); - x += widths[i]; + for (size_t i = 0; i < len; ++i) { + fPos[i].set(x, SkIntToScalar(50)); + x += adv[i]; } - } else { - fCount = 0; - fPos = NULL; + delete[] adv; } } @@ -56,15 +80,14 @@ public: protected: virtual const char* onGetName() { fName.printf("text_%g", SkScalarToFloat(fPaint.getTextSize())); - if (fPaint.isLinearText()) { - fName.append("_linear"); - } - if (fPos) { - fName.append("_pos"); + if (fDoPos) { + fName.appendf("_pos"); } - + fName.appendf("_%s", fontQualityName(fPaint)); if (SK_ColorBLACK != fPaint.getColor()) { fName.appendf("_%02X", fPaint.getAlpha()); + } else { + fName.appendf("_BK"); } return fName.c_str(); } @@ -75,20 +98,26 @@ protected: SkPaint paint(fPaint); this->setupPaint(&paint); - paint.setColor(fPaint.getColor()); // need our specified color + // explicitly need these + paint.setColor(fPaint.getColor()); + paint.setAntiAlias(kBW != fFQ); + paint.setLCDRenderText(kLCD == fFQ); const SkScalar x0 = SkIntToScalar(-10); const SkScalar y0 = SkIntToScalar(-10); + if (fDoPos) { + // realistically, the matrix is often at least translated, so we + // do that since it exercises different code in drawPosText. + canvas->translate(SK_Scalar1, SK_Scalar1); + } + for (int i = 0; i < N; i++) { - SkScalar x = x0 + rand.nextUScalar1() * dim.fX; - SkScalar y = y0 + rand.nextUScalar1() * dim.fY; - if (fPos) { - canvas->save(SkCanvas::kMatrix_SaveFlag); - canvas->translate(x, y); + if (fDoPos) { canvas->drawPosText(fText.c_str(), fText.size(), fPos, paint); - canvas->restore(); } else { + SkScalar x = x0 + rand.nextUScalar1() * dim.fX; + SkScalar y = y0 + rand.nextUScalar1() * dim.fY; canvas->drawText(fText.c_str(), fText.size(), x, y, paint); } } @@ -101,35 +130,31 @@ private: /////////////////////////////////////////////////////////////////////////////// #define STR "Hamburgefons" -#define SMALL 9 -#define BIG 48 -static SkBenchmark* Fact0(void* p) { return new TextBench(p, STR, SMALL, false, false); } -static SkBenchmark* Fact01(void* p) { return new TextBench(p, STR, SMALL, false, false, 0xFFFF0000); } -static SkBenchmark* Fact02(void* p) { return new TextBench(p, STR, SMALL, false, false, 0x88FF0000); } +static SkBenchmark* Fact01(void* p) { return new TextBench(p, STR, 16, 0xFF000000, kBW); } +static SkBenchmark* Fact02(void* p) { return new TextBench(p, STR, 16, 0xFFFF0000, kBW); } +static SkBenchmark* Fact03(void* p) { return new TextBench(p, STR, 16, 0x88FF0000, kBW); } -static SkBenchmark* Fact1(void* p) { return new TextBench(p, STR, SMALL, false, true); } -static SkBenchmark* Fact2(void* p) { return new TextBench(p, STR, SMALL, true, false); } -static SkBenchmark* Fact3(void* p) { return new TextBench(p, STR, SMALL, true, true); } +static SkBenchmark* Fact11(void* p) { return new TextBench(p, STR, 16, 0xFF000000, kAA); } +static SkBenchmark* Fact12(void* p) { return new TextBench(p, STR, 16, 0xFFFF0000, kAA); } +static SkBenchmark* Fact13(void* p) { return new TextBench(p, STR, 16, 0x88FF0000, kAA); } -static SkBenchmark* Fact4(void* p) { return new TextBench(p, STR, BIG, false, false); } -static SkBenchmark* Fact41(void* p) { return new TextBench(p, STR, BIG, false, false, 0xFFFF0000); } -static SkBenchmark* Fact42(void* p) { return new TextBench(p, STR, BIG, false, false, 0x88FF0000); } +static SkBenchmark* Fact21(void* p) { return new TextBench(p, STR, 16, 0xFF000000, kLCD); } +static SkBenchmark* Fact22(void* p) { return new TextBench(p, STR, 16, 0xFFFF0000, kLCD); } +static SkBenchmark* Fact23(void* p) { return new TextBench(p, STR, 16, 0x88FF0000, kLCD); } -static SkBenchmark* Fact5(void* p) { return new TextBench(p, STR, BIG, false, true); } -static SkBenchmark* Fact6(void* p) { return new TextBench(p, STR, BIG, true, false); } -static SkBenchmark* Fact7(void* p) { return new TextBench(p, STR, BIG, true, true); } +static SkBenchmark* Fact111(void* p) { return new TextBench(p, STR, 16, 0xFF000000, kAA, true); } -static BenchRegistry gReg0(Fact0); static BenchRegistry gReg01(Fact01); static BenchRegistry gReg02(Fact02); -static BenchRegistry gReg1(Fact1); -static BenchRegistry gReg2(Fact2); -static BenchRegistry gReg3(Fact3); -static BenchRegistry gReg4(Fact4); -static BenchRegistry gReg41(Fact41); -static BenchRegistry gReg42(Fact42); -static BenchRegistry gReg5(Fact5); -static BenchRegistry gReg6(Fact6); -static BenchRegistry gReg7(Fact7); +static BenchRegistry gReg03(Fact03); + +static BenchRegistry gReg11(Fact11); +static BenchRegistry gReg12(Fact12); +static BenchRegistry gReg13(Fact13); + +static BenchRegistry gReg21(Fact21); +static BenchRegistry gReg22(Fact22); +static BenchRegistry gReg23(Fact23); +static BenchRegistry gReg111(Fact111); diff --git a/bench/VertBench.cpp b/bench/VertBench.cpp new file mode 100644 index 0000000..98df449 --- /dev/null +++ b/bench/VertBench.cpp @@ -0,0 +1,99 @@ +/* + * 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 "SkBenchmark.h" +#include "SkCanvas.h" +#include "SkPaint.h" +#include "SkRandom.h" +#include "SkString.h" +#include "SkShader.h" + +enum VertFlags { + kColors_VertFlag, + kTexture_VertFlag, +}; + +class VertBench : public SkBenchmark { + SkString fName; + enum { + W = 640, + H = 480, + ROW = 20, + COL = 20, + PTS = (ROW + 1) * (COL + 1), + IDX = ROW * COL * 6, + N = SkBENCHLOOP(10) + }; + + SkPoint fPts[PTS]; + SkColor fColors[PTS]; + SkPoint fTex[PTS]; + uint16_t fIdx[IDX]; + + static void load_2_tris(uint16_t idx[], int x, int y, int rb) { + int n = y * rb + x; + idx[0] = n; idx[1] = n + 1; idx[2] = rb + n + 1; + idx[3] = n; idx[4] = rb + n + 1; idx[5] = n + rb; + } + +public: + VertBench(void* param) : INHERITED(param) { + const SkScalar dx = SkIntToScalar(W) / COL; + const SkScalar dy = SkIntToScalar(H) / COL; + + SkPoint* pts = fPts; + uint16_t* idx = fIdx; + + SkScalar yy = 0; + for (int y = 0; y <= ROW; y++) { + SkScalar xx = 0; + for (int x = 0; x <= COL; ++x) { + pts->set(xx, yy); + pts += 1; + xx += dx; + + if (x < COL && y < ROW) { + load_2_tris(idx, x, y, COL + 1); + for (int i = 0; i < 6; i++) { + SkASSERT(idx[i] < PTS); + } + idx += 6; + } + } + yy += dy; + } + SkASSERT(PTS == pts - fPts); + SkASSERT(IDX == idx - fIdx); + + SkRandom rand; + for (int i = 0; i < PTS; ++i) { + fColors[i] = rand.nextU() | (0xFF << 24); + } + + fName.set("verts"); + } + +protected: + virtual const char* onGetName() { return fName.c_str(); } + virtual void onDraw(SkCanvas* canvas) { + SkPaint paint; + this->setupPaint(&paint); + + for (int i = 0; i < N; i++) { + canvas->drawVertices(SkCanvas::kTriangles_VertexMode, PTS, + fPts, NULL, fColors, NULL, fIdx, IDX, paint); + } + } +private: + typedef SkBenchmark INHERITED; +}; + +/////////////////////////////////////////////////////////////////////////////// + +static SkBenchmark* Fact(void* p) { return SkNEW_ARGS(VertBench, (p)); } + +static BenchRegistry gReg(Fact); diff --git a/bench/bench_compare.py b/bench/bench_compare.py index f6909b1..c1a1ff9 100644 --- a/bench/bench_compare.py +++ b/bench/bench_compare.py @@ -5,31 +5,7 @@ Created on May 16, 2011 ''' import sys import getopt -import re - -def parse(lines): - """Takes iterable lines of bench output, returns {bench:{config:time}}.""" - - benches = {} - current_bench = None - - for line in lines: - #see if this line starts a new bench - new_bench = re.search('running bench \[\d+ \d+\] (.{28})', line) - if new_bench: - current_bench = new_bench.group(1) - - #add configs on this line to the current bench - if current_bench: - for new_config in re.finditer(' (.{4}): msecs = (\d+\.\d+)', line): - current_config = new_config.group(1) - current_time = float(new_config.group(2)) - if current_bench in benches: - benches[current_bench][current_config] = current_time - else: - benches[current_bench] = {current_config : current_time} - - return benches +import bench_util def usage(): """Prints simple usage information.""" @@ -38,20 +14,39 @@ def usage(): print '-n <file> the new bench output file.' print '-h causes headers to be output.' print '-f <fieldSpec> which fields to output and in what order.' - print ' Not specifying is the same as -f "bcondp".' + print ' Not specifying is the same as -f "bctondp".' print ' b: bench' print ' c: config' + print ' t: time type' print ' o: old time' print ' n: new time' print ' d: diff' print ' p: percent diff' - +class BenchDiff: + """A compare between data points produced by bench. + + (BenchDataPoint, BenchDataPoint)""" + def __init__(self, old, new): + self.old = old + self.new = new + self.diff = old.time - new.time + diffp = 0 + if old.time != 0: + diffp = self.diff / old.time + self.diffp = diffp + + def __repr__(self): + return "BenchDiff(%s, %s)" % ( + str(self.new), + str(self.old), + ) + def main(): """Parses command line and writes output.""" try: - opts, args = getopt.getopt(sys.argv[1:], "f:o:n:h") + opts, _ = getopt.getopt(sys.argv[1:], "f:o:n:h") except getopt.GetoptError, err: print str(err) usage() @@ -60,25 +55,27 @@ def main(): column_formats = { 'b' : '{bench: >28} ', 'c' : '{config: <4} ', + 't' : '{time_type: <4} ', 'o' : '{old_time: >10.2f} ', 'n' : '{new_time: >10.2f} ', 'd' : '{diff: >+10.2f} ', - 'p' : '{diffp: >+7.1%} ', + 'p' : '{diffp: >+8.1%} ', } header_formats = { 'b' : '{bench: >28} ', 'c' : '{config: <4} ', + 't' : '{time_type: <4} ', 'o' : '{old_time: >10} ', 'n' : '{new_time: >10} ', 'd' : '{diff: >10} ', - 'p' : '{diffp: >7} ', + 'p' : '{diffp: >8} ', } old = None new = None column_format = "" header_format = "" - columns = 'bcondp' + columns = 'bctondp' header = False for option, value in opts: @@ -110,31 +107,43 @@ def main(): print header_format.format( bench='bench' , config='conf' + , time_type='time' , old_time='old' , new_time='new' , diff='diff' , diffp='diffP' ) - old_benches = parse(open(old, 'r')) - new_benches = parse(open(new, 'r')) - - for old_bench, old_configs in old_benches.items(): - if old_bench in new_benches: - new_configs = new_benches[old_bench] - for old_config, old_time in old_configs.items(): - if old_config in new_configs: - new_time = new_configs[old_config] - old_time = old_configs[old_config] - print column_format.format( - bench=old_bench.strip() - , config=old_config.strip() - , old_time=old_time - , new_time=new_time - , diff=(old_time - new_time) - , diffp=((old_time-new_time)/old_time) - ) - + old_benches = bench_util.parse({}, open(old, 'r')) + new_benches = bench_util.parse({}, open(new, 'r')) + + bench_diffs = [] + for old_bench in old_benches: + #filter new_benches for benches that match old_bench + new_bench_match = [bench for bench in new_benches + if old_bench.bench == bench.bench and + old_bench.config == bench.config and + old_bench.time_type == bench.time_type + ] + if (len(new_bench_match) < 1): + continue + bench_diffs.append(BenchDiff(old_bench, new_bench_match[0])) + + bench_diffs.sort(key=lambda d : [d.diffp, + d.old.bench, + d.old.config, + d.old.time_type, + ]) + for bench_diff in bench_diffs: + print column_format.format( + bench=bench_diff.old.bench.strip() + , config=bench_diff.old.config.strip() + , time_type=bench_diff.old.time_type + , old_time=bench_diff.old.time + , new_time=bench_diff.new.time + , diff=bench_diff.diff + , diffp=bench_diff.diffp + ) if __name__ == "__main__": main() diff --git a/bench/bench_graph_svg.py b/bench/bench_graph_svg.py new file mode 100644 index 0000000..d8cd54b --- /dev/null +++ b/bench/bench_graph_svg.py @@ -0,0 +1,750 @@ +''' +Created on May 16, 2011 + +@author: bungeman +''' +import sys +import getopt +import re +import os +import bench_util +import json +import xml.sax.saxutils + +def usage(): + """Prints simple usage information.""" + + print '-d <dir> a directory containing bench_r<revision>_<scalar> files.' + print '-b <bench> the bench to show.' + print '-c <config> the config to show (GPU, 8888, 565, etc).' + print '-t <time> the time to show (w, c, g, etc).' + print '-s <setting>[=<value>] a setting to show (alpha, scalar, etc).' + print '-r <revision>[:<revision>] the revisions to show.' + print ' Negative <revision> is taken as offset from most recent revision.' + print '-f <revision>[:<revision>] the revisions to use for fitting.' + print ' Negative <revision> is taken as offset from most recent revision.' + print '-x <int> the desired width of the svg.' + print '-y <int> the desired height of the svg.' + print '-l <title> title to use for the output graph' + print '--default-setting <setting>[=<value>] setting for those without.' + + +class Label: + """The information in a label. + + (str, str, str, str, {str:str})""" + def __init__(self, bench, config, time_type, settings): + self.bench = bench + self.config = config + self.time_type = time_type + self.settings = settings + + def __repr__(self): + return "Label(%s, %s, %s, %s)" % ( + str(self.bench), + str(self.config), + str(self.time_type), + str(self.settings), + ) + + def __str__(self): + return "%s_%s_%s_%s" % ( + str(self.bench), + str(self.config), + str(self.time_type), + str(self.settings), + ) + + def __eq__(self, other): + return (self.bench == other.bench and + self.config == other.config and + self.time_type == other.time_type and + self.settings == other.settings) + + def __hash__(self): + return (hash(self.bench) ^ + hash(self.config) ^ + hash(self.time_type) ^ + hash(frozenset(self.settings.iteritems()))) + +def get_latest_revision(directory): + """Returns the latest revision number found within this directory. + """ + latest_revision_found = -1 + for bench_file in os.listdir(directory): + file_name_match = re.match('bench_r(\d+)_(\S+)', bench_file) + if (file_name_match is None): + continue + revision = int(file_name_match.group(1)) + if revision > latest_revision_found: + latest_revision_found = revision + if latest_revision_found < 0: + return None + else: + return latest_revision_found + +def parse_dir(directory, default_settings, oldest_revision, newest_revision): + """Parses bench data from files like bench_r<revision>_<scalar>. + + (str, {str, str}, Number, Number) -> {int:[BenchDataPoints]}""" + revision_data_points = {} # {revision : [BenchDataPoints]} + for bench_file in os.listdir(directory): + file_name_match = re.match('bench_r(\d+)_(\S+)', bench_file) + if (file_name_match is None): + continue + + revision = int(file_name_match.group(1)) + scalar_type = file_name_match.group(2) + + if (revision < oldest_revision or revision > newest_revision): + continue + + file_handle = open(directory + '/' + bench_file, 'r') + + if (revision not in revision_data_points): + revision_data_points[revision] = [] + default_settings['scalar'] = scalar_type + revision_data_points[revision].extend( + bench_util.parse(default_settings, file_handle)) + file_handle.close() + return revision_data_points + +def create_lines(revision_data_points, settings + , bench_of_interest, config_of_interest, time_of_interest): + """Convert revision data into sorted line data. + + ({int:[BenchDataPoints]}, {str:str}, str?, str?, str?) + -> {Label:[(x,y)] | [n].x <= [n+1].x}""" + revisions = revision_data_points.keys() + revisions.sort() + lines = {} # {Label:[(x,y)] | x[n] <= x[n+1]} + for revision in revisions: + for point in revision_data_points[revision]: + if (bench_of_interest is not None and + not bench_of_interest == point.bench): + continue + + if (config_of_interest is not None and + not config_of_interest == point.config): + continue + + if (time_of_interest is not None and + not time_of_interest == point.time_type): + continue + + skip = False + for key, value in settings.items(): + if key in point.settings and point.settings[key] != value: + skip = True + break + if skip: + continue + + line_name = Label(point.bench + , point.config + , point.time_type + , point.settings) + + if line_name not in lines: + lines[line_name] = [] + + lines[line_name].append((revision, point.time)) + + return lines + +def bounds(lines): + """Finds the bounding rectangle for the lines. + + {Label:[(x,y)]} -> ((min_x, min_y),(max_x,max_y))""" + min_x = bench_util.Max + min_y = bench_util.Max + max_x = bench_util.Min + max_y = bench_util.Min + + for line in lines.itervalues(): + for x, y in line: + min_x = min(min_x, x) + min_y = min(min_y, y) + max_x = max(max_x, x) + max_y = max(max_y, y) + + return ((min_x, min_y), (max_x, max_y)) + +def create_regressions(lines, start_x, end_x): + """Creates regression data from line segments. + + ({Label:[(x,y)] | [n].x <= [n+1].x}, Number, Number) + -> {Label:LinearRegression}""" + regressions = {} # {Label : LinearRegression} + + for label, line in lines.iteritems(): + regression_line = [p for p in line if start_x <= p[0] <= end_x] + + if (len(regression_line) < 2): + continue + regression = bench_util.LinearRegression(regression_line) + regressions[label] = regression + + return regressions + +def bounds_slope(regressions): + """Finds the extreme up and down slopes of a set of linear regressions. + + ({Label:LinearRegression}) -> (max_up_slope, min_down_slope)""" + max_up_slope = 0 + min_down_slope = 0 + for regression in regressions.itervalues(): + min_slope = regression.find_min_slope() + max_up_slope = max(max_up_slope, min_slope) + min_down_slope = min(min_down_slope, min_slope) + + return (max_up_slope, min_down_slope) + +def main(): + """Parses command line and writes output.""" + + try: + opts, _ = getopt.getopt(sys.argv[1:] + , "d:b:c:l:t:s:r:f:x:y:" + , "default-setting=") + except getopt.GetoptError, err: + print str(err) + usage() + sys.exit(2) + + directory = None + config_of_interest = None + bench_of_interest = None + time_of_interest = None + revision_range = '0:' + regression_range = '0:' + latest_revision = None + requested_height = None + requested_width = None + title = 'Bench graph' + settings = {} + default_settings = {} + + def parse_range(range): + """Takes '<old>[:<new>]' as a string and returns (old, new). + Any revision numbers that are dependent on the latest revision number + will be filled in based on latest_revision. + """ + old, _, new = range.partition(":") + old = int(old) + if old < 0: + old += latest_revision; + if not new: + new = latest_revision; + new = int(new) + if new < 0: + new += latest_revision; + return (old, new) + + def add_setting(settings, setting): + """Takes <key>[=<value>] adds {key:value} or {key:True} to settings.""" + name, _, value = setting.partition('=') + if not value: + settings[name] = True + else: + settings[name] = value + + try: + for option, value in opts: + if option == "-d": + directory = value + elif option == "-b": + bench_of_interest = value + elif option == "-c": + config_of_interest = value + elif option == "-t": + time_of_interest = value + elif option == "-s": + add_setting(settings, value) + elif option == "-r": + revision_range = value + elif option == "-f": + regression_range = value + elif option == "-x": + requested_width = int(value) + elif option == "-y": + requested_height = int(value) + elif option == "-l": + title = value + elif option == "--default-setting": + add_setting(default_settings, value) + else: + usage() + assert False, "unhandled option" + except ValueError: + usage() + sys.exit(2) + + if directory is None: + usage() + sys.exit(2) + + latest_revision = get_latest_revision(directory) + oldest_revision, newest_revision = parse_range(revision_range) + oldest_regression, newest_regression = parse_range(regression_range) + + revision_data_points = parse_dir(directory + , default_settings + , oldest_revision + , newest_revision) + + # Update oldest_revision and newest_revision based on the data we could find + all_revision_numbers = revision_data_points.keys() + oldest_revision = min(all_revision_numbers) + newest_revision = max(all_revision_numbers) + + lines = create_lines(revision_data_points + , settings + , bench_of_interest + , config_of_interest + , time_of_interest) + + regressions = create_regressions(lines + , oldest_regression + , newest_regression) + + output_xhtml(lines, oldest_revision, newest_revision, + regressions, requested_width, requested_height, title) + +def qa(out): + """Stringify input and quote as an xml attribute.""" + return xml.sax.saxutils.quoteattr(str(out)) +def qe(out): + """Stringify input and escape as xml data.""" + return xml.sax.saxutils.escape(str(out)) + +def create_select(qualifier, lines, select_id=None): + """Output select with options showing lines which qualifier maps to it. + + ((Label) -> str, {Label:_}, str?) -> _""" + options = {} #{ option : [Label]} + for label in lines.keys(): + option = qualifier(label) + if (option not in options): + options[option] = [] + options[option].append(label) + option_list = list(options.keys()) + option_list.sort() + print '<select class="lines"', + if select_id is not None: + print 'id=%s' % qa(select_id) + print 'multiple="true" size="10" onchange="updateSvg();">' + for option in option_list: + print '<option value=' + qa('[' + + reduce(lambda x,y:x+json.dumps(str(y))+',',options[option],"")[0:-1] + + ']') + '>'+qe(option)+'</option>' + print '</select>' + +def output_xhtml(lines, oldest_revision, newest_revision, + regressions, requested_width, requested_height, title): + """Outputs an svg/xhtml view of the data.""" + print '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"', + print '"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">' + print '<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">' + print '<head>' + print '<title>%s</title>' % title + print '</head>' + print '<body>' + + output_svg(lines, regressions, requested_width, requested_height) + + #output the manipulation controls + print """ +<script type="text/javascript">//<![CDATA[ + function getElementsByClass(node, searchClass, tag) { + var classElements = new Array(); + var elements = node.getElementsByTagName(tag); + var pattern = new RegExp("^|\\s"+searchClass+"\\s|$"); + for (var i = 0, elementsFound = 0; i < elements.length; ++i) { + if (pattern.test(elements[i].className)) { + classElements[elementsFound] = elements[i]; + ++elementsFound; + } + } + return classElements; + } + function getAllLines() { + var selectElem = document.getElementById('benchSelect'); + var linesObj = {}; + for (var i = 0; i < selectElem.options.length; ++i) { + var lines = JSON.parse(selectElem.options[i].value); + for (var j = 0; j < lines.length; ++j) { + linesObj[lines[j]] = true; + } + } + return linesObj; + } + function getOptions(selectElem) { + var linesSelectedObj = {}; + for (var i = 0; i < selectElem.options.length; ++i) { + if (!selectElem.options[i].selected) continue; + + var linesSelected = JSON.parse(selectElem.options[i].value); + for (var j = 0; j < linesSelected.length; ++j) { + linesSelectedObj[linesSelected[j]] = true; + } + } + return linesSelectedObj; + } + function objectEmpty(obj) { + for (var p in obj) { + return false; + } + return true; + } + function markSelectedLines(selectElem, allLines) { + var linesSelected = getOptions(selectElem); + if (!objectEmpty(linesSelected)) { + for (var line in allLines) { + allLines[line] &= (linesSelected[line] == true); + } + } + } + function updateSvg() { + var allLines = getAllLines(); + + var selects = getElementsByClass(document, 'lines', 'select'); + for (var i = 0; i < selects.length; ++i) { + markSelectedLines(selects[i], allLines); + } + + for (var line in allLines) { + var svgLine = document.getElementById(line); + var display = (allLines[line] ? 'inline' : 'none'); + svgLine.setAttributeNS(null,'display', display); + } + } + + function mark(markerId) { + for (var line in getAllLines()) { + var svgLineGroup = document.getElementById(line); + var display = svgLineGroup.getAttributeNS(null,'display'); + if (display == null || display == "" || display != "none") { + var svgLine = document.getElementById(line+'_line'); + if (markerId == null) { + svgLine.removeAttributeNS(null,'marker-mid'); + } else { + svgLine.setAttributeNS(null,'marker-mid', markerId); + } + } + } + } +//]]></script>""" + + print '<table border="0" width="%s">' % requested_width + print """ +<form> +<tr valign="bottom" align="center"> +<td width="1">Bench Type</td> +<td width="1">Bitmap Config</td> +<td width="1">Timer Type (Cpu/Gpu/wall)</td> +<td width="1"><!--buttons--></td> +<td width="10%"><!--spacing--></td>""" + + print '<td>%s<br></br>revisions r%s - r%s</td>' % ( + title, + bench_util.CreateRevisionLink(oldest_revision), + bench_util.CreateRevisionLink(newest_revision)) + print '</tr><tr valign="top" align="center">' + print '<td width="1">' + create_select(lambda l: l.bench, lines, 'benchSelect') + print '</td><td width="1">' + create_select(lambda l: l.config, lines) + print '</td><td width="1">' + create_select(lambda l: l.time_type, lines) + + all_settings = {} + variant_settings = set() + for label in lines.keys(): + for key, value in label.settings.items(): + if key not in all_settings: + all_settings[key] = value + elif all_settings[key] != value: + variant_settings.add(key) + + for k in variant_settings: + create_select(lambda l: l.settings[k], lines) + + print '</td><td width="1"><button type="button"', + print 'onclick=%s' % qa("mark('url(#circleMark)'); return false;"), + print '>Mark Points</button>' + print '<button type="button" onclick="mark(null);">Clear Points</button>' + + print """ +</td> +<td width="10%"></td> +<td align="left"> +<p>Brighter red indicates tests that have gotten worse; brighter green +indicates tests that have gotten better.</p> +<p>To highlight individual tests, hold down CONTROL and mouse over +graph lines.</p> +<p>To highlight revision numbers, hold down SHIFT and mouse over +the graph area.</p> +<p>To only show certain tests on the graph, select any combination of +tests in the selectors at left. (To show all, select all.)</p> +<p>Use buttons at left to mark/clear points on the lines for selected +benchmarks.</p> +</td> +</tr> +</form> +</table> +</body> +</html>""" + +def compute_size(requested_width, requested_height, rev_width, time_height): + """Converts potentially empty requested size into a concrete size. + + (Number?, Number?) -> (Number, Number)""" + pic_width = 0 + pic_height = 0 + if (requested_width is not None and requested_height is not None): + pic_height = requested_height + pic_width = requested_width + + elif (requested_width is not None): + pic_width = requested_width + pic_height = pic_width * (float(time_height) / rev_width) + + elif (requested_height is not None): + pic_height = requested_height + pic_width = pic_height * (float(rev_width) / time_height) + + else: + pic_height = 800 + pic_width = max(rev_width*3 + , pic_height * (float(rev_width) / time_height)) + + return (pic_width, pic_height) + +def output_svg(lines, regressions, requested_width, requested_height): + """Outputs an svg view of the data.""" + + (global_min_x, _), (global_max_x, global_max_y) = bounds(lines) + max_up_slope, min_down_slope = bounds_slope(regressions) + + #output + global_min_y = 0 + x = global_min_x + y = global_min_y + w = global_max_x - global_min_x + h = global_max_y - global_min_y + font_size = 16 + line_width = 2 + + pic_width, pic_height = compute_size(requested_width, requested_height + , w, h) + + def cw(w1): + """Converts a revision difference to display width.""" + return (pic_width / float(w)) * w1 + def cx(x): + """Converts a revision to a horizontal display position.""" + return cw(x - global_min_x) + + def ch(h1): + """Converts a time difference to a display height.""" + return -(pic_height / float(h)) * h1 + def cy(y): + """Converts a time to a vertical display position.""" + return pic_height + ch(y - global_min_y) + + print '<svg', + print 'width=%s' % qa(str(pic_width)+'px') + print 'height=%s' % qa(str(pic_height)+'px') + print 'viewBox="0 0 %s %s"' % (str(pic_width), str(pic_height)) + print 'onclick=%s' % qa( + "var event = arguments[0] || window.event;" + " if (event.shiftKey) { highlightRevision(null); }" + " if (event.ctrlKey) { highlight(null); }" + " return false;") + print 'xmlns="http://www.w3.org/2000/svg"' + print 'xmlns:xlink="http://www.w3.org/1999/xlink">' + + print """ +<defs> + <marker id="circleMark" + viewBox="0 0 2 2" refX="1" refY="1" + markerUnits="strokeWidth" + markerWidth="2" markerHeight="2" + orient="0"> + <circle cx="1" cy="1" r="1"/> + </marker> +</defs>""" + + #output the revisions + print """ +<script type="text/javascript">//<![CDATA[ + var previousRevision; + var previousRevisionFill; + var previousRevisionStroke + function highlightRevision(id) { + if (previousRevision == id) return; + + document.getElementById('revision').firstChild.nodeValue = 'r' + id; + document.getElementById('rev_link').setAttribute('xlink:href', + 'http://code.google.com/p/skia/source/detail?r=' + id); + + var preRevision = document.getElementById(previousRevision); + if (preRevision) { + preRevision.setAttributeNS(null,'fill', previousRevisionFill); + preRevision.setAttributeNS(null,'stroke', previousRevisionStroke); + } + + var revision = document.getElementById(id); + previousRevision = id; + if (revision) { + previousRevisionFill = revision.getAttributeNS(null,'fill'); + revision.setAttributeNS(null,'fill','rgb(100%, 95%, 95%)'); + + previousRevisionStroke = revision.getAttributeNS(null,'stroke'); + revision.setAttributeNS(null,'stroke','rgb(100%, 90%, 90%)'); + } + } +//]]></script>""" + + def print_rect(x, y, w, h, revision): + """Outputs a revision rectangle in display space, + taking arguments in revision space.""" + disp_y = cy(y) + disp_h = ch(h) + if disp_h < 0: + disp_y += disp_h + disp_h = -disp_h + + print '<rect id=%s x=%s y=%s' % (qa(revision), qa(cx(x)), qa(disp_y),), + print 'width=%s height=%s' % (qa(cw(w)), qa(disp_h),), + print 'fill="white"', + print 'stroke="rgb(98%%,98%%,88%%)" stroke-width=%s' % qa(line_width), + print 'onmouseover=%s' % qa( + "var event = arguments[0] || window.event;" + " if (event.shiftKey) {" + " highlightRevision('"+str(revision)+"');" + " return false;" + " }"), + print ' />' + + xes = set() + for line in lines.itervalues(): + for point in line: + xes.add(point[0]) + revisions = list(xes) + revisions.sort() + + left = x + current_revision = revisions[0] + for next_revision in revisions[1:]: + width = (((next_revision - current_revision) / 2.0) + + (current_revision - left)) + print_rect(left, y, width, h, current_revision) + left += width + current_revision = next_revision + print_rect(left, y, x+w - left, h, current_revision) + + #output the lines + print """ +<script type="text/javascript">//<![CDATA[ + var previous; + var previousColor; + var previousOpacity; + function highlight(id) { + if (previous == id) return; + + document.getElementById('label').firstChild.nodeValue = id; + + var preGroup = document.getElementById(previous); + if (preGroup) { + var preLine = document.getElementById(previous+'_line'); + preLine.setAttributeNS(null,'stroke', previousColor); + preLine.setAttributeNS(null,'opacity', previousOpacity); + + var preSlope = document.getElementById(previous+'_linear'); + if (preSlope) { + preSlope.setAttributeNS(null,'visibility', 'hidden'); + } + } + + var group = document.getElementById(id); + previous = id; + if (group) { + group.parentNode.appendChild(group); + + var line = document.getElementById(id+'_line'); + previousColor = line.getAttributeNS(null,'stroke'); + previousOpacity = line.getAttributeNS(null,'opacity'); + line.setAttributeNS(null,'stroke', 'blue'); + line.setAttributeNS(null,'opacity', '1'); + + var slope = document.getElementById(id+'_linear'); + if (slope) { + slope.setAttributeNS(null,'visibility', 'visible'); + } + } + } +//]]></script>""" + for label, line in lines.items(): + print '<g id=%s>' % qa(label) + r = 128 + g = 128 + b = 128 + a = .10 + if label in regressions: + regression = regressions[label] + min_slope = regression.find_min_slope() + if min_slope < 0: + d = max(0, (min_slope / min_down_slope)) + g += int(d*128) + a += d*0.9 + elif min_slope > 0: + d = max(0, (min_slope / max_up_slope)) + r += int(d*128) + a += d*0.9 + + slope = regression.slope + intercept = regression.intercept + min_x = regression.min_x + max_x = regression.max_x + print '<polyline id=%s' % qa(str(label)+'_linear'), + print 'fill="none" stroke="yellow"', + print 'stroke-width=%s' % qa(abs(ch(regression.serror*2))), + print 'opacity="0.5" pointer-events="none" visibility="hidden"', + print 'points="', + print '%s,%s' % (str(cx(min_x)), str(cy(slope*min_x + intercept))), + print '%s,%s' % (str(cx(max_x)), str(cy(slope*max_x + intercept))), + print '"/>' + + print '<polyline id=%s' % qa(str(label)+'_line'), + print 'onmouseover=%s' % qa( + "var event = arguments[0] || window.event;" + " if (event.ctrlKey) {" + " highlight('"+str(label).replace("'", "\\'")+"');" + " return false;" + " }"), + print 'fill="none" stroke="rgb(%s,%s,%s)"' % (str(r), str(g), str(b)), + print 'stroke-width=%s' % qa(line_width), + print 'opacity=%s' % qa(a), + print 'points="', + for point in line: + print '%s,%s' % (str(cx(point[0])), str(cy(point[1]))), + print '"/>' + + print '</g>' + + #output the labels + print '<text id="label" x="0" y=%s' % qa(font_size), + print 'font-size=%s> </text>' % qa(font_size) + + print '<a id="rev_link" xlink:href="" target="_top">' + print '<text id="revision" x="0" y=%s style="' % qa(font_size*2) + print 'font-size: %s; ' % qe(font_size) + print 'stroke: #0000dd; text-decoration: underline; ' + print '"> </text></a>' + + print '</svg>' + +if __name__ == "__main__": + main() diff --git a/bench/bench_util.py b/bench/bench_util.py new file mode 100644 index 0000000..e36e6c6 --- /dev/null +++ b/bench/bench_util.py @@ -0,0 +1,178 @@ +''' +Created on May 19, 2011 + +@author: bungeman +''' + +import re +import math + +class BenchDataPoint: + """A single data point produced by bench. + + (str, str, str, float, {str:str})""" + def __init__(self, bench, config, time_type, time, settings): + self.bench = bench + self.config = config + self.time_type = time_type + self.time = time + self.settings = settings + + def __repr__(self): + return "BenchDataPoint(%s, %s, %s, %s, %s)" % ( + str(self.bench), + str(self.config), + str(self.time_type), + str(self.time), + str(self.settings), + ) + +class _ExtremeType(object): + """Instances of this class compare greater or less than other objects.""" + def __init__(self, cmpr, rep): + object.__init__(self) + self._cmpr = cmpr + self._rep = rep + + def __cmp__(self, other): + if isinstance(other, self.__class__) and other._cmpr == self._cmpr: + return 0 + return self._cmpr + + def __repr__(self): + return self._rep + +Max = _ExtremeType(1, "Max") +Min = _ExtremeType(-1, "Min") + +def parse(settings, lines): + """Parses bench output into a useful data structure. + + ({str:str}, __iter__ -> str) -> [BenchDataPoint]""" + + benches = [] + current_bench = None + setting_re = '([^\s=]+)(?:=(\S+))?' + settings_re = 'skia bench:((?:\s+' + setting_re + ')*)' + bench_re = 'running bench (?:\[\d+ \d+\] )?\s*(\S+)' + time_re = '(?:(\w*)msecs = )?\s*(\d+\.\d+)' + config_re = '(\S+): ((?:' + time_re + '\s+)+)' + + for line in lines: + + #see if this line is a settings line + settingsMatch = re.search(settings_re, line) + if (settingsMatch): + settings = dict(settings) + for settingMatch in re.finditer(setting_re, settingsMatch.group(1)): + if (settingMatch.group(2)): + settings[settingMatch.group(1)] = settingMatch.group(2) + else: + settings[settingMatch.group(1)] = True + + #see if this line starts a new bench + new_bench = re.search(bench_re, line) + if new_bench: + current_bench = new_bench.group(1) + + #add configs on this line to the current bench + if current_bench: + for new_config in re.finditer(config_re, line): + current_config = new_config.group(1) + times = new_config.group(2) + for new_time in re.finditer(time_re, times): + current_time_type = new_time.group(1) + current_time = float(new_time.group(2)) + benches.append(BenchDataPoint( + current_bench + , current_config + , current_time_type + , current_time + , settings)) + + return benches + +class LinearRegression: + """Linear regression data based on a set of data points. + + ([(Number,Number)]) + There must be at least two points for this to make sense.""" + def __init__(self, points): + n = len(points) + max_x = Min + min_x = Max + + Sx = 0.0 + Sy = 0.0 + Sxx = 0.0 + Sxy = 0.0 + Syy = 0.0 + for point in points: + x = point[0] + y = point[1] + max_x = max(max_x, x) + min_x = min(min_x, x) + + Sx += x + Sy += y + Sxx += x*x + Sxy += x*y + Syy += y*y + + B = (n*Sxy - Sx*Sy) / (n*Sxx - Sx*Sx) + a = (1.0/n)*(Sy - B*Sx) + + se2 = 0 + sB2 = 0 + sa2 = 0 + if (n >= 3): + se2 = (1.0/(n*(n-2)) * (n*Syy - Sy*Sy - B*B*(n*Sxx - Sx*Sx))) + sB2 = (n*se2) / (n*Sxx - Sx*Sx) + sa2 = sB2 * (1.0/n) * Sxx + + + self.slope = B + self.intercept = a + self.serror = math.sqrt(max(0, se2)) + self.serror_slope = math.sqrt(max(0, sB2)) + self.serror_intercept = math.sqrt(max(0, sa2)) + self.max_x = max_x + self.min_x = min_x + + def __repr__(self): + return "LinearRegression(%s, %s, %s, %s, %s)" % ( + str(self.slope), + str(self.intercept), + str(self.serror), + str(self.serror_slope), + str(self.serror_intercept), + ) + + def find_min_slope(self): + """Finds the minimal slope given one standard deviation.""" + slope = self.slope + intercept = self.intercept + error = self.serror + regr_start = self.min_x + regr_end = self.max_x + regr_width = regr_end - regr_start + + if slope < 0: + lower_left_y = slope*regr_start + intercept - error + upper_right_y = slope*regr_end + intercept + error + return min(0, (upper_right_y - lower_left_y) / regr_width) + + elif slope > 0: + upper_left_y = slope*regr_start + intercept + error + lower_right_y = slope*regr_end + intercept - error + return max(0, (lower_right_y - upper_left_y) / regr_width) + + return 0 + +def CreateRevisionLink(revision_number): + """Returns HTML displaying the given revision number and linking to + that revision's change page at code.google.com, e.g. + http://code.google.com/p/skia/source/detail?r=2056 + """ + return '<a href="http://code.google.com/p/skia/source/detail?r=%s">%s</a>'%( + revision_number, revision_number) diff --git a/bench/benchmain.cpp b/bench/benchmain.cpp index 34f8a1a..024ad0f 100644 --- a/bench/benchmain.cpp +++ b/bench/benchmain.cpp @@ -1,18 +1,30 @@ + +/* + * 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" + +#include "GrContext.h" +#include "GrRenderTarget.h" + +#include "SkBenchmark.h" #include "SkCanvas.h" #include "SkColorPriv.h" +#include "SkGpuDevice.h" #include "SkGraphics.h" #include "SkImageEncoder.h" +#include "SkNativeGLContext.h" +#include "SkNullGLContext.h" #include "SkNWayCanvas.h" #include "SkPicture.h" #include "SkString.h" -#include "GrContext.h" -#include "SkGpuDevice.h" -#include "SkEGLContext.h" -#include "SkBenchmark.h" -#include "BenchTimer.h" - -#ifdef ANDROID +#ifdef SK_BUILD_FOR_ANDROID static void log_error(const char msg[]) { SkDebugf("%s", msg); } static void log_progress(const char msg[]) { SkDebugf("%s", msg); } #else @@ -161,8 +173,67 @@ enum Backend { kPDF_Backend, }; +class GLHelper { +public: + GLHelper() { + } + + bool init(SkGLContext* glCtx, int width, int height) { + GrContext* grCtx; + GrRenderTarget* rt; + if (glCtx->init(width, height)) { + 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(); + rt = grCtx->createPlatformRenderTarget(desc); + if (NULL == rt) { + grCtx->unref(); + return false; + } + } + } else { + return false; + } + glCtx->ref(); + fGLContext.reset(glCtx); + fGrContext.reset(grCtx); + fRenderTarget.reset(rt); + return true; + } + + 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 SkDevice* make_device(SkBitmap::Config config, const SkIPoint& size, - Backend backend, GrContext* context) { + Backend backend, GLHelper* glHelper) { SkDevice* device = NULL; SkBitmap bitmap; bitmap.setConfig(config, size.fX, size.fY); @@ -171,11 +242,11 @@ static SkDevice* make_device(SkBitmap::Config config, const SkIPoint& size, case kRaster_Backend: bitmap.allocPixels(); erase(bitmap); - device = new SkDevice(NULL, bitmap, true); + device = new SkDevice(bitmap); break; case kGPU_Backend: - device = new SkGpuDevice(context, bitmap, SkGpuDevice::Current3DApiRenderTarget()); -// device->clear(0xFFFFFFFF); + device = new SkGpuDevice(glHelper->grContext(), + glHelper->renderTarget()); break; case kPDF_Backend: default: @@ -188,10 +259,12 @@ static const struct { SkBitmap::Config fConfig; const char* fName; Backend fBackend; + GLHelper* fGLHelper; } gConfigs[] = { - { SkBitmap::kARGB_8888_Config, "8888", kRaster_Backend }, - { SkBitmap::kRGB_565_Config, "565", kRaster_Backend }, - { SkBitmap::kARGB_8888_Config, "GPU", kGPU_Backend }, + { SkBitmap::kARGB_8888_Config, "8888", kRaster_Backend, NULL }, + { SkBitmap::kRGB_565_Config, "565", kRaster_Backend, NULL }, + { SkBitmap::kARGB_8888_Config, "GPU", kGPU_Backend, &gRealGLHelper }, + { SkBitmap::kARGB_8888_Config, "NULLGPU", kGPU_Backend, &gNullGLHelper }, }; static int findConfig(const char config[]) { @@ -203,6 +276,36 @@ static int findConfig(const char config[]) { 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; + } + } +} + +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; +} + int main (int argc, char * const argv[]) { SkAutoGraphics ag; @@ -218,12 +321,13 @@ int main (int argc, char * const argv[]) { bool doScale = false; bool doRotate = false; bool doClip = false; - const char* matchStr = NULL; bool hasStrokeWidth = false; float strokeWidth; + SkTDArray<const char*> fMatches; SkString outDir; SkBitmap::Config outConfig = SkBitmap::kNo_Config; + GLHelper* glHelper = NULL; const char* configName = ""; Backend backend = kRaster_Backend; // for warning int configCount = SK_ARRAY_COUNT(gConfigs); @@ -312,7 +416,7 @@ int main (int argc, char * const argv[]) { } else if (strcmp(*argv, "-match") == 0) { argv++; if (argv < stop) { - matchStr = *argv; + *fMatches.append() = *argv; } else { log_error("missing arg for -match\n"); return -1; @@ -325,6 +429,7 @@ int main (int argc, char * const argv[]) { outConfig = gConfigs[index].fConfig; configName = gConfigs[index].fName; backend = gConfigs[index].fBackend; + glHelper = gConfigs[index].fGLHelper; configCount = 1; } else { SkString str; @@ -355,19 +460,63 @@ int main (int argc, char * const argv[]) { // report our current settings { SkString str; - str.printf("skia bench: alpha=0x%02X antialias=%d filter=%d\n", + str.printf("skia bench: alpha=0x%02X antialias=%d filter=%d", forceAlpha, forceAA, forceFilter); + str.appendf(" rotate=%d scale=%d clip=%d", + doRotate, doScale, doClip); + + 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"); log_progress(str); } - - GrContext* context = NULL; - SkEGLContext eglContext; - if (eglContext.init(1024, 1024)) { - context = GrContext::CreateGLShaderContext(); - } - - BenchTimer timer = BenchTimer(); - + + //Don't do GL when fixed. +#if !defined(SK_SCALAR_IS_FIXED) + int contextWidth = 1024; + int contextHeight = 1024; + determine_gpu_context_size(defineDict, &contextWidth, &contextHeight); + SkAutoTUnref<SkGLContext> realGLCtx(new SkNativeGLContext); + SkAutoTUnref<SkGLContext> nullGLCtx(new SkNullGLContext); + gRealGLHelper.init(realGLCtx.get(), contextWidth, contextHeight); + gNullGLHelper.init(nullGLCtx.get(), contextWidth, contextHeight); +#endif + BenchTimer timer = BenchTimer(gRealGLHelper.glContext()); + Iter iter(&defineDict); SkBenchmark* bench; while ((bench = iter.next()) != NULL) { @@ -385,7 +534,7 @@ int main (int argc, char * const argv[]) { } // only run benchmarks if their name contains matchStr - if (matchStr && strstr(bench->getName(), matchStr) == NULL) { + if (skip_name(fMatches, bench->getName())) { continue; } @@ -401,13 +550,15 @@ int main (int argc, char * const argv[]) { outConfig = gConfigs[configIndex].fConfig; configName = gConfigs[configIndex].fName; backend = gConfigs[configIndex].fBackend; + glHelper = gConfigs[configIndex].fGLHelper; } - - if (kGPU_Backend == backend && NULL == context) { + + if (kGPU_Backend == backend && + (NULL == glHelper || !glHelper->isValid())) { continue; } - SkDevice* device = make_device(outConfig, dim, backend, context); + SkDevice* device = make_device(outConfig, dim, backend, glHelper); SkCanvas canvas(device); device->unref(); @@ -420,15 +571,14 @@ int main (int argc, char * const argv[]) { if (doRotate) { performRotate(&canvas, dim.fX, dim.fY); } - - bool gpu = kGPU_Backend == backend && context; + //warm up caches if needed if (repeatDraw > 1) { SkAutoCanvasRestore acr(&canvas, true); bench->draw(&canvas); - if (gpu) { - context->flush(); - glFinish(); + if (glHelper) { + glHelper->grContext()->flush(); + SK_GL(*glHelper->glContext(), Finish()); } } @@ -436,8 +586,14 @@ int main (int argc, char * const argv[]) { for (int i = 0; i < repeatDraw; i++) { SkAutoCanvasRestore acr(&canvas, true); bench->draw(&canvas); + if (glHelper) { + glHelper->grContext()->flush(); + } } - timer.end(); + if (glHelper) { + SK_GL(*glHelper->glContext(), Finish()); + } + timer.end(); if (repeatDraw > 1) { SkString str; @@ -448,7 +604,7 @@ int main (int argc, char * const argv[]) { if (timerCpu) { str.appendf(" cmsecs = %6.2f", timer.fCpu / repeatDraw); } - if (timerGpu && gpu && timer.fGpu > 0) { + if (timerGpu && glHelper && timer.fGpu > 0) { str.appendf(" gmsecs = %6.2f", timer.fGpu / repeatDraw); } log_progress(str); @@ -460,6 +616,6 @@ int main (int argc, char * const argv[]) { } log_progress("\n"); } - + return 0; } |