Rewrite memset benches, then use results to add a small-N optimization.
The benches for N <= 10 get around 2x faster on my N7 and N9. I believe this
is because of the reduced function-call-then-function-pointer-call overhead on
the N7, and additionally because it seems autovectorization beats our NEON code
for small N on the N9.
My desktop is unchanged, though that's probably because N=10 lies well within a
region where memset's performance is essentially constant: N=100 takes only
about 2x as long as N=1 and N=10, which perform nearly identically.
BUG=skia:
Review URL: https://codereview.chromium.org/1073863002
diff --git a/bench/MemsetBench.cpp b/bench/MemsetBench.cpp
index e0390bb..d1682bd 100644
--- a/bench/MemsetBench.cpp
+++ b/bench/MemsetBench.cpp
@@ -6,110 +6,79 @@
*/
#include "Benchmark.h"
-#include "SkCanvas.h"
-#include "SkString.h"
+#include "SkTemplates.h"
#include "SkUtils.h"
+template <typename T, bool kInline>
class MemsetBench : public Benchmark {
- SkString fName;
-
-protected:
- int fMinSize;
- int fMaxSize;
- enum {
- kBufferSize = 10000,
- VALUE32 = 0x12345678,
- VALUE16 = 0x1234
- };
-
- enum MemsetType {
- MEMSET16 = 16,
- MEMSET32 = 32
- };
-
public:
- MemsetBench(MemsetType type, int minSize, int maxSize) {
- SkASSERT((minSize < maxSize) && (maxSize <= kBufferSize));
- fMinSize = minSize;
- fMaxSize = maxSize;
- fName.printf("memset%d_%d_%d", type, minSize, maxSize);
- }
+ explicit MemsetBench(int n)
+ : fN(n)
+ , fBuffer(n)
+ , fName(SkStringPrintf("memset%d_%d%s", sizeof(T)*8, n, kInline ? "_inline" : "")) {}
- bool isSuitableFor(Backend backend) override {
- return backend == kNonRendering_Backend;
- }
+ bool isSuitableFor(Backend backend) override { return backend == kNonRendering_Backend; }
+ const char* onGetName() override { return fName.c_str(); }
- virtual void performTest() = 0;
-
-protected:
- const char* onGetName() override {
- return fName.c_str();
- }
-
- void onDraw(const int loops, SkCanvas* canvas) override {
- for (int i = 0; i < loops; ++i) {
- this->performTest();
- }
- }
+ void onDraw(const int loops, SkCanvas*) override;
private:
- typedef Benchmark INHERITED;
+ int fN;
+ SkAutoTMalloc<T> fBuffer;
+ SkString fName;
};
-class Memset32Bench : public MemsetBench {
- uint32_t kBuffer[kBufferSize + 3];
-public:
- Memset32Bench(int minSize, int maxSize)
- : INHERITED(MEMSET32, minSize, maxSize) {}
-
-protected:
- void performTest() override {
- for(int j = fMinSize; j < fMaxSize; ++j){
- sk_memset32(kBuffer, VALUE32, j);
- sk_memset32(kBuffer + 1, VALUE32, j);
- sk_memset32(kBuffer + 2, VALUE32, j);
- sk_memset32(kBuffer + 3, VALUE32, j);
- }
+template <> void MemsetBench<uint32_t, false>::onDraw(const int loops, SkCanvas*) {
+ for (int i = 0; i < 1000*loops; i++) {
+ sk_memset32(fBuffer.get(), 0xFACEB004, fN);
}
-private:
- typedef MemsetBench INHERITED;
-};
+}
-class Memset16Bench : public MemsetBench {
- uint16_t kBuffer[kBufferSize + 7];
-public:
- Memset16Bench(int minSize, int maxSize)
- : INHERITED(MEMSET16, minSize, maxSize) {}
-
-protected:
- void performTest() override {
- for(int j = fMinSize; j < fMaxSize; ++j){
- sk_memset16(kBuffer, VALUE16, j);
- sk_memset16(kBuffer + 1, VALUE16, j);
- sk_memset16(kBuffer + 2, VALUE16, j);
- sk_memset16(kBuffer + 3, VALUE16, j);
- sk_memset16(kBuffer + 4, VALUE16, j);
- sk_memset16(kBuffer + 5, VALUE16, j);
- sk_memset16(kBuffer + 6, VALUE16, j);
- sk_memset16(kBuffer + 7, VALUE16, j);
- }
+template <> void MemsetBench<uint16_t, false>::onDraw(const int loops, SkCanvas*) {
+ for (int i = 0; i < 1000*loops; i++) {
+ sk_memset16(fBuffer.get(), 0x4973, fN);
}
-private:
- typedef MemsetBench INHERITED;
-};
+}
-DEF_BENCH(return new Memset32Bench(1, 600);)
-DEF_BENCH(return new Memset32Bench(600, 800);)
-DEF_BENCH(return new Memset32Bench(800, 1000);)
-DEF_BENCH(return new Memset32Bench(1000, 2000);)
-DEF_BENCH(return new Memset32Bench(2000, 3000);)
-DEF_BENCH(return new Memset32Bench(3000, 4000);)
-DEF_BENCH(return new Memset32Bench(4000, 5000);)
+template <typename T>
+static void memsetT(T* dst, T val, int n) {
+ for (int i = 0; i < n; i++) { dst[i] = val; }
+}
-DEF_BENCH(return new Memset16Bench(1, 600);)
-DEF_BENCH(return new Memset16Bench(600, 800);)
-DEF_BENCH(return new Memset16Bench(800, 1000);)
-DEF_BENCH(return new Memset16Bench(1000, 2000);)
-DEF_BENCH(return new Memset16Bench(2000, 3000);)
-DEF_BENCH(return new Memset16Bench(3000, 4000);)
-DEF_BENCH(return new Memset16Bench(4000, 5000);)
+template <> void MemsetBench<uint32_t, true>::onDraw(const int loops, SkCanvas*) {
+ for (int i = 0; i < 1000*loops; i++) {
+ memsetT<uint32_t>(fBuffer.get(), 0xFACEB004, fN);
+ }
+}
+
+template <> void MemsetBench<uint16_t, true>::onDraw(const int loops, SkCanvas*) {
+ for (int i = 0; i < 1000*loops; i++) {
+ memsetT<uint16_t>(fBuffer.get(), 0x4973, fN);
+ }
+}
+
+DEF_BENCH(return (new MemsetBench<uint32_t, true>(1)));
+DEF_BENCH(return (new MemsetBench<uint32_t, false>(1)));
+DEF_BENCH(return (new MemsetBench<uint32_t, true>(10)));
+DEF_BENCH(return (new MemsetBench<uint32_t, false>(10)));
+DEF_BENCH(return (new MemsetBench<uint32_t, true>(100)));
+DEF_BENCH(return (new MemsetBench<uint32_t, false>(100)));
+DEF_BENCH(return (new MemsetBench<uint32_t, true>(1000)));
+DEF_BENCH(return (new MemsetBench<uint32_t, false>(1000)));
+DEF_BENCH(return (new MemsetBench<uint32_t, true>(10000)));
+DEF_BENCH(return (new MemsetBench<uint32_t, false>(10000)));
+DEF_BENCH(return (new MemsetBench<uint32_t, true>(100000)));
+DEF_BENCH(return (new MemsetBench<uint32_t, false>(100000)));
+
+DEF_BENCH(return (new MemsetBench<uint16_t, true>(1)));
+DEF_BENCH(return (new MemsetBench<uint16_t, false>(1)));
+DEF_BENCH(return (new MemsetBench<uint16_t, true>(10)));
+DEF_BENCH(return (new MemsetBench<uint16_t, false>(10)));
+DEF_BENCH(return (new MemsetBench<uint16_t, true>(100)));
+DEF_BENCH(return (new MemsetBench<uint16_t, false>(100)));
+DEF_BENCH(return (new MemsetBench<uint16_t, true>(1000)));
+DEF_BENCH(return (new MemsetBench<uint16_t, false>(1000)));
+DEF_BENCH(return (new MemsetBench<uint16_t, true>(10000)));
+DEF_BENCH(return (new MemsetBench<uint16_t, false>(10000)));
+DEF_BENCH(return (new MemsetBench<uint16_t, true>(100000)));
+DEF_BENCH(return (new MemsetBench<uint16_t, false>(100000)));