7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have
21 * questions.
22 */
23
24 package benchmark.jdk.incubator.vector;
25
26 import jdk.incubator.vector.Vector;
27 import jdk.incubator.vector.VectorShape;
28 import jdk.incubator.vector.VectorSpecies;
29 import jdk.incubator.vector.VectorShuffle;
30 import jdk.incubator.vector.ShortVector;
31
32 import java.util.concurrent.TimeUnit;
33 import java.util.function.BiFunction;
34 import java.util.function.IntFunction;
35
36 import org.openjdk.jmh.annotations.*;
37 import org.openjdk.jmh.infra.Blackhole;
38
39 @BenchmarkMode(Mode.Throughput)
40 @OutputTimeUnit(TimeUnit.MILLISECONDS)
41 @State(Scope.Benchmark)
42 @Warmup(iterations = 3, time = 1)
43 @Measurement(iterations = 5, time = 1)
44 @Fork(value = 1, jvmArgsPrepend = {"--add-modules=jdk.incubator.vector"})
45 public class Short512Vector extends AbstractVectorBenchmark {
46 static final VectorSpecies<Short> SPECIES = ShortVector.SPECIES_512;
304 boolean[] mask = fm.apply(SPECIES.length());
305 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
306
307 for (int ic = 0; ic < INVOC_COUNT; ic++) {
308 for (int i = 0; i < a.length; i += SPECIES.length()) {
309 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
310 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
311 av.xor(bv, vmask).intoArray(r, i);
312 }
313 }
314
315 bh.consume(r);
316 }
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338 @Benchmark
339 public void aShiftRShift(Blackhole bh) {
340 short[] a = fa.apply(SPECIES.length());
341 short[] b = fb.apply(SPECIES.length());
342 short[] r = fr.apply(SPECIES.length());
343
344 for (int ic = 0; ic < INVOC_COUNT; ic++) {
345 for (int i = 0; i < a.length; i += SPECIES.length()) {
346 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
347 av.aShiftR((int)b[i]).intoArray(r, i);
348 }
349 }
350
351 bh.consume(r);
352 }
353
354
355
356 @Benchmark
357 public void aShiftRMaskedShift(Blackhole bh) {
358 short[] a = fa.apply(SPECIES.length());
359 short[] b = fb.apply(SPECIES.length());
360 short[] r = fr.apply(SPECIES.length());
361 boolean[] mask = fm.apply(SPECIES.length());
362 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
363
364 for (int ic = 0; ic < INVOC_COUNT; ic++) {
365 for (int i = 0; i < a.length; i += SPECIES.length()) {
366 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
367 av.aShiftR((int)b[i], vmask).intoArray(r, i);
368 }
369 }
370
371 bh.consume(r);
372 }
373
374
375
376 @Benchmark
377 public void shiftLShift(Blackhole bh) {
378 short[] a = fa.apply(SPECIES.length());
379 short[] b = fb.apply(SPECIES.length());
380 short[] r = fr.apply(SPECIES.length());
381
382 for (int ic = 0; ic < INVOC_COUNT; ic++) {
383 for (int i = 0; i < a.length; i += SPECIES.length()) {
384 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
385 av.shiftL((int)b[i]).intoArray(r, i);
386 }
387 }
388
389 bh.consume(r);
390 }
391
392
393
394 @Benchmark
395 public void shiftLMaskedShift(Blackhole bh) {
396 short[] a = fa.apply(SPECIES.length());
397 short[] b = fb.apply(SPECIES.length());
398 short[] r = fr.apply(SPECIES.length());
399 boolean[] mask = fm.apply(SPECIES.length());
400 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
401
402 for (int ic = 0; ic < INVOC_COUNT; ic++) {
403 for (int i = 0; i < a.length; i += SPECIES.length()) {
404 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
405 av.shiftL((int)b[i], vmask).intoArray(r, i);
406 }
407 }
408
409 bh.consume(r);
410 }
411
412
413
414 @Benchmark
415 public void shiftRShift(Blackhole bh) {
416 short[] a = fa.apply(SPECIES.length());
417 short[] b = fb.apply(SPECIES.length());
418 short[] r = fr.apply(SPECIES.length());
419
420 for (int ic = 0; ic < INVOC_COUNT; ic++) {
421 for (int i = 0; i < a.length; i += SPECIES.length()) {
422 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
423 av.shiftR((int)b[i]).intoArray(r, i);
424 }
425 }
426
427 bh.consume(r);
428 }
429
430
431
432 @Benchmark
433 public void shiftRMaskedShift(Blackhole bh) {
434 short[] a = fa.apply(SPECIES.length());
435 short[] b = fb.apply(SPECIES.length());
436 short[] r = fr.apply(SPECIES.length());
437 boolean[] mask = fm.apply(SPECIES.length());
438 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
439
440 for (int ic = 0; ic < INVOC_COUNT; ic++) {
441 for (int i = 0; i < a.length; i += SPECIES.length()) {
442 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
443 av.shiftR((int)b[i], vmask).intoArray(r, i);
444 }
445 }
446
447 bh.consume(r);
448 }
449
450
451 @Benchmark
452 public void max(Blackhole bh) {
453 short[] a = fa.apply(SPECIES.length());
454 short[] b = fb.apply(SPECIES.length());
455 short[] r = fr.apply(SPECIES.length());
456
457 for (int ic = 0; ic < INVOC_COUNT; ic++) {
458 for (int i = 0; i < a.length; i += SPECIES.length()) {
459 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
460 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
461 av.max(bv).intoArray(r, i);
462 }
463 }
467
468 @Benchmark
469 public void min(Blackhole bh) {
470 short[] a = fa.apply(SPECIES.length());
471 short[] b = fb.apply(SPECIES.length());
472 short[] r = fr.apply(SPECIES.length());
473
474 for (int ic = 0; ic < INVOC_COUNT; ic++) {
475 for (int i = 0; i < a.length; i += SPECIES.length()) {
476 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
477 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
478 av.min(bv).intoArray(r, i);
479 }
480 }
481
482 bh.consume(r);
483 }
484
485
486 @Benchmark
487 public void andAll(Blackhole bh) {
488 short[] a = fa.apply(SPECIES.length());
489 short ra = -1;
490
491 for (int ic = 0; ic < INVOC_COUNT; ic++) {
492 ra = -1;
493 for (int i = 0; i < a.length; i += SPECIES.length()) {
494 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
495 ra &= av.andAll();
496 }
497 }
498 bh.consume(ra);
499 }
500
501
502
503 @Benchmark
504 public void orAll(Blackhole bh) {
505 short[] a = fa.apply(SPECIES.length());
506 short ra = 0;
507
508 for (int ic = 0; ic < INVOC_COUNT; ic++) {
509 ra = 0;
510 for (int i = 0; i < a.length; i += SPECIES.length()) {
511 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
512 ra |= av.orAll();
513 }
514 }
515 bh.consume(ra);
516 }
517
518
519
520 @Benchmark
521 public void xorAll(Blackhole bh) {
522 short[] a = fa.apply(SPECIES.length());
523 short ra = 0;
524
525 for (int ic = 0; ic < INVOC_COUNT; ic++) {
526 ra = 0;
527 for (int i = 0; i < a.length; i += SPECIES.length()) {
528 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
529 ra ^= av.xorAll();
530 }
531 }
532 bh.consume(ra);
533 }
534
535
536 @Benchmark
537 public void addAll(Blackhole bh) {
538 short[] a = fa.apply(SPECIES.length());
539 short ra = 0;
540
541 for (int ic = 0; ic < INVOC_COUNT; ic++) {
542 ra = 0;
543 for (int i = 0; i < a.length; i += SPECIES.length()) {
544 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
545 ra += av.addAll();
546 }
547 }
548 bh.consume(ra);
549 }
550
551 @Benchmark
552 public void mulAll(Blackhole bh) {
553 short[] a = fa.apply(SPECIES.length());
554 short ra = 1;
555
556 for (int ic = 0; ic < INVOC_COUNT; ic++) {
557 ra = 1;
558 for (int i = 0; i < a.length; i += SPECIES.length()) {
559 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
560 ra *= av.mulAll();
561 }
562 }
563 bh.consume(ra);
564 }
565
566 @Benchmark
567 public void minAll(Blackhole bh) {
568 short[] a = fa.apply(SPECIES.length());
569 short ra = Short.MAX_VALUE;
570
571 for (int ic = 0; ic < INVOC_COUNT; ic++) {
572 ra = Short.MAX_VALUE;
573 for (int i = 0; i < a.length; i += SPECIES.length()) {
574 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
575 ra = (short)Math.min(ra, av.minAll());
576 }
577 }
578 bh.consume(ra);
579 }
580
581 @Benchmark
582 public void maxAll(Blackhole bh) {
583 short[] a = fa.apply(SPECIES.length());
584 short ra = Short.MIN_VALUE;
585
586 for (int ic = 0; ic < INVOC_COUNT; ic++) {
587 ra = Short.MIN_VALUE;
588 for (int i = 0; i < a.length; i += SPECIES.length()) {
589 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
590 ra = (short)Math.max(ra, av.maxAll());
591 }
592 }
593 bh.consume(ra);
594 }
595
596
597 @Benchmark
598 public void anyTrue(Blackhole bh) {
599 boolean[] mask = fm.apply(SPECIES.length());
600 boolean[] r = fmr.apply(SPECIES.length());
601
602 for (int ic = 0; ic < INVOC_COUNT; ic++) {
603 for (int i = 0; i < mask.length; i += SPECIES.length()) {
604 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, i);
605 r[i] = vmask.anyTrue();
606 }
607 }
608
609 bh.consume(r);
610 }
630 @Benchmark
631 public void with(Blackhole bh) {
632 short[] a = fa.apply(SPECIES.length());
633 short[] r = fr.apply(SPECIES.length());
634
635 for (int ic = 0; ic < INVOC_COUNT; ic++) {
636 for (int i = 0; i < a.length; i += SPECIES.length()) {
637 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
638 av.with(0, (short)4).intoArray(r, i);
639 }
640 }
641
642 bh.consume(r);
643 }
644
645 @Benchmark
646 public Object lessThan() {
647 short[] a = fa.apply(size);
648 short[] b = fb.apply(size);
649 boolean[] ms = fm.apply(size);
650 VectorMask<Short> m = VectorMask.maskFromArray(SPECIES, ms, 0);
651
652 for (int ic = 0; ic < INVOC_COUNT; ic++) {
653 for (int i = 0; i < a.length; i += SPECIES.length()) {
654 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
655 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
656 VectorMask<Short> mv = av.lessThan(bv);
657
658 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
659 }
660 }
661 return m;
662 }
663
664
665 @Benchmark
666 public Object greaterThan() {
667 short[] a = fa.apply(size);
668 short[] b = fb.apply(size);
669 boolean[] ms = fm.apply(size);
670 VectorMask<Short> m = VectorMask.maskFromArray(SPECIES, ms, 0);
671
672 for (int ic = 0; ic < INVOC_COUNT; ic++) {
673 for (int i = 0; i < a.length; i += SPECIES.length()) {
674 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
675 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
676 VectorMask<Short> mv = av.greaterThan(bv);
677
678 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
679 }
680 }
681 return m;
682 }
683
684
685 @Benchmark
686 public Object equal() {
687 short[] a = fa.apply(size);
688 short[] b = fb.apply(size);
689 boolean[] ms = fm.apply(size);
690 VectorMask<Short> m = VectorMask.maskFromArray(SPECIES, ms, 0);
691
692 for (int ic = 0; ic < INVOC_COUNT; ic++) {
693 for (int i = 0; i < a.length; i += SPECIES.length()) {
694 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
695 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
696 VectorMask<Short> mv = av.equal(bv);
697
698 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
699 }
700 }
701 return m;
702 }
703
704
705 @Benchmark
706 public Object notEqual() {
707 short[] a = fa.apply(size);
708 short[] b = fb.apply(size);
709 boolean[] ms = fm.apply(size);
710 VectorMask<Short> m = VectorMask.maskFromArray(SPECIES, ms, 0);
711
712 for (int ic = 0; ic < INVOC_COUNT; ic++) {
713 for (int i = 0; i < a.length; i += SPECIES.length()) {
714 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
715 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
716 VectorMask<Short> mv = av.notEqual(bv);
717
718 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
719 }
720 }
721 return m;
722 }
723
724
725 @Benchmark
726 public Object lessThanEq() {
727 short[] a = fa.apply(size);
728 short[] b = fb.apply(size);
729 boolean[] ms = fm.apply(size);
730 VectorMask<Short> m = VectorMask.maskFromArray(SPECIES, ms, 0);
731
732 for (int ic = 0; ic < INVOC_COUNT; ic++) {
733 for (int i = 0; i < a.length; i += SPECIES.length()) {
734 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
735 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
736 VectorMask<Short> mv = av.lessThanEq(bv);
737
738 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
739 }
740 }
741 return m;
742 }
743
744
745 @Benchmark
746 public Object greaterThanEq() {
747 short[] a = fa.apply(size);
748 short[] b = fb.apply(size);
749 boolean[] ms = fm.apply(size);
750 VectorMask<Short> m = VectorMask.maskFromArray(SPECIES, ms, 0);
751
752 for (int ic = 0; ic < INVOC_COUNT; ic++) {
753 for (int i = 0; i < a.length; i += SPECIES.length()) {
754 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
755 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
756 VectorMask<Short> mv = av.greaterThanEq(bv);
757
758 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
759 }
760 }
761 return m;
762 }
763
764
765 @Benchmark
766 public void blend(Blackhole bh) {
767 short[] a = fa.apply(SPECIES.length());
768 short[] b = fb.apply(SPECIES.length());
769 short[] r = fr.apply(SPECIES.length());
770 boolean[] mask = fm.apply(SPECIES.length());
|
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have
21 * questions.
22 */
23
24 package benchmark.jdk.incubator.vector;
25
26 import jdk.incubator.vector.Vector;
27 import jdk.incubator.vector.VectorMask;
28 import jdk.incubator.vector.VectorShape;
29 import jdk.incubator.vector.VectorSpecies;
30 import jdk.incubator.vector.VectorShuffle;
31 import jdk.incubator.vector.ShortVector;
32
33 import java.util.concurrent.TimeUnit;
34 import java.util.function.BiFunction;
35 import java.util.function.IntFunction;
36
37 import org.openjdk.jmh.annotations.*;
38 import org.openjdk.jmh.infra.Blackhole;
39
40 @BenchmarkMode(Mode.Throughput)
41 @OutputTimeUnit(TimeUnit.MILLISECONDS)
42 @State(Scope.Benchmark)
43 @Warmup(iterations = 3, time = 1)
44 @Measurement(iterations = 5, time = 1)
45 @Fork(value = 1, jvmArgsPrepend = {"--add-modules=jdk.incubator.vector"})
46 public class Short512Vector extends AbstractVectorBenchmark {
47 static final VectorSpecies<Short> SPECIES = ShortVector.SPECIES_512;
305 boolean[] mask = fm.apply(SPECIES.length());
306 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
307
308 for (int ic = 0; ic < INVOC_COUNT; ic++) {
309 for (int i = 0; i < a.length; i += SPECIES.length()) {
310 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
311 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
312 av.xor(bv, vmask).intoArray(r, i);
313 }
314 }
315
316 bh.consume(r);
317 }
318
319
320
321
322
323
324
325 @Benchmark
326 public void shiftLeft(Blackhole bh) {
327 short[] a = fa.apply(SPECIES.length());
328 short[] b = fb.apply(SPECIES.length());
329 short[] r = fr.apply(SPECIES.length());
330
331 for (int ic = 0; ic < INVOC_COUNT; ic++) {
332 for (int i = 0; i < a.length; i += SPECIES.length()) {
333 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
334 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
335 av.shiftLeft(bv).intoArray(r, i);
336 }
337 }
338
339 bh.consume(r);
340 }
341
342
343
344 @Benchmark
345 public void shiftLeftMasked(Blackhole bh) {
346 short[] a = fa.apply(SPECIES.length());
347 short[] b = fb.apply(SPECIES.length());
348 short[] r = fr.apply(SPECIES.length());
349 boolean[] mask = fm.apply(SPECIES.length());
350 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
351
352 for (int ic = 0; ic < INVOC_COUNT; ic++) {
353 for (int i = 0; i < a.length; i += SPECIES.length()) {
354 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
355 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
356 av.shiftLeft(bv, vmask).intoArray(r, i);
357 }
358 }
359
360 bh.consume(r);
361 }
362
363
364
365
366
367
368
369 @Benchmark
370 public void shiftRight(Blackhole bh) {
371 short[] a = fa.apply(SPECIES.length());
372 short[] b = fb.apply(SPECIES.length());
373 short[] r = fr.apply(SPECIES.length());
374
375 for (int ic = 0; ic < INVOC_COUNT; ic++) {
376 for (int i = 0; i < a.length; i += SPECIES.length()) {
377 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
378 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
379 av.shiftRight(bv).intoArray(r, i);
380 }
381 }
382
383 bh.consume(r);
384 }
385
386
387
388 @Benchmark
389 public void shiftRightMasked(Blackhole bh) {
390 short[] a = fa.apply(SPECIES.length());
391 short[] b = fb.apply(SPECIES.length());
392 short[] r = fr.apply(SPECIES.length());
393 boolean[] mask = fm.apply(SPECIES.length());
394 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
395
396 for (int ic = 0; ic < INVOC_COUNT; ic++) {
397 for (int i = 0; i < a.length; i += SPECIES.length()) {
398 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
399 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
400 av.shiftRight(bv, vmask).intoArray(r, i);
401 }
402 }
403
404 bh.consume(r);
405 }
406
407
408
409
410
411
412
413 @Benchmark
414 public void shiftArithmeticRight(Blackhole bh) {
415 short[] a = fa.apply(SPECIES.length());
416 short[] b = fb.apply(SPECIES.length());
417 short[] r = fr.apply(SPECIES.length());
418
419 for (int ic = 0; ic < INVOC_COUNT; ic++) {
420 for (int i = 0; i < a.length; i += SPECIES.length()) {
421 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
422 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
423 av.shiftArithmeticRight(bv).intoArray(r, i);
424 }
425 }
426
427 bh.consume(r);
428 }
429
430
431
432 @Benchmark
433 public void shiftArithmeticRightMasked(Blackhole bh) {
434 short[] a = fa.apply(SPECIES.length());
435 short[] b = fb.apply(SPECIES.length());
436 short[] r = fr.apply(SPECIES.length());
437 boolean[] mask = fm.apply(SPECIES.length());
438 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
439
440 for (int ic = 0; ic < INVOC_COUNT; ic++) {
441 for (int i = 0; i < a.length; i += SPECIES.length()) {
442 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
443 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
444 av.shiftArithmeticRight(bv, vmask).intoArray(r, i);
445 }
446 }
447
448 bh.consume(r);
449 }
450
451
452
453
454
455
456
457 @Benchmark
458 public void shiftLeftShift(Blackhole bh) {
459 short[] a = fa.apply(SPECIES.length());
460 short[] b = fb.apply(SPECIES.length());
461 short[] r = fr.apply(SPECIES.length());
462
463 for (int ic = 0; ic < INVOC_COUNT; ic++) {
464 for (int i = 0; i < a.length; i += SPECIES.length()) {
465 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
466 av.shiftLeft((int)b[i]).intoArray(r, i);
467 }
468 }
469
470 bh.consume(r);
471 }
472
473
474
475 @Benchmark
476 public void shiftLeftMaskedShift(Blackhole bh) {
477 short[] a = fa.apply(SPECIES.length());
478 short[] b = fb.apply(SPECIES.length());
479 short[] r = fr.apply(SPECIES.length());
480 boolean[] mask = fm.apply(SPECIES.length());
481 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
482
483 for (int ic = 0; ic < INVOC_COUNT; ic++) {
484 for (int i = 0; i < a.length; i += SPECIES.length()) {
485 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
486 av.shiftLeft((int)b[i], vmask).intoArray(r, i);
487 }
488 }
489
490 bh.consume(r);
491 }
492
493
494
495
496
497
498
499 @Benchmark
500 public void shiftRightShift(Blackhole bh) {
501 short[] a = fa.apply(SPECIES.length());
502 short[] b = fb.apply(SPECIES.length());
503 short[] r = fr.apply(SPECIES.length());
504
505 for (int ic = 0; ic < INVOC_COUNT; ic++) {
506 for (int i = 0; i < a.length; i += SPECIES.length()) {
507 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
508 av.shiftRight((int)b[i]).intoArray(r, i);
509 }
510 }
511
512 bh.consume(r);
513 }
514
515
516
517 @Benchmark
518 public void shiftRightMaskedShift(Blackhole bh) {
519 short[] a = fa.apply(SPECIES.length());
520 short[] b = fb.apply(SPECIES.length());
521 short[] r = fr.apply(SPECIES.length());
522 boolean[] mask = fm.apply(SPECIES.length());
523 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
524
525 for (int ic = 0; ic < INVOC_COUNT; ic++) {
526 for (int i = 0; i < a.length; i += SPECIES.length()) {
527 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
528 av.shiftRight((int)b[i], vmask).intoArray(r, i);
529 }
530 }
531
532 bh.consume(r);
533 }
534
535
536
537
538
539
540
541 @Benchmark
542 public void shiftArithmeticRightShift(Blackhole bh) {
543 short[] a = fa.apply(SPECIES.length());
544 short[] b = fb.apply(SPECIES.length());
545 short[] r = fr.apply(SPECIES.length());
546
547 for (int ic = 0; ic < INVOC_COUNT; ic++) {
548 for (int i = 0; i < a.length; i += SPECIES.length()) {
549 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
550 av.shiftArithmeticRight((int)b[i]).intoArray(r, i);
551 }
552 }
553
554 bh.consume(r);
555 }
556
557
558
559 @Benchmark
560 public void shiftArithmeticRightMaskedShift(Blackhole bh) {
561 short[] a = fa.apply(SPECIES.length());
562 short[] b = fb.apply(SPECIES.length());
563 short[] r = fr.apply(SPECIES.length());
564 boolean[] mask = fm.apply(SPECIES.length());
565 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
566
567 for (int ic = 0; ic < INVOC_COUNT; ic++) {
568 for (int i = 0; i < a.length; i += SPECIES.length()) {
569 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
570 av.shiftArithmeticRight((int)b[i], vmask).intoArray(r, i);
571 }
572 }
573
574 bh.consume(r);
575 }
576
577
578 @Benchmark
579 public void max(Blackhole bh) {
580 short[] a = fa.apply(SPECIES.length());
581 short[] b = fb.apply(SPECIES.length());
582 short[] r = fr.apply(SPECIES.length());
583
584 for (int ic = 0; ic < INVOC_COUNT; ic++) {
585 for (int i = 0; i < a.length; i += SPECIES.length()) {
586 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
587 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
588 av.max(bv).intoArray(r, i);
589 }
590 }
594
595 @Benchmark
596 public void min(Blackhole bh) {
597 short[] a = fa.apply(SPECIES.length());
598 short[] b = fb.apply(SPECIES.length());
599 short[] r = fr.apply(SPECIES.length());
600
601 for (int ic = 0; ic < INVOC_COUNT; ic++) {
602 for (int i = 0; i < a.length; i += SPECIES.length()) {
603 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
604 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
605 av.min(bv).intoArray(r, i);
606 }
607 }
608
609 bh.consume(r);
610 }
611
612
613 @Benchmark
614 public void andLanes(Blackhole bh) {
615 short[] a = fa.apply(SPECIES.length());
616 short ra = -1;
617
618 for (int ic = 0; ic < INVOC_COUNT; ic++) {
619 ra = -1;
620 for (int i = 0; i < a.length; i += SPECIES.length()) {
621 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
622 ra &= av.andLanes();
623 }
624 }
625 bh.consume(ra);
626 }
627
628
629
630 @Benchmark
631 public void orLanes(Blackhole bh) {
632 short[] a = fa.apply(SPECIES.length());
633 short ra = 0;
634
635 for (int ic = 0; ic < INVOC_COUNT; ic++) {
636 ra = 0;
637 for (int i = 0; i < a.length; i += SPECIES.length()) {
638 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
639 ra |= av.orLanes();
640 }
641 }
642 bh.consume(ra);
643 }
644
645
646
647 @Benchmark
648 public void xorLanes(Blackhole bh) {
649 short[] a = fa.apply(SPECIES.length());
650 short ra = 0;
651
652 for (int ic = 0; ic < INVOC_COUNT; ic++) {
653 ra = 0;
654 for (int i = 0; i < a.length; i += SPECIES.length()) {
655 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
656 ra ^= av.xorLanes();
657 }
658 }
659 bh.consume(ra);
660 }
661
662
663 @Benchmark
664 public void addLanes(Blackhole bh) {
665 short[] a = fa.apply(SPECIES.length());
666 short ra = 0;
667
668 for (int ic = 0; ic < INVOC_COUNT; ic++) {
669 ra = 0;
670 for (int i = 0; i < a.length; i += SPECIES.length()) {
671 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
672 ra += av.addLanes();
673 }
674 }
675 bh.consume(ra);
676 }
677
678 @Benchmark
679 public void mulLanes(Blackhole bh) {
680 short[] a = fa.apply(SPECIES.length());
681 short ra = 1;
682
683 for (int ic = 0; ic < INVOC_COUNT; ic++) {
684 ra = 1;
685 for (int i = 0; i < a.length; i += SPECIES.length()) {
686 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
687 ra *= av.mulLanes();
688 }
689 }
690 bh.consume(ra);
691 }
692
693 @Benchmark
694 public void minLanes(Blackhole bh) {
695 short[] a = fa.apply(SPECIES.length());
696 short ra = Short.MAX_VALUE;
697
698 for (int ic = 0; ic < INVOC_COUNT; ic++) {
699 ra = Short.MAX_VALUE;
700 for (int i = 0; i < a.length; i += SPECIES.length()) {
701 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
702 ra = (short)Math.min(ra, av.minLanes());
703 }
704 }
705 bh.consume(ra);
706 }
707
708 @Benchmark
709 public void maxLanes(Blackhole bh) {
710 short[] a = fa.apply(SPECIES.length());
711 short ra = Short.MIN_VALUE;
712
713 for (int ic = 0; ic < INVOC_COUNT; ic++) {
714 ra = Short.MIN_VALUE;
715 for (int i = 0; i < a.length; i += SPECIES.length()) {
716 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
717 ra = (short)Math.max(ra, av.maxLanes());
718 }
719 }
720 bh.consume(ra);
721 }
722
723
724 @Benchmark
725 public void anyTrue(Blackhole bh) {
726 boolean[] mask = fm.apply(SPECIES.length());
727 boolean[] r = fmr.apply(SPECIES.length());
728
729 for (int ic = 0; ic < INVOC_COUNT; ic++) {
730 for (int i = 0; i < mask.length; i += SPECIES.length()) {
731 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, i);
732 r[i] = vmask.anyTrue();
733 }
734 }
735
736 bh.consume(r);
737 }
757 @Benchmark
758 public void with(Blackhole bh) {
759 short[] a = fa.apply(SPECIES.length());
760 short[] r = fr.apply(SPECIES.length());
761
762 for (int ic = 0; ic < INVOC_COUNT; ic++) {
763 for (int i = 0; i < a.length; i += SPECIES.length()) {
764 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
765 av.with(0, (short)4).intoArray(r, i);
766 }
767 }
768
769 bh.consume(r);
770 }
771
772 @Benchmark
773 public Object lessThan() {
774 short[] a = fa.apply(size);
775 short[] b = fb.apply(size);
776 boolean[] ms = fm.apply(size);
777 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
778
779 for (int ic = 0; ic < INVOC_COUNT; ic++) {
780 for (int i = 0; i < a.length; i += SPECIES.length()) {
781 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
782 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
783 VectorMask<Short> mv = av.lessThan(bv);
784
785 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
786 }
787 }
788 return m;
789 }
790
791
792 @Benchmark
793 public Object greaterThan() {
794 short[] a = fa.apply(size);
795 short[] b = fb.apply(size);
796 boolean[] ms = fm.apply(size);
797 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
798
799 for (int ic = 0; ic < INVOC_COUNT; ic++) {
800 for (int i = 0; i < a.length; i += SPECIES.length()) {
801 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
802 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
803 VectorMask<Short> mv = av.greaterThan(bv);
804
805 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
806 }
807 }
808 return m;
809 }
810
811
812 @Benchmark
813 public Object equal() {
814 short[] a = fa.apply(size);
815 short[] b = fb.apply(size);
816 boolean[] ms = fm.apply(size);
817 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
818
819 for (int ic = 0; ic < INVOC_COUNT; ic++) {
820 for (int i = 0; i < a.length; i += SPECIES.length()) {
821 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
822 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
823 VectorMask<Short> mv = av.equal(bv);
824
825 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
826 }
827 }
828 return m;
829 }
830
831
832 @Benchmark
833 public Object notEqual() {
834 short[] a = fa.apply(size);
835 short[] b = fb.apply(size);
836 boolean[] ms = fm.apply(size);
837 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
838
839 for (int ic = 0; ic < INVOC_COUNT; ic++) {
840 for (int i = 0; i < a.length; i += SPECIES.length()) {
841 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
842 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
843 VectorMask<Short> mv = av.notEqual(bv);
844
845 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
846 }
847 }
848 return m;
849 }
850
851
852 @Benchmark
853 public Object lessThanEq() {
854 short[] a = fa.apply(size);
855 short[] b = fb.apply(size);
856 boolean[] ms = fm.apply(size);
857 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
858
859 for (int ic = 0; ic < INVOC_COUNT; ic++) {
860 for (int i = 0; i < a.length; i += SPECIES.length()) {
861 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
862 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
863 VectorMask<Short> mv = av.lessThanEq(bv);
864
865 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
866 }
867 }
868 return m;
869 }
870
871
872 @Benchmark
873 public Object greaterThanEq() {
874 short[] a = fa.apply(size);
875 short[] b = fb.apply(size);
876 boolean[] ms = fm.apply(size);
877 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
878
879 for (int ic = 0; ic < INVOC_COUNT; ic++) {
880 for (int i = 0; i < a.length; i += SPECIES.length()) {
881 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
882 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
883 VectorMask<Short> mv = av.greaterThanEq(bv);
884
885 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
886 }
887 }
888 return m;
889 }
890
891
892 @Benchmark
893 public void blend(Blackhole bh) {
894 short[] a = fa.apply(SPECIES.length());
895 short[] b = fb.apply(SPECIES.length());
896 short[] r = fr.apply(SPECIES.length());
897 boolean[] mask = fm.apply(SPECIES.length());
|