301 long[] rs = fr.apply(size);
302 boolean[] ms = fm.apply(size);
303
304 for (int ic = 0; ic < INVOC_COUNT; ic++) {
305 for (int i = 0; i < as.length; i++) {
306 long a = as[i];
307 long b = bs[i];
308 if (ms[i % ms.length]) {
309 rs[i] = (long)(a ^ b);
310 } else {
311 rs[i] = a;
312 }
313 }
314 }
315 bh.consume(rs);
316 }
317
318
319
320 @Benchmark
321 public void shiftR(Blackhole bh) {
322 long[] as = fa.apply(size);
323 long[] bs = fb.apply(size);
324 long[] rs = fr.apply(size);
325
326 for (int ic = 0; ic < INVOC_COUNT; ic++) {
327 for (int i = 0; i < as.length; i++) {
328 long a = as[i];
329 long b = bs[i];
330 rs[i] = (long)((a >>> b));
331 }
332 }
333
334 bh.consume(rs);
335 }
336
337
338
339 @Benchmark
340 public void shiftRMasked(Blackhole bh) {
341 long[] as = fa.apply(size);
342 long[] bs = fb.apply(size);
343 long[] rs = fr.apply(size);
344 boolean[] ms = fm.apply(size);
345
346 for (int ic = 0; ic < INVOC_COUNT; ic++) {
347 for (int i = 0; i < as.length; i++) {
348 long a = as[i];
349 long b = bs[i];
350 if (ms[i % ms.length]) {
351 rs[i] = (long)((a >>> b));
352 } else {
353 rs[i] = a;
354 }
355 }
356 }
357 bh.consume(rs);
358 }
359
360
361
362 @Benchmark
363 public void shiftL(Blackhole bh) {
364 long[] as = fa.apply(size);
365 long[] bs = fb.apply(size);
366 long[] rs = fr.apply(size);
367
368 for (int ic = 0; ic < INVOC_COUNT; ic++) {
369 for (int i = 0; i < as.length; i++) {
370 long a = as[i];
371 long b = bs[i];
372 rs[i] = (long)((a << b));
373 }
374 }
375
376 bh.consume(rs);
377 }
378
379
380
381 @Benchmark
382 public void shiftLMasked(Blackhole bh) {
383 long[] as = fa.apply(size);
384 long[] bs = fb.apply(size);
385 long[] rs = fr.apply(size);
386 boolean[] ms = fm.apply(size);
387
388 for (int ic = 0; ic < INVOC_COUNT; ic++) {
389 for (int i = 0; i < as.length; i++) {
390 long a = as[i];
391 long b = bs[i];
392 if (ms[i % ms.length]) {
393 rs[i] = (long)((a << b));
394 } else {
395 rs[i] = a;
396 }
397 }
398 }
399 bh.consume(rs);
400 }
401
402
403
404 @Benchmark
405 public void aShiftR(Blackhole bh) {
406 long[] as = fa.apply(size);
407 long[] bs = fb.apply(size);
408 long[] rs = fr.apply(size);
409
410 for (int ic = 0; ic < INVOC_COUNT; ic++) {
411 for (int i = 0; i < as.length; i++) {
412 long a = as[i];
413 long b = bs[i];
414 rs[i] = (long)((a >> b));
415 }
416 }
417
418 bh.consume(rs);
419 }
420
421
422
423 @Benchmark
424 public void aShiftRMasked(Blackhole bh) {
425 long[] as = fa.apply(size);
426 long[] bs = fb.apply(size);
427 long[] rs = fr.apply(size);
428 boolean[] ms = fm.apply(size);
429
430 for (int ic = 0; ic < INVOC_COUNT; ic++) {
431 for (int i = 0; i < as.length; i++) {
432 long a = as[i];
433 long b = bs[i];
434 if (ms[i % ms.length]) {
435 rs[i] = (long)((a >> b));
436 } else {
437 rs[i] = a;
438 }
439 }
440 }
441 bh.consume(rs);
442 }
443
444
445
446 @Benchmark
447 public void aShiftRShift(Blackhole bh) {
448 long[] as = fa.apply(size);
449 long[] bs = fb.apply(size);
450 long[] rs = fr.apply(size);
451
452 for (int ic = 0; ic < INVOC_COUNT; ic++) {
453 for (int i = 0; i < as.length; i++) {
454 long a = as[i];
455 long b = bs[i];
456 rs[i] = (long)((a >> b));
457 }
458 }
459
460 bh.consume(rs);
461 }
462
463
464
465 @Benchmark
466 public void aShiftRMaskedShift(Blackhole bh) {
467 long[] as = fa.apply(size);
468 long[] bs = fb.apply(size);
469 long[] rs = fr.apply(size);
470 boolean[] ms = fm.apply(size);
471
472 for (int ic = 0; ic < INVOC_COUNT; ic++) {
473 for (int i = 0; i < as.length; i++) {
474 long a = as[i];
475 long b = bs[i];
476 boolean m = ms[i % ms.length];
477 rs[i] = (m ? (long)((a >> b)) : a);
478 }
479 }
480
481 bh.consume(rs);
482 }
483
484
485
486 @Benchmark
487 public void shiftRShift(Blackhole bh) {
488 long[] as = fa.apply(size);
489 long[] bs = fb.apply(size);
490 long[] rs = fr.apply(size);
491
492 for (int ic = 0; ic < INVOC_COUNT; ic++) {
493 for (int i = 0; i < as.length; i++) {
494 long a = as[i];
495 long b = bs[i];
496 rs[i] = (long)((a >>> b));
497 }
498 }
499
500 bh.consume(rs);
501 }
502
503
504
505 @Benchmark
506 public void shiftRMaskedShift(Blackhole bh) {
507 long[] as = fa.apply(size);
508 long[] bs = fb.apply(size);
509 long[] rs = fr.apply(size);
510 boolean[] ms = fm.apply(size);
511
512 for (int ic = 0; ic < INVOC_COUNT; ic++) {
513 for (int i = 0; i < as.length; i++) {
514 long a = as[i];
515 long b = bs[i];
516 boolean m = ms[i % ms.length];
517 rs[i] = (m ? (long)((a >>> b)) : a);
518 }
519 }
520
521 bh.consume(rs);
522 }
523
524
525
526 @Benchmark
527 public void shiftLShift(Blackhole bh) {
528 long[] as = fa.apply(size);
529 long[] bs = fb.apply(size);
530 long[] rs = fr.apply(size);
531
532 for (int ic = 0; ic < INVOC_COUNT; ic++) {
533 for (int i = 0; i < as.length; i++) {
534 long a = as[i];
535 long b = bs[i];
536 rs[i] = (long)((a << b));
537 }
538 }
539
540 bh.consume(rs);
541 }
542
543
544
545 @Benchmark
546 public void shiftLMaskedShift(Blackhole bh) {
547 long[] as = fa.apply(size);
548 long[] bs = fb.apply(size);
549 long[] rs = fr.apply(size);
550 boolean[] ms = fm.apply(size);
551
552 for (int ic = 0; ic < INVOC_COUNT; ic++) {
553 for (int i = 0; i < as.length; i++) {
554 long a = as[i];
555 long b = bs[i];
556 boolean m = ms[i % ms.length];
557 rs[i] = (m ? (long)((a << b)) : a);
558 }
559 }
560
561 bh.consume(rs);
562 }
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577 @Benchmark
578 public void max(Blackhole bh) {
579 long[] as = fa.apply(size);
580 long[] bs = fb.apply(size);
581 long[] rs = fr.apply(size);
582
583 for (int ic = 0; ic < INVOC_COUNT; ic++) {
584 for (int i = 0; i < as.length; i++) {
585 long a = as[i];
586 long b = bs[i];
587 rs[i] = (long)(Math.max(a, b));
588 }
589 }
590
591 bh.consume(rs);
592 }
593
594 @Benchmark
595 public void min(Blackhole bh) {
596 long[] as = fa.apply(size);
597 long[] bs = fb.apply(size);
598 long[] rs = fr.apply(size);
599
600 for (int ic = 0; ic < INVOC_COUNT; ic++) {
601 for (int i = 0; i < as.length; i++) {
602 long a = as[i];
603 long b = bs[i];
604 rs[i] = (long)(Math.min(a, b));
605 }
606 }
607
608 bh.consume(rs);
609 }
610
611
612 @Benchmark
613 public void andAll(Blackhole bh) {
614 long[] as = fa.apply(size);
615 long r = -1;
616 for (int ic = 0; ic < INVOC_COUNT; ic++) {
617 r = -1;
618 for (int i = 0; i < as.length; i++) {
619 r &= as[i];
620 }
621 }
622 bh.consume(r);
623 }
624
625
626
627 @Benchmark
628 public void orAll(Blackhole bh) {
629 long[] as = fa.apply(size);
630 long r = 0;
631 for (int ic = 0; ic < INVOC_COUNT; ic++) {
632 r = 0;
633 for (int i = 0; i < as.length; i++) {
634 r |= as[i];
635 }
636 }
637 bh.consume(r);
638 }
639
640
641
642 @Benchmark
643 public void xorAll(Blackhole bh) {
644 long[] as = fa.apply(size);
645 long r = 0;
646 for (int ic = 0; ic < INVOC_COUNT; ic++) {
647 r = 0;
648 for (int i = 0; i < as.length; i++) {
649 r ^= as[i];
650 }
651 }
652 bh.consume(r);
653 }
654
655
656 @Benchmark
657 public void addAll(Blackhole bh) {
658 long[] as = fa.apply(size);
659 long r = 0;
660 for (int ic = 0; ic < INVOC_COUNT; ic++) {
661 r = 0;
662 for (int i = 0; i < as.length; i++) {
663 r += as[i];
664 }
665 }
666 bh.consume(r);
667 }
668
669 @Benchmark
670 public void mulAll(Blackhole bh) {
671 long[] as = fa.apply(size);
672 long r = 1;
673 for (int ic = 0; ic < INVOC_COUNT; ic++) {
674 r = 1;
675 for (int i = 0; i < as.length; i++) {
676 r *= as[i];
677 }
678 }
679 bh.consume(r);
680 }
681
682 @Benchmark
683 public void minAll(Blackhole bh) {
684 long[] as = fa.apply(size);
685 long r = Long.MAX_VALUE;
686 for (int ic = 0; ic < INVOC_COUNT; ic++) {
687 r = Long.MAX_VALUE;
688 for (int i = 0; i < as.length; i++) {
689 r = (long)Math.min(r, as[i]);
690 }
691 }
692 bh.consume(r);
693 }
694
695 @Benchmark
696 public void maxAll(Blackhole bh) {
697 long[] as = fa.apply(size);
698 long r = Long.MIN_VALUE;
699 for (int ic = 0; ic < INVOC_COUNT; ic++) {
700 r = Long.MIN_VALUE;
701 for (int i = 0; i < as.length; i++) {
702 r = (long)Math.max(r, as[i]);
703 }
704 }
705 bh.consume(r);
706 }
707
708
709 @Benchmark
710 public void anyTrue(Blackhole bh) {
711 boolean[] ms = fm.apply(size);
712 boolean r = false;
713 for (int ic = 0; ic < INVOC_COUNT; ic++) {
714 r = false;
715 for (int i = 0; i < ms.length; i++) {
716 r |= ms[i];
|
301 long[] rs = fr.apply(size);
302 boolean[] ms = fm.apply(size);
303
304 for (int ic = 0; ic < INVOC_COUNT; ic++) {
305 for (int i = 0; i < as.length; i++) {
306 long a = as[i];
307 long b = bs[i];
308 if (ms[i % ms.length]) {
309 rs[i] = (long)(a ^ b);
310 } else {
311 rs[i] = a;
312 }
313 }
314 }
315 bh.consume(rs);
316 }
317
318
319
320 @Benchmark
321 public void shiftLeft(Blackhole bh) {
322 long[] as = fa.apply(size);
323 long[] bs = fb.apply(size);
324 long[] rs = fr.apply(size);
325
326 for (int ic = 0; ic < INVOC_COUNT; ic++) {
327 for (int i = 0; i < as.length; i++) {
328 long a = as[i];
329 long b = bs[i];
330 rs[i] = (long)((a << b));
331 }
332 }
333
334 bh.consume(rs);
335 }
336
337
338
339 @Benchmark
340 public void shiftLeftMasked(Blackhole bh) {
341 long[] as = fa.apply(size);
342 long[] bs = fb.apply(size);
343 long[] rs = fr.apply(size);
344 boolean[] ms = fm.apply(size);
345
346 for (int ic = 0; ic < INVOC_COUNT; ic++) {
347 for (int i = 0; i < as.length; i++) {
348 long a = as[i];
349 long b = bs[i];
350 if (ms[i % ms.length]) {
351 rs[i] = (long)((a << b));
352 } else {
353 rs[i] = a;
354 }
355 }
356 }
357 bh.consume(rs);
358 }
359
360
361
362
363
364
365
366 @Benchmark
367 public void shiftRight(Blackhole bh) {
368 long[] as = fa.apply(size);
369 long[] bs = fb.apply(size);
370 long[] rs = fr.apply(size);
371
372 for (int ic = 0; ic < INVOC_COUNT; ic++) {
373 for (int i = 0; i < as.length; i++) {
374 long a = as[i];
375 long b = bs[i];
376 rs[i] = (long)((a >>> b));
377 }
378 }
379
380 bh.consume(rs);
381 }
382
383
384
385 @Benchmark
386 public void shiftRightMasked(Blackhole bh) {
387 long[] as = fa.apply(size);
388 long[] bs = fb.apply(size);
389 long[] rs = fr.apply(size);
390 boolean[] ms = fm.apply(size);
391
392 for (int ic = 0; ic < INVOC_COUNT; ic++) {
393 for (int i = 0; i < as.length; i++) {
394 long a = as[i];
395 long b = bs[i];
396 if (ms[i % ms.length]) {
397 rs[i] = (long)((a >>> b));
398 } else {
399 rs[i] = a;
400 }
401 }
402 }
403 bh.consume(rs);
404 }
405
406
407
408
409
410
411
412 @Benchmark
413 public void shiftArithmeticRight(Blackhole bh) {
414 long[] as = fa.apply(size);
415 long[] bs = fb.apply(size);
416 long[] rs = fr.apply(size);
417
418 for (int ic = 0; ic < INVOC_COUNT; ic++) {
419 for (int i = 0; i < as.length; i++) {
420 long a = as[i];
421 long b = bs[i];
422 rs[i] = (long)((a >> b));
423 }
424 }
425
426 bh.consume(rs);
427 }
428
429
430
431 @Benchmark
432 public void shiftArithmeticRightMasked(Blackhole bh) {
433 long[] as = fa.apply(size);
434 long[] bs = fb.apply(size);
435 long[] rs = fr.apply(size);
436 boolean[] ms = fm.apply(size);
437
438 for (int ic = 0; ic < INVOC_COUNT; ic++) {
439 for (int i = 0; i < as.length; i++) {
440 long a = as[i];
441 long b = bs[i];
442 if (ms[i % ms.length]) {
443 rs[i] = (long)((a >> b));
444 } else {
445 rs[i] = a;
446 }
447 }
448 }
449 bh.consume(rs);
450 }
451
452
453
454
455
456
457
458 @Benchmark
459 public void shiftLeftShift(Blackhole bh) {
460 long[] as = fa.apply(size);
461 long[] bs = fb.apply(size);
462 long[] rs = fr.apply(size);
463
464 for (int ic = 0; ic < INVOC_COUNT; ic++) {
465 for (int i = 0; i < as.length; i++) {
466 long a = as[i];
467 long b = bs[i];
468 rs[i] = (long)((a << b));
469 }
470 }
471
472 bh.consume(rs);
473 }
474
475
476
477 @Benchmark
478 public void shiftLeftMaskedShift(Blackhole bh) {
479 long[] as = fa.apply(size);
480 long[] bs = fb.apply(size);
481 long[] rs = fr.apply(size);
482 boolean[] ms = fm.apply(size);
483
484 for (int ic = 0; ic < INVOC_COUNT; ic++) {
485 for (int i = 0; i < as.length; i++) {
486 long a = as[i];
487 long b = bs[i];
488 boolean m = ms[i % ms.length];
489 rs[i] = (m ? (long)((a << b)) : a);
490 }
491 }
492
493 bh.consume(rs);
494 }
495
496
497
498
499
500
501
502 @Benchmark
503 public void shiftRightShift(Blackhole bh) {
504 long[] as = fa.apply(size);
505 long[] bs = fb.apply(size);
506 long[] rs = fr.apply(size);
507
508 for (int ic = 0; ic < INVOC_COUNT; ic++) {
509 for (int i = 0; i < as.length; i++) {
510 long a = as[i];
511 long b = bs[i];
512 rs[i] = (long)((a >>> b));
513 }
514 }
515
516 bh.consume(rs);
517 }
518
519
520
521 @Benchmark
522 public void shiftRightMaskedShift(Blackhole bh) {
523 long[] as = fa.apply(size);
524 long[] bs = fb.apply(size);
525 long[] rs = fr.apply(size);
526 boolean[] ms = fm.apply(size);
527
528 for (int ic = 0; ic < INVOC_COUNT; ic++) {
529 for (int i = 0; i < as.length; i++) {
530 long a = as[i];
531 long b = bs[i];
532 boolean m = ms[i % ms.length];
533 rs[i] = (m ? (long)((a >>> b)) : a);
534 }
535 }
536
537 bh.consume(rs);
538 }
539
540
541
542
543
544
545
546 @Benchmark
547 public void shiftArithmeticRightShift(Blackhole bh) {
548 long[] as = fa.apply(size);
549 long[] bs = fb.apply(size);
550 long[] rs = fr.apply(size);
551
552 for (int ic = 0; ic < INVOC_COUNT; ic++) {
553 for (int i = 0; i < as.length; i++) {
554 long a = as[i];
555 long b = bs[i];
556 rs[i] = (long)((a >> b));
557 }
558 }
559
560 bh.consume(rs);
561 }
562
563
564
565 @Benchmark
566 public void shiftArithmeticRightMaskedShift(Blackhole bh) {
567 long[] as = fa.apply(size);
568 long[] bs = fb.apply(size);
569 long[] rs = fr.apply(size);
570 boolean[] ms = fm.apply(size);
571
572 for (int ic = 0; ic < INVOC_COUNT; ic++) {
573 for (int i = 0; i < as.length; i++) {
574 long a = as[i];
575 long b = bs[i];
576 boolean m = ms[i % ms.length];
577 rs[i] = (m ? (long)((a >> b)) : a);
578 }
579 }
580
581 bh.consume(rs);
582 }
583
584
585
586
587
588
589 @Benchmark
590 public void max(Blackhole bh) {
591 long[] as = fa.apply(size);
592 long[] bs = fb.apply(size);
593 long[] rs = fr.apply(size);
594
595 for (int ic = 0; ic < INVOC_COUNT; ic++) {
596 for (int i = 0; i < as.length; i++) {
597 long a = as[i];
598 long b = bs[i];
599 rs[i] = (long)(Math.max(a, b));
600 }
601 }
602
603 bh.consume(rs);
604 }
605
606 @Benchmark
607 public void min(Blackhole bh) {
608 long[] as = fa.apply(size);
609 long[] bs = fb.apply(size);
610 long[] rs = fr.apply(size);
611
612 for (int ic = 0; ic < INVOC_COUNT; ic++) {
613 for (int i = 0; i < as.length; i++) {
614 long a = as[i];
615 long b = bs[i];
616 rs[i] = (long)(Math.min(a, b));
617 }
618 }
619
620 bh.consume(rs);
621 }
622
623
624 @Benchmark
625 public void andLanes(Blackhole bh) {
626 long[] as = fa.apply(size);
627 long r = -1;
628 for (int ic = 0; ic < INVOC_COUNT; ic++) {
629 r = -1;
630 for (int i = 0; i < as.length; i++) {
631 r &= as[i];
632 }
633 }
634 bh.consume(r);
635 }
636
637
638
639 @Benchmark
640 public void orLanes(Blackhole bh) {
641 long[] as = fa.apply(size);
642 long r = 0;
643 for (int ic = 0; ic < INVOC_COUNT; ic++) {
644 r = 0;
645 for (int i = 0; i < as.length; i++) {
646 r |= as[i];
647 }
648 }
649 bh.consume(r);
650 }
651
652
653
654 @Benchmark
655 public void xorLanes(Blackhole bh) {
656 long[] as = fa.apply(size);
657 long r = 0;
658 for (int ic = 0; ic < INVOC_COUNT; ic++) {
659 r = 0;
660 for (int i = 0; i < as.length; i++) {
661 r ^= as[i];
662 }
663 }
664 bh.consume(r);
665 }
666
667
668 @Benchmark
669 public void addLanes(Blackhole bh) {
670 long[] as = fa.apply(size);
671 long r = 0;
672 for (int ic = 0; ic < INVOC_COUNT; ic++) {
673 r = 0;
674 for (int i = 0; i < as.length; i++) {
675 r += as[i];
676 }
677 }
678 bh.consume(r);
679 }
680
681 @Benchmark
682 public void mulLanes(Blackhole bh) {
683 long[] as = fa.apply(size);
684 long r = 1;
685 for (int ic = 0; ic < INVOC_COUNT; ic++) {
686 r = 1;
687 for (int i = 0; i < as.length; i++) {
688 r *= as[i];
689 }
690 }
691 bh.consume(r);
692 }
693
694 @Benchmark
695 public void minLanes(Blackhole bh) {
696 long[] as = fa.apply(size);
697 long r = Long.MAX_VALUE;
698 for (int ic = 0; ic < INVOC_COUNT; ic++) {
699 r = Long.MAX_VALUE;
700 for (int i = 0; i < as.length; i++) {
701 r = (long)Math.min(r, as[i]);
702 }
703 }
704 bh.consume(r);
705 }
706
707 @Benchmark
708 public void maxLanes(Blackhole bh) {
709 long[] as = fa.apply(size);
710 long r = Long.MIN_VALUE;
711 for (int ic = 0; ic < INVOC_COUNT; ic++) {
712 r = Long.MIN_VALUE;
713 for (int i = 0; i < as.length; i++) {
714 r = (long)Math.max(r, as[i]);
715 }
716 }
717 bh.consume(r);
718 }
719
720
721 @Benchmark
722 public void anyTrue(Blackhole bh) {
723 boolean[] ms = fm.apply(size);
724 boolean r = false;
725 for (int ic = 0; ic < INVOC_COUNT; ic++) {
726 r = false;
727 for (int i = 0; i < ms.length; i++) {
728 r |= ms[i];
|