1 /* 2 * Copyright (c) 2017, 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. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have 23 * questions. 24 */ 25 package jdk.incubator.vector; 26 27 import java.nio.ByteBuffer; 28 import java.util.Arrays; 29 import java.util.Objects; 30 import jdk.internal.vm.annotation.ForceInline; 31 import static jdk.incubator.vector.VectorIntrinsics.*; 32 33 @SuppressWarnings("cast") 34 final class Long64Vector extends LongVector<Shapes.S64Bit> { 35 static final Long64Species SPECIES = new Long64Species(); 36 37 static final Long64Vector ZERO = new Long64Vector(); 38 39 static final int LENGTH = SPECIES.length(); 40 41 private final long[] vec; // Don't access directly, use getElements() instead. 42 43 private long[] getElements() { 44 return VectorIntrinsics.maybeRebox(this).vec; 45 } 46 47 Long64Vector() { 48 vec = new long[SPECIES.length()]; 49 } 50 51 Long64Vector(long[] v) { 52 vec = v; 53 } 54 55 @Override 56 public int length() { return LENGTH; } 57 58 // Unary operator 59 60 @Override 61 Long64Vector uOp(FUnOp f) { 62 long[] vec = getElements(); 63 long[] res = new long[length()]; 64 for (int i = 0; i < length(); i++) { 65 res[i] = f.apply(i, vec[i]); 66 } 67 return new Long64Vector(res); 68 } 69 70 @Override 71 Long64Vector uOp(Mask<Long, Shapes.S64Bit> o, FUnOp f) { 72 long[] vec = getElements(); 73 long[] res = new long[length()]; 74 boolean[] mbits = ((Long64Mask)o).getBits(); 75 for (int i = 0; i < length(); i++) { 76 res[i] = mbits[i] ? f.apply(i, vec[i]) : vec[i]; 77 } 78 return new Long64Vector(res); 79 } 80 81 // Binary operator 82 83 @Override 84 Long64Vector bOp(Vector<Long, Shapes.S64Bit> o, FBinOp f) { 85 long[] res = new long[length()]; 86 long[] vec1 = this.getElements(); 87 long[] vec2 = ((Long64Vector)o).getElements(); 88 for (int i = 0; i < length(); i++) { 89 res[i] = f.apply(i, vec1[i], vec2[i]); 90 } 91 return new Long64Vector(res); 92 } 93 94 @Override 95 Long64Vector bOp(Vector<Long, Shapes.S64Bit> o1, Mask<Long, Shapes.S64Bit> o2, FBinOp f) { 96 long[] res = new long[length()]; 97 long[] vec1 = this.getElements(); 98 long[] vec2 = ((Long64Vector)o1).getElements(); 99 boolean[] mbits = ((Long64Mask)o2).getBits(); 100 for (int i = 0; i < length(); i++) { 101 res[i] = mbits[i] ? f.apply(i, vec1[i], vec2[i]) : vec1[i]; 102 } 103 return new Long64Vector(res); 104 } 105 106 // Trinary operator 107 108 @Override 109 Long64Vector tOp(Vector<Long, Shapes.S64Bit> o1, Vector<Long, Shapes.S64Bit> o2, FTriOp f) { 110 long[] res = new long[length()]; 111 long[] vec1 = this.getElements(); 112 long[] vec2 = ((Long64Vector)o1).getElements(); 113 long[] vec3 = ((Long64Vector)o2).getElements(); 114 for (int i = 0; i < length(); i++) { 115 res[i] = f.apply(i, vec1[i], vec2[i], vec3[i]); 116 } 117 return new Long64Vector(res); 118 } 119 120 @Override 121 Long64Vector tOp(Vector<Long, Shapes.S64Bit> o1, Vector<Long, Shapes.S64Bit> o2, Mask<Long, Shapes.S64Bit> o3, FTriOp f) { 122 long[] res = new long[length()]; 123 long[] vec1 = getElements(); 124 long[] vec2 = ((Long64Vector)o1).getElements(); 125 long[] vec3 = ((Long64Vector)o2).getElements(); 126 boolean[] mbits = ((Long64Mask)o3).getBits(); 127 for (int i = 0; i < length(); i++) { 128 res[i] = mbits[i] ? f.apply(i, vec1[i], vec2[i], vec3[i]) : vec1[i]; 129 } 130 return new Long64Vector(res); 131 } 132 133 @Override 134 long rOp(long v, FBinOp f) { 135 long[] vec = getElements(); 136 for (int i = 0; i < length(); i++) { 137 v = f.apply(i, v, vec[i]); 138 } 139 return v; 140 } 141 142 // Binary operations with scalars 143 144 @Override 145 @ForceInline 146 public LongVector<Shapes.S64Bit> add(long o) { 147 return add(SPECIES.broadcast(o)); 148 } 149 150 @Override 151 @ForceInline 152 public LongVector<Shapes.S64Bit> add(long o, Mask<Long,Shapes.S64Bit> m) { 153 return add(SPECIES.broadcast(o), m); 154 } 155 156 @Override 157 @ForceInline 158 public LongVector<Shapes.S64Bit> addSaturate(long o) { 159 return addSaturate(SPECIES.broadcast(o)); 160 } 161 162 @Override 163 @ForceInline 164 public LongVector<Shapes.S64Bit> addSaturate(long o, Mask<Long,Shapes.S64Bit> m) { 165 return addSaturate(SPECIES.broadcast(o), m); 166 } 167 168 @Override 169 @ForceInline 170 public LongVector<Shapes.S64Bit> sub(long o) { 171 return sub(SPECIES.broadcast(o)); 172 } 173 174 @Override 175 @ForceInline 176 public LongVector<Shapes.S64Bit> sub(long o, Mask<Long,Shapes.S64Bit> m) { 177 return sub(SPECIES.broadcast(o), m); 178 } 179 180 @Override 181 @ForceInline 182 public LongVector<Shapes.S64Bit> subSaturate(long o) { 183 return subSaturate(SPECIES.broadcast(o)); 184 } 185 186 @Override 187 @ForceInline 188 public LongVector<Shapes.S64Bit> subSaturate(long o, Mask<Long,Shapes.S64Bit> m) { 189 return subSaturate(SPECIES.broadcast(o), m); 190 } 191 192 @Override 193 @ForceInline 194 public LongVector<Shapes.S64Bit> mul(long o) { 195 return mul(SPECIES.broadcast(o)); 196 } 197 198 @Override 199 @ForceInline 200 public LongVector<Shapes.S64Bit> mul(long o, Mask<Long,Shapes.S64Bit> m) { 201 return mul(SPECIES.broadcast(o), m); 202 } 203 204 @Override 205 @ForceInline 206 public LongVector<Shapes.S64Bit> min(long o) { 207 return min(SPECIES.broadcast(o)); 208 } 209 210 @Override 211 @ForceInline 212 public LongVector<Shapes.S64Bit> max(long o) { 213 return max(SPECIES.broadcast(o)); 214 } 215 216 @Override 217 @ForceInline 218 public Mask<Long, Shapes.S64Bit> equal(long o) { 219 return equal(SPECIES.broadcast(o)); 220 } 221 222 @Override 223 @ForceInline 224 public Mask<Long, Shapes.S64Bit> notEqual(long o) { 225 return notEqual(SPECIES.broadcast(o)); 226 } 227 228 @Override 229 @ForceInline 230 public Mask<Long, Shapes.S64Bit> lessThan(long o) { 231 return lessThan(SPECIES.broadcast(o)); 232 } 233 234 @Override 235 @ForceInline 236 public Mask<Long, Shapes.S64Bit> lessThanEq(long o) { 237 return lessThanEq(SPECIES.broadcast(o)); 238 } 239 240 @Override 241 @ForceInline 242 public Mask<Long, Shapes.S64Bit> greaterThan(long o) { 243 return greaterThan(SPECIES.broadcast(o)); 244 } 245 246 @Override 247 @ForceInline 248 public Mask<Long, Shapes.S64Bit> greaterThanEq(long o) { 249 return greaterThanEq(SPECIES.broadcast(o)); 250 } 251 252 @Override 253 @ForceInline 254 public LongVector<Shapes.S64Bit> blend(long o, Mask<Long,Shapes.S64Bit> m) { 255 return blend(SPECIES.broadcast(o), m); 256 } 257 258 259 @Override 260 @ForceInline 261 public LongVector<Shapes.S64Bit> and(long o) { 262 return and(SPECIES.broadcast(o)); 263 } 264 265 @Override 266 @ForceInline 267 public LongVector<Shapes.S64Bit> and(long o, Mask<Long,Shapes.S64Bit> m) { 268 return and(SPECIES.broadcast(o), m); 269 } 270 271 @Override 272 @ForceInline 273 public LongVector<Shapes.S64Bit> or(long o) { 274 return or(SPECIES.broadcast(o)); 275 } 276 277 @Override 278 @ForceInline 279 public LongVector<Shapes.S64Bit> or(long o, Mask<Long,Shapes.S64Bit> m) { 280 return or(SPECIES.broadcast(o), m); 281 } 282 283 @Override 284 @ForceInline 285 public LongVector<Shapes.S64Bit> xor(long o) { 286 return xor(SPECIES.broadcast(o)); 287 } 288 289 @Override 290 @ForceInline 291 public LongVector<Shapes.S64Bit> xor(long o, Mask<Long,Shapes.S64Bit> m) { 292 return xor(SPECIES.broadcast(o), m); 293 } 294 295 296 // Unary operations 297 298 299 300 @Override 301 @ForceInline 302 public Long64Vector not() { 303 return (Long64Vector) VectorIntrinsics.unaryOp( 304 VECTOR_OP_NOT, Long64Vector.class, long.class, LENGTH, 305 this, 306 v1 -> ((Long64Vector)v1).uOp((i, a) -> (long) ~a)); 307 } 308 // Binary operations 309 310 @Override 311 @ForceInline 312 public Long64Vector add(Vector<Long,Shapes.S64Bit> o) { 313 Objects.requireNonNull(o); 314 Long64Vector v = (Long64Vector)o; 315 return (Long64Vector) VectorIntrinsics.binaryOp( 316 VECTOR_OP_ADD, Long64Vector.class, long.class, LENGTH, 317 this, v, 318 (v1, v2) -> ((Long64Vector)v1).bOp(v2, (i, a, b) -> (long)(a + b))); 319 } 320 321 @Override 322 @ForceInline 323 public Long64Vector sub(Vector<Long,Shapes.S64Bit> o) { 324 Objects.requireNonNull(o); 325 Long64Vector v = (Long64Vector)o; 326 return (Long64Vector) VectorIntrinsics.binaryOp( 327 VECTOR_OP_SUB, Long64Vector.class, long.class, LENGTH, 328 this, v, 329 (v1, v2) -> ((Long64Vector)v1).bOp(v2, (i, a, b) -> (long)(a - b))); 330 } 331 332 @Override 333 @ForceInline 334 public Long64Vector mul(Vector<Long,Shapes.S64Bit> o) { 335 Objects.requireNonNull(o); 336 Long64Vector v = (Long64Vector)o; 337 return (Long64Vector) VectorIntrinsics.binaryOp( 338 VECTOR_OP_MUL, Long64Vector.class, long.class, LENGTH, 339 this, v, 340 (v1, v2) -> ((Long64Vector)v1).bOp(v2, (i, a, b) -> (long)(a * b))); 341 } 342 343 344 345 @Override 346 @ForceInline 347 public Long64Vector and(Vector<Long,Shapes.S64Bit> o) { 348 Objects.requireNonNull(o); 349 Long64Vector v = (Long64Vector)o; 350 return (Long64Vector) VectorIntrinsics.binaryOp( 351 VECTOR_OP_AND, Long64Vector.class, long.class, LENGTH, 352 this, v, 353 (v1, v2) -> ((Long64Vector)v1).bOp(v2, (i, a, b) -> (long)(a & b))); 354 } 355 356 @Override 357 @ForceInline 358 public Long64Vector or(Vector<Long,Shapes.S64Bit> o) { 359 Objects.requireNonNull(o); 360 Long64Vector v = (Long64Vector)o; 361 return (Long64Vector) VectorIntrinsics.binaryOp( 362 VECTOR_OP_OR, Long64Vector.class, long.class, LENGTH, 363 this, v, 364 (v1, v2) -> ((Long64Vector)v1).bOp(v2, (i, a, b) -> (long)(a | b))); 365 } 366 367 @Override 368 @ForceInline 369 public Long64Vector xor(Vector<Long,Shapes.S64Bit> o) { 370 Objects.requireNonNull(o); 371 Long64Vector v = (Long64Vector)o; 372 return (Long64Vector) VectorIntrinsics.binaryOp( 373 VECTOR_OP_XOR, Long64Vector.class, long.class, LENGTH, 374 this, v, 375 (v1, v2) -> ((Long64Vector)v1).bOp(v2, (i, a, b) -> (long)(a ^ b))); 376 } 377 378 @Override 379 @ForceInline 380 public Long64Vector and(Vector<Long,Shapes.S64Bit> v, Mask<Long, Shapes.S64Bit> m) { 381 return blend(and(v), m); 382 } 383 384 @Override 385 @ForceInline 386 public Long64Vector or(Vector<Long,Shapes.S64Bit> v, Mask<Long, Shapes.S64Bit> m) { 387 return blend(or(v), m); 388 } 389 390 @Override 391 @ForceInline 392 public Long64Vector xor(Vector<Long,Shapes.S64Bit> v, Mask<Long, Shapes.S64Bit> m) { 393 return blend(xor(v), m); 394 } 395 396 @Override 397 @ForceInline 398 public Long64Vector shiftL(int s) { 399 return (Long64Vector) VectorIntrinsics.broadcastInt( 400 VECTOR_OP_LSHIFT, Long64Vector.class, long.class, LENGTH, 401 this, s, 402 (v, i) -> v.uOp((__, a) -> (long) (a << i))); 403 } 404 405 @Override 406 @ForceInline 407 public Long64Vector shiftR(int s) { 408 return (Long64Vector) VectorIntrinsics.broadcastInt( 409 VECTOR_OP_URSHIFT, Long64Vector.class, long.class, LENGTH, 410 this, s, 411 (v, i) -> v.uOp((__, a) -> (long) (a >>> i))); 412 } 413 414 @Override 415 @ForceInline 416 public Long64Vector aShiftR(int s) { 417 return (Long64Vector) VectorIntrinsics.broadcastInt( 418 VECTOR_OP_RSHIFT, Long64Vector.class, long.class, LENGTH, 419 this, s, 420 (v, i) -> v.uOp((__, a) -> (long) (a >> i))); 421 } 422 423 // Ternary operations 424 425 426 // Type specific horizontal reductions 427 428 @Override 429 @ForceInline 430 public long addAll() { 431 return (long) VectorIntrinsics.reductionCoerced( 432 VECTOR_OP_ADD, Long64Vector.class, long.class, LENGTH, 433 this, 434 v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a + b))); 435 } 436 437 @Override 438 @ForceInline 439 public long andAll() { 440 return (long) VectorIntrinsics.reductionCoerced( 441 VECTOR_OP_AND, Long64Vector.class, long.class, LENGTH, 442 this, 443 v -> (long) v.rOp((long) -1, (i, a, b) -> (long) (a & b))); 444 } 445 446 @Override 447 @ForceInline 448 public long mulAll() { 449 return (long) VectorIntrinsics.reductionCoerced( 450 VECTOR_OP_MUL, Long64Vector.class, long.class, LENGTH, 451 this, 452 v -> (long) v.rOp((long) 1, (i, a, b) -> (long) (a * b))); 453 } 454 455 @Override 456 @ForceInline 457 public long orAll() { 458 return (long) VectorIntrinsics.reductionCoerced( 459 VECTOR_OP_OR, Long64Vector.class, long.class, LENGTH, 460 this, 461 v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a | b))); 462 } 463 464 @Override 465 @ForceInline 466 public long xorAll() { 467 return (long) VectorIntrinsics.reductionCoerced( 468 VECTOR_OP_XOR, Long64Vector.class, long.class, LENGTH, 469 this, 470 v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a ^ b))); 471 } 472 473 @Override 474 @ForceInline 475 public long subAll() { 476 return (long) VectorIntrinsics.reductionCoerced( 477 VECTOR_OP_SUB, Long64Vector.class, long.class, LENGTH, 478 this, 479 v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a - b))); 480 } 481 482 // Memory operations 483 484 @Override 485 @ForceInline 486 public void intoArray(long[] a, int ix) { 487 Objects.requireNonNull(a); 488 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH); 489 VectorIntrinsics.store(Long64Vector.class, long.class, LENGTH, 490 a, ix, this, 491 (arr, idx, v) -> v.forEach((i, a_) -> ((long[])arr)[idx + i] = a_)); 492 } 493 494 @Override 495 @ForceInline 496 public void intoArray(long[] a, int ax, Mask<Long, Shapes.S64Bit> m) { 497 // TODO: use better default impl: forEach(m, (i, a_) -> a[ax + i] = a_); 498 Long64Vector oldVal = SPECIES.fromArray(a, ax); 499 Long64Vector newVal = oldVal.blend(this, m); 500 newVal.intoArray(a, ax); 501 } 502 503 // 504 505 @Override 506 public String toString() { 507 return Arrays.toString(getElements()); 508 } 509 510 @Override 511 public boolean equals(Object o) { 512 if (this == o) return true; 513 if (o == null || this.getClass() != o.getClass()) return false; 514 515 Long64Vector that = (Long64Vector) o; 516 return Arrays.equals(this.getElements(), that.getElements()); 517 } 518 519 @Override 520 public int hashCode() { 521 return Arrays.hashCode(vec); 522 } 523 524 // Binary test 525 526 @Override 527 Long64Mask bTest(Vector<Long, Shapes.S64Bit> o, FBinTest f) { 528 long[] vec1 = getElements(); 529 long[] vec2 = ((Long64Vector)o).getElements(); 530 boolean[] bits = new boolean[length()]; 531 for (int i = 0; i < length(); i++){ 532 bits[i] = f.apply(i, vec1[i], vec2[i]); 533 } 534 return new Long64Mask(bits); 535 } 536 537 // Comparisons 538 539 @Override 540 @ForceInline 541 public Long64Mask equal(Vector<Long, Shapes.S64Bit> o) { 542 Objects.requireNonNull(o); 543 Long64Vector v = (Long64Vector)o; 544 545 return (Long64Mask) VectorIntrinsics.compare( 546 BT_eq, Long64Vector.class, Long64Mask.class, long.class, LENGTH, 547 this, v, 548 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a == b)); 549 } 550 551 @Override 552 @ForceInline 553 public Long64Mask notEqual(Vector<Long, Shapes.S64Bit> o) { 554 Objects.requireNonNull(o); 555 Long64Vector v = (Long64Vector)o; 556 557 return (Long64Mask) VectorIntrinsics.compare( 558 BT_ne, Long64Vector.class, Long64Mask.class, long.class, LENGTH, 559 this, v, 560 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a != b)); 561 } 562 563 @Override 564 @ForceInline 565 public Long64Mask lessThan(Vector<Long, Shapes.S64Bit> o) { 566 Objects.requireNonNull(o); 567 Long64Vector v = (Long64Vector)o; 568 569 return (Long64Mask) VectorIntrinsics.compare( 570 BT_lt, Long64Vector.class, Long64Mask.class, long.class, LENGTH, 571 this, v, 572 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a < b)); 573 } 574 575 @Override 576 @ForceInline 577 public Long64Mask lessThanEq(Vector<Long, Shapes.S64Bit> o) { 578 Objects.requireNonNull(o); 579 Long64Vector v = (Long64Vector)o; 580 581 return (Long64Mask) VectorIntrinsics.compare( 582 BT_le, Long64Vector.class, Long64Mask.class, long.class, LENGTH, 583 this, v, 584 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a <= b)); 585 } 586 587 @Override 588 @ForceInline 589 public Long64Mask greaterThan(Vector<Long, Shapes.S64Bit> o) { 590 Objects.requireNonNull(o); 591 Long64Vector v = (Long64Vector)o; 592 593 return (Long64Mask) VectorIntrinsics.compare( 594 BT_gt, Long64Vector.class, Long64Mask.class, long.class, LENGTH, 595 this, v, 596 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a > b)); 597 } 598 599 @Override 600 @ForceInline 601 public Long64Mask greaterThanEq(Vector<Long, Shapes.S64Bit> o) { 602 Objects.requireNonNull(o); 603 Long64Vector v = (Long64Vector)o; 604 605 return (Long64Mask) VectorIntrinsics.compare( 606 BT_ge, Long64Vector.class, Long64Mask.class, long.class, LENGTH, 607 this, v, 608 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a >= b)); 609 } 610 611 // Foreach 612 613 @Override 614 void forEach(FUnCon f) { 615 long[] vec = getElements(); 616 for (int i = 0; i < length(); i++) { 617 f.apply(i, vec[i]); 618 } 619 } 620 621 @Override 622 void forEach(Mask<Long, Shapes.S64Bit> o, FUnCon f) { 623 boolean[] mbits = ((Long64Mask)o).getBits(); 624 forEach((i, a) -> { 625 if (mbits[i]) { f.apply(i, a); } 626 }); 627 } 628 629 630 Double64Vector toFP() { 631 long[] vec = getElements(); 632 double[] res = new double[this.species().length()]; 633 for(int i = 0; i < this.species().length(); i++){ 634 res[i] = Double.longBitsToDouble(vec[i]); 635 } 636 return new Double64Vector(res); 637 } 638 639 @Override 640 public Long64Vector rotateEL(int j) { 641 long[] vec = getElements(); 642 long[] res = new long[length()]; 643 for (int i = 0; i < length(); i++){ 644 res[(j + i) % length()] = vec[i]; 645 } 646 return new Long64Vector(res); 647 } 648 649 @Override 650 public Long64Vector rotateER(int j) { 651 long[] vec = getElements(); 652 long[] res = new long[length()]; 653 for (int i = 0; i < length(); i++){ 654 int z = i - j; 655 if(j < 0) { 656 res[length() + z] = vec[i]; 657 } else { 658 res[z] = vec[i]; 659 } 660 } 661 return new Long64Vector(res); 662 } 663 664 @Override 665 public Long64Vector shiftEL(int j) { 666 long[] vec = getElements(); 667 long[] res = new long[length()]; 668 for (int i = 0; i < length() - j; i++) { 669 res[i] = vec[i + j]; 670 } 671 return new Long64Vector(res); 672 } 673 674 @Override 675 public Long64Vector shiftER(int j) { 676 long[] vec = getElements(); 677 long[] res = new long[length()]; 678 for (int i = 0; i < length() - j; i++){ 679 res[i + j] = vec[i]; 680 } 681 return new Long64Vector(res); 682 } 683 684 @Override 685 public Long64Vector shuffle(Vector<Long, Shapes.S64Bit> o, Shuffle<Long, Shapes.S64Bit> s) { 686 Long64Vector v = (Long64Vector) o; 687 return uOp((i, a) -> { 688 long[] vec = this.getElements(); 689 int e = s.getElement(i); 690 if(e >= 0 && e < length()) { 691 //from this 692 return vec[e]; 693 } else if(e < length() * 2) { 694 //from o 695 return v.getElements()[e - length()]; 696 } else { 697 throw new ArrayIndexOutOfBoundsException("Bad reordering for shuffle"); 698 } 699 }); 700 } 701 702 @Override 703 public Long64Vector swizzle(Shuffle<Long, Shapes.S64Bit> s) { 704 return uOp((i, a) -> { 705 long[] vec = this.getElements(); 706 int e = s.getElement(i); 707 if(e >= 0 && e < length()) { 708 return vec[e]; 709 } else { 710 throw new ArrayIndexOutOfBoundsException("Bad reordering for shuffle"); 711 } 712 }); 713 } 714 715 @Override 716 @ForceInline 717 public Long64Vector blend(Vector<Long, Shapes.S64Bit> o1, Mask<Long, Shapes.S64Bit> o2) { 718 Objects.requireNonNull(o1); 719 Objects.requireNonNull(o2); 720 Long64Vector v = (Long64Vector)o1; 721 Long64Mask m = (Long64Mask)o2; 722 723 return (Long64Vector) VectorIntrinsics.blend( 724 Long64Vector.class, Long64Mask.class, long.class, LENGTH, 725 this, v, m, 726 (v1, v2, m_) -> v1.bOp(v2, (i, a, b) -> m_.getElement(i) ? b : a)); 727 } 728 729 // Accessors 730 731 @Override 732 public long get(int i) { 733 long[] vec = getElements(); 734 return vec[i]; 735 } 736 737 @Override 738 public Long64Vector with(int i, long e) { 739 long[] res = vec.clone(); 740 res[i] = e; 741 return new Long64Vector(res); 742 } 743 744 // Mask 745 746 static final class Long64Mask extends AbstractMask<Long, Shapes.S64Bit> { 747 static final Long64Mask TRUE_MASK = new Long64Mask(true); 748 static final Long64Mask FALSE_MASK = new Long64Mask(false); 749 750 // FIXME: was temporarily put here to simplify rematerialization support in the JVM 751 private final boolean[] bits; // Don't access directly, use getBits() instead. 752 753 public Long64Mask(boolean[] bits) { 754 this(bits, 0); 755 } 756 757 public Long64Mask(boolean[] bits, int i) { 758 this.bits = Arrays.copyOfRange(bits, i, i + species().length()); 759 } 760 761 public Long64Mask(boolean val) { 762 boolean[] bits = new boolean[species().length()]; 763 Arrays.fill(bits, val); 764 this.bits = bits; 765 } 766 767 boolean[] getBits() { 768 return VectorIntrinsics.maybeRebox(this).bits; 769 } 770 771 @Override 772 Long64Mask uOp(MUnOp f) { 773 boolean[] res = new boolean[species().length()]; 774 boolean[] bits = getBits(); 775 for (int i = 0; i < species().length(); i++) { 776 res[i] = f.apply(i, bits[i]); 777 } 778 return new Long64Mask(res); 779 } 780 781 @Override 782 Long64Mask bOp(Mask<Long, Shapes.S64Bit> o, MBinOp f) { 783 boolean[] res = new boolean[species().length()]; 784 boolean[] bits = getBits(); 785 boolean[] mbits = ((Long64Mask)o).getBits(); 786 for (int i = 0; i < species().length(); i++) { 787 res[i] = f.apply(i, bits[i], mbits[i]); 788 } 789 return new Long64Mask(res); 790 } 791 792 @Override 793 public Long64Species species() { 794 return SPECIES; 795 } 796 797 @Override 798 public Long64Vector toVector() { 799 long[] res = new long[species().length()]; 800 boolean[] bits = getBits(); 801 for (int i = 0; i < species().length(); i++) { 802 res[i] = (long) (bits[i] ? -1 : 0); 803 } 804 return new Long64Vector(res); 805 } 806 807 @Override 808 @ForceInline 809 @SuppressWarnings("unchecked") 810 public <Z> Mask<Z, Shapes.S64Bit> rebracket(Species<Z, Shapes.S64Bit> species) { 811 Objects.requireNonNull(species); 812 // TODO: check proper element type 813 return VectorIntrinsics.reinterpret( 814 Long64Mask.class, long.class, LENGTH, 815 species.elementType(), species.length(), this, 816 (m, t) -> m.reshape(species) 817 ); 818 } 819 820 // Unary operations 821 822 //Mask<E, S> not(); 823 824 // Binary operations 825 826 @Override 827 @ForceInline 828 public Long64Mask and(Mask<Long,Shapes.S64Bit> o) { 829 Objects.requireNonNull(o); 830 Long64Mask m = (Long64Mask)o; 831 return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Long64Mask.class, long.class, LENGTH, 832 this, m, 833 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b)); 834 } 835 836 @Override 837 @ForceInline 838 public Long64Mask or(Mask<Long,Shapes.S64Bit> o) { 839 Objects.requireNonNull(o); 840 Long64Mask m = (Long64Mask)o; 841 return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Long64Mask.class, long.class, LENGTH, 842 this, m, 843 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a | b)); 844 } 845 846 // Reductions 847 848 @Override 849 @ForceInline 850 public boolean anyTrue() { 851 return VectorIntrinsics.test(COND_notZero, Long64Mask.class, long.class, LENGTH, 852 this, this, 853 (m1, m2) -> super.anyTrue()); 854 } 855 856 @Override 857 @ForceInline 858 public boolean allTrue() { 859 return VectorIntrinsics.test(COND_carrySet, Long64Mask.class, long.class, LENGTH, 860 this, species().maskAllTrue(), 861 (m1, m2) -> super.allTrue()); 862 } 863 } 864 865 // Shuffle 866 867 static final class Long64Shuffle extends AbstractShuffle<Long, Shapes.S64Bit> { 868 static final IntVector.IntSpecies<Shapes.S64Bit> INT_SPECIES = IntVector.speciesInstance(Shapes.S_64_BIT); 869 870 public Long64Shuffle(int[] reorder) { 871 super(reorder); 872 } 873 874 public Long64Shuffle(int[] reorder, int i) { 875 super(reorder, i); 876 } 877 878 @Override 879 public Long64Species species() { 880 return SPECIES; 881 } 882 883 @Override 884 public IntVector.IntSpecies<Shapes.S64Bit> intSpecies() { 885 return INT_SPECIES; 886 } 887 } 888 889 // Species 890 891 @Override 892 public Long64Species species() { 893 return SPECIES; 894 } 895 896 static final class Long64Species extends LongSpecies<Shapes.S64Bit> { 897 static final int BIT_SIZE = Shapes.S_64_BIT.bitSize(); 898 899 static final int LENGTH = BIT_SIZE / Long.SIZE; 900 901 @Override 902 public String toString() { 903 StringBuilder sb = new StringBuilder("Shape["); 904 sb.append(bitSize()).append(" bits, "); 905 sb.append(length()).append(" ").append(long.class.getSimpleName()).append("s x "); 906 sb.append(elementSize()).append(" bits"); 907 sb.append("]"); 908 return sb.toString(); 909 } 910 911 @Override 912 @ForceInline 913 public int bitSize() { 914 return BIT_SIZE; 915 } 916 917 @Override 918 @ForceInline 919 public int length() { 920 return LENGTH; 921 } 922 923 @Override 924 @ForceInline 925 public Class<Long> elementType() { 926 return long.class; 927 } 928 929 @Override 930 @ForceInline 931 public int elementSize() { 932 return Long.SIZE; 933 } 934 935 @Override 936 @ForceInline 937 public Shapes.S64Bit shape() { 938 return Shapes.S_64_BIT; 939 } 940 941 @Override 942 Long64Vector op(FOp f) { 943 long[] res = new long[length()]; 944 for (int i = 0; i < length(); i++) { 945 res[i] = f.apply(i); 946 } 947 return new Long64Vector(res); 948 } 949 950 @Override 951 Long64Vector op(Mask<Long, Shapes.S64Bit> o, FOp f) { 952 long[] res = new long[length()]; 953 boolean[] mbits = ((Long64Mask)o).getBits(); 954 for (int i = 0; i < length(); i++) { 955 if (mbits[i]) { 956 res[i] = f.apply(i); 957 } 958 } 959 return new Long64Vector(res); 960 } 961 962 // Factories 963 964 @Override 965 public Long64Mask maskFromValues(boolean... bits) { 966 return new Long64Mask(bits); 967 } 968 969 @Override 970 public Long64Mask maskFromArray(boolean[] bits, int i) { 971 return new Long64Mask(bits, i); 972 } 973 974 @Override 975 public Long64Shuffle shuffleFromValues(int... ixs) { 976 return new Long64Shuffle(ixs); 977 } 978 979 @Override 980 public Long64Shuffle shuffleFromArray(int[] ixs, int i) { 981 return new Long64Shuffle(ixs, i); 982 } 983 984 @Override 985 public Long64Shuffle shuffleFromVector(Vector<Integer, Shapes.S64Bit> v) { 986 int[] a = ((IntVector<Shapes.S64Bit>) v).toArray(); 987 return new Long64Shuffle(a, 0); 988 } 989 990 @Override 991 @ForceInline 992 public Long64Vector zero() { 993 return VectorIntrinsics.broadcastCoerced(Long64Vector.class, long.class, LENGTH, 994 0, 995 (z -> ZERO)); 996 } 997 998 @Override 999 @ForceInline 1000 public Long64Vector broadcast(long e) { 1001 return VectorIntrinsics.broadcastCoerced( 1002 Long64Vector.class, long.class, LENGTH, 1003 e, 1004 ((long bits) -> SPECIES.op(i -> (long)bits))); 1005 } 1006 1007 @Override 1008 @ForceInline 1009 public Long64Mask maskAllTrue() { 1010 return VectorIntrinsics.broadcastCoerced(Long64Mask.class, long.class, LENGTH, 1011 (long)-1, 1012 (z -> Long64Mask.TRUE_MASK)); 1013 } 1014 1015 @Override 1016 @ForceInline 1017 public Long64Mask maskAllFalse() { 1018 return VectorIntrinsics.broadcastCoerced(Long64Mask.class, long.class, LENGTH, 1019 0, 1020 (z -> Long64Mask.FALSE_MASK)); 1021 } 1022 1023 @Override 1024 @ForceInline 1025 public Long64Vector fromArray(long[] a, int ix) { 1026 Objects.requireNonNull(a); 1027 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH); 1028 return (Long64Vector) VectorIntrinsics.load(Long64Vector.class, long.class, LENGTH, 1029 a, ix, 1030 (arr, idx) -> super.fromArray((long[]) arr, idx)); 1031 } 1032 1033 @Override 1034 @ForceInline 1035 public Long64Vector fromArray(long[] a, int ax, Mask<Long, Shapes.S64Bit> m) { 1036 return zero().blend(fromArray(a, ax), m); // TODO: use better default impl: op(m, i -> a[ax + i]); 1037 } 1038 1039 @Override 1040 @ForceInline 1041 @SuppressWarnings("unchecked") 1042 public <F> Long64Vector rebracket(Vector<F, Shapes.S64Bit> o) { 1043 Objects.requireNonNull(o); 1044 if (o.elementType() == byte.class) { 1045 Byte64Vector so = (Byte64Vector)o; 1046 return VectorIntrinsics.reinterpret( 1047 Byte64Vector.class, byte.class, so.length(), 1048 long.class, LENGTH, so, 1049 (v, t) -> (Long64Vector)reshape(v) 1050 ); 1051 } else if (o.elementType() == short.class) { 1052 Short64Vector so = (Short64Vector)o; 1053 return VectorIntrinsics.reinterpret( 1054 Short64Vector.class, short.class, so.length(), 1055 long.class, LENGTH, so, 1056 (v, t) -> (Long64Vector)reshape(v) 1057 ); 1058 } else if (o.elementType() == int.class) { 1059 Int64Vector so = (Int64Vector)o; 1060 return VectorIntrinsics.reinterpret( 1061 Int64Vector.class, int.class, so.length(), 1062 long.class, LENGTH, so, 1063 (v, t) -> (Long64Vector)reshape(v) 1064 ); 1065 } else if (o.elementType() == long.class) { 1066 Long64Vector so = (Long64Vector)o; 1067 return VectorIntrinsics.reinterpret( 1068 Long64Vector.class, long.class, so.length(), 1069 long.class, LENGTH, so, 1070 (v, t) -> (Long64Vector)reshape(v) 1071 ); 1072 } else if (o.elementType() == float.class) { 1073 Float64Vector so = (Float64Vector)o; 1074 return VectorIntrinsics.reinterpret( 1075 Float64Vector.class, float.class, so.length(), 1076 long.class, LENGTH, so, 1077 (v, t) -> (Long64Vector)reshape(v) 1078 ); 1079 } else if (o.elementType() == double.class) { 1080 Double64Vector so = (Double64Vector)o; 1081 return VectorIntrinsics.reinterpret( 1082 Double64Vector.class, double.class, so.length(), 1083 long.class, LENGTH, so, 1084 (v, t) -> (Long64Vector)reshape(v) 1085 ); 1086 } else { 1087 throw new InternalError("Unimplemented size"); 1088 } 1089 } 1090 1091 @Override 1092 @ForceInline 1093 @SuppressWarnings("unchecked") 1094 public <T extends Shape> Long64Vector resize(Vector<Long, T> o) { 1095 Objects.requireNonNull(o); 1096 if (o.bitSize() == 64) { 1097 Long64Vector so = (Long64Vector)o; 1098 return VectorIntrinsics.reinterpret( 1099 Long64Vector.class, long.class, so.length(), 1100 long.class, LENGTH, so, 1101 (v, t) -> (Long64Vector)reshape(v) 1102 ); 1103 } else if (o.bitSize() == 128) { 1104 Long128Vector so = (Long128Vector)o; 1105 return VectorIntrinsics.reinterpret( 1106 Long128Vector.class, long.class, so.length(), 1107 long.class, LENGTH, so, 1108 (v, t) -> (Long64Vector)reshape(v) 1109 ); 1110 } else if (o.bitSize() == 256) { 1111 Long256Vector so = (Long256Vector)o; 1112 return VectorIntrinsics.reinterpret( 1113 Long256Vector.class, long.class, so.length(), 1114 long.class, LENGTH, so, 1115 (v, t) -> (Long64Vector)reshape(v) 1116 ); 1117 } else if (o.bitSize() == 512) { 1118 Long512Vector so = (Long512Vector)o; 1119 return VectorIntrinsics.reinterpret( 1120 Long512Vector.class, long.class, so.length(), 1121 long.class, LENGTH, so, 1122 (v, t) -> (Long64Vector)reshape(v) 1123 ); 1124 } else { 1125 throw new InternalError("Unimplemented size"); 1126 } 1127 } 1128 } 1129 }