< prev index next >

test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/LongScalar.java

Print this page
rev 55894 : 8222897: [vector] Renaming of shift, rotate operations. Few other api changes.
Summary: Renaming of shift, rotate operations. Few other api changes.
Reviewed-by: jrose, briangoetz


 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];


< prev index next >