skia2/bench/InterpBench.cpp
John Stiles 7571f9e490 Replace 'typedef xxxxx INHERITED' with 'using INHERITED = xxxx;'.
Mechanically updated via Xcode "Replace Regular Expression":

  typedef (.*) INHERITED;
    -->
  using INHERITED = $1;

The ClangTidy approach generated an even larger CL which would have
required a significant amount of hand-tweaking to be usable.

Change-Id: I671dc9d9efdf6d60151325c8d4d13fad7e10a15b
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/314999
Commit-Queue: Mike Klein <mtklein@google.com>
Reviewed-by: Mike Klein <mtklein@google.com>
Auto-Submit: John Stiles <johnstiles@google.com>
2020-09-03 03:41:26 +00:00

172 lines
5.1 KiB
C++

/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "bench/Benchmark.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkString.h"
#include "include/private/SkColorData.h"
#include "include/private/SkFixed.h"
#include "include/utils/SkRandom.h"
#define TILE(x, width) (((x) & 0xFFFF) * width >> 16)
class InterpBench : public Benchmark {
enum {
kBuffer = 128,
kLoop = 20000
};
SkString fName;
int16_t fDst[kBuffer];
float fFx, fDx;
public:
InterpBench(const char name[]) {
fName.printf("interp_%s", name);
fFx = 3.3f;
fDx = 0.1257f;
}
bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
virtual void performTest(int16_t dst[], float x, float dx, int count) = 0;
protected:
virtual int mulLoopCount() const { return 1; }
const char* onGetName() override {
return fName.c_str();
}
void onDraw(int loops, SkCanvas*) override {
int n = loops * this->mulLoopCount();
for (int i = 0; i < n; i++) {
this->performTest(fDst, fFx, fDx, kBuffer);
}
}
private:
using INHERITED = Benchmark;
};
class Fixed16D16Interp : public InterpBench {
public:
Fixed16D16Interp() : INHERITED("16.16") {}
protected:
void performTest(int16_t dst[], float fx, float dx, int count) override {
SkFixed curr = SkFloatToFixed(fx);
SkFixed step = SkFloatToFixed(dx);
for (int i = 0; i < count; i += 4) {
dst[i + 0] = TILE(curr, count); curr += step;
dst[i + 1] = TILE(curr, count); curr += step;
dst[i + 2] = TILE(curr, count); curr += step;
dst[i + 3] = TILE(curr, count); curr += step;
}
}
private:
using INHERITED = InterpBench;
};
class Fixed32D32Interp : public InterpBench {
public:
Fixed32D32Interp() : INHERITED("32.32") {}
protected:
void performTest(int16_t dst[], float fx, float dx, int count) override {
int64_t curr = (int64_t)(fx * 65536 * 655536);
int64_t step = (int64_t)(dx * 65536 * 655536);
SkFixed tmp;
for (int i = 0; i < count; i += 4) {
tmp = (SkFixed)(curr >> 16);
dst[i + 0] = TILE(tmp, count);
curr += step;
tmp = (SkFixed)(curr >> 16);
dst[i + 1] = TILE(tmp, count);
curr += step;
tmp = (SkFixed)(curr >> 16);
dst[i + 2] = TILE(tmp, count);
curr += step;
tmp = (SkFixed)(curr >> 16);
dst[i + 3] = TILE(tmp, count);
curr += step;
}
}
private:
using INHERITED = InterpBench;
};
class Fixed16D48Interp : public InterpBench {
public:
Fixed16D48Interp() : INHERITED("16.48") {}
protected:
void performTest(int16_t dst[], float fx, float dx, int count) override {
int64_t curr = (int64_t)(fx * 65536 * 655536 * 65536);
int64_t step = (int64_t)(dx * 65536 * 655536 * 65536);
SkFixed tmp;
for (int i = 0; i < count; i += 4) {
tmp = (SkFixed) (curr >> 32); dst[i + 0] = TILE(tmp, count); curr += step;
tmp = (SkFixed) (curr >> 32); dst[i + 1] = TILE(tmp, count); curr += step;
tmp = (SkFixed) (curr >> 32); dst[i + 2] = TILE(tmp, count); curr += step;
tmp = (SkFixed) (curr >> 32); dst[i + 3] = TILE(tmp, count); curr += step;
}
}
private:
using INHERITED = InterpBench;
};
class FloatInterp : public InterpBench {
public:
FloatInterp() : INHERITED("float") {}
protected:
void performTest(int16_t dst[], float fx, float dx, int count) override {
SkFixed tmp;
for (int i = 0; i < count; i += 4) {
tmp = SkFloatToFixed(fx); dst[i + 0] = TILE(tmp, count); fx += dx;
tmp = SkFloatToFixed(fx); dst[i + 1] = TILE(tmp, count); fx += dx;
tmp = SkFloatToFixed(fx); dst[i + 2] = TILE(tmp, count); fx += dx;
tmp = SkFloatToFixed(fx); dst[i + 3] = TILE(tmp, count); fx += dx;
}
}
private:
using INHERITED = InterpBench;
};
class DoubleInterp : public InterpBench {
public:
DoubleInterp() : INHERITED("double") {}
protected:
void performTest(int16_t dst[], float fx, float dx, int count) override {
double ffx = fx;
double ddx = dx;
SkFixed tmp;
for (int i = 0; i < count; i += 4) {
tmp = SkDoubleToFixed(ffx); dst[i + 0] = TILE(tmp, count); ffx += ddx;
tmp = SkDoubleToFixed(ffx); dst[i + 1] = TILE(tmp, count); ffx += ddx;
tmp = SkDoubleToFixed(ffx); dst[i + 2] = TILE(tmp, count); ffx += ddx;
tmp = SkDoubleToFixed(ffx); dst[i + 3] = TILE(tmp, count); ffx += ddx;
}
}
private:
using INHERITED = InterpBench;
};
///////////////////////////////////////////////////////////////////////////////
DEF_BENCH( return new Fixed16D16Interp(); )
DEF_BENCH( return new Fixed32D32Interp(); )
DEF_BENCH( return new Fixed16D48Interp(); )
DEF_BENCH( return new FloatInterp(); )
DEF_BENCH( return new DoubleInterp(); )