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