1 /* 2 * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 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 any 21 * questions. 22 */ 23 24 package benchmark.jdk.incubator.vector; 25 26 // -- This file was mechanically generated: Do not edit! -- // 27 28 import jdk.incubator.vector.Vector; 29 import jdk.incubator.vector.VectorMask; 30 import jdk.incubator.vector.VectorOperators; 31 import jdk.incubator.vector.VectorShape; 32 import jdk.incubator.vector.VectorSpecies; 33 import jdk.incubator.vector.VectorShuffle; 34 import jdk.incubator.vector.IntVector; 35 36 import java.util.concurrent.TimeUnit; 37 import java.util.function.BiFunction; 38 import java.util.function.IntFunction; 39 40 import org.openjdk.jmh.annotations.*; 41 import org.openjdk.jmh.infra.Blackhole; 42 43 @BenchmarkMode(Mode.Throughput) 44 @OutputTimeUnit(TimeUnit.MILLISECONDS) 45 @State(Scope.Benchmark) 46 @Warmup(iterations = 3, time = 1) 47 @Measurement(iterations = 5, time = 1) 48 @Fork(value = 1, jvmArgsPrepend = {"--add-modules=jdk.incubator.vector"}) 49 public class Int256Vector extends AbstractVectorBenchmark { 50 static final VectorSpecies<Integer> SPECIES = IntVector.SPECIES_256; 51 52 static final int INVOC_COUNT = 1; // get rid of outer loop 53 54 static void replaceZero(int[] a, int v) { 55 for (int i = 0; i < a.length; i++) { 56 if (a[i] == 0) { 57 a[i] = v; 58 } 59 } 60 } 61 62 static void replaceZero(int[] a, boolean[] mask, int v) { 63 for (int i = 0; i < a.length; i++) { 64 if (mask[i % mask.length] && a[i] == 0) { 65 a[i] = v; 66 } 67 } 68 } 69 70 @Param("1024") 71 int size; 72 73 int[] fill(IntFunction<Integer> f) { 74 int[] array = new int[size]; 75 for (int i = 0; i < array.length; i++) { 76 array[i] = f.apply(i); 77 } 78 return array; 79 } 80 81 int[] a, b, c, r; 82 boolean[] m, mt, rm; 83 int[] s; 84 85 @Setup 86 public void init() { 87 size += size % SPECIES.length(); // FIXME: add post-loops 88 89 a = fill(i -> (int)(2*i)); 90 b = fill(i -> (int)(i+1)); 91 c = fill(i -> (int)(i+5)); 92 r = fill(i -> (int)0); 93 94 m = fillMask(size, i -> (i % 2) == 0); 95 mt = fillMask(size, i -> true); 96 rm = fillMask(size, i -> false); 97 98 s = fillInt(size, i -> RANDOM.nextInt(SPECIES.length())); 99 } 100 101 final IntFunction<int[]> fa = vl -> a; 102 final IntFunction<int[]> fb = vl -> b; 103 final IntFunction<int[]> fc = vl -> c; 104 final IntFunction<int[]> fr = vl -> r; 105 final IntFunction<boolean[]> fm = vl -> m; 106 final IntFunction<boolean[]> fmt = vl -> mt; 107 final IntFunction<boolean[]> fmr = vl -> rm; 108 final BiFunction<Integer,Integer,int[]> fs = (i,j) -> s; 109 110 111 @Benchmark 112 public void ADD(Blackhole bh) { 113 int[] a = fa.apply(SPECIES.length()); 114 int[] b = fb.apply(SPECIES.length()); 115 int[] r = fr.apply(SPECIES.length()); 116 117 for (int ic = 0; ic < INVOC_COUNT; ic++) { 118 for (int i = 0; i < a.length; i += SPECIES.length()) { 119 IntVector av = IntVector.fromArray(SPECIES, a, i); 120 IntVector bv = IntVector.fromArray(SPECIES, b, i); 121 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i); 122 } 123 } 124 125 bh.consume(r); 126 } 127 128 @Benchmark 129 public void ADDMasked(Blackhole bh) { 130 int[] a = fa.apply(SPECIES.length()); 131 int[] b = fb.apply(SPECIES.length()); 132 int[] r = fr.apply(SPECIES.length()); 133 boolean[] mask = fm.apply(SPECIES.length()); 134 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 135 136 for (int ic = 0; ic < INVOC_COUNT; ic++) { 137 for (int i = 0; i < a.length; i += SPECIES.length()) { 138 IntVector av = IntVector.fromArray(SPECIES, a, i); 139 IntVector bv = IntVector.fromArray(SPECIES, b, i); 140 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i); 141 } 142 } 143 144 bh.consume(r); 145 } 146 147 @Benchmark 148 public void SUB(Blackhole bh) { 149 int[] a = fa.apply(SPECIES.length()); 150 int[] b = fb.apply(SPECIES.length()); 151 int[] r = fr.apply(SPECIES.length()); 152 153 for (int ic = 0; ic < INVOC_COUNT; ic++) { 154 for (int i = 0; i < a.length; i += SPECIES.length()) { 155 IntVector av = IntVector.fromArray(SPECIES, a, i); 156 IntVector bv = IntVector.fromArray(SPECIES, b, i); 157 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i); 158 } 159 } 160 161 bh.consume(r); 162 } 163 164 @Benchmark 165 public void SUBMasked(Blackhole bh) { 166 int[] a = fa.apply(SPECIES.length()); 167 int[] b = fb.apply(SPECIES.length()); 168 int[] r = fr.apply(SPECIES.length()); 169 boolean[] mask = fm.apply(SPECIES.length()); 170 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 171 172 for (int ic = 0; ic < INVOC_COUNT; ic++) { 173 for (int i = 0; i < a.length; i += SPECIES.length()) { 174 IntVector av = IntVector.fromArray(SPECIES, a, i); 175 IntVector bv = IntVector.fromArray(SPECIES, b, i); 176 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i); 177 } 178 } 179 180 bh.consume(r); 181 } 182 183 @Benchmark 184 public void MUL(Blackhole bh) { 185 int[] a = fa.apply(SPECIES.length()); 186 int[] b = fb.apply(SPECIES.length()); 187 int[] r = fr.apply(SPECIES.length()); 188 189 for (int ic = 0; ic < INVOC_COUNT; ic++) { 190 for (int i = 0; i < a.length; i += SPECIES.length()) { 191 IntVector av = IntVector.fromArray(SPECIES, a, i); 192 IntVector bv = IntVector.fromArray(SPECIES, b, i); 193 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i); 194 } 195 } 196 197 bh.consume(r); 198 } 199 200 @Benchmark 201 public void MULMasked(Blackhole bh) { 202 int[] a = fa.apply(SPECIES.length()); 203 int[] b = fb.apply(SPECIES.length()); 204 int[] r = fr.apply(SPECIES.length()); 205 boolean[] mask = fm.apply(SPECIES.length()); 206 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 207 208 for (int ic = 0; ic < INVOC_COUNT; ic++) { 209 for (int i = 0; i < a.length; i += SPECIES.length()) { 210 IntVector av = IntVector.fromArray(SPECIES, a, i); 211 IntVector bv = IntVector.fromArray(SPECIES, b, i); 212 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i); 213 } 214 } 215 216 bh.consume(r); 217 } 218 219 220 221 222 @Benchmark 223 public void DIV(Blackhole bh) { 224 int[] a = fa.apply(SPECIES.length()); 225 int[] b = fb.apply(SPECIES.length()); 226 int[] r = fr.apply(SPECIES.length()); 227 228 replaceZero(b, (int) 1); 229 230 for (int ic = 0; ic < INVOC_COUNT; ic++) { 231 for (int i = 0; i < a.length; i += SPECIES.length()) { 232 IntVector av = IntVector.fromArray(SPECIES, a, i); 233 IntVector bv = IntVector.fromArray(SPECIES, b, i); 234 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i); 235 } 236 } 237 238 bh.consume(r); 239 } 240 241 242 243 @Benchmark 244 public void DIVMasked(Blackhole bh) { 245 int[] a = fa.apply(SPECIES.length()); 246 int[] b = fb.apply(SPECIES.length()); 247 int[] r = fr.apply(SPECIES.length()); 248 boolean[] mask = fm.apply(SPECIES.length()); 249 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 250 251 replaceZero(b, mask, (int) 1); 252 253 for (int ic = 0; ic < INVOC_COUNT; ic++) { 254 for (int i = 0; i < a.length; i += SPECIES.length()) { 255 IntVector av = IntVector.fromArray(SPECIES, a, i); 256 IntVector bv = IntVector.fromArray(SPECIES, b, i); 257 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i); 258 } 259 } 260 261 bh.consume(r); 262 } 263 264 265 @Benchmark 266 public void FIRST_NONZERO(Blackhole bh) { 267 int[] a = fa.apply(SPECIES.length()); 268 int[] b = fb.apply(SPECIES.length()); 269 int[] r = fr.apply(SPECIES.length()); 270 271 for (int ic = 0; ic < INVOC_COUNT; ic++) { 272 for (int i = 0; i < a.length; i += SPECIES.length()) { 273 IntVector av = IntVector.fromArray(SPECIES, a, i); 274 IntVector bv = IntVector.fromArray(SPECIES, b, i); 275 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i); 276 } 277 } 278 279 bh.consume(r); 280 } 281 282 @Benchmark 283 public void FIRST_NONZEROMasked(Blackhole bh) { 284 int[] a = fa.apply(SPECIES.length()); 285 int[] b = fb.apply(SPECIES.length()); 286 int[] r = fr.apply(SPECIES.length()); 287 boolean[] mask = fm.apply(SPECIES.length()); 288 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 289 290 for (int ic = 0; ic < INVOC_COUNT; ic++) { 291 for (int i = 0; i < a.length; i += SPECIES.length()) { 292 IntVector av = IntVector.fromArray(SPECIES, a, i); 293 IntVector bv = IntVector.fromArray(SPECIES, b, i); 294 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i); 295 } 296 } 297 298 bh.consume(r); 299 } 300 301 302 @Benchmark 303 public void AND(Blackhole bh) { 304 int[] a = fa.apply(SPECIES.length()); 305 int[] b = fb.apply(SPECIES.length()); 306 int[] r = fr.apply(SPECIES.length()); 307 308 for (int ic = 0; ic < INVOC_COUNT; ic++) { 309 for (int i = 0; i < a.length; i += SPECIES.length()) { 310 IntVector av = IntVector.fromArray(SPECIES, a, i); 311 IntVector bv = IntVector.fromArray(SPECIES, b, i); 312 av.lanewise(VectorOperators.AND, bv).intoArray(r, i); 313 } 314 } 315 316 bh.consume(r); 317 } 318 319 320 321 @Benchmark 322 public void ANDMasked(Blackhole bh) { 323 int[] a = fa.apply(SPECIES.length()); 324 int[] b = fb.apply(SPECIES.length()); 325 int[] r = fr.apply(SPECIES.length()); 326 boolean[] mask = fm.apply(SPECIES.length()); 327 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 328 329 for (int ic = 0; ic < INVOC_COUNT; ic++) { 330 for (int i = 0; i < a.length; i += SPECIES.length()) { 331 IntVector av = IntVector.fromArray(SPECIES, a, i); 332 IntVector bv = IntVector.fromArray(SPECIES, b, i); 333 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i); 334 } 335 } 336 337 bh.consume(r); 338 } 339 340 341 342 @Benchmark 343 public void AND_NOT(Blackhole bh) { 344 int[] a = fa.apply(SPECIES.length()); 345 int[] b = fb.apply(SPECIES.length()); 346 int[] r = fr.apply(SPECIES.length()); 347 348 for (int ic = 0; ic < INVOC_COUNT; ic++) { 349 for (int i = 0; i < a.length; i += SPECIES.length()) { 350 IntVector av = IntVector.fromArray(SPECIES, a, i); 351 IntVector bv = IntVector.fromArray(SPECIES, b, i); 352 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i); 353 } 354 } 355 356 bh.consume(r); 357 } 358 359 360 361 @Benchmark 362 public void AND_NOTMasked(Blackhole bh) { 363 int[] a = fa.apply(SPECIES.length()); 364 int[] b = fb.apply(SPECIES.length()); 365 int[] r = fr.apply(SPECIES.length()); 366 boolean[] mask = fm.apply(SPECIES.length()); 367 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 368 369 for (int ic = 0; ic < INVOC_COUNT; ic++) { 370 for (int i = 0; i < a.length; i += SPECIES.length()) { 371 IntVector av = IntVector.fromArray(SPECIES, a, i); 372 IntVector bv = IntVector.fromArray(SPECIES, b, i); 373 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i); 374 } 375 } 376 377 bh.consume(r); 378 } 379 380 381 382 @Benchmark 383 public void OR(Blackhole bh) { 384 int[] a = fa.apply(SPECIES.length()); 385 int[] b = fb.apply(SPECIES.length()); 386 int[] r = fr.apply(SPECIES.length()); 387 388 for (int ic = 0; ic < INVOC_COUNT; ic++) { 389 for (int i = 0; i < a.length; i += SPECIES.length()) { 390 IntVector av = IntVector.fromArray(SPECIES, a, i); 391 IntVector bv = IntVector.fromArray(SPECIES, b, i); 392 av.lanewise(VectorOperators.OR, bv).intoArray(r, i); 393 } 394 } 395 396 bh.consume(r); 397 } 398 399 400 401 @Benchmark 402 public void ORMasked(Blackhole bh) { 403 int[] a = fa.apply(SPECIES.length()); 404 int[] b = fb.apply(SPECIES.length()); 405 int[] r = fr.apply(SPECIES.length()); 406 boolean[] mask = fm.apply(SPECIES.length()); 407 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 408 409 for (int ic = 0; ic < INVOC_COUNT; ic++) { 410 for (int i = 0; i < a.length; i += SPECIES.length()) { 411 IntVector av = IntVector.fromArray(SPECIES, a, i); 412 IntVector bv = IntVector.fromArray(SPECIES, b, i); 413 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i); 414 } 415 } 416 417 bh.consume(r); 418 } 419 420 421 422 @Benchmark 423 public void XOR(Blackhole bh) { 424 int[] a = fa.apply(SPECIES.length()); 425 int[] b = fb.apply(SPECIES.length()); 426 int[] r = fr.apply(SPECIES.length()); 427 428 for (int ic = 0; ic < INVOC_COUNT; ic++) { 429 for (int i = 0; i < a.length; i += SPECIES.length()) { 430 IntVector av = IntVector.fromArray(SPECIES, a, i); 431 IntVector bv = IntVector.fromArray(SPECIES, b, i); 432 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i); 433 } 434 } 435 436 bh.consume(r); 437 } 438 439 440 441 @Benchmark 442 public void XORMasked(Blackhole bh) { 443 int[] a = fa.apply(SPECIES.length()); 444 int[] b = fb.apply(SPECIES.length()); 445 int[] r = fr.apply(SPECIES.length()); 446 boolean[] mask = fm.apply(SPECIES.length()); 447 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 448 449 for (int ic = 0; ic < INVOC_COUNT; ic++) { 450 for (int i = 0; i < a.length; i += SPECIES.length()) { 451 IntVector av = IntVector.fromArray(SPECIES, a, i); 452 IntVector bv = IntVector.fromArray(SPECIES, b, i); 453 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i); 454 } 455 } 456 457 bh.consume(r); 458 } 459 460 461 462 @Benchmark 463 public void LSHL(Blackhole bh) { 464 int[] a = fa.apply(SPECIES.length()); 465 int[] b = fb.apply(SPECIES.length()); 466 int[] r = fr.apply(SPECIES.length()); 467 468 for (int ic = 0; ic < INVOC_COUNT; ic++) { 469 for (int i = 0; i < a.length; i += SPECIES.length()) { 470 IntVector av = IntVector.fromArray(SPECIES, a, i); 471 IntVector bv = IntVector.fromArray(SPECIES, b, i); 472 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i); 473 } 474 } 475 476 bh.consume(r); 477 } 478 479 480 481 @Benchmark 482 public void LSHLMasked(Blackhole bh) { 483 int[] a = fa.apply(SPECIES.length()); 484 int[] b = fb.apply(SPECIES.length()); 485 int[] r = fr.apply(SPECIES.length()); 486 boolean[] mask = fm.apply(SPECIES.length()); 487 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 488 489 for (int ic = 0; ic < INVOC_COUNT; ic++) { 490 for (int i = 0; i < a.length; i += SPECIES.length()) { 491 IntVector av = IntVector.fromArray(SPECIES, a, i); 492 IntVector bv = IntVector.fromArray(SPECIES, b, i); 493 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i); 494 } 495 } 496 497 bh.consume(r); 498 } 499 500 501 502 503 504 505 506 @Benchmark 507 public void ASHR(Blackhole bh) { 508 int[] a = fa.apply(SPECIES.length()); 509 int[] b = fb.apply(SPECIES.length()); 510 int[] r = fr.apply(SPECIES.length()); 511 512 for (int ic = 0; ic < INVOC_COUNT; ic++) { 513 for (int i = 0; i < a.length; i += SPECIES.length()) { 514 IntVector av = IntVector.fromArray(SPECIES, a, i); 515 IntVector bv = IntVector.fromArray(SPECIES, b, i); 516 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i); 517 } 518 } 519 520 bh.consume(r); 521 } 522 523 524 525 @Benchmark 526 public void ASHRMasked(Blackhole bh) { 527 int[] a = fa.apply(SPECIES.length()); 528 int[] b = fb.apply(SPECIES.length()); 529 int[] r = fr.apply(SPECIES.length()); 530 boolean[] mask = fm.apply(SPECIES.length()); 531 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 532 533 for (int ic = 0; ic < INVOC_COUNT; ic++) { 534 for (int i = 0; i < a.length; i += SPECIES.length()) { 535 IntVector av = IntVector.fromArray(SPECIES, a, i); 536 IntVector bv = IntVector.fromArray(SPECIES, b, i); 537 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i); 538 } 539 } 540 541 bh.consume(r); 542 } 543 544 545 546 547 548 549 550 @Benchmark 551 public void LSHR(Blackhole bh) { 552 int[] a = fa.apply(SPECIES.length()); 553 int[] b = fb.apply(SPECIES.length()); 554 int[] r = fr.apply(SPECIES.length()); 555 556 for (int ic = 0; ic < INVOC_COUNT; ic++) { 557 for (int i = 0; i < a.length; i += SPECIES.length()) { 558 IntVector av = IntVector.fromArray(SPECIES, a, i); 559 IntVector bv = IntVector.fromArray(SPECIES, b, i); 560 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i); 561 } 562 } 563 564 bh.consume(r); 565 } 566 567 568 569 @Benchmark 570 public void LSHRMasked(Blackhole bh) { 571 int[] a = fa.apply(SPECIES.length()); 572 int[] b = fb.apply(SPECIES.length()); 573 int[] r = fr.apply(SPECIES.length()); 574 boolean[] mask = fm.apply(SPECIES.length()); 575 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 576 577 for (int ic = 0; ic < INVOC_COUNT; ic++) { 578 for (int i = 0; i < a.length; i += SPECIES.length()) { 579 IntVector av = IntVector.fromArray(SPECIES, a, i); 580 IntVector bv = IntVector.fromArray(SPECIES, b, i); 581 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i); 582 } 583 } 584 585 bh.consume(r); 586 } 587 588 589 590 591 592 593 594 @Benchmark 595 public void LSHLShift(Blackhole bh) { 596 int[] a = fa.apply(SPECIES.length()); 597 int[] b = fb.apply(SPECIES.length()); 598 int[] r = fr.apply(SPECIES.length()); 599 600 for (int ic = 0; ic < INVOC_COUNT; ic++) { 601 for (int i = 0; i < a.length; i += SPECIES.length()) { 602 IntVector av = IntVector.fromArray(SPECIES, a, i); 603 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i); 604 } 605 } 606 607 bh.consume(r); 608 } 609 610 611 612 @Benchmark 613 public void LSHLMaskedShift(Blackhole bh) { 614 int[] a = fa.apply(SPECIES.length()); 615 int[] b = fb.apply(SPECIES.length()); 616 int[] r = fr.apply(SPECIES.length()); 617 boolean[] mask = fm.apply(SPECIES.length()); 618 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 619 620 for (int ic = 0; ic < INVOC_COUNT; ic++) { 621 for (int i = 0; i < a.length; i += SPECIES.length()) { 622 IntVector av = IntVector.fromArray(SPECIES, a, i); 623 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i); 624 } 625 } 626 627 bh.consume(r); 628 } 629 630 631 632 633 634 635 636 @Benchmark 637 public void LSHRShift(Blackhole bh) { 638 int[] a = fa.apply(SPECIES.length()); 639 int[] b = fb.apply(SPECIES.length()); 640 int[] r = fr.apply(SPECIES.length()); 641 642 for (int ic = 0; ic < INVOC_COUNT; ic++) { 643 for (int i = 0; i < a.length; i += SPECIES.length()) { 644 IntVector av = IntVector.fromArray(SPECIES, a, i); 645 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i); 646 } 647 } 648 649 bh.consume(r); 650 } 651 652 653 654 @Benchmark 655 public void LSHRMaskedShift(Blackhole bh) { 656 int[] a = fa.apply(SPECIES.length()); 657 int[] b = fb.apply(SPECIES.length()); 658 int[] r = fr.apply(SPECIES.length()); 659 boolean[] mask = fm.apply(SPECIES.length()); 660 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 661 662 for (int ic = 0; ic < INVOC_COUNT; ic++) { 663 for (int i = 0; i < a.length; i += SPECIES.length()) { 664 IntVector av = IntVector.fromArray(SPECIES, a, i); 665 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i); 666 } 667 } 668 669 bh.consume(r); 670 } 671 672 673 674 675 676 677 678 @Benchmark 679 public void ASHRShift(Blackhole bh) { 680 int[] a = fa.apply(SPECIES.length()); 681 int[] b = fb.apply(SPECIES.length()); 682 int[] r = fr.apply(SPECIES.length()); 683 684 for (int ic = 0; ic < INVOC_COUNT; ic++) { 685 for (int i = 0; i < a.length; i += SPECIES.length()) { 686 IntVector av = IntVector.fromArray(SPECIES, a, i); 687 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i); 688 } 689 } 690 691 bh.consume(r); 692 } 693 694 695 696 @Benchmark 697 public void ASHRMaskedShift(Blackhole bh) { 698 int[] a = fa.apply(SPECIES.length()); 699 int[] b = fb.apply(SPECIES.length()); 700 int[] r = fr.apply(SPECIES.length()); 701 boolean[] mask = fm.apply(SPECIES.length()); 702 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 703 704 for (int ic = 0; ic < INVOC_COUNT; ic++) { 705 for (int i = 0; i < a.length; i += SPECIES.length()) { 706 IntVector av = IntVector.fromArray(SPECIES, a, i); 707 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i); 708 } 709 } 710 711 bh.consume(r); 712 } 713 714 715 716 717 718 719 @Benchmark 720 public void MIN(Blackhole bh) { 721 int[] a = fa.apply(SPECIES.length()); 722 int[] b = fb.apply(SPECIES.length()); 723 int[] r = fr.apply(SPECIES.length()); 724 725 for (int ic = 0; ic < INVOC_COUNT; ic++) { 726 for (int i = 0; i < a.length; i += SPECIES.length()) { 727 IntVector av = IntVector.fromArray(SPECIES, a, i); 728 IntVector bv = IntVector.fromArray(SPECIES, b, i); 729 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i); 730 } 731 } 732 733 bh.consume(r); 734 } 735 736 @Benchmark 737 public void MAX(Blackhole bh) { 738 int[] a = fa.apply(SPECIES.length()); 739 int[] b = fb.apply(SPECIES.length()); 740 int[] r = fr.apply(SPECIES.length()); 741 742 for (int ic = 0; ic < INVOC_COUNT; ic++) { 743 for (int i = 0; i < a.length; i += SPECIES.length()) { 744 IntVector av = IntVector.fromArray(SPECIES, a, i); 745 IntVector bv = IntVector.fromArray(SPECIES, b, i); 746 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i); 747 } 748 } 749 750 bh.consume(r); 751 } 752 753 754 @Benchmark 755 public void ANDLanes(Blackhole bh) { 756 int[] a = fa.apply(SPECIES.length()); 757 int ra = -1; 758 759 for (int ic = 0; ic < INVOC_COUNT; ic++) { 760 ra = -1; 761 for (int i = 0; i < a.length; i += SPECIES.length()) { 762 IntVector av = IntVector.fromArray(SPECIES, a, i); 763 ra &= av.reduceLanes(VectorOperators.AND); 764 } 765 } 766 bh.consume(ra); 767 } 768 769 770 771 @Benchmark 772 public void ANDMaskedLanes(Blackhole bh) { 773 int[] a = fa.apply(SPECIES.length()); 774 boolean[] mask = fm.apply(SPECIES.length()); 775 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 776 int ra = -1; 777 778 for (int ic = 0; ic < INVOC_COUNT; ic++) { 779 ra = -1; 780 for (int i = 0; i < a.length; i += SPECIES.length()) { 781 IntVector av = IntVector.fromArray(SPECIES, a, i); 782 ra &= av.reduceLanes(VectorOperators.AND, vmask); 783 } 784 } 785 bh.consume(ra); 786 } 787 788 789 790 @Benchmark 791 public void ORLanes(Blackhole bh) { 792 int[] a = fa.apply(SPECIES.length()); 793 int ra = 0; 794 795 for (int ic = 0; ic < INVOC_COUNT; ic++) { 796 ra = 0; 797 for (int i = 0; i < a.length; i += SPECIES.length()) { 798 IntVector av = IntVector.fromArray(SPECIES, a, i); 799 ra |= av.reduceLanes(VectorOperators.OR); 800 } 801 } 802 bh.consume(ra); 803 } 804 805 806 807 @Benchmark 808 public void ORMaskedLanes(Blackhole bh) { 809 int[] a = fa.apply(SPECIES.length()); 810 boolean[] mask = fm.apply(SPECIES.length()); 811 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 812 int ra = 0; 813 814 for (int ic = 0; ic < INVOC_COUNT; ic++) { 815 ra = 0; 816 for (int i = 0; i < a.length; i += SPECIES.length()) { 817 IntVector av = IntVector.fromArray(SPECIES, a, i); 818 ra |= av.reduceLanes(VectorOperators.OR, vmask); 819 } 820 } 821 bh.consume(ra); 822 } 823 824 825 826 @Benchmark 827 public void XORLanes(Blackhole bh) { 828 int[] a = fa.apply(SPECIES.length()); 829 int ra = 0; 830 831 for (int ic = 0; ic < INVOC_COUNT; ic++) { 832 ra = 0; 833 for (int i = 0; i < a.length; i += SPECIES.length()) { 834 IntVector av = IntVector.fromArray(SPECIES, a, i); 835 ra ^= av.reduceLanes(VectorOperators.XOR); 836 } 837 } 838 bh.consume(ra); 839 } 840 841 842 843 @Benchmark 844 public void XORMaskedLanes(Blackhole bh) { 845 int[] a = fa.apply(SPECIES.length()); 846 boolean[] mask = fm.apply(SPECIES.length()); 847 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 848 int ra = 0; 849 850 for (int ic = 0; ic < INVOC_COUNT; ic++) { 851 ra = 0; 852 for (int i = 0; i < a.length; i += SPECIES.length()) { 853 IntVector av = IntVector.fromArray(SPECIES, a, i); 854 ra ^= av.reduceLanes(VectorOperators.XOR, vmask); 855 } 856 } 857 bh.consume(ra); 858 } 859 860 861 @Benchmark 862 public void ADDLanes(Blackhole bh) { 863 int[] a = fa.apply(SPECIES.length()); 864 int ra = 0; 865 866 for (int ic = 0; ic < INVOC_COUNT; ic++) { 867 ra = 0; 868 for (int i = 0; i < a.length; i += SPECIES.length()) { 869 IntVector av = IntVector.fromArray(SPECIES, a, i); 870 ra += av.reduceLanes(VectorOperators.ADD); 871 } 872 } 873 bh.consume(ra); 874 } 875 876 @Benchmark 877 public void ADDMaskedLanes(Blackhole bh) { 878 int[] a = fa.apply(SPECIES.length()); 879 boolean[] mask = fm.apply(SPECIES.length()); 880 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 881 int ra = 0; 882 883 for (int ic = 0; ic < INVOC_COUNT; ic++) { 884 ra = 0; 885 for (int i = 0; i < a.length; i += SPECIES.length()) { 886 IntVector av = IntVector.fromArray(SPECIES, a, i); 887 ra += av.reduceLanes(VectorOperators.ADD, vmask); 888 } 889 } 890 bh.consume(ra); 891 } 892 893 @Benchmark 894 public void MULLanes(Blackhole bh) { 895 int[] a = fa.apply(SPECIES.length()); 896 int ra = 1; 897 898 for (int ic = 0; ic < INVOC_COUNT; ic++) { 899 ra = 1; 900 for (int i = 0; i < a.length; i += SPECIES.length()) { 901 IntVector av = IntVector.fromArray(SPECIES, a, i); 902 ra *= av.reduceLanes(VectorOperators.MUL); 903 } 904 } 905 bh.consume(ra); 906 } 907 908 @Benchmark 909 public void MULMaskedLanes(Blackhole bh) { 910 int[] a = fa.apply(SPECIES.length()); 911 boolean[] mask = fm.apply(SPECIES.length()); 912 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 913 int ra = 1; 914 915 for (int ic = 0; ic < INVOC_COUNT; ic++) { 916 ra = 1; 917 for (int i = 0; i < a.length; i += SPECIES.length()) { 918 IntVector av = IntVector.fromArray(SPECIES, a, i); 919 ra *= av.reduceLanes(VectorOperators.MUL, vmask); 920 } 921 } 922 bh.consume(ra); 923 } 924 925 @Benchmark 926 public void MINLanes(Blackhole bh) { 927 int[] a = fa.apply(SPECIES.length()); 928 int ra = Integer.MAX_VALUE; 929 930 for (int ic = 0; ic < INVOC_COUNT; ic++) { 931 ra = Integer.MAX_VALUE; 932 for (int i = 0; i < a.length; i += SPECIES.length()) { 933 IntVector av = IntVector.fromArray(SPECIES, a, i); 934 ra = (int)Math.min(ra, av.reduceLanes(VectorOperators.MIN)); 935 } 936 } 937 bh.consume(ra); 938 } 939 940 @Benchmark 941 public void MINMaskedLanes(Blackhole bh) { 942 int[] a = fa.apply(SPECIES.length()); 943 boolean[] mask = fm.apply(SPECIES.length()); 944 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 945 int ra = Integer.MAX_VALUE; 946 947 for (int ic = 0; ic < INVOC_COUNT; ic++) { 948 ra = Integer.MAX_VALUE; 949 for (int i = 0; i < a.length; i += SPECIES.length()) { 950 IntVector av = IntVector.fromArray(SPECIES, a, i); 951 ra = (int)Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask)); 952 } 953 } 954 bh.consume(ra); 955 } 956 957 @Benchmark 958 public void MAXLanes(Blackhole bh) { 959 int[] a = fa.apply(SPECIES.length()); 960 int ra = Integer.MIN_VALUE; 961 962 for (int ic = 0; ic < INVOC_COUNT; ic++) { 963 ra = Integer.MIN_VALUE; 964 for (int i = 0; i < a.length; i += SPECIES.length()) { 965 IntVector av = IntVector.fromArray(SPECIES, a, i); 966 ra = (int)Math.max(ra, av.reduceLanes(VectorOperators.MAX)); 967 } 968 } 969 bh.consume(ra); 970 } 971 972 @Benchmark 973 public void MAXMaskedLanes(Blackhole bh) { 974 int[] a = fa.apply(SPECIES.length()); 975 boolean[] mask = fm.apply(SPECIES.length()); 976 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 977 int ra = Integer.MIN_VALUE; 978 979 for (int ic = 0; ic < INVOC_COUNT; ic++) { 980 ra = Integer.MIN_VALUE; 981 for (int i = 0; i < a.length; i += SPECIES.length()) { 982 IntVector av = IntVector.fromArray(SPECIES, a, i); 983 ra = (int)Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask)); 984 } 985 } 986 bh.consume(ra); 987 } 988 989 990 @Benchmark 991 public void anyTrue(Blackhole bh) { 992 boolean[] mask = fm.apply(SPECIES.length()); 993 boolean[] r = fmr.apply(SPECIES.length()); 994 995 for (int ic = 0; ic < INVOC_COUNT; ic++) { 996 for (int i = 0; i < mask.length; i += SPECIES.length()) { 997 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i); 998 r[i] = vmask.anyTrue(); 999 } 1000 } 1001 1002 bh.consume(r); 1003 } 1004 1005 1006 1007 @Benchmark 1008 public void allTrue(Blackhole bh) { 1009 boolean[] mask = fm.apply(SPECIES.length()); 1010 boolean[] r = fmr.apply(SPECIES.length()); 1011 1012 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1013 for (int i = 0; i < mask.length; i += SPECIES.length()) { 1014 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i); 1015 r[i] = vmask.allTrue(); 1016 } 1017 } 1018 1019 bh.consume(r); 1020 } 1021 1022 1023 @Benchmark 1024 public void withLane(Blackhole bh) { 1025 int[] a = fa.apply(SPECIES.length()); 1026 int[] r = fr.apply(SPECIES.length()); 1027 1028 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1029 for (int i = 0; i < a.length; i += SPECIES.length()) { 1030 IntVector av = IntVector.fromArray(SPECIES, a, i); 1031 av.withLane(0, (int)4).intoArray(r, i); 1032 } 1033 } 1034 1035 bh.consume(r); 1036 } 1037 1038 @Benchmark 1039 public Object IS_DEFAULT() { 1040 int[] a = fa.apply(size); 1041 boolean[] ms = fmt.apply(size); 1042 VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0); 1043 1044 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1045 for (int i = 0; i < a.length; i += SPECIES.length()) { 1046 IntVector av = IntVector.fromArray(SPECIES, a, i); 1047 1048 // accumulate results, so JIT can't eliminate relevant computations 1049 m = m.and(av.test(VectorOperators.IS_DEFAULT)); 1050 } 1051 } 1052 1053 return m; 1054 } 1055 1056 @Benchmark 1057 public Object IS_NEGATIVE() { 1058 int[] a = fa.apply(size); 1059 boolean[] ms = fmt.apply(size); 1060 VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0); 1061 1062 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1063 for (int i = 0; i < a.length; i += SPECIES.length()) { 1064 IntVector av = IntVector.fromArray(SPECIES, a, i); 1065 1066 // accumulate results, so JIT can't eliminate relevant computations 1067 m = m.and(av.test(VectorOperators.IS_NEGATIVE)); 1068 } 1069 } 1070 1071 return m; 1072 } 1073 1074 1075 1076 1077 @Benchmark 1078 public Object LT() { 1079 int[] a = fa.apply(size); 1080 int[] b = fb.apply(size); 1081 boolean[] ms = fmt.apply(size); 1082 VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0); 1083 1084 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1085 for (int i = 0; i < a.length; i += SPECIES.length()) { 1086 IntVector av = IntVector.fromArray(SPECIES, a, i); 1087 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1088 1089 // accumulate results, so JIT can't eliminate relevant computations 1090 m = m.and(av.compare(VectorOperators.LT, bv)); 1091 } 1092 } 1093 1094 return m; 1095 } 1096 1097 @Benchmark 1098 public Object GT() { 1099 int[] a = fa.apply(size); 1100 int[] b = fb.apply(size); 1101 boolean[] ms = fmt.apply(size); 1102 VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0); 1103 1104 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1105 for (int i = 0; i < a.length; i += SPECIES.length()) { 1106 IntVector av = IntVector.fromArray(SPECIES, a, i); 1107 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1108 1109 // accumulate results, so JIT can't eliminate relevant computations 1110 m = m.and(av.compare(VectorOperators.GT, bv)); 1111 } 1112 } 1113 1114 return m; 1115 } 1116 1117 @Benchmark 1118 public Object EQ() { 1119 int[] a = fa.apply(size); 1120 int[] b = fb.apply(size); 1121 boolean[] ms = fmt.apply(size); 1122 VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0); 1123 1124 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1125 for (int i = 0; i < a.length; i += SPECIES.length()) { 1126 IntVector av = IntVector.fromArray(SPECIES, a, i); 1127 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1128 1129 // accumulate results, so JIT can't eliminate relevant computations 1130 m = m.and(av.compare(VectorOperators.EQ, bv)); 1131 } 1132 } 1133 1134 return m; 1135 } 1136 1137 @Benchmark 1138 public Object NE() { 1139 int[] a = fa.apply(size); 1140 int[] b = fb.apply(size); 1141 boolean[] ms = fmt.apply(size); 1142 VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0); 1143 1144 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1145 for (int i = 0; i < a.length; i += SPECIES.length()) { 1146 IntVector av = IntVector.fromArray(SPECIES, a, i); 1147 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1148 1149 // accumulate results, so JIT can't eliminate relevant computations 1150 m = m.and(av.compare(VectorOperators.NE, bv)); 1151 } 1152 } 1153 1154 return m; 1155 } 1156 1157 @Benchmark 1158 public Object LE() { 1159 int[] a = fa.apply(size); 1160 int[] b = fb.apply(size); 1161 boolean[] ms = fmt.apply(size); 1162 VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0); 1163 1164 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1165 for (int i = 0; i < a.length; i += SPECIES.length()) { 1166 IntVector av = IntVector.fromArray(SPECIES, a, i); 1167 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1168 1169 // accumulate results, so JIT can't eliminate relevant computations 1170 m = m.and(av.compare(VectorOperators.LE, bv)); 1171 } 1172 } 1173 1174 return m; 1175 } 1176 1177 @Benchmark 1178 public Object GE() { 1179 int[] a = fa.apply(size); 1180 int[] b = fb.apply(size); 1181 boolean[] ms = fmt.apply(size); 1182 VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0); 1183 1184 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1185 for (int i = 0; i < a.length; i += SPECIES.length()) { 1186 IntVector av = IntVector.fromArray(SPECIES, a, i); 1187 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1188 1189 // accumulate results, so JIT can't eliminate relevant computations 1190 m = m.and(av.compare(VectorOperators.GE, bv)); 1191 } 1192 } 1193 1194 return m; 1195 } 1196 1197 @Benchmark 1198 public void blend(Blackhole bh) { 1199 int[] a = fa.apply(SPECIES.length()); 1200 int[] b = fb.apply(SPECIES.length()); 1201 int[] r = fr.apply(SPECIES.length()); 1202 boolean[] mask = fm.apply(SPECIES.length()); 1203 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1204 1205 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1206 for (int i = 0; i < a.length; i += SPECIES.length()) { 1207 IntVector av = IntVector.fromArray(SPECIES, a, i); 1208 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1209 av.blend(bv, vmask).intoArray(r, i); 1210 } 1211 } 1212 1213 bh.consume(r); 1214 } 1215 1216 @Benchmark 1217 public void rearrange(Blackhole bh) { 1218 int[] a = fa.apply(SPECIES.length()); 1219 int[] order = fs.apply(a.length, SPECIES.length()); 1220 int[] r = fr.apply(SPECIES.length()); 1221 1222 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1223 for (int i = 0; i < a.length; i += SPECIES.length()) { 1224 IntVector av = IntVector.fromArray(SPECIES, a, i); 1225 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i); 1226 } 1227 } 1228 1229 bh.consume(r); 1230 } 1231 1232 @Benchmark 1233 public void extract(Blackhole bh) { 1234 int[] a = fa.apply(SPECIES.length()); 1235 int[] r = fr.apply(SPECIES.length()); 1236 1237 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1238 for (int i = 0; i < a.length; i += SPECIES.length()) { 1239 IntVector av = IntVector.fromArray(SPECIES, a, i); 1240 int num_lanes = SPECIES.length(); 1241 // Manually unroll because full unroll happens after intrinsification. 1242 // Unroll is needed because get intrinsic requires for index to be a known constant. 1243 if (num_lanes == 1) { 1244 r[i]=av.lane(0); 1245 } else if (num_lanes == 2) { 1246 r[i]=av.lane(0); 1247 r[i+1]=av.lane(1); 1248 } else if (num_lanes == 4) { 1249 r[i]=av.lane(0); 1250 r[i+1]=av.lane(1); 1251 r[i+2]=av.lane(2); 1252 r[i+3]=av.lane(3); 1253 } else if (num_lanes == 8) { 1254 r[i]=av.lane(0); 1255 r[i+1]=av.lane(1); 1256 r[i+2]=av.lane(2); 1257 r[i+3]=av.lane(3); 1258 r[i+4]=av.lane(4); 1259 r[i+5]=av.lane(5); 1260 r[i+6]=av.lane(6); 1261 r[i+7]=av.lane(7); 1262 } else if (num_lanes == 16) { 1263 r[i]=av.lane(0); 1264 r[i+1]=av.lane(1); 1265 r[i+2]=av.lane(2); 1266 r[i+3]=av.lane(3); 1267 r[i+4]=av.lane(4); 1268 r[i+5]=av.lane(5); 1269 r[i+6]=av.lane(6); 1270 r[i+7]=av.lane(7); 1271 r[i+8]=av.lane(8); 1272 r[i+9]=av.lane(9); 1273 r[i+10]=av.lane(10); 1274 r[i+11]=av.lane(11); 1275 r[i+12]=av.lane(12); 1276 r[i+13]=av.lane(13); 1277 r[i+14]=av.lane(14); 1278 r[i+15]=av.lane(15); 1279 } else if (num_lanes == 32) { 1280 r[i]=av.lane(0); 1281 r[i+1]=av.lane(1); 1282 r[i+2]=av.lane(2); 1283 r[i+3]=av.lane(3); 1284 r[i+4]=av.lane(4); 1285 r[i+5]=av.lane(5); 1286 r[i+6]=av.lane(6); 1287 r[i+7]=av.lane(7); 1288 r[i+8]=av.lane(8); 1289 r[i+9]=av.lane(9); 1290 r[i+10]=av.lane(10); 1291 r[i+11]=av.lane(11); 1292 r[i+12]=av.lane(12); 1293 r[i+13]=av.lane(13); 1294 r[i+14]=av.lane(14); 1295 r[i+15]=av.lane(15); 1296 r[i+16]=av.lane(16); 1297 r[i+17]=av.lane(17); 1298 r[i+18]=av.lane(18); 1299 r[i+19]=av.lane(19); 1300 r[i+20]=av.lane(20); 1301 r[i+21]=av.lane(21); 1302 r[i+22]=av.lane(22); 1303 r[i+23]=av.lane(23); 1304 r[i+24]=av.lane(24); 1305 r[i+25]=av.lane(25); 1306 r[i+26]=av.lane(26); 1307 r[i+27]=av.lane(27); 1308 r[i+28]=av.lane(28); 1309 r[i+29]=av.lane(29); 1310 r[i+30]=av.lane(30); 1311 r[i+31]=av.lane(31); 1312 } else if (num_lanes == 64) { 1313 r[i]=av.lane(0); 1314 r[i+1]=av.lane(1); 1315 r[i+2]=av.lane(2); 1316 r[i+3]=av.lane(3); 1317 r[i+4]=av.lane(4); 1318 r[i+5]=av.lane(5); 1319 r[i+6]=av.lane(6); 1320 r[i+7]=av.lane(7); 1321 r[i+8]=av.lane(8); 1322 r[i+9]=av.lane(9); 1323 r[i+10]=av.lane(10); 1324 r[i+11]=av.lane(11); 1325 r[i+12]=av.lane(12); 1326 r[i+13]=av.lane(13); 1327 r[i+14]=av.lane(14); 1328 r[i+15]=av.lane(15); 1329 r[i+16]=av.lane(16); 1330 r[i+17]=av.lane(17); 1331 r[i+18]=av.lane(18); 1332 r[i+19]=av.lane(19); 1333 r[i+20]=av.lane(20); 1334 r[i+21]=av.lane(21); 1335 r[i+22]=av.lane(22); 1336 r[i+23]=av.lane(23); 1337 r[i+24]=av.lane(24); 1338 r[i+25]=av.lane(25); 1339 r[i+26]=av.lane(26); 1340 r[i+27]=av.lane(27); 1341 r[i+28]=av.lane(28); 1342 r[i+29]=av.lane(29); 1343 r[i+30]=av.lane(30); 1344 r[i+31]=av.lane(31); 1345 r[i+32]=av.lane(32); 1346 r[i+33]=av.lane(33); 1347 r[i+34]=av.lane(34); 1348 r[i+35]=av.lane(35); 1349 r[i+36]=av.lane(36); 1350 r[i+37]=av.lane(37); 1351 r[i+38]=av.lane(38); 1352 r[i+39]=av.lane(39); 1353 r[i+40]=av.lane(40); 1354 r[i+41]=av.lane(41); 1355 r[i+42]=av.lane(42); 1356 r[i+43]=av.lane(43); 1357 r[i+44]=av.lane(44); 1358 r[i+45]=av.lane(45); 1359 r[i+46]=av.lane(46); 1360 r[i+47]=av.lane(47); 1361 r[i+48]=av.lane(48); 1362 r[i+49]=av.lane(49); 1363 r[i+50]=av.lane(50); 1364 r[i+51]=av.lane(51); 1365 r[i+52]=av.lane(52); 1366 r[i+53]=av.lane(53); 1367 r[i+54]=av.lane(54); 1368 r[i+55]=av.lane(55); 1369 r[i+56]=av.lane(56); 1370 r[i+57]=av.lane(57); 1371 r[i+58]=av.lane(58); 1372 r[i+59]=av.lane(59); 1373 r[i+60]=av.lane(60); 1374 r[i+61]=av.lane(61); 1375 r[i+62]=av.lane(62); 1376 r[i+63]=av.lane(63); 1377 } else { 1378 for (int j = 0; j < SPECIES.length(); j++) { 1379 r[i+j]=av.lane(j); 1380 } 1381 } 1382 } 1383 } 1384 1385 bh.consume(r); 1386 } 1387 1388 @Benchmark 1389 public void broadcast(Blackhole bh) { 1390 int[] a = fa.apply(SPECIES.length()); 1391 int[] r = new int[a.length]; 1392 1393 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1394 for (int i = 0; i < a.length; i += SPECIES.length()) { 1395 IntVector.broadcast(SPECIES, a[i]).intoArray(r, i); 1396 } 1397 } 1398 1399 bh.consume(r); 1400 } 1401 1402 @Benchmark 1403 public void zero(Blackhole bh) { 1404 int[] a = fa.apply(SPECIES.length()); 1405 int[] r = new int[a.length]; 1406 1407 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1408 for (int i = 0; i < a.length; i += SPECIES.length()) { 1409 IntVector.zero(SPECIES).intoArray(a, i); 1410 } 1411 } 1412 1413 bh.consume(r); 1414 } 1415 1416 @Benchmark 1417 public void sliceUnary(Blackhole bh) { 1418 int[] a = fa.apply(SPECIES.length()); 1419 int[] r = new int[a.length]; 1420 int origin = (new java.util.Random()).nextInt(SPECIES.length()); 1421 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1422 for (int i = 0; i < a.length; i += SPECIES.length()) { 1423 IntVector av = IntVector.fromArray(SPECIES, a, i); 1424 av.slice(origin).intoArray(r, i); 1425 } 1426 } 1427 1428 bh.consume(r); 1429 } 1430 1431 @Benchmark 1432 public void sliceBinary(Blackhole bh) { 1433 int[] a = fa.apply(SPECIES.length()); 1434 int[] b = fb.apply(SPECIES.length()); 1435 int[] r = new int[a.length]; 1436 int origin = (new java.util.Random()).nextInt(SPECIES.length()); 1437 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1438 for (int i = 0; i < a.length; i += SPECIES.length()) { 1439 IntVector av = IntVector.fromArray(SPECIES, a, i); 1440 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1441 av.slice(origin, bv).intoArray(r, i); 1442 } 1443 } 1444 1445 bh.consume(r); 1446 } 1447 1448 @Benchmark 1449 public void sliceMasked(Blackhole bh) { 1450 int[] a = fa.apply(SPECIES.length()); 1451 int[] b = fb.apply(SPECIES.length()); 1452 boolean[] mask = fm.apply(SPECIES.length()); 1453 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1454 1455 int[] r = new int[a.length]; 1456 int origin = (new java.util.Random()).nextInt(SPECIES.length()); 1457 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1458 for (int i = 0; i < a.length; i += SPECIES.length()) { 1459 IntVector av = IntVector.fromArray(SPECIES, a, i); 1460 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1461 av.slice(origin, bv, vmask).intoArray(r, i); 1462 } 1463 } 1464 1465 bh.consume(r); 1466 } 1467 1468 @Benchmark 1469 public void unsliceUnary(Blackhole bh) { 1470 int[] a = fa.apply(SPECIES.length()); 1471 int[] r = new int[a.length]; 1472 int origin = (new java.util.Random()).nextInt(SPECIES.length()); 1473 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1474 for (int i = 0; i < a.length; i += SPECIES.length()) { 1475 IntVector av = IntVector.fromArray(SPECIES, a, i); 1476 av.unslice(origin).intoArray(r, i); 1477 } 1478 } 1479 1480 bh.consume(r); 1481 } 1482 1483 @Benchmark 1484 public void unsliceBinary(Blackhole bh) { 1485 int[] a = fa.apply(SPECIES.length()); 1486 int[] b = fb.apply(SPECIES.length()); 1487 int[] r = new int[a.length]; 1488 int origin = (new java.util.Random()).nextInt(SPECIES.length()); 1489 int part = (new java.util.Random()).nextInt(2); 1490 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1491 for (int i = 0; i < a.length; i += SPECIES.length()) { 1492 IntVector av = IntVector.fromArray(SPECIES, a, i); 1493 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1494 av.unslice(origin, bv, part).intoArray(r, i); 1495 } 1496 } 1497 1498 bh.consume(r); 1499 } 1500 1501 @Benchmark 1502 public void unsliceMasked(Blackhole bh) { 1503 int[] a = fa.apply(SPECIES.length()); 1504 int[] b = fb.apply(SPECIES.length()); 1505 boolean[] mask = fm.apply(SPECIES.length()); 1506 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1507 int[] r = new int[a.length]; 1508 int origin = (new java.util.Random()).nextInt(SPECIES.length()); 1509 int part = (new java.util.Random()).nextInt(2); 1510 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1511 for (int i = 0; i < a.length; i += SPECIES.length()) { 1512 IntVector av = IntVector.fromArray(SPECIES, a, i); 1513 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1514 av.unslice(origin, bv, part, vmask).intoArray(r, i); 1515 } 1516 } 1517 1518 bh.consume(r); 1519 } 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 @Benchmark 1543 public void BITWISE_BLEND(Blackhole bh) { 1544 int[] a = fa.apply(SPECIES.length()); 1545 int[] b = fb.apply(SPECIES.length()); 1546 int[] c = fc.apply(SPECIES.length()); 1547 int[] r = fr.apply(SPECIES.length()); 1548 1549 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1550 for (int i = 0; i < a.length; i += SPECIES.length()) { 1551 IntVector av = IntVector.fromArray(SPECIES, a, i); 1552 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1553 IntVector cv = IntVector.fromArray(SPECIES, c, i); 1554 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i); 1555 } 1556 } 1557 1558 bh.consume(r); 1559 } 1560 1561 1562 1563 @Benchmark 1564 public void BITWISE_BLENDMasked(Blackhole bh) { 1565 int[] a = fa.apply(SPECIES.length()); 1566 int[] b = fb.apply(SPECIES.length()); 1567 int[] c = fc.apply(SPECIES.length()); 1568 int[] r = fr.apply(SPECIES.length()); 1569 boolean[] mask = fm.apply(SPECIES.length()); 1570 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1571 1572 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1573 for (int i = 0; i < a.length; i += SPECIES.length()) { 1574 IntVector av = IntVector.fromArray(SPECIES, a, i); 1575 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1576 IntVector cv = IntVector.fromArray(SPECIES, c, i); 1577 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i); 1578 } 1579 } 1580 1581 bh.consume(r); 1582 } 1583 1584 1585 @Benchmark 1586 public void NEG(Blackhole bh) { 1587 int[] a = fa.apply(SPECIES.length()); 1588 int[] r = fr.apply(SPECIES.length()); 1589 1590 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1591 for (int i = 0; i < a.length; i += SPECIES.length()) { 1592 IntVector av = IntVector.fromArray(SPECIES, a, i); 1593 av.lanewise(VectorOperators.NEG).intoArray(r, i); 1594 } 1595 } 1596 1597 bh.consume(r); 1598 } 1599 1600 @Benchmark 1601 public void NEGMasked(Blackhole bh) { 1602 int[] a = fa.apply(SPECIES.length()); 1603 int[] r = fr.apply(SPECIES.length()); 1604 boolean[] mask = fm.apply(SPECIES.length()); 1605 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1606 1607 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1608 for (int i = 0; i < a.length; i += SPECIES.length()) { 1609 IntVector av = IntVector.fromArray(SPECIES, a, i); 1610 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i); 1611 } 1612 } 1613 1614 bh.consume(r); 1615 } 1616 1617 @Benchmark 1618 public void ABS(Blackhole bh) { 1619 int[] a = fa.apply(SPECIES.length()); 1620 int[] r = fr.apply(SPECIES.length()); 1621 1622 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1623 for (int i = 0; i < a.length; i += SPECIES.length()) { 1624 IntVector av = IntVector.fromArray(SPECIES, a, i); 1625 av.lanewise(VectorOperators.ABS).intoArray(r, i); 1626 } 1627 } 1628 1629 bh.consume(r); 1630 } 1631 1632 @Benchmark 1633 public void ABSMasked(Blackhole bh) { 1634 int[] a = fa.apply(SPECIES.length()); 1635 int[] r = fr.apply(SPECIES.length()); 1636 boolean[] mask = fm.apply(SPECIES.length()); 1637 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1638 1639 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1640 for (int i = 0; i < a.length; i += SPECIES.length()) { 1641 IntVector av = IntVector.fromArray(SPECIES, a, i); 1642 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i); 1643 } 1644 } 1645 1646 bh.consume(r); 1647 } 1648 1649 1650 @Benchmark 1651 public void NOT(Blackhole bh) { 1652 int[] a = fa.apply(SPECIES.length()); 1653 int[] r = fr.apply(SPECIES.length()); 1654 1655 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1656 for (int i = 0; i < a.length; i += SPECIES.length()) { 1657 IntVector av = IntVector.fromArray(SPECIES, a, i); 1658 av.lanewise(VectorOperators.NOT).intoArray(r, i); 1659 } 1660 } 1661 1662 bh.consume(r); 1663 } 1664 1665 1666 1667 @Benchmark 1668 public void NOTMasked(Blackhole bh) { 1669 int[] a = fa.apply(SPECIES.length()); 1670 int[] r = fr.apply(SPECIES.length()); 1671 boolean[] mask = fm.apply(SPECIES.length()); 1672 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1673 1674 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1675 for (int i = 0; i < a.length; i += SPECIES.length()) { 1676 IntVector av = IntVector.fromArray(SPECIES, a, i); 1677 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i); 1678 } 1679 } 1680 1681 bh.consume(r); 1682 } 1683 1684 1685 1686 @Benchmark 1687 public void ZOMO(Blackhole bh) { 1688 int[] a = fa.apply(SPECIES.length()); 1689 int[] r = fr.apply(SPECIES.length()); 1690 1691 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1692 for (int i = 0; i < a.length; i += SPECIES.length()) { 1693 IntVector av = IntVector.fromArray(SPECIES, a, i); 1694 av.lanewise(VectorOperators.ZOMO).intoArray(r, i); 1695 } 1696 } 1697 1698 bh.consume(r); 1699 } 1700 1701 1702 1703 @Benchmark 1704 public void ZOMOMasked(Blackhole bh) { 1705 int[] a = fa.apply(SPECIES.length()); 1706 int[] r = fr.apply(SPECIES.length()); 1707 boolean[] mask = fm.apply(SPECIES.length()); 1708 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1709 1710 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1711 for (int i = 0; i < a.length; i += SPECIES.length()) { 1712 IntVector av = IntVector.fromArray(SPECIES, a, i); 1713 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i); 1714 } 1715 } 1716 1717 bh.consume(r); 1718 } 1719 1720 1721 1722 1723 @Benchmark 1724 public void gather(Blackhole bh) { 1725 int[] a = fa.apply(SPECIES.length()); 1726 int[] b = fs.apply(a.length, SPECIES.length()); 1727 int[] r = new int[a.length]; 1728 1729 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1730 for (int i = 0; i < a.length; i += SPECIES.length()) { 1731 IntVector av = IntVector.fromArray(SPECIES, a, i, b, i); 1732 av.intoArray(r, i); 1733 } 1734 } 1735 1736 bh.consume(r); 1737 } 1738 1739 @Benchmark 1740 public void gatherMasked(Blackhole bh) { 1741 int[] a = fa.apply(SPECIES.length()); 1742 int[] b = fs.apply(a.length, SPECIES.length()); 1743 int[] r = new int[a.length]; 1744 boolean[] mask = fm.apply(SPECIES.length()); 1745 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1746 1747 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1748 for (int i = 0; i < a.length; i += SPECIES.length()) { 1749 IntVector av = IntVector.fromArray(SPECIES, a, i, b, i, vmask); 1750 av.intoArray(r, i); 1751 } 1752 } 1753 1754 bh.consume(r); 1755 } 1756 1757 @Benchmark 1758 public void scatter(Blackhole bh) { 1759 int[] a = fa.apply(SPECIES.length()); 1760 int[] b = fs.apply(a.length, SPECIES.length()); 1761 int[] r = new int[a.length]; 1762 1763 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1764 for (int i = 0; i < a.length; i += SPECIES.length()) { 1765 IntVector av = IntVector.fromArray(SPECIES, a, i); 1766 av.intoArray(r, i, b, i); 1767 } 1768 } 1769 1770 bh.consume(r); 1771 } 1772 1773 @Benchmark 1774 public void scatterMasked(Blackhole bh) { 1775 int[] a = fa.apply(SPECIES.length()); 1776 int[] b = fs.apply(a.length, SPECIES.length()); 1777 int[] r = fb.apply(SPECIES.length()); 1778 boolean[] mask = fm.apply(SPECIES.length()); 1779 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1780 1781 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1782 for (int i = 0; i < a.length; i += SPECIES.length()) { 1783 IntVector av = IntVector.fromArray(SPECIES, a, i); 1784 av.intoArray(r, i, b, i, vmask); 1785 } 1786 } 1787 1788 bh.consume(r); 1789 } 1790 } 1791