Home | History | Annotate | Download | only in bench 
      1 
      2 /*
      3  * Copyright 2011 Google Inc.
      4  *
      5  * Use of this source code is governed by a BSD-style license that can be
      6  * found in the LICENSE file.
      7  */
      8 #include "SkBenchmark.h"
      9 #include "SkRandom.h"
     10 #include "SkRegion.h"
     11 #include "SkString.h"
     12 
     13 static bool union_proc(SkRegion& a, SkRegion& b) {
     14     SkRegion result;
     15     return result.op(a, b, SkRegion::kUnion_Op);
     16 }
     17 
     18 static bool sect_proc(SkRegion& a, SkRegion& b) {
     19     SkRegion result;
     20     return result.op(a, b, SkRegion::kIntersect_Op);
     21 }
     22 
     23 static bool diff_proc(SkRegion& a, SkRegion& b) {
     24     SkRegion result;
     25     return result.op(a, b, SkRegion::kDifference_Op);
     26 }
     27 
     28 static bool diffrect_proc(SkRegion& a, SkRegion& b) {
     29     SkRegion result;
     30     return result.op(a, b.getBounds(), SkRegion::kDifference_Op);
     31 }
     32 
     33 static bool diffrectbig_proc(SkRegion& a, SkRegion& b) {
     34     SkRegion result;
     35     return result.op(a, a.getBounds(), SkRegion::kDifference_Op);
     36 }
     37 
     38 static bool containsrect_proc(SkRegion& a, SkRegion& b) {
     39     SkIRect r = a.getBounds();
     40     r.inset(r.width()/4, r.height()/4);
     41     (void)a.contains(r);
     42 
     43     r = b.getBounds();
     44     r.inset(r.width()/4, r.height()/4);
     45     return b.contains(r);
     46 }
     47 
     48 static bool sectsrgn_proc(SkRegion& a, SkRegion& b) {
     49     return a.intersects(b);
     50 }
     51 
     52 static bool sectsrect_proc(SkRegion& a, SkRegion& b) {
     53     SkIRect r = a.getBounds();
     54     r.inset(r.width()/4, r.height()/4);
     55     return a.intersects(r);
     56 }
     57 
     58 static bool containsxy_proc(SkRegion& a, SkRegion& b) {
     59     const SkIRect& r = a.getBounds();
     60     const int dx = r.width() / 8;
     61     const int dy = r.height() / 8;
     62     for (int y = r.fTop; y < r.fBottom; y += dy) {
     63         for (int x = r.fLeft; x < r.fRight; x += dx) {
     64             (void)a.contains(x, y);
     65         }
     66     }
     67     return true;
     68 }
     69 
     70 class RegionBench : public SkBenchmark {
     71 public:
     72     typedef bool (*Proc)(SkRegion& a, SkRegion& b);
     73 
     74     SkRegion fA, fB;
     75     Proc     fProc;
     76     SkString fName;
     77     int      fLoopMul;
     78 
     79     enum {
     80         W = 1024,
     81         H = 768,
     82         N = SkBENCHLOOP(2000)
     83     };
     84 
     85     SkIRect randrect(SkRandom& rand) {
     86         int x = rand.nextU() % W;
     87         int y = rand.nextU() % H;
     88         int w = rand.nextU() % W;
     89         int h = rand.nextU() % H;
     90         return SkIRect::MakeXYWH(x, y, w >> 1, h >> 1);
     91     }
     92 
     93     RegionBench(void* param, int count, Proc proc, const char name[], int mul = 1) : INHERITED(param) {
     94         fProc = proc;
     95         fName.printf("region_%s_%d", name, count);
     96         fLoopMul = mul;
     97 
     98         SkRandom rand;
     99         for (int i = 0; i < count; i++) {
    100             fA.op(randrect(rand), SkRegion::kXOR_Op);
    101             fB.op(randrect(rand), SkRegion::kXOR_Op);
    102         }
    103         fIsRendering = false;
    104     }
    105 
    106 protected:
    107     virtual const char* onGetName() { return fName.c_str(); }
    108 
    109     virtual void onDraw(SkCanvas* canvas) {
    110         Proc proc = fProc;
    111         int n = fLoopMul * N;
    112         for (int i = 0; i < n; ++i) {
    113             proc(fA, fB);
    114         }
    115     }
    116 
    117 private:
    118     typedef SkBenchmark INHERITED;
    119 };
    120 
    121 #define SMALL   16
    122 
    123 static SkBenchmark* gF0(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, union_proc, "union")); }
    124 static SkBenchmark* gF1(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, sect_proc, "intersect")); }
    125 static SkBenchmark* gF2(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, diff_proc, "difference")); }
    126 static SkBenchmark* gF3(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, diffrect_proc, "differencerect")); }
    127 static SkBenchmark* gF4(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, diffrectbig_proc, "differencerectbig")); }
    128 static SkBenchmark* gF5(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, containsrect_proc, "containsrect", 100)); }
    129 static SkBenchmark* gF6(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, sectsrgn_proc, "intersectsrgn", 10)); }
    130 static SkBenchmark* gF7(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, sectsrect_proc, "intersectsrect", 200)); }
    131 static SkBenchmark* gF8(void* p) { return SkNEW_ARGS(RegionBench, (p, SMALL, containsxy_proc, "containsxy")); }
    132 
    133 static BenchRegistry gR0(gF0);
    134 static BenchRegistry gR1(gF1);
    135 static BenchRegistry gR2(gF2);
    136 static BenchRegistry gR3(gF3);
    137 static BenchRegistry gR4(gF4);
    138 static BenchRegistry gR5(gF5);
    139 static BenchRegistry gR6(gF6);
    140 static BenchRegistry gR7(gF7);
    141 static BenchRegistry gR8(gF8);
    142