1 /* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 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 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 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. 15 */ 16 17 #ifndef __BANDWIDTH_H__ 18 #define __BANDWIDTH_H__ 19 20 #include "memtest.h" 21 22 // Bandwidth Class definitions. 23 class BandwidthBenchmark { 24 public: 25 BandwidthBenchmark() 26 : _size(0), 27 _num_warm_loops(DEFAULT_NUM_WARM_LOOPS), 28 _num_loops(DEFAULT_NUM_LOOPS) {} 29 virtual ~BandwidthBenchmark() {} 30 31 bool run() { 32 if (_size == 0) { 33 return false; 34 } 35 if (!canRun()) { 36 return false; 37 } 38 39 bench(_num_warm_loops); 40 41 nsecs_t t = system_time(); 42 bench(_num_loops); 43 t = system_time() - t; 44 45 _mb_per_sec = (_size*(_num_loops/_BYTES_PER_MB))/(t/_NUM_NS_PER_SEC); 46 47 return true; 48 } 49 50 bool canRun() { return !usesNeon() || isNeonSupported(); } 51 52 virtual bool setSize(size_t size) = 0; 53 54 virtual const char *getName() = 0; 55 56 virtual bool verify() = 0; 57 58 virtual bool usesNeon() { return false; } 59 60 bool isNeonSupported() { 61 #if defined(__ARM_NEON__) 62 return true; 63 #else 64 return false; 65 #endif 66 } 67 68 // Accessors/mutators. 69 double mb_per_sec() { return _mb_per_sec; } 70 size_t num_warm_loops() { return _num_warm_loops; } 71 size_t num_loops() { return _num_loops; } 72 size_t size() { return _size; } 73 74 void set_num_warm_loops(size_t num_warm_loops) { 75 _num_warm_loops = num_warm_loops; 76 } 77 void set_num_loops(size_t num_loops) { _num_loops = num_loops; } 78 79 // Static constants 80 static const unsigned int DEFAULT_NUM_WARM_LOOPS = 1000000; 81 static const unsigned int DEFAULT_NUM_LOOPS = 20000000; 82 83 protected: 84 virtual void bench(size_t num_loops) = 0; 85 86 double _mb_per_sec; 87 size_t _size; 88 size_t _num_warm_loops; 89 size_t _num_loops; 90 91 private: 92 // Static constants 93 static const double _NUM_NS_PER_SEC = 1000000000.0; 94 static const double _BYTES_PER_MB = 1024.0* 1024.0; 95 }; 96 97 class CopyBandwidthBenchmark : public BandwidthBenchmark { 98 public: 99 CopyBandwidthBenchmark() : BandwidthBenchmark(), _src(NULL), _dst(NULL) { } 100 101 bool setSize(size_t size) { 102 if (_src) { 103 free(_src); 104 } 105 if (_dst) { 106 free(_dst); 107 } 108 109 if (size == 0) { 110 _size = DEFAULT_COPY_SIZE; 111 } else { 112 _size = size; 113 } 114 115 _src = reinterpret_cast<char*>(memalign(64, _size)); 116 if (!_src) { 117 perror("Failed to allocate memory for test."); 118 return false; 119 } 120 _dst = reinterpret_cast<char*>(memalign(64, _size)); 121 if (!_dst) { 122 perror("Failed to allocate memory for test."); 123 return false; 124 } 125 126 return true; 127 } 128 virtual ~CopyBandwidthBenchmark() { 129 if (_src) { 130 free(_src); 131 _src = NULL; 132 } 133 if (_dst) { 134 free(_dst); 135 _dst = NULL; 136 } 137 } 138 139 bool verify() { 140 memset(_src, 0x23, _size); 141 memset(_dst, 0, _size); 142 bench(1); 143 if (memcmp(_src, _dst, _size) != 0) { 144 printf("Buffers failed to compare after one loop.\n"); 145 return false; 146 } 147 148 memset(_src, 0x23, _size); 149 memset(_dst, 0, _size); 150 _num_loops = 2; 151 bench(2); 152 if (memcmp(_src, _dst, _size) != 0) { 153 printf("Buffers failed to compare after two loops.\n"); 154 return false; 155 } 156 157 return true; 158 } 159 160 protected: 161 char *_src; 162 char *_dst; 163 164 static const unsigned int DEFAULT_COPY_SIZE = 8000; 165 }; 166 167 class CopyLdrdStrdBenchmark : public CopyBandwidthBenchmark { 168 public: 169 CopyLdrdStrdBenchmark() : CopyBandwidthBenchmark() { } 170 virtual ~CopyLdrdStrdBenchmark() {} 171 172 const char *getName() { return "ldrd/strd"; } 173 174 protected: 175 // Copy using ldrd/strd instructions. 176 void bench(size_t num_loops) { 177 asm volatile( 178 "stmfd sp!, {r0,r1,r2,r3,r4,r6,r7}\n" 179 180 "mov r0, %0\n" 181 "mov r1, %1\n" 182 "mov r2, %2\n" 183 "mov r3, %3\n" 184 185 "0:\n" 186 "mov r4, r2, lsr #6\n" 187 188 "1:\n" 189 "ldrd r6, r7, [r0]\n" 190 "strd r6, r7, [r1]\n" 191 "ldrd r6, r7, [r0, #8]\n" 192 "strd r6, r7, [r1, #8]\n" 193 "ldrd r6, r7, [r0, #16]\n" 194 "strd r6, r7, [r1, #16]\n" 195 "ldrd r6, r7, [r0, #24]\n" 196 "strd r6, r7, [r1, #24]\n" 197 "ldrd r6, r7, [r0, #32]\n" 198 "strd r6, r7, [r1, #32]\n" 199 "ldrd r6, r7, [r0, #40]\n" 200 "strd r6, r7, [r1, #40]\n" 201 "ldrd r6, r7, [r0, #48]\n" 202 "strd r6, r7, [r1, #48]\n" 203 "ldrd r6, r7, [r0, #56]\n" 204 "strd r6, r7, [r1, #56]\n" 205 206 "add r0, r0, #64\n" 207 "add r1, r1, #64\n" 208 "subs r4, r4, #1\n" 209 "bgt 1b\n" 210 211 "sub r0, r0, r2\n" 212 "sub r1, r1, r2\n" 213 "subs r3, r3, #1\n" 214 "bgt 0b\n" 215 216 "ldmfd sp!, {r0,r1,r2,r3,r4,r6,r7}\n" 217 :: "r" (_src), "r" (_dst), "r" (_size), "r" (num_loops) : "r0", "r1", "r2", "r3"); 218 } 219 }; 220 221 class CopyLdmiaStmiaBenchmark : public CopyBandwidthBenchmark { 222 public: 223 CopyLdmiaStmiaBenchmark() : CopyBandwidthBenchmark() { } 224 virtual ~CopyLdmiaStmiaBenchmark() {} 225 226 const char *getName() { return "ldmia/stmia"; } 227 228 protected: 229 // Copy using ldmia/stmia instructions. 230 void bench(size_t num_loops) { 231 asm volatile( 232 "stmfd sp!, {r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12}\n" 233 234 "mov r0, %0\n" 235 "mov r1, %1\n" 236 "mov r2, %2\n" 237 "mov r3, %3\n" 238 239 "0:\n" 240 "mov r4, r2, lsr #6\n" 241 242 "1:\n" 243 "ldmia r0!, {r5, r6, r7, r8, r9, r10, r11, r12}\n" 244 "stmia r1!, {r5, r6, r7, r8, r9, r10, r11, r12}\n" 245 "subs r4, r4, #1\n" 246 "ldmia r0!, {r5, r6, r7, r8, r9, r10, r11, r12}\n" 247 "stmia r1!, {r5, r6, r7, r8, r9, r10, r11, r12}\n" 248 "bgt 1b\n" 249 250 "sub r0, r0, r2\n" 251 "sub r1, r1, r2\n" 252 "subs r3, r3, #1\n" 253 "bgt 0b\n" 254 255 "ldmfd sp!, {r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12}\n" 256 :: "r" (_src), "r" (_dst), "r" (_size), "r" (num_loops) : "r0", "r1", "r2", "r3"); 257 } 258 }; 259 260 class CopyVld1Vst1Benchmark : public CopyBandwidthBenchmark { 261 public: 262 CopyVld1Vst1Benchmark() : CopyBandwidthBenchmark() { } 263 virtual ~CopyVld1Vst1Benchmark() {} 264 265 const char *getName() { return "vld1/vst1"; } 266 267 bool usesNeon() { return true; } 268 269 protected: 270 // Copy using vld1/vst1 instructions. 271 void bench(size_t num_loops) { 272 #if defined(__ARM_NEON__) 273 asm volatile( 274 "stmfd sp!, {r0,r1,r2,r3,r4}\n" 275 276 "mov r0, %0\n" 277 "mov r1, %1\n" 278 "mov r2, %2\n" 279 "mov r3, %3\n" 280 281 "0:\n" 282 "mov r4, r2, lsr #6\n" 283 284 "1:\n" 285 "vld1.8 {d0-d3}, [r0]!\n" 286 "vld1.8 {d4-d7}, [r0]!\n" 287 "subs r4, r4, #1\n" 288 "vst1.8 {d0-d3}, [r1:128]!\n" 289 "vst1.8 {d4-d7}, [r1:128]!\n" 290 "bgt 1b\n" 291 292 "sub r0, r0, r2\n" 293 "sub r1, r1, r2\n" 294 "subs r3, r3, #1\n" 295 "bgt 0b\n" 296 297 "ldmfd sp!, {r0,r1,r2,r3,r4}\n" 298 :: "r" (_src), "r" (_dst), "r" (_size), "r" (num_loops) : "r0", "r1", "r2", "r3"); 299 #endif 300 } 301 }; 302 303 class CopyVldrVstrBenchmark : public CopyBandwidthBenchmark { 304 public: 305 CopyVldrVstrBenchmark() : CopyBandwidthBenchmark() { } 306 virtual ~CopyVldrVstrBenchmark() {} 307 308 const char *getName() { return "vldr/vstr"; } 309 310 bool usesNeon() { return true; } 311 312 protected: 313 // Copy using vldr/vstr instructions. 314 void bench(size_t num_loops) { 315 #if defined(__ARM_NEON__) 316 asm volatile( 317 "stmfd sp!, {r0,r1,r2,r3,r4}\n" 318 319 "mov r0, %0\n" 320 "mov r1, %1\n" 321 "mov r2, %2\n" 322 "mov r3, %3\n" 323 324 "0:\n" 325 "mov r4, r2, lsr #6\n" 326 327 "1:\n" 328 "vldr d0, [r0, #0]\n" 329 "subs r4, r4, #1\n" 330 "vldr d1, [r0, #8]\n" 331 "vstr d0, [r1, #0]\n" 332 "vldr d0, [r0, #16]\n" 333 "vstr d1, [r1, #8]\n" 334 "vldr d1, [r0, #24]\n" 335 "vstr d0, [r1, #16]\n" 336 "vldr d0, [r0, #32]\n" 337 "vstr d1, [r1, #24]\n" 338 "vldr d1, [r0, #40]\n" 339 "vstr d0, [r1, #32]\n" 340 "vldr d0, [r0, #48]\n" 341 "vstr d1, [r1, #40]\n" 342 "vldr d1, [r0, #56]\n" 343 "vstr d0, [r1, #48]\n" 344 "add r0, r0, #64\n" 345 "vstr d1, [r1, #56]\n" 346 "add r1, r1, #64\n" 347 "bgt 1b\n" 348 349 "sub r0, r0, r2\n" 350 "sub r1, r1, r2\n" 351 "subs r3, r3, #1\n" 352 "bgt 0b\n" 353 354 "ldmfd sp!, {r0,r1,r2,r3,r4}\n" 355 :: "r" (_src), "r" (_dst), "r" (_size), "r" (num_loops) : "r0", "r1", "r2", "r3"); 356 #endif 357 } 358 }; 359 360 class CopyVldmiaVstmiaBenchmark : public CopyBandwidthBenchmark { 361 public: 362 CopyVldmiaVstmiaBenchmark() : CopyBandwidthBenchmark() { } 363 virtual ~CopyVldmiaVstmiaBenchmark() {} 364 365 const char *getName() { return "vldmia/vstmia"; } 366 367 bool usesNeon() { return true; } 368 369 protected: 370 // Copy using vldmia/vstmia instructions. 371 void bench(size_t num_loops) { 372 #if defined(__ARM_NEON__) 373 asm volatile( 374 "stmfd sp!, {r0,r1,r2,r3,r4}\n" 375 376 "mov r0, %0\n" 377 "mov r1, %1\n" 378 "mov r2, %2\n" 379 "mov r3, %3\n" 380 381 "0:\n" 382 "mov r4, r2, lsr #6\n" 383 384 "1:\n" 385 "vldmia r0!, {d0-d7}\n" 386 "subs r4, r4, #1\n" 387 "vstmia r1!, {d0-d7}\n" 388 "bgt 1b\n" 389 390 "sub r0, r0, r2\n" 391 "sub r1, r1, r2\n" 392 "subs r3, r3, #1\n" 393 "bgt 0b\n" 394 395 "ldmfd sp!, {r0,r1,r2,r3,r4}\n" 396 :: "r" (_src), "r" (_dst), "r" (_size), "r" (num_loops) : "r0", "r1", "r2", "r3"); 397 #endif 398 } 399 }; 400 401 class MemcpyBenchmark : public CopyBandwidthBenchmark { 402 public: 403 MemcpyBenchmark() : CopyBandwidthBenchmark() { } 404 virtual ~MemcpyBenchmark() {} 405 406 const char *getName() { return "memcpy"; } 407 408 protected: 409 void bench(size_t num_loops) { 410 for (size_t i = 0; i < num_loops; i++) { 411 memcpy(_dst, _src, _size); 412 } 413 } 414 }; 415 416 class SingleBufferBandwidthBenchmark : public BandwidthBenchmark { 417 public: 418 SingleBufferBandwidthBenchmark() : BandwidthBenchmark(), _buffer(NULL) { } 419 virtual ~SingleBufferBandwidthBenchmark() { 420 if (_buffer) { 421 free(_buffer); 422 _buffer = NULL; 423 } 424 } 425 426 bool setSize(size_t size) { 427 if (_buffer) { 428 free(_buffer); 429 _buffer = NULL; 430 } 431 432 if (_size == 0) { 433 _size = DEFAULT_SINGLE_BUFFER_SIZE; 434 } else { 435 _size = size; 436 } 437 438 _buffer = reinterpret_cast<char*>(memalign(64, _size)); 439 if (!_buffer) { 440 perror("Failed to allocate memory for test."); 441 return false; 442 } 443 memset(_buffer, 0, _size); 444 445 return true; 446 } 447 448 bool verify() { return true; } 449 450 protected: 451 char *_buffer; 452 453 static const unsigned int DEFAULT_SINGLE_BUFFER_SIZE = 16000; 454 }; 455 456 class WriteBandwidthBenchmark : public SingleBufferBandwidthBenchmark { 457 public: 458 WriteBandwidthBenchmark() : SingleBufferBandwidthBenchmark() { } 459 virtual ~WriteBandwidthBenchmark() { } 460 461 bool verify() { 462 memset(_buffer, 0, _size); 463 bench(1); 464 for (size_t i = 0; i < _size; i++) { 465 if (_buffer[i] != 1) { 466 printf("Buffer failed to compare after one loop.\n"); 467 return false; 468 } 469 } 470 471 memset(_buffer, 0, _size); 472 bench(2); 473 for (size_t i = 0; i < _size; i++) { 474 if (_buffer[i] != 2) { 475 printf("Buffer failed to compare after two loops.\n"); 476 return false; 477 } 478 } 479 480 return true; 481 } 482 }; 483 484 class WriteStrdBenchmark : public WriteBandwidthBenchmark { 485 public: 486 WriteStrdBenchmark() : WriteBandwidthBenchmark() { } 487 virtual ~WriteStrdBenchmark() {} 488 489 const char *getName() { return "strd"; } 490 491 protected: 492 // Write a given value using strd. 493 void bench(size_t num_loops) { 494 asm volatile( 495 "stmfd sp!, {r0,r1,r2,r3,r4,r5}\n" 496 497 "mov r0, %0\n" 498 "mov r1, %1\n" 499 "mov r2, %2\n" 500 501 "mov r4, #0\n" 502 "mov r5, #0\n" 503 504 "0:\n" 505 "mov r3, r1, lsr #5\n" 506 507 "add r4, r4, #0x01010101\n" 508 "mov r5, r4\n" 509 510 "1:\n" 511 "subs r3, r3, #1\n" 512 "strd r4, r5, [r0]\n" 513 "strd r4, r5, [r0, #8]\n" 514 "strd r4, r5, [r0, #16]\n" 515 "strd r4, r5, [r0, #24]\n" 516 "add r0, r0, #32\n" 517 "bgt 1b\n" 518 519 "sub r0, r0, r1\n" 520 "subs r2, r2, #1\n" 521 "bgt 0b\n" 522 523 "ldmfd sp!, {r0,r1,r2,r3,r4,r5}\n" 524 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2"); 525 } 526 }; 527 528 class WriteStmiaBenchmark : public WriteBandwidthBenchmark { 529 public: 530 WriteStmiaBenchmark() : WriteBandwidthBenchmark() { } 531 virtual ~WriteStmiaBenchmark() {} 532 533 const char *getName() { return "stmia"; } 534 535 protected: 536 // Write a given value using stmia. 537 void bench(size_t num_loops) { 538 asm volatile( 539 "stmfd sp!, {r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11}\n" 540 541 "mov r0, %0\n" 542 "mov r1, %1\n" 543 "mov r2, %2\n" 544 545 "mov r4, #0\n" 546 547 "0:\n" 548 "mov r3, r1, lsr #5\n" 549 550 "add r4, r4, #0x01010101\n" 551 "mov r5, r4\n" 552 "mov r6, r4\n" 553 "mov r7, r4\n" 554 "mov r8, r4\n" 555 "mov r9, r4\n" 556 "mov r10, r4\n" 557 "mov r11, r4\n" 558 559 "1:\n" 560 "subs r3, r3, #1\n" 561 "stmia r0!, {r4, r5, r6, r7, r8, r9, r10, r11}\n" 562 "bgt 1b\n" 563 564 "sub r0, r0, r1\n" 565 "subs r2, r2, #1\n" 566 "bgt 0b\n" 567 568 "ldmfd sp!, {r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11}\n" 569 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2"); 570 } 571 }; 572 573 class WriteVst1Benchmark : public WriteBandwidthBenchmark { 574 public: 575 WriteVst1Benchmark() : WriteBandwidthBenchmark() { } 576 virtual ~WriteVst1Benchmark() {} 577 578 const char *getName() { return "vst1"; } 579 580 bool usesNeon() { return true; } 581 582 protected: 583 // Write a given value using vst. 584 void bench(size_t num_loops) { 585 #if defined(__ARM_NEON__) 586 asm volatile( 587 "stmfd sp!, {r0,r1,r2,r3,r4}\n" 588 589 "mov r0, %0\n" 590 "mov r1, %1\n" 591 "mov r2, %2\n" 592 "mov r4, #0\n" 593 594 "0:\n" 595 "mov r3, r1, lsr #5\n" 596 597 "add r4, r4, #1\n" 598 "vdup.8 d0, r4\n" 599 "vmov d1, d0\n" 600 "vmov d2, d0\n" 601 "vmov d3, d0\n" 602 603 "1:\n" 604 "subs r3, r3, #1\n" 605 "vst1.8 {d0-d3}, [r0:128]!\n" 606 "bgt 1b\n" 607 608 "sub r0, r0, r1\n" 609 "subs r2, r2, #1\n" 610 "bgt 0b\n" 611 612 "ldmfd sp!, {r0,r1,r2,r3,r4}\n" 613 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2"); 614 #endif 615 } 616 }; 617 618 class WriteVstrBenchmark : public WriteBandwidthBenchmark { 619 public: 620 WriteVstrBenchmark() : WriteBandwidthBenchmark() { } 621 virtual ~WriteVstrBenchmark() {} 622 623 const char *getName() { return "vstr"; } 624 625 bool usesNeon() { return true; } 626 627 protected: 628 // Write a given value using vst. 629 void bench(size_t num_loops) { 630 #if defined(__ARM_NEON__) 631 asm volatile( 632 "stmfd sp!, {r0,r1,r2,r3,r4}\n" 633 634 "mov r0, %0\n" 635 "mov r1, %1\n" 636 "mov r2, %2\n" 637 "mov r4, #0\n" 638 639 "0:\n" 640 "mov r3, r1, lsr #5\n" 641 642 "add r4, r4, #1\n" 643 "vdup.8 d0, r4\n" 644 "vmov d1, d0\n" 645 "vmov d2, d0\n" 646 "vmov d3, d0\n" 647 648 "1:\n" 649 "vstr d0, [r0, #0]\n" 650 "subs r3, r3, #1\n" 651 "vstr d1, [r0, #8]\n" 652 "vstr d0, [r0, #16]\n" 653 "vstr d1, [r0, #24]\n" 654 "add r0, r0, #32\n" 655 "bgt 1b\n" 656 657 "sub r0, r0, r1\n" 658 "subs r2, r2, #1\n" 659 "bgt 0b\n" 660 661 "ldmfd sp!, {r0,r1,r2,r3,r4}\n" 662 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2"); 663 #endif 664 } 665 }; 666 667 class WriteVstmiaBenchmark : public WriteBandwidthBenchmark { 668 public: 669 WriteVstmiaBenchmark() : WriteBandwidthBenchmark() { } 670 virtual ~WriteVstmiaBenchmark() {} 671 672 const char *getName() { return "vstmia"; } 673 674 bool usesNeon() { return true; } 675 676 protected: 677 // Write a given value using vstmia. 678 void bench(size_t num_loops) { 679 #if defined(__ARM_NEON__) 680 asm volatile( 681 "stmfd sp!, {r0,r1,r2,r3,r4}\n" 682 683 "mov r0, %0\n" 684 "mov r1, %1\n" 685 "mov r2, %2\n" 686 "mov r4, #0\n" 687 688 "0:\n" 689 "mov r3, r1, lsr #5\n" 690 691 "add r4, r4, #1\n" 692 "vdup.8 d0, r4\n" 693 "vmov d1, d0\n" 694 "vmov d2, d0\n" 695 "vmov d3, d0\n" 696 697 "1:\n" 698 "subs r3, r3, #1\n" 699 "vstmia r0!, {d0-d3}\n" 700 "bgt 1b\n" 701 702 "sub r0, r0, r1\n" 703 "subs r2, r2, #1\n" 704 "bgt 0b\n" 705 706 "ldmfd sp!, {r0,r1,r2,r3,r4}\n" 707 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2"); 708 #endif 709 } 710 }; 711 712 class MemsetBenchmark : public WriteBandwidthBenchmark { 713 public: 714 MemsetBenchmark() : WriteBandwidthBenchmark() { } 715 virtual ~MemsetBenchmark() {} 716 717 const char *getName() { return "memset"; } 718 719 protected: 720 void bench(size_t num_loops) { 721 for (size_t i = 0; i < num_loops; i++) { 722 memset(_buffer, (i % 255) + 1, _size); 723 } 724 } 725 }; 726 727 class ReadLdrdBenchmark : public SingleBufferBandwidthBenchmark { 728 public: 729 ReadLdrdBenchmark() : SingleBufferBandwidthBenchmark() { } 730 virtual ~ReadLdrdBenchmark() {} 731 732 const char *getName() { return "ldrd"; } 733 734 protected: 735 // Write a given value using strd. 736 void bench(size_t num_loops) { 737 asm volatile( 738 "stmfd sp!, {r0,r1,r2,r3,r4,r5}\n" 739 740 "mov r0, %0\n" 741 "mov r1, %1\n" 742 "mov r2, %2\n" 743 744 "0:\n" 745 "mov r3, r1, lsr #5\n" 746 747 "1:\n" 748 "subs r3, r3, #1\n" 749 "ldrd r4, r5, [r0]\n" 750 "ldrd r4, r5, [r0, #8]\n" 751 "ldrd r4, r5, [r0, #16]\n" 752 "ldrd r4, r5, [r0, #24]\n" 753 "add r0, r0, #32\n" 754 "bgt 1b\n" 755 756 "sub r0, r0, r1\n" 757 "subs r2, r2, #1\n" 758 "bgt 0b\n" 759 760 "ldmfd sp!, {r0,r1,r2,r3,r4,r5}\n" 761 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2"); 762 } 763 }; 764 765 class ReadLdmiaBenchmark : public SingleBufferBandwidthBenchmark { 766 public: 767 ReadLdmiaBenchmark() : SingleBufferBandwidthBenchmark() { } 768 virtual ~ReadLdmiaBenchmark() {} 769 770 const char *getName() { return "ldmia"; } 771 772 protected: 773 // Write a given value using stmia. 774 void bench(size_t num_loops) { 775 asm volatile( 776 "stmfd sp!, {r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11}\n" 777 778 "mov r0, %0\n" 779 "mov r1, %1\n" 780 "mov r2, %2\n" 781 782 "0:\n" 783 "mov r3, r1, lsr #5\n" 784 785 "1:\n" 786 "subs r3, r3, #1\n" 787 "ldmia r0!, {r4, r5, r6, r7, r8, r9, r10, r11}\n" 788 "bgt 1b\n" 789 790 "sub r0, r0, r1\n" 791 "subs r2, r2, #1\n" 792 "bgt 0b\n" 793 794 "ldmfd sp!, {r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11}\n" 795 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2"); 796 } 797 }; 798 799 class ReadVld1Benchmark : public SingleBufferBandwidthBenchmark { 800 public: 801 ReadVld1Benchmark() : SingleBufferBandwidthBenchmark() { } 802 virtual ~ReadVld1Benchmark() {} 803 804 const char *getName() { return "vld1"; } 805 806 bool usesNeon() { return true; } 807 808 protected: 809 // Write a given value using vst. 810 void bench(size_t num_loops) { 811 #if defined(__ARM_NEON__) 812 asm volatile( 813 "stmfd sp!, {r0,r1,r2,r3}\n" 814 815 "mov r0, %0\n" 816 "mov r1, %1\n" 817 "mov r2, %2\n" 818 819 "0:\n" 820 "mov r3, r1, lsr #5\n" 821 822 "1:\n" 823 "subs r3, r3, #1\n" 824 "vld1.8 {d0-d3}, [r0:128]!\n" 825 "bgt 1b\n" 826 827 "sub r0, r0, r1\n" 828 "subs r2, r2, #1\n" 829 "bgt 0b\n" 830 831 "ldmfd sp!, {r0,r1,r2,r3}\n" 832 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2"); 833 #endif 834 } 835 }; 836 837 class ReadVldrBenchmark : public SingleBufferBandwidthBenchmark { 838 public: 839 ReadVldrBenchmark() : SingleBufferBandwidthBenchmark() { } 840 virtual ~ReadVldrBenchmark() {} 841 842 const char *getName() { return "vldr"; } 843 844 bool usesNeon() { return true; } 845 846 protected: 847 // Write a given value using vst. 848 void bench(size_t num_loops) { 849 #if defined(__ARM_NEON__) 850 asm volatile( 851 "stmfd sp!, {r0,r1,r2,r3}\n" 852 853 "mov r0, %0\n" 854 "mov r1, %1\n" 855 "mov r2, %2\n" 856 857 "0:\n" 858 "mov r3, r1, lsr #5\n" 859 860 "1:\n" 861 "vldr d0, [r0, #0]\n" 862 "subs r3, r3, #1\n" 863 "vldr d1, [r0, #8]\n" 864 "vldr d0, [r0, #16]\n" 865 "vldr d1, [r0, #24]\n" 866 "add r0, r0, #32\n" 867 "bgt 1b\n" 868 869 "sub r0, r0, r1\n" 870 "subs r2, r2, #1\n" 871 "bgt 0b\n" 872 873 "ldmfd sp!, {r0,r1,r2,r3}\n" 874 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2"); 875 #endif 876 } 877 }; 878 879 880 class ReadVldmiaBenchmark : public SingleBufferBandwidthBenchmark { 881 public: 882 ReadVldmiaBenchmark() : SingleBufferBandwidthBenchmark() { } 883 virtual ~ReadVldmiaBenchmark() {} 884 885 const char *getName() { return "vldmia"; } 886 887 bool usesNeon() { return true; } 888 889 protected: 890 // Write a given value using vstmia. 891 void bench(size_t num_loops) { 892 #if defined(__ARM_NEON__) 893 asm volatile( 894 "stmfd sp!, {r0,r1,r2,r3}\n" 895 896 "mov r0, %0\n" 897 "mov r1, %1\n" 898 "mov r2, %2\n" 899 900 "0:\n" 901 "mov r3, r1, lsr #5\n" 902 903 "1:\n" 904 "subs r3, r3, #1\n" 905 "vldmia r0!, {d0-d3}\n" 906 "bgt 1b\n" 907 908 "sub r0, r0, r1\n" 909 "subs r2, r2, #1\n" 910 "bgt 0b\n" 911 912 "ldmfd sp!, {r0,r1,r2,r3}\n" 913 :: "r" (_buffer), "r" (_size), "r" (num_loops) : "r0", "r1", "r2"); 914 #endif 915 } 916 }; 917 918 #endif // __BANDWIDTH_H__ 919
