1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
/*
* Copyright 2012 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 "SkChecksum.h"
#include "SkString.h"
class ComputeChecksumBench : public SkBenchmark {
public:
ComputeChecksumBench(void* param, const char name[]) : INHERITED(param) {
fName.printf("compute_checksum_%s", name);
}
enum {
DATA_SIZE = 1024,
N = SkBENCHLOOP(100000),
};
protected:
virtual const char* onGetName() {
return fName.c_str();
}
virtual void onDraw(SkCanvas* canvas) {
uint64_t data[DATA_SIZE / sizeof(uint64_t)];
computeChecksum(data, DATA_SIZE);
}
virtual void computeChecksum(const uint64_t*, size_t) = 0;
SkString fName;
private:
typedef SkBenchmark INHERITED;
};
/*
* Use SkComputeChecksum32 to compute a checksum on a datablock
*/
class ComputeChecksum32Bench : public ComputeChecksumBench {
public:
ComputeChecksum32Bench(void* param)
: INHERITED(param, "32") { }
protected:
virtual void computeChecksum(const uint64_t* data, size_t len) {
for (int i = 0; i < N; i++) {
volatile uint32_t result = SkComputeChecksum32(reinterpret_cast<const uint32_t*>(data), len);
}
}
private:
typedef ComputeChecksumBench INHERITED;
};
/*
* Use SkComputeChecksum64 to compute a checksum on a datablock
*/
class ComputeChecksum64Bench : public ComputeChecksumBench {
public:
ComputeChecksum64Bench(void* param)
: INHERITED(param, "64") { }
protected:
virtual void computeChecksum(const uint64_t* data, size_t len) {
for (int i = 0; i < N; i++) {
volatile uint64_t result = SkComputeChecksum64(data, len);
}
}
private:
typedef ComputeChecksumBench INHERITED;
};
/*
* Use SkComputeChecksum64 to compute a checksum on a datablock
*/
class ComputeChecksumXXBench : public ComputeChecksumBench {
public:
ComputeChecksumXXBench(void* param) : INHERITED(param, "XX") { }
protected:
virtual void computeChecksum(const uint64_t* data, size_t len) {
for (int i = 0; i < N; i++) {
volatile uint32_t result = SkChecksum::Compute(reinterpret_cast<const uint32_t*>(data), len);
}
}
private:
typedef ComputeChecksumBench INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
static SkBenchmark* Fact0(void* p) { return new ComputeChecksum32Bench(p); }
static SkBenchmark* Fact1(void* p) { return new ComputeChecksum64Bench(p); }
static SkBenchmark* Fact2(void* p) { return new ComputeChecksumXXBench(p); }
static BenchRegistry gReg0(Fact0);
static BenchRegistry gReg1(Fact1);
static BenchRegistry gReg2(Fact2);
|
