2 * Copyright (C) 2013 The Android Open Source Project
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #ifndef __BANDWIDTH_H__
18 #define __BANDWIDTH_H__
23 #include "utils/Compat.h"
26 // Bandwidth Class definitions.
27 class BandwidthBenchmark {
31 _num_warm_loops(DEFAULT_NUM_WARM_LOOPS),
32 _num_loops(DEFAULT_NUM_LOOPS) {}
33 virtual ~BandwidthBenchmark() {}
43 bench(_num_warm_loops);
45 nsecs_t t = system_time();
47 t = system_time() - t;
49 _mb_per_sec = (_size*(_num_loops/_BYTES_PER_MB))/(t/_NUM_NS_PER_SEC);
54 bool canRun() { return !usesNeon() || isNeonSupported(); }
56 virtual bool setSize(size_t size) = 0;
58 virtual const char *getName() = 0;
60 virtual bool verify() = 0;
62 virtual bool usesNeon() { return false; }
64 bool isNeonSupported() {
65 #if defined(__ARM_NEON__)
72 // Accessors/mutators.
73 double mb_per_sec() { return _mb_per_sec; }
74 size_t num_warm_loops() { return _num_warm_loops; }
75 size_t num_loops() { return _num_loops; }
76 size_t size() { return _size; }
78 void set_num_warm_loops(size_t num_warm_loops) {
79 _num_warm_loops = num_warm_loops;
81 void set_num_loops(size_t num_loops) { _num_loops = num_loops; }
84 static const unsigned int DEFAULT_NUM_WARM_LOOPS = 1000000;
85 static const unsigned int DEFAULT_NUM_LOOPS = 20000000;
88 virtual void bench(size_t num_loops) = 0;
92 size_t _num_warm_loops;
97 static const CONSTEXPR double _NUM_NS_PER_SEC = 1000000000.0;
98 static const CONSTEXPR double _BYTES_PER_MB = 1024.0* 1024.0;
101 class CopyBandwidthBenchmark : public BandwidthBenchmark {
103 CopyBandwidthBenchmark() : BandwidthBenchmark(), _src(NULL), _dst(NULL) { }
105 bool setSize(size_t size) {
114 _size = DEFAULT_COPY_SIZE;
119 _src = reinterpret_cast<char*>(memalign(64, _size));
121 perror("Failed to allocate memory for test.");
124 _dst = reinterpret_cast<char*>(memalign(64, _size));
126 perror("Failed to allocate memory for test.");
132 virtual ~CopyBandwidthBenchmark() {
144 memset(_src, 0x23, _size);
145 memset(_dst, 0, _size);
147 if (memcmp(_src, _dst, _size) != 0) {
148 printf("Buffers failed to compare after one loop.\n");
152 memset(_src, 0x23, _size);
153 memset(_dst, 0, _size);
156 if (memcmp(_src, _dst, _size) != 0) {
157 printf("Buffers failed to compare after two loops.\n");
168 static const unsigned int DEFAULT_COPY_SIZE = 8000;
171 class CopyLdrdStrdBenchmark : public CopyBandwidthBenchmark {
173 CopyLdrdStrdBenchmark() : CopyBandwidthBenchmark() { }
174 virtual ~CopyLdrdStrdBenchmark() {}
176 const char *getName() { return "ldrd/strd"; }
179 // Copy using ldrd/strd instructions.
180 void bench(size_t num_loops) {
182 "stmfd sp!, {r0,r1,r2,r3,r4,r6,r7}\n"
190 "mov r4, r2, lsr #6\n"
193 "ldrd r6, r7, [r0]\n"
194 "strd r6, r7, [r1]\n"
195 "ldrd r6, r7, [r0, #8]\n"
196 "strd r6, r7, [r1, #8]\n"
197 "ldrd r6, r7, [r0, #16]\n"
198 "strd r6, r7, [r1, #16]\n"
199 "ldrd r6, r7, [r0, #24]\n"
200 "strd r6, r7, [r1, #24]\n"
201 "ldrd r6, r7, [r0, #32]\n"
202 "strd r6, r7, [r1, #32]\n"
203 "ldrd r6, r7, [r0, #40]\n"
204 "strd r6, r7, [r1, #40]\n"
205 "ldrd r6, r7, [r0, #48]\n"
206 "strd r6, r7, [r1, #48]\n"
207 "ldrd r6, r7, [r0, #56]\n"
208 "strd r6, r7, [r1, #56]\n"
220 "ldmfd sp!, {r0,r1,r2,r3,r4,r6,r7}\n"
221 :: "r" (_src), "r" (_dst), "r" (_size), "r" (num_loops) : "r0", "r1", "r2", "r3");
225 class CopyLdmiaStmiaBenchmark : public CopyBandwidthBenchmark {
227 CopyLdmiaStmiaBenchmark() : CopyBandwidthBenchmark() { }
228 virtual ~CopyLdmiaStmiaBenchmark() {}
230 const char *getName() { return "ldmia/stmia"; }
233 // Copy using ldmia/stmia instructions.
234 void bench(size_t num_loops) {
236 "stmfd sp!, {r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12}\n"
244 "mov r4, r2, lsr #6\n"
247 "ldmia r0!, {r5, r6, r7, r8, r9, r10, r11, r12}\n"
248 "stmia r1!, {r5, r6, r7, r8, r9, r10, r11, r12}\n"
250 "ldmia r0!, {r5, r6, r7, r8, r9, r10, r11, r12}\n"
251 "stmia r1!, {r5, r6, r7, r8, r9, r10, r11, r12}\n"
259 "ldmfd sp!, {r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12}\n"
260 :: "r" (_src), "r" (_dst), "r" (_size), "r" (num_loops) : "r0", "r1", "r2", "r3");
264 class CopyVld1Vst1Benchmark : public CopyBandwidthBenchmark {
266 CopyVld1Vst1Benchmark() : CopyBandwidthBenchmark() { }
267 virtual ~CopyVld1Vst1Benchmark() {}
269 const char *getName() { return "vld1/vst1"; }
271 bool usesNeon() { return true; }
274 // Copy using vld1/vst1 instructions.
275 #if defined(__ARM_NEON__)
276 void bench(size_t num_loops) {
278 "stmfd sp!, {r0,r1,r2,r3,r4}\n"
286 "mov r4, r2, lsr #6\n"
289 "vld1.8 {d0-d3}, [r0]!\n"
290 "vld1.8 {d4-d7}, [r0]!\n"
292 "vst1.8 {d0-d3}, [r1:128]!\n"
293 "vst1.8 {d4-d7}, [r1:128]!\n"
301 "ldmfd sp!, {r0,r1,r2,r3,r4}\n"
302 :: "r" (_src), "r" (_dst), "r" (_size), "r" (num_loops) : "r0", "r1", "r2", "r3");
309 class CopyVldrVstrBenchmark : public CopyBandwidthBenchmark {
311 CopyVldrVstrBenchmark() : CopyBandwidthBenchmark() { }
312 virtual ~CopyVldrVstrBenchmark() {}
314 const char *getName() { return "vldr/vstr"; }
316 bool usesNeon() { return true; }
319 // Copy using vldr/vstr instructions.
320 #if defined(__ARM_NEON__)
321 void bench(size_t num_loops) {
323 "stmfd sp!, {r0,r1,r2,r3,r4}\n"
331 "mov r4, r2, lsr #6\n"
334 "vldr d0, [r0, #0]\n"
336 "vldr d1, [r0, #8]\n"
337 "vstr d0, [r1, #0]\n"
338 "vldr d0, [r0, #16]\n"
339 "vstr d1, [r1, #8]\n"
340 "vldr d1, [r0, #24]\n"
341 "vstr d0, [r1, #16]\n"
342 "vldr d0, [r0, #32]\n"
343 "vstr d1, [r1, #24]\n"
344 "vldr d1, [r0, #40]\n"
345 "vstr d0, [r1, #32]\n"
346 "vldr d0, [r0, #48]\n"
347 "vstr d1, [r1, #40]\n"
348 "vldr d1, [r0, #56]\n"
349 "vstr d0, [r1, #48]\n"
351 "vstr d1, [r1, #56]\n"
360 "ldmfd sp!, {r0,r1,r2,r3,r4}\n"
361 :: "r" (_src), "r" (_dst), "r" (_size), "r" (num_loops) : "r0", "r1", "r2", "r3");
368 class CopyVldmiaVstmiaBenchmark : public CopyBandwidthBenchmark {
370 CopyVldmiaVstmiaBenchmark() : CopyBandwidthBenchmark() { }
371 virtual ~CopyVldmiaVstmiaBenchmark() {}
373 const char *getName() { return "vldmia/vstmia"; }
375 bool usesNeon() { return true; }
378 // Copy using vldmia/vstmia instructions.
379 #if defined(__ARM_NEON__)
380 void bench(size_t num_loops) {
382 "stmfd sp!, {r0,r1,r2,r3,r4}\n"
390 "mov r4, r2, lsr #6\n"
393 "vldmia r0!, {d0-d7}\n"
395 "vstmia r1!, {d0-d7}\n"
403 "ldmfd sp!, {r0,r1,r2,r3,r4}\n"
404 :: "r" (_src), "r" (_dst), "r" (_size), "r" (num_loops) : "r0", "r1", "r2", "r3");
411 class MemcpyBenchmark : public CopyBandwidthBenchmark {
413 MemcpyBenchmark() : CopyBandwidthBenchmark() { }
414 virtual ~MemcpyBenchmark() {}
416 const char *getName() { return "memcpy"; }
419 void bench(size_t num_loops) {
420 for (size_t i = 0; i < num_loops; i++) {
421 memcpy(_dst, _src, _size);
426 class SingleBufferBandwidthBenchmark : public BandwidthBenchmark {
428 SingleBufferBandwidthBenchmark() : BandwidthBenchmark(), _buffer(NULL) { }
429 virtual ~SingleBufferBandwidthBenchmark() {
436 bool setSize(size_t size) {
443 _size = DEFAULT_SINGLE_BUFFER_SIZE;
448 _buffer = reinterpret_cast<char*>(memalign(64, _size));
450 perror("Failed to allocate memory for test.");
453 memset(_buffer, 0, _size);
458 bool verify() { return true; }
463 static const unsigned int DEFAULT_SINGLE_BUFFER_SIZE = 16000;
466 class WriteBandwidthBenchmark : public SingleBufferBandwidthBenchmark {
468 WriteBandwidthBenchmark() : SingleBufferBandwidthBenchmark() { }
469 virtual ~WriteBandwidthBenchmark() { }
472 memset(_buffer, 0, _size);
474 for (size_t i = 0; i < _size; i++) {
475 if (_buffer[i] != 1) {
476 printf("Buffer failed to compare after one loop.\n");
481 memset(_buffer, 0, _size);
483 for (size_t i = 0; i < _size; i++) {
484 if (_buffer[i] != 2) {
485 printf("Buffer failed to compare after two loops.\n");
494 class WriteStrdBenchmark : public WriteBandwidthBenchmark {
496 WriteStrdBenchmark() : WriteBandwidthBenchmark() { }
497 virtual ~WriteStrdBenchmark() {}
499 const char *getName() { return "strd"; }
502 // Write a given value using strd.
503 void bench(size_t num_loops) {
505 "stmfd sp!, {r0,r1,r2,r3,r4,r5}\n"
515 "mov r3, r1, lsr #5\n"
517 "add r4, r4, #0x01010101\n"
522 "strd r4, r5, [r0]\n"
523 "strd r4, r5, [r0, #8]\n"
524 "strd r4, r5, [r0, #16]\n"
525 "strd r4, r5, [r0, #24]\n"
533 "ldmfd sp!, {r0,r1,r2,r3,r4,r5}\n"
534 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2");
538 class WriteStmiaBenchmark : public WriteBandwidthBenchmark {
540 WriteStmiaBenchmark() : WriteBandwidthBenchmark() { }
541 virtual ~WriteStmiaBenchmark() {}
543 const char *getName() { return "stmia"; }
546 // Write a given value using stmia.
547 void bench(size_t num_loops) {
549 "stmfd sp!, {r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11}\n"
558 "mov r3, r1, lsr #5\n"
560 "add r4, r4, #0x01010101\n"
571 "stmia r0!, {r4, r5, r6, r7, r8, r9, r10, r11}\n"
578 "ldmfd sp!, {r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11}\n"
579 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2");
583 class WriteVst1Benchmark : public WriteBandwidthBenchmark {
585 WriteVst1Benchmark() : WriteBandwidthBenchmark() { }
586 virtual ~WriteVst1Benchmark() {}
588 const char *getName() { return "vst1"; }
590 bool usesNeon() { return true; }
593 // Write a given value using vst.
594 #if defined(__ARM_NEON__)
595 void bench(size_t num_loops) {
597 "stmfd sp!, {r0,r1,r2,r3,r4}\n"
605 "mov r3, r1, lsr #5\n"
615 "vst1.8 {d0-d3}, [r0:128]!\n"
622 "ldmfd sp!, {r0,r1,r2,r3,r4}\n"
623 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2");
630 class WriteVstrBenchmark : public WriteBandwidthBenchmark {
632 WriteVstrBenchmark() : WriteBandwidthBenchmark() { }
633 virtual ~WriteVstrBenchmark() {}
635 const char *getName() { return "vstr"; }
637 bool usesNeon() { return true; }
640 // Write a given value using vst.
641 #if defined(__ARM_NEON__)
642 void bench(size_t num_loops) {
644 "stmfd sp!, {r0,r1,r2,r3,r4}\n"
652 "mov r3, r1, lsr #5\n"
661 "vstr d0, [r0, #0]\n"
663 "vstr d1, [r0, #8]\n"
664 "vstr d0, [r0, #16]\n"
665 "vstr d1, [r0, #24]\n"
673 "ldmfd sp!, {r0,r1,r2,r3,r4}\n"
674 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2");
681 class WriteVstmiaBenchmark : public WriteBandwidthBenchmark {
683 WriteVstmiaBenchmark() : WriteBandwidthBenchmark() { }
684 virtual ~WriteVstmiaBenchmark() {}
686 const char *getName() { return "vstmia"; }
688 bool usesNeon() { return true; }
691 // Write a given value using vstmia.
692 #if defined(__ARM_NEON__)
693 void bench(size_t num_loops) {
695 "stmfd sp!, {r0,r1,r2,r3,r4}\n"
703 "mov r3, r1, lsr #5\n"
713 "vstmia r0!, {d0-d3}\n"
720 "ldmfd sp!, {r0,r1,r2,r3,r4}\n"
721 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2");
728 class MemsetBenchmark : public WriteBandwidthBenchmark {
730 MemsetBenchmark() : WriteBandwidthBenchmark() { }
731 virtual ~MemsetBenchmark() {}
733 const char *getName() { return "memset"; }
736 void bench(size_t num_loops) {
737 for (size_t i = 0; i < num_loops; i++) {
738 memset(_buffer, (i % 255) + 1, _size);
743 class ReadLdrdBenchmark : public SingleBufferBandwidthBenchmark {
745 ReadLdrdBenchmark() : SingleBufferBandwidthBenchmark() { }
746 virtual ~ReadLdrdBenchmark() {}
748 const char *getName() { return "ldrd"; }
751 // Write a given value using strd.
752 void bench(size_t num_loops) {
754 "stmfd sp!, {r0,r1,r2,r3,r4,r5}\n"
761 "mov r3, r1, lsr #5\n"
765 "ldrd r4, r5, [r0]\n"
766 "ldrd r4, r5, [r0, #8]\n"
767 "ldrd r4, r5, [r0, #16]\n"
768 "ldrd r4, r5, [r0, #24]\n"
776 "ldmfd sp!, {r0,r1,r2,r3,r4,r5}\n"
777 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2");
781 class ReadLdmiaBenchmark : public SingleBufferBandwidthBenchmark {
783 ReadLdmiaBenchmark() : SingleBufferBandwidthBenchmark() { }
784 virtual ~ReadLdmiaBenchmark() {}
786 const char *getName() { return "ldmia"; }
789 // Write a given value using stmia.
790 void bench(size_t num_loops) {
792 "stmfd sp!, {r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11}\n"
799 "mov r3, r1, lsr #5\n"
803 "ldmia r0!, {r4, r5, r6, r7, r8, r9, r10, r11}\n"
810 "ldmfd sp!, {r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11}\n"
811 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2");
815 class ReadVld1Benchmark : public SingleBufferBandwidthBenchmark {
817 ReadVld1Benchmark() : SingleBufferBandwidthBenchmark() { }
818 virtual ~ReadVld1Benchmark() {}
820 const char *getName() { return "vld1"; }
822 bool usesNeon() { return true; }
825 // Write a given value using vst.
826 #if defined(__ARM_NEON__)
827 void bench(size_t num_loops) {
829 "stmfd sp!, {r0,r1,r2,r3}\n"
836 "mov r3, r1, lsr #5\n"
840 "vld1.8 {d0-d3}, [r0:128]!\n"
847 "ldmfd sp!, {r0,r1,r2,r3}\n"
848 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2");
855 class ReadVldrBenchmark : public SingleBufferBandwidthBenchmark {
857 ReadVldrBenchmark() : SingleBufferBandwidthBenchmark() { }
858 virtual ~ReadVldrBenchmark() {}
860 const char *getName() { return "vldr"; }
862 bool usesNeon() { return true; }
865 // Write a given value using vst.
866 #if defined(__ARM_NEON__)
867 void bench(size_t num_loops) {
869 "stmfd sp!, {r0,r1,r2,r3}\n"
876 "mov r3, r1, lsr #5\n"
879 "vldr d0, [r0, #0]\n"
881 "vldr d1, [r0, #8]\n"
882 "vldr d0, [r0, #16]\n"
883 "vldr d1, [r0, #24]\n"
891 "ldmfd sp!, {r0,r1,r2,r3}\n"
892 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2");
900 class ReadVldmiaBenchmark : public SingleBufferBandwidthBenchmark {
902 ReadVldmiaBenchmark() : SingleBufferBandwidthBenchmark() { }
903 virtual ~ReadVldmiaBenchmark() {}
905 const char *getName() { return "vldmia"; }
907 bool usesNeon() { return true; }
910 // Write a given value using vstmia.
911 #if defined(__ARM_NEON__)
912 void bench(size_t num_loops) {
914 "stmfd sp!, {r0,r1,r2,r3}\n"
921 "mov r3, r1, lsr #5\n"
925 "vldmia r0!, {d0-d3}\n"
932 "ldmfd sp!, {r0,r1,r2,r3}\n"
933 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2");
940 #endif // __BANDWIDTH_H__