mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 8 | #include "Benchmark.h" |
reed@google.com | e05cc8e | 2011-10-10 14:19:40 +0000 | [diff] [blame] | 9 | #include "SkColorPriv.h" |
benjaminwagner | 6c71e0a | 2016-04-07 08:49:31 -0700 | [diff] [blame] | 10 | #include "SkFixed.h" |
halcanary | 4dbbd04 | 2016-06-07 17:21:10 -0700 | [diff] [blame] | 11 | #include "SkMathPriv.h" |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 12 | #include "SkMatrix.h" |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 13 | #include "SkPaint.h" |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 14 | #include "SkRandom.h" |
| 15 | #include "SkString.h" |
| 16 | |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 17 | static float sk_fsel(float pred, float result_ge, float result_lt) { |
| 18 | return pred >= 0 ? result_ge : result_lt; |
| 19 | } |
| 20 | |
| 21 | static float fast_floor(float x) { |
reed@google.com | f3a8d8e | 2012-05-30 14:08:57 +0000 | [diff] [blame] | 22 | // float big = sk_fsel(x, 0x1.0p+23, -0x1.0p+23); |
| 23 | float big = sk_fsel(x, (float)(1 << 23), -(float)(1 << 23)); |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 24 | return (x + big) - big; |
| 25 | } |
| 26 | |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 27 | class MathBench : public Benchmark { |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 28 | enum { |
| 29 | kBuffer = 100, |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 30 | }; |
| 31 | SkString fName; |
| 32 | float fSrc[kBuffer], fDst[kBuffer]; |
| 33 | public: |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 34 | MathBench(const char name[]) { |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 35 | fName.printf("math_%s", name); |
| 36 | |
commit-bot@chromium.org | e0e7cfe | 2013-09-09 20:09:12 +0000 | [diff] [blame] | 37 | SkRandom rand; |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 38 | for (int i = 0; i < kBuffer; ++i) { |
| 39 | fSrc[i] = rand.nextSScalar1(); |
| 40 | } |
commit-bot@chromium.org | 644629c | 2013-11-21 06:21:58 +0000 | [diff] [blame] | 41 | } |
tomhudson@google.com | 9dc2713 | 2012-09-13 15:50:24 +0000 | [diff] [blame] | 42 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 43 | bool isSuitableFor(Backend backend) override { |
commit-bot@chromium.org | 644629c | 2013-11-21 06:21:58 +0000 | [diff] [blame] | 44 | return backend == kNonRendering_Backend; |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 45 | } |
| 46 | |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 47 | virtual void performTest(float* SK_RESTRICT dst, |
| 48 | const float* SK_RESTRICT src, |
robertphillips@google.com | 6853e80 | 2012-04-16 15:50:18 +0000 | [diff] [blame] | 49 | int count) = 0; |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 50 | |
| 51 | protected: |
| 52 | virtual int mulLoopCount() const { return 1; } |
| 53 | |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 54 | const char* onGetName() override { |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 55 | return fName.c_str(); |
| 56 | } |
| 57 | |
mtklein | a1ebeb2 | 2015-10-01 09:43:39 -0700 | [diff] [blame] | 58 | void onDraw(int loops, SkCanvas*) override { |
commit-bot@chromium.org | 3361471 | 2013-12-03 18:17:16 +0000 | [diff] [blame] | 59 | int n = loops * this->mulLoopCount(); |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 60 | for (int i = 0; i < n; i++) { |
| 61 | this->performTest(fDst, fSrc, kBuffer); |
| 62 | } |
| 63 | } |
| 64 | |
| 65 | private: |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 66 | typedef Benchmark INHERITED; |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 67 | }; |
| 68 | |
reed@google.com | e05cc8e | 2011-10-10 14:19:40 +0000 | [diff] [blame] | 69 | class MathBenchU32 : public MathBench { |
| 70 | public: |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 71 | MathBenchU32(const char name[]) : INHERITED(name) {} |
skia.committer@gmail.com | 8152113 | 2013-04-30 07:01:03 +0000 | [diff] [blame] | 72 | |
reed@google.com | e05cc8e | 2011-10-10 14:19:40 +0000 | [diff] [blame] | 73 | protected: |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 74 | virtual void performITest(uint32_t* SK_RESTRICT dst, |
| 75 | const uint32_t* SK_RESTRICT src, |
robertphillips@google.com | 6853e80 | 2012-04-16 15:50:18 +0000 | [diff] [blame] | 76 | int count) = 0; |
skia.committer@gmail.com | 8152113 | 2013-04-30 07:01:03 +0000 | [diff] [blame] | 77 | |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 78 | void performTest(float* SK_RESTRICT dst, const float* SK_RESTRICT src, int count) override { |
reed@google.com | e05cc8e | 2011-10-10 14:19:40 +0000 | [diff] [blame] | 79 | uint32_t* d = SkTCast<uint32_t*>(dst); |
| 80 | const uint32_t* s = SkTCast<const uint32_t*>(src); |
| 81 | this->performITest(d, s, count); |
| 82 | } |
| 83 | private: |
| 84 | typedef MathBench INHERITED; |
| 85 | }; |
| 86 | |
| 87 | /////////////////////////////////////////////////////////////////////////////// |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 88 | |
| 89 | class NoOpMathBench : public MathBench { |
| 90 | public: |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 91 | NoOpMathBench() : INHERITED("noOp") {} |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 92 | protected: |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 93 | void performTest(float* SK_RESTRICT dst, const float* SK_RESTRICT src, int count) override { |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 94 | for (int i = 0; i < count; ++i) { |
| 95 | dst[i] = src[i] + 1; |
| 96 | } |
| 97 | } |
| 98 | private: |
| 99 | typedef MathBench INHERITED; |
| 100 | }; |
| 101 | |
commit-bot@chromium.org | 11e5b97 | 2013-11-08 20:14:16 +0000 | [diff] [blame] | 102 | class SkRSqrtMathBench : public MathBench { |
| 103 | public: |
| 104 | SkRSqrtMathBench() : INHERITED("sk_float_rsqrt") {} |
| 105 | protected: |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 106 | void performTest(float* SK_RESTRICT dst, const float* SK_RESTRICT src, int count) override { |
commit-bot@chromium.org | 11e5b97 | 2013-11-08 20:14:16 +0000 | [diff] [blame] | 107 | for (int i = 0; i < count; ++i) { |
| 108 | dst[i] = sk_float_rsqrt(src[i]); |
| 109 | } |
| 110 | } |
| 111 | private: |
| 112 | typedef MathBench INHERITED; |
| 113 | }; |
| 114 | |
| 115 | |
robertphillips@google.com | 36bb270 | 2013-08-12 12:02:28 +0000 | [diff] [blame] | 116 | class SlowISqrtMathBench : public MathBench { |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 117 | public: |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 118 | SlowISqrtMathBench() : INHERITED("slowIsqrt") {} |
commit-bot@chromium.org | b3ecdc4 | 2013-08-12 08:37:51 +0000 | [diff] [blame] | 119 | protected: |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 120 | void performTest(float* SK_RESTRICT dst, const float* SK_RESTRICT src, int count) override { |
robertphillips@google.com | 36bb270 | 2013-08-12 12:02:28 +0000 | [diff] [blame] | 121 | for (int i = 0; i < count; ++i) { |
| 122 | dst[i] = 1.0f / sk_float_sqrt(src[i]); |
commit-bot@chromium.org | b3ecdc4 | 2013-08-12 08:37:51 +0000 | [diff] [blame] | 123 | } |
commit-bot@chromium.org | b3ecdc4 | 2013-08-12 08:37:51 +0000 | [diff] [blame] | 124 | } |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 125 | private: |
robertphillips@google.com | 36bb270 | 2013-08-12 12:02:28 +0000 | [diff] [blame] | 126 | typedef MathBench INHERITED; |
| 127 | }; |
| 128 | |
| 129 | static inline float SkFastInvSqrt(float x) { |
| 130 | float xhalf = 0.5f*x; |
mtklein | 1f6a1bd | 2015-12-08 10:53:01 -0800 | [diff] [blame] | 131 | uint32_t i = *SkTCast<uint32_t*>(&x); |
robertphillips@google.com | 36bb270 | 2013-08-12 12:02:28 +0000 | [diff] [blame] | 132 | i = 0x5f3759df - (i>>1); |
| 133 | x = *SkTCast<float*>(&i); |
| 134 | x = x*(1.5f-xhalf*x*x); |
| 135 | // x = x*(1.5f-xhalf*x*x); // this line takes err from 10^-3 to 10^-6 |
| 136 | return x; |
| 137 | } |
| 138 | |
| 139 | class FastISqrtMathBench : public MathBench { |
| 140 | public: |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 141 | FastISqrtMathBench() : INHERITED("fastIsqrt") {} |
robertphillips@google.com | 36bb270 | 2013-08-12 12:02:28 +0000 | [diff] [blame] | 142 | protected: |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 143 | void performTest(float* SK_RESTRICT dst, const float* SK_RESTRICT src, int count) override { |
robertphillips@google.com | 36bb270 | 2013-08-12 12:02:28 +0000 | [diff] [blame] | 144 | for (int i = 0; i < count; ++i) { |
| 145 | dst[i] = SkFastInvSqrt(src[i]); |
| 146 | } |
| 147 | } |
| 148 | private: |
| 149 | typedef MathBench INHERITED; |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 150 | }; |
| 151 | |
reed@google.com | e05cc8e | 2011-10-10 14:19:40 +0000 | [diff] [blame] | 152 | static inline uint32_t QMul64(uint32_t value, U8CPU alpha) { |
| 153 | SkASSERT((uint8_t)alpha == alpha); |
| 154 | const uint32_t mask = 0xFF00FF; |
| 155 | |
| 156 | uint64_t tmp = value; |
| 157 | tmp = (tmp & mask) | ((tmp & ~mask) << 24); |
| 158 | tmp *= alpha; |
caryclark@google.com | 19069a2 | 2012-06-06 12:11:45 +0000 | [diff] [blame] | 159 | return (uint32_t) (((tmp >> 8) & mask) | ((tmp >> 32) & ~mask)); |
reed@google.com | e05cc8e | 2011-10-10 14:19:40 +0000 | [diff] [blame] | 160 | } |
| 161 | |
| 162 | class QMul64Bench : public MathBenchU32 { |
| 163 | public: |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 164 | QMul64Bench() : INHERITED("qmul64") {} |
reed@google.com | e05cc8e | 2011-10-10 14:19:40 +0000 | [diff] [blame] | 165 | protected: |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 166 | void performITest(uint32_t* SK_RESTRICT dst, |
| 167 | const uint32_t* SK_RESTRICT src, |
| 168 | int count) override { |
reed@google.com | e05cc8e | 2011-10-10 14:19:40 +0000 | [diff] [blame] | 169 | for (int i = 0; i < count; ++i) { |
| 170 | dst[i] = QMul64(src[i], (uint8_t)i); |
| 171 | } |
| 172 | } |
| 173 | private: |
| 174 | typedef MathBenchU32 INHERITED; |
| 175 | }; |
| 176 | |
| 177 | class QMul32Bench : public MathBenchU32 { |
| 178 | public: |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 179 | QMul32Bench() : INHERITED("qmul32") {} |
reed@google.com | e05cc8e | 2011-10-10 14:19:40 +0000 | [diff] [blame] | 180 | protected: |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 181 | void performITest(uint32_t* SK_RESTRICT dst, |
| 182 | const uint32_t* SK_RESTRICT src, |
| 183 | int count) override { |
reed@google.com | e05cc8e | 2011-10-10 14:19:40 +0000 | [diff] [blame] | 184 | for (int i = 0; i < count; ++i) { |
| 185 | dst[i] = SkAlphaMulQ(src[i], (uint8_t)i); |
| 186 | } |
| 187 | } |
| 188 | private: |
| 189 | typedef MathBenchU32 INHERITED; |
| 190 | }; |
| 191 | |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 192 | /////////////////////////////////////////////////////////////////////////////// |
| 193 | |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 194 | static bool isFinite_int(float x) { |
| 195 | uint32_t bits = SkFloat2Bits(x); // need unsigned for our shifts |
| 196 | int exponent = bits << 1 >> 24; |
| 197 | return exponent != 0xFF; |
| 198 | } |
| 199 | |
| 200 | static bool isFinite_float(float x) { |
robertphillips@google.com | 6853e80 | 2012-04-16 15:50:18 +0000 | [diff] [blame] | 201 | return SkToBool(sk_float_isfinite(x)); |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 202 | } |
| 203 | |
| 204 | static bool isFinite_mulzero(float x) { |
| 205 | float y = x * 0; |
| 206 | return y == y; |
| 207 | } |
| 208 | |
| 209 | static bool isfinite_and_int(const float data[4]) { |
| 210 | return isFinite_int(data[0]) && isFinite_int(data[1]) && isFinite_int(data[2]) && isFinite_int(data[3]); |
| 211 | } |
| 212 | |
| 213 | static bool isfinite_and_float(const float data[4]) { |
| 214 | return isFinite_float(data[0]) && isFinite_float(data[1]) && isFinite_float(data[2]) && isFinite_float(data[3]); |
| 215 | } |
| 216 | |
| 217 | static bool isfinite_and_mulzero(const float data[4]) { |
| 218 | return isFinite_mulzero(data[0]) && isFinite_mulzero(data[1]) && isFinite_mulzero(data[2]) && isFinite_mulzero(data[3]); |
| 219 | } |
| 220 | |
| 221 | #define mulzeroadd(data) (data[0]*0 + data[1]*0 + data[2]*0 + data[3]*0) |
| 222 | |
| 223 | static bool isfinite_plus_int(const float data[4]) { |
| 224 | return isFinite_int(mulzeroadd(data)); |
| 225 | } |
| 226 | |
| 227 | static bool isfinite_plus_float(const float data[4]) { |
reed@google.com | 5ae777d | 2011-12-06 20:18:05 +0000 | [diff] [blame] | 228 | return !sk_float_isnan(mulzeroadd(data)); |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 229 | } |
| 230 | |
| 231 | static bool isfinite_plus_mulzero(const float data[4]) { |
| 232 | float x = mulzeroadd(data); |
| 233 | return x == x; |
| 234 | } |
| 235 | |
| 236 | typedef bool (*IsFiniteProc)(const float[]); |
| 237 | |
| 238 | #define MAKEREC(name) { name, #name } |
| 239 | |
| 240 | static const struct { |
| 241 | IsFiniteProc fProc; |
| 242 | const char* fName; |
| 243 | } gRec[] = { |
| 244 | MAKEREC(isfinite_and_int), |
| 245 | MAKEREC(isfinite_and_float), |
| 246 | MAKEREC(isfinite_and_mulzero), |
| 247 | MAKEREC(isfinite_plus_int), |
| 248 | MAKEREC(isfinite_plus_float), |
| 249 | MAKEREC(isfinite_plus_mulzero), |
| 250 | }; |
| 251 | |
| 252 | #undef MAKEREC |
| 253 | |
reed@google.com | 1607863 | 2011-12-06 18:56:37 +0000 | [diff] [blame] | 254 | static bool isFinite(const SkRect& r) { |
| 255 | // x * 0 will be NaN iff x is infinity or NaN. |
| 256 | // a + b will be NaN iff either a or b is NaN. |
| 257 | float value = r.fLeft * 0 + r.fTop * 0 + r.fRight * 0 + r.fBottom * 0; |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 258 | |
reed@google.com | 1607863 | 2011-12-06 18:56:37 +0000 | [diff] [blame] | 259 | // value is either NaN or it is finite (zero). |
| 260 | // value==value will be true iff value is not NaN |
| 261 | return value == value; |
| 262 | } |
| 263 | |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 264 | class IsFiniteBench : public Benchmark { |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 265 | enum { |
mtklein@google.com | c289743 | 2013-09-10 19:23:38 +0000 | [diff] [blame] | 266 | N = 1000, |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 267 | }; |
| 268 | float fData[N]; |
| 269 | public: |
| 270 | |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 271 | IsFiniteBench(int index) { |
commit-bot@chromium.org | e0e7cfe | 2013-09-09 20:09:12 +0000 | [diff] [blame] | 272 | SkRandom rand; |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 273 | |
| 274 | for (int i = 0; i < N; ++i) { |
| 275 | fData[i] = rand.nextSScalar1(); |
| 276 | } |
reed@google.com | 1607863 | 2011-12-06 18:56:37 +0000 | [diff] [blame] | 277 | |
| 278 | if (index < 0) { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 279 | fProc = nullptr; |
reed@google.com | 1607863 | 2011-12-06 18:56:37 +0000 | [diff] [blame] | 280 | fName = "isfinite_rect"; |
| 281 | } else { |
| 282 | fProc = gRec[index].fProc; |
| 283 | fName = gRec[index].fName; |
| 284 | } |
commit-bot@chromium.org | 644629c | 2013-11-21 06:21:58 +0000 | [diff] [blame] | 285 | } |
| 286 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 287 | bool isSuitableFor(Backend backend) override { |
commit-bot@chromium.org | 644629c | 2013-11-21 06:21:58 +0000 | [diff] [blame] | 288 | return backend == kNonRendering_Backend; |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 289 | } |
| 290 | |
| 291 | protected: |
mtklein | a1ebeb2 | 2015-10-01 09:43:39 -0700 | [diff] [blame] | 292 | void onDraw(int loops, SkCanvas*) override { |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 293 | IsFiniteProc proc = fProc; |
| 294 | const float* data = fData; |
reed@google.com | 1607863 | 2011-12-06 18:56:37 +0000 | [diff] [blame] | 295 | // do this so the compiler won't throw away the function call |
| 296 | int counter = 0; |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 297 | |
reed@google.com | 1607863 | 2011-12-06 18:56:37 +0000 | [diff] [blame] | 298 | if (proc) { |
commit-bot@chromium.org | 3361471 | 2013-12-03 18:17:16 +0000 | [diff] [blame] | 299 | for (int j = 0; j < loops; ++j) { |
reed@google.com | 1607863 | 2011-12-06 18:56:37 +0000 | [diff] [blame] | 300 | for (int i = 0; i < N - 4; ++i) { |
| 301 | counter += proc(&data[i]); |
| 302 | } |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 303 | } |
reed@google.com | 1607863 | 2011-12-06 18:56:37 +0000 | [diff] [blame] | 304 | } else { |
commit-bot@chromium.org | 3361471 | 2013-12-03 18:17:16 +0000 | [diff] [blame] | 305 | for (int j = 0; j < loops; ++j) { |
reed@google.com | 1607863 | 2011-12-06 18:56:37 +0000 | [diff] [blame] | 306 | for (int i = 0; i < N - 4; ++i) { |
| 307 | const SkRect* r = reinterpret_cast<const SkRect*>(&data[i]); |
caryclark@google.com | 19069a2 | 2012-06-06 12:11:45 +0000 | [diff] [blame] | 308 | if (false) { // avoid bit rot, suppress warning |
| 309 | isFinite(*r); |
| 310 | } |
reed@google.com | 1607863 | 2011-12-06 18:56:37 +0000 | [diff] [blame] | 311 | counter += r->isFinite(); |
| 312 | } |
| 313 | } |
| 314 | } |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 315 | |
reed@google.com | 1607863 | 2011-12-06 18:56:37 +0000 | [diff] [blame] | 316 | SkPaint paint; |
| 317 | if (paint.getAlpha() == 0) { |
| 318 | SkDebugf("%d\n", counter); |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 319 | } |
| 320 | } |
| 321 | |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 322 | const char* onGetName() override { |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 323 | return fName; |
| 324 | } |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 325 | |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 326 | private: |
| 327 | IsFiniteProc fProc; |
| 328 | const char* fName; |
| 329 | |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 330 | typedef Benchmark INHERITED; |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 331 | }; |
| 332 | |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 333 | class FloorBench : public Benchmark { |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 334 | enum { |
mtklein@google.com | c289743 | 2013-09-10 19:23:38 +0000 | [diff] [blame] | 335 | ARRAY = 1000, |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 336 | }; |
| 337 | float fData[ARRAY]; |
| 338 | bool fFast; |
| 339 | public: |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 340 | |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 341 | FloorBench(bool fast) : fFast(fast) { |
commit-bot@chromium.org | e0e7cfe | 2013-09-09 20:09:12 +0000 | [diff] [blame] | 342 | SkRandom rand; |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 343 | |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 344 | for (int i = 0; i < ARRAY; ++i) { |
| 345 | fData[i] = rand.nextSScalar1(); |
| 346 | } |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 347 | |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 348 | if (fast) { |
| 349 | fName = "floor_fast"; |
| 350 | } else { |
| 351 | fName = "floor_std"; |
| 352 | } |
commit-bot@chromium.org | 644629c | 2013-11-21 06:21:58 +0000 | [diff] [blame] | 353 | } |
| 354 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 355 | bool isSuitableFor(Backend backend) override { |
commit-bot@chromium.org | 644629c | 2013-11-21 06:21:58 +0000 | [diff] [blame] | 356 | return backend == kNonRendering_Backend; |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 357 | } |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 358 | |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 359 | virtual void process(float) {} |
| 360 | |
| 361 | protected: |
mtklein | a1ebeb2 | 2015-10-01 09:43:39 -0700 | [diff] [blame] | 362 | void onDraw(int loops, SkCanvas*) override { |
commit-bot@chromium.org | e0e7cfe | 2013-09-09 20:09:12 +0000 | [diff] [blame] | 363 | SkRandom rand; |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 364 | float accum = 0; |
| 365 | const float* data = fData; |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 366 | |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 367 | if (fFast) { |
commit-bot@chromium.org | 3361471 | 2013-12-03 18:17:16 +0000 | [diff] [blame] | 368 | for (int j = 0; j < loops; ++j) { |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 369 | for (int i = 0; i < ARRAY; ++i) { |
| 370 | accum += fast_floor(data[i]); |
| 371 | } |
| 372 | this->process(accum); |
| 373 | } |
| 374 | } else { |
commit-bot@chromium.org | 3361471 | 2013-12-03 18:17:16 +0000 | [diff] [blame] | 375 | for (int j = 0; j < loops; ++j) { |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 376 | for (int i = 0; i < ARRAY; ++i) { |
| 377 | accum += sk_float_floor(data[i]); |
| 378 | } |
| 379 | this->process(accum); |
| 380 | } |
| 381 | } |
| 382 | } |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 383 | |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 384 | const char* onGetName() override { |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 385 | return fName; |
| 386 | } |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 387 | |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 388 | private: |
| 389 | const char* fName; |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 390 | |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 391 | typedef Benchmark INHERITED; |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 392 | }; |
| 393 | |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 394 | class CLZBench : public Benchmark { |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 395 | enum { |
mtklein@google.com | c289743 | 2013-09-10 19:23:38 +0000 | [diff] [blame] | 396 | ARRAY = 1000, |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 397 | }; |
| 398 | uint32_t fData[ARRAY]; |
| 399 | bool fUsePortable; |
| 400 | |
skia.committer@gmail.com | 8152113 | 2013-04-30 07:01:03 +0000 | [diff] [blame] | 401 | public: |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 402 | CLZBench(bool usePortable) : fUsePortable(usePortable) { |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 403 | |
commit-bot@chromium.org | e0e7cfe | 2013-09-09 20:09:12 +0000 | [diff] [blame] | 404 | SkRandom rand; |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 405 | for (int i = 0; i < ARRAY; ++i) { |
| 406 | fData[i] = rand.nextU(); |
| 407 | } |
skia.committer@gmail.com | 8152113 | 2013-04-30 07:01:03 +0000 | [diff] [blame] | 408 | |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 409 | if (fUsePortable) { |
| 410 | fName = "clz_portable"; |
| 411 | } else { |
| 412 | fName = "clz_intrinsic"; |
| 413 | } |
commit-bot@chromium.org | 644629c | 2013-11-21 06:21:58 +0000 | [diff] [blame] | 414 | } |
| 415 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 416 | bool isSuitableFor(Backend backend) override { |
commit-bot@chromium.org | 644629c | 2013-11-21 06:21:58 +0000 | [diff] [blame] | 417 | return backend == kNonRendering_Backend; |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 418 | } |
skia.committer@gmail.com | 8152113 | 2013-04-30 07:01:03 +0000 | [diff] [blame] | 419 | |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 420 | // just so the compiler doesn't remove our loops |
| 421 | virtual void process(int) {} |
skia.committer@gmail.com | 8152113 | 2013-04-30 07:01:03 +0000 | [diff] [blame] | 422 | |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 423 | protected: |
mtklein | a1ebeb2 | 2015-10-01 09:43:39 -0700 | [diff] [blame] | 424 | void onDraw(int loops, SkCanvas*) override { |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 425 | int accum = 0; |
skia.committer@gmail.com | 8152113 | 2013-04-30 07:01:03 +0000 | [diff] [blame] | 426 | |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 427 | if (fUsePortable) { |
commit-bot@chromium.org | 3361471 | 2013-12-03 18:17:16 +0000 | [diff] [blame] | 428 | for (int j = 0; j < loops; ++j) { |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 429 | for (int i = 0; i < ARRAY; ++i) { |
| 430 | accum += SkCLZ_portable(fData[i]); |
| 431 | } |
| 432 | this->process(accum); |
| 433 | } |
| 434 | } else { |
commit-bot@chromium.org | 3361471 | 2013-12-03 18:17:16 +0000 | [diff] [blame] | 435 | for (int j = 0; j < loops; ++j) { |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 436 | for (int i = 0; i < ARRAY; ++i) { |
| 437 | accum += SkCLZ(fData[i]); |
| 438 | } |
| 439 | this->process(accum); |
| 440 | } |
| 441 | } |
| 442 | } |
skia.committer@gmail.com | 8152113 | 2013-04-30 07:01:03 +0000 | [diff] [blame] | 443 | |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 444 | const char* onGetName() override { |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 445 | return fName; |
| 446 | } |
skia.committer@gmail.com | 8152113 | 2013-04-30 07:01:03 +0000 | [diff] [blame] | 447 | |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 448 | private: |
| 449 | const char* fName; |
skia.committer@gmail.com | 8152113 | 2013-04-30 07:01:03 +0000 | [diff] [blame] | 450 | |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 451 | typedef Benchmark INHERITED; |
reed@google.com | 0d7aac9 | 2013-04-29 13:55:11 +0000 | [diff] [blame] | 452 | }; |
| 453 | |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 454 | /////////////////////////////////////////////////////////////////////////////// |
| 455 | |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 456 | class NormalizeBench : public Benchmark { |
reed@google.com | 0889f68 | 2013-05-03 12:56:39 +0000 | [diff] [blame] | 457 | enum { |
mtklein@google.com | c289743 | 2013-09-10 19:23:38 +0000 | [diff] [blame] | 458 | ARRAY =1000, |
reed@google.com | 0889f68 | 2013-05-03 12:56:39 +0000 | [diff] [blame] | 459 | }; |
| 460 | SkVector fVec[ARRAY]; |
skia.committer@gmail.com | ecc9d28 | 2013-05-04 07:01:15 +0000 | [diff] [blame] | 461 | |
reed@google.com | 0889f68 | 2013-05-03 12:56:39 +0000 | [diff] [blame] | 462 | public: |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 463 | NormalizeBench() { |
commit-bot@chromium.org | e0e7cfe | 2013-09-09 20:09:12 +0000 | [diff] [blame] | 464 | SkRandom rand; |
reed@google.com | 0889f68 | 2013-05-03 12:56:39 +0000 | [diff] [blame] | 465 | for (int i = 0; i < ARRAY; ++i) { |
| 466 | fVec[i].set(rand.nextSScalar1(), rand.nextSScalar1()); |
| 467 | } |
skia.committer@gmail.com | ecc9d28 | 2013-05-04 07:01:15 +0000 | [diff] [blame] | 468 | |
reed@google.com | 0889f68 | 2013-05-03 12:56:39 +0000 | [diff] [blame] | 469 | fName = "point_normalize"; |
commit-bot@chromium.org | 644629c | 2013-11-21 06:21:58 +0000 | [diff] [blame] | 470 | } |
| 471 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 472 | bool isSuitableFor(Backend backend) override { |
commit-bot@chromium.org | 644629c | 2013-11-21 06:21:58 +0000 | [diff] [blame] | 473 | return backend == kNonRendering_Backend; |
reed@google.com | 0889f68 | 2013-05-03 12:56:39 +0000 | [diff] [blame] | 474 | } |
skia.committer@gmail.com | ecc9d28 | 2013-05-04 07:01:15 +0000 | [diff] [blame] | 475 | |
reed@google.com | 0889f68 | 2013-05-03 12:56:39 +0000 | [diff] [blame] | 476 | // just so the compiler doesn't remove our loops |
| 477 | virtual void process(int) {} |
skia.committer@gmail.com | ecc9d28 | 2013-05-04 07:01:15 +0000 | [diff] [blame] | 478 | |
reed@google.com | 0889f68 | 2013-05-03 12:56:39 +0000 | [diff] [blame] | 479 | protected: |
mtklein | a1ebeb2 | 2015-10-01 09:43:39 -0700 | [diff] [blame] | 480 | void onDraw(int loops, SkCanvas*) override { |
reed@google.com | 0889f68 | 2013-05-03 12:56:39 +0000 | [diff] [blame] | 481 | int accum = 0; |
skia.committer@gmail.com | ecc9d28 | 2013-05-04 07:01:15 +0000 | [diff] [blame] | 482 | |
commit-bot@chromium.org | 3361471 | 2013-12-03 18:17:16 +0000 | [diff] [blame] | 483 | for (int j = 0; j < loops; ++j) { |
reed@google.com | 0889f68 | 2013-05-03 12:56:39 +0000 | [diff] [blame] | 484 | for (int i = 0; i < ARRAY; ++i) { |
| 485 | accum += fVec[i].normalize(); |
| 486 | } |
| 487 | this->process(accum); |
| 488 | } |
| 489 | } |
skia.committer@gmail.com | ecc9d28 | 2013-05-04 07:01:15 +0000 | [diff] [blame] | 490 | |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 491 | const char* onGetName() override { |
reed@google.com | 0889f68 | 2013-05-03 12:56:39 +0000 | [diff] [blame] | 492 | return fName; |
| 493 | } |
skia.committer@gmail.com | ecc9d28 | 2013-05-04 07:01:15 +0000 | [diff] [blame] | 494 | |
reed@google.com | 0889f68 | 2013-05-03 12:56:39 +0000 | [diff] [blame] | 495 | private: |
| 496 | const char* fName; |
skia.committer@gmail.com | ecc9d28 | 2013-05-04 07:01:15 +0000 | [diff] [blame] | 497 | |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 498 | typedef Benchmark INHERITED; |
reed@google.com | 0889f68 | 2013-05-03 12:56:39 +0000 | [diff] [blame] | 499 | }; |
| 500 | |
| 501 | /////////////////////////////////////////////////////////////////////////////// |
| 502 | |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 503 | class FixedMathBench : public Benchmark { |
djsollen@google.com | 25a11e4 | 2013-07-18 19:11:30 +0000 | [diff] [blame] | 504 | enum { |
mtklein@google.com | c289743 | 2013-09-10 19:23:38 +0000 | [diff] [blame] | 505 | N = 1000, |
djsollen@google.com | 25a11e4 | 2013-07-18 19:11:30 +0000 | [diff] [blame] | 506 | }; |
| 507 | float fData[N]; |
| 508 | SkFixed fResult[N]; |
| 509 | public: |
| 510 | |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 511 | FixedMathBench() { |
commit-bot@chromium.org | e0e7cfe | 2013-09-09 20:09:12 +0000 | [diff] [blame] | 512 | SkRandom rand; |
commit-bot@chromium.org | 3361471 | 2013-12-03 18:17:16 +0000 | [diff] [blame] | 513 | for (int i = 0; i < N; ++i) { |
| 514 | fData[i] = rand.nextSScalar1(); |
djsollen@google.com | 25a11e4 | 2013-07-18 19:11:30 +0000 | [diff] [blame] | 515 | } |
| 516 | |
commit-bot@chromium.org | 644629c | 2013-11-21 06:21:58 +0000 | [diff] [blame] | 517 | } |
| 518 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 519 | bool isSuitableFor(Backend backend) override { |
commit-bot@chromium.org | 644629c | 2013-11-21 06:21:58 +0000 | [diff] [blame] | 520 | return backend == kNonRendering_Backend; |
djsollen@google.com | 25a11e4 | 2013-07-18 19:11:30 +0000 | [diff] [blame] | 521 | } |
| 522 | |
| 523 | protected: |
mtklein | a1ebeb2 | 2015-10-01 09:43:39 -0700 | [diff] [blame] | 524 | void onDraw(int loops, SkCanvas*) override { |
commit-bot@chromium.org | 3361471 | 2013-12-03 18:17:16 +0000 | [diff] [blame] | 525 | for (int j = 0; j < loops; ++j) { |
djsollen@google.com | 25a11e4 | 2013-07-18 19:11:30 +0000 | [diff] [blame] | 526 | for (int i = 0; i < N - 4; ++i) { |
| 527 | fResult[i] = SkFloatToFixed(fData[i]); |
| 528 | } |
| 529 | } |
| 530 | |
| 531 | SkPaint paint; |
| 532 | if (paint.getAlpha() == 0) { |
| 533 | SkDebugf("%d\n", fResult[0]); |
| 534 | } |
| 535 | } |
| 536 | |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 537 | const char* onGetName() override { |
djsollen@google.com | 25a11e4 | 2013-07-18 19:11:30 +0000 | [diff] [blame] | 538 | return "float_to_fixed"; |
| 539 | } |
| 540 | |
| 541 | private: |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 542 | typedef Benchmark INHERITED; |
djsollen@google.com | 25a11e4 | 2013-07-18 19:11:30 +0000 | [diff] [blame] | 543 | }; |
| 544 | |
| 545 | /////////////////////////////////////////////////////////////////////////////// |
| 546 | |
commit-bot@chromium.org | 2c86fbb | 2013-09-26 19:22:54 +0000 | [diff] [blame] | 547 | template <typename T> |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 548 | class DivModBench : public Benchmark { |
mtklein@google.com | 9cb5177 | 2013-09-27 13:39:14 +0000 | [diff] [blame] | 549 | SkString fName; |
commit-bot@chromium.org | 2c86fbb | 2013-09-26 19:22:54 +0000 | [diff] [blame] | 550 | public: |
mtklein@google.com | 9cb5177 | 2013-09-27 13:39:14 +0000 | [diff] [blame] | 551 | explicit DivModBench(const char* name) { |
| 552 | fName.printf("divmod_%s", name); |
commit-bot@chromium.org | 644629c | 2013-11-21 06:21:58 +0000 | [diff] [blame] | 553 | } |
| 554 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 555 | bool isSuitableFor(Backend backend) override { |
commit-bot@chromium.org | 644629c | 2013-11-21 06:21:58 +0000 | [diff] [blame] | 556 | return backend == kNonRendering_Backend; |
commit-bot@chromium.org | 2c86fbb | 2013-09-26 19:22:54 +0000 | [diff] [blame] | 557 | } |
| 558 | |
| 559 | protected: |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 560 | const char* onGetName() override { |
mtklein@google.com | 9cb5177 | 2013-09-27 13:39:14 +0000 | [diff] [blame] | 561 | return fName.c_str(); |
commit-bot@chromium.org | 2c86fbb | 2013-09-26 19:22:54 +0000 | [diff] [blame] | 562 | } |
| 563 | |
mtklein | a1ebeb2 | 2015-10-01 09:43:39 -0700 | [diff] [blame] | 564 | void onDraw(int loops, SkCanvas*) override { |
commit-bot@chromium.org | 2c86fbb | 2013-09-26 19:22:54 +0000 | [diff] [blame] | 565 | volatile T a = 0, b = 0; |
| 566 | T div = 0, mod = 0; |
commit-bot@chromium.org | 3361471 | 2013-12-03 18:17:16 +0000 | [diff] [blame] | 567 | for (int i = 0; i < loops; i++) { |
commit-bot@chromium.org | 2c86fbb | 2013-09-26 19:22:54 +0000 | [diff] [blame] | 568 | if ((T)i == 0) continue; // Small T will wrap around. |
| 569 | SkTDivMod((T)(i+1), (T)i, &div, &mod); |
| 570 | a ^= div; |
| 571 | b ^= mod; |
| 572 | } |
| 573 | } |
| 574 | }; |
| 575 | DEF_BENCH(return new DivModBench<uint8_t>("uint8_t")) |
| 576 | DEF_BENCH(return new DivModBench<uint16_t>("uint16_t")) |
| 577 | DEF_BENCH(return new DivModBench<uint32_t>("uint32_t")) |
| 578 | DEF_BENCH(return new DivModBench<uint64_t>("uint64_t")) |
| 579 | |
| 580 | DEF_BENCH(return new DivModBench<int8_t>("int8_t")) |
| 581 | DEF_BENCH(return new DivModBench<int16_t>("int16_t")) |
| 582 | DEF_BENCH(return new DivModBench<int32_t>("int32_t")) |
| 583 | DEF_BENCH(return new DivModBench<int64_t>("int64_t")) |
| 584 | |
| 585 | /////////////////////////////////////////////////////////////////////////////// |
| 586 | |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 587 | DEF_BENCH( return new NoOpMathBench(); ) |
commit-bot@chromium.org | 11e5b97 | 2013-11-08 20:14:16 +0000 | [diff] [blame] | 588 | DEF_BENCH( return new SkRSqrtMathBench(); ) |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 589 | DEF_BENCH( return new SlowISqrtMathBench(); ) |
| 590 | DEF_BENCH( return new FastISqrtMathBench(); ) |
| 591 | DEF_BENCH( return new QMul64Bench(); ) |
| 592 | DEF_BENCH( return new QMul32Bench(); ) |
reed@google.com | ddc518b | 2011-08-29 17:49:23 +0000 | [diff] [blame] | 593 | |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 594 | DEF_BENCH( return new IsFiniteBench(-1); ) |
| 595 | DEF_BENCH( return new IsFiniteBench(0); ) |
| 596 | DEF_BENCH( return new IsFiniteBench(1); ) |
| 597 | DEF_BENCH( return new IsFiniteBench(2); ) |
| 598 | DEF_BENCH( return new IsFiniteBench(3); ) |
| 599 | DEF_BENCH( return new IsFiniteBench(4); ) |
| 600 | DEF_BENCH( return new IsFiniteBench(5); ) |
reed@google.com | 0be5eb7 | 2011-12-05 21:53:22 +0000 | [diff] [blame] | 601 | |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 602 | DEF_BENCH( return new FloorBench(false); ) |
| 603 | DEF_BENCH( return new FloorBench(true); ) |
reed@google.com | 7f19241 | 2012-05-30 12:26:52 +0000 | [diff] [blame] | 604 | |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 605 | DEF_BENCH( return new CLZBench(false); ) |
| 606 | DEF_BENCH( return new CLZBench(true); ) |
reed@google.com | 0889f68 | 2013-05-03 12:56:39 +0000 | [diff] [blame] | 607 | |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 608 | DEF_BENCH( return new NormalizeBench(); ) |
djsollen@google.com | 25a11e4 | 2013-07-18 19:11:30 +0000 | [diff] [blame] | 609 | |
mtklein@google.com | 410e6e8 | 2013-09-13 19:52:27 +0000 | [diff] [blame] | 610 | DEF_BENCH( return new FixedMathBench(); ) |
mtklein | 785a5b9 | 2016-05-27 10:47:31 -0700 | [diff] [blame] | 611 | |
| 612 | |
| 613 | struct FloatToIntBench : public Benchmark { |
| 614 | enum { N = 1000000 }; |
| 615 | float fFloats[N]; |
| 616 | int fInts [N]; |
| 617 | |
| 618 | const char* onGetName() override { return "float_to_int"; } |
| 619 | bool isSuitableFor(Backend backend) override { return backend == kNonRendering_Backend; } |
| 620 | |
| 621 | void onDelayedSetup() override { |
| 622 | const auto f32 = 4294967296.0f; |
| 623 | for (int i = 0; i < N; ++i) { |
| 624 | fFloats[i] = -f32 + i*(2*f32/N); |
| 625 | } |
| 626 | } |
| 627 | |
| 628 | void onDraw(int loops, SkCanvas*) override { |
| 629 | while (loops --> 0) { |
| 630 | for (int i = 0; i < N; i++) { |
| 631 | fInts[i] = SkFloatToIntFloor(fFloats[i]); |
| 632 | } |
| 633 | } |
| 634 | } |
| 635 | }; |
| 636 | DEF_BENCH( return new FloatToIntBench; ) |