1) Don't allocate 100,000 ints when we only need 1,000.
2) Don't sort past the end of the array when using SkTQSort.
3) Don't allocate any arrays until we need them (in onDraw).
Also, propagate the constant N everywhere through the bench.
BUG=
R=bungeman@google.com
Review URL: https://codereview.chromium.org/23890033
git-svn-id: http://skia.googlecode.com/svn/trunk@11329 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/bench/SortBench.cpp b/bench/SortBench.cpp
index f8bb686..6fb3a71 100644
--- a/bench/SortBench.cpp
+++ b/bench/SortBench.cpp
@@ -12,40 +12,40 @@
static const int N = 1000;
-static void rand_proc(int array[], int count) {
+static void rand_proc(int array[N]) {
SkRandom rand;
- for (int i = 0; i < count; ++i) {
+ for (int i = 0; i < N; ++i) {
array[i] = rand.nextS();
}
}
-static void randN_proc(int array[], int count) {
+static void randN_proc(int array[N]) {
SkRandom rand;
int mod = N / 10;
- for (int i = 0; i < count; ++i) {
+ for (int i = 0; i < N; ++i) {
array[i] = rand.nextU() % mod;
}
}
-static void forward_proc(int array[], int count) {
- for (int i = 0; i < count; ++i) {
+static void forward_proc(int array[N]) {
+ for (int i = 0; i < N; ++i) {
array[i] = i;
}
}
-static void backward_proc(int array[], int count) {
- for (int i = 0; i < count; ++i) {
+static void backward_proc(int array[N]) {
+ for (int i = 0; i < N; ++i) {
array[i] = -i;
}
}
-static void same_proc(int array[], int count) {
- for (int i = 0; i < count; ++i) {
- array[i] = count;
+static void same_proc(int array[N]) {
+ for (int i = 0; i < N; ++i) {
+ array[i] = N;
}
}
-typedef void (*SortProc)(int array[], int count);
+typedef void (*SortProc)(int array[N]);
enum Type {
kRand, kRandN, kFore, kBack, kSame
@@ -62,12 +62,13 @@
{ "repeated", same_proc },
};
-static void skqsort_sort(int array[], int count) {
- SkTQSort<int>(array, array + count);
+static void skqsort_sort(int array[N]) {
+ // End is inclusive for SkTQSort!
+ SkTQSort<int>(array, array + N - 1);
}
-static void skheap_sort(int array[], int count) {
- SkTHeapSort<int>(array, count);
+static void skheap_sort(int array[N]) {
+ SkTHeapSort<int>(array, N);
}
extern "C" {
@@ -78,8 +79,8 @@
}
}
-static void qsort_sort(int array[], int count) {
- qsort(array, count, sizeof(int), int_compare);
+static void qsort_sort(int array[N]) {
+ qsort(array, N, sizeof(int), int_compare);
}
enum SortType {
@@ -96,23 +97,15 @@
};
class SortBench : public SkBenchmark {
- SkString fName;
- enum { MAX = 100000 };
- int fUnsorted[MAX];
- int fSorted[MAX];
- int fCount;
- SortProc fSortProc;
+ SkString fName;
+ const Type fType;
+ const SortProc fSortProc;
+ SkAutoTMalloc<int> fUnsorted;
public:
- SortBench(Type t, int n, SortType s) {
- if (n > MAX) {
- n = MAX;
- }
- fName.printf("sort_%s_%s", gSorts[s].fName, gRec[t].fName);
- fCount = n;
- gRec[t].fProc(fUnsorted, n);
- fSortProc = gSorts[s].fProc;
+ SortBench(Type t, SortType s) : fType(t), fSortProc(gSorts[s].fProc) {
fIsRendering = false;
+ fName.printf("sort_%s_%s", gSorts[s].fName, gRec[t].fName);
}
protected:
@@ -120,13 +113,20 @@
return fName.c_str();
}
- virtual void onDraw(SkCanvas*) {
+ // Delayed initialization only done if onDraw will be called.
+ virtual void onPreDraw() SK_OVERRIDE {
+ fUnsorted.reset(N);
+ gRec[fType].fProc(fUnsorted.get());
+ }
+
+ virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ SkAutoTMalloc<int> sorted(N);
for (int i = 0; i < this->getLoops(); i++) {
- memcpy(fSorted, fUnsorted, fCount * sizeof(int));
- fSortProc(fSorted, fCount);
+ memcpy(sorted.get(), fUnsorted.get(), N*sizeof(int));
+ fSortProc(sorted.get());
#ifdef SK_DEBUG
- for (int j = 1; j < fCount; ++j) {
- SkASSERT(fSorted[j - 1] <= fSorted[j]);
+ for (int j = 1; j < N; ++j) {
+ SkASSERT(sorted[j - 1] <= sorted[j]);
}
#endif
}
@@ -139,13 +139,13 @@
///////////////////////////////////////////////////////////////////////////////
static SkBenchmark* NewSkQSort(Type t) {
- return new SortBench(t, N, kSKQSort);
+ return new SortBench(t, kSKQSort);
}
static SkBenchmark* NewSkHeap(Type t) {
- return new SortBench(t, N, kSKHeap);
+ return new SortBench(t, kSKHeap);
}
static SkBenchmark* NewQSort(Type t) {
- return new SortBench(t, N, kQSort);
+ return new SortBench(t, kQSort);
}
DEF_BENCH( return NewSkQSort(kRand); )