224 225 interface FBinMaskOp { 226 byte apply(byte a, byte b, boolean m); 227 228 static FBinMaskOp lift(FBinOp f) { 229 return (a, b, m) -> m ? f.apply(a, b) : a; 230 } 231 } 232 233 static void assertArraysEquals(byte[] a, byte[] b, byte[] r, FBinOp f) { 234 int i = 0; 235 try { 236 for (; i < a.length; i++) { 237 Assert.assertEquals(r[i], f.apply(a[i], b[i])); 238 } 239 } catch (AssertionError e) { 240 Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i); 241 } 242 } 243 244 static void assertArraysEquals(byte[] a, byte[] b, byte[] r, boolean[] mask, FBinOp f) { 245 assertArraysEquals(a, b, r, mask, FBinMaskOp.lift(f)); 246 } 247 248 static void assertArraysEquals(byte[] a, byte[] b, byte[] r, boolean[] mask, FBinMaskOp f) { 249 int i = 0; 250 try { 251 for (; i < a.length; i++) { 252 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()])); 253 } 254 } catch (AssertionError err) { 255 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", mask = " + mask[i % SPECIES.length()]); 256 } 257 } 258 259 static void assertShiftArraysEquals(byte[] a, byte[] b, byte[] r, FBinOp f) { 260 int i = 0; 261 int j = 0; 262 try { 263 for (; j < a.length; j += SPECIES.length()) { 264 for (i = 0; i < SPECIES.length(); i++) { 265 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j])); 266 } 267 } 268 } catch (AssertionError e) { 269 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j); 270 } 271 } 272 273 static void assertShiftArraysEquals(byte[] a, byte[] b, byte[] r, boolean[] mask, FBinOp f) { 274 assertShiftArraysEquals(a, b, r, mask, FBinMaskOp.lift(f)); 275 } 276 277 static void assertShiftArraysEquals(byte[] a, byte[] b, byte[] r, boolean[] mask, FBinMaskOp f) { 278 int i = 0; 1352 static byte OR(byte a, byte b) { 1353 return (byte)(a | b); 1354 } 1355 1356 @Test(dataProvider = "byteBinaryOpProvider") 1357 static void ORByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 1358 byte[] a = fa.apply(SPECIES.length()); 1359 byte[] b = fb.apply(SPECIES.length()); 1360 byte[] r = fr.apply(SPECIES.length()); 1361 1362 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1363 for (int i = 0; i < a.length; i += SPECIES.length()) { 1364 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1365 ByteVector bv = ByteVector.fromArray(SPECIES, b, i); 1366 av.lanewise(VectorOperators.OR, bv).intoArray(r, i); 1367 } 1368 } 1369 1370 assertArraysEquals(a, b, r, Byte256VectorTests::OR); 1371 } 1372 1373 1374 1375 @Test(dataProvider = "byteBinaryOpMaskProvider") 1376 static void ORByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb, 1377 IntFunction<boolean[]> fm) { 1378 byte[] a = fa.apply(SPECIES.length()); 1379 byte[] b = fb.apply(SPECIES.length()); 1380 byte[] r = fr.apply(SPECIES.length()); 1381 boolean[] mask = fm.apply(SPECIES.length()); 1382 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1383 1384 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1385 for (int i = 0; i < a.length; i += SPECIES.length()) { 1386 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1387 ByteVector bv = ByteVector.fromArray(SPECIES, b, i); 1388 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i); 1389 } 1390 } 1391 1420 static void XORByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb, 1421 IntFunction<boolean[]> fm) { 1422 byte[] a = fa.apply(SPECIES.length()); 1423 byte[] b = fb.apply(SPECIES.length()); 1424 byte[] r = fr.apply(SPECIES.length()); 1425 boolean[] mask = fm.apply(SPECIES.length()); 1426 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1427 1428 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1429 for (int i = 0; i < a.length; i += SPECIES.length()) { 1430 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1431 ByteVector bv = ByteVector.fromArray(SPECIES, b, i); 1432 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i); 1433 } 1434 } 1435 1436 assertArraysEquals(a, b, r, mask, Byte256VectorTests::XOR); 1437 } 1438 1439 1440 1441 1442 static byte LSHL(byte a, byte b) { 1443 return (byte)((a << (b & 0x7))); 1444 } 1445 1446 @Test(dataProvider = "byteBinaryOpProvider") 1447 static void LSHLByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 1448 byte[] a = fa.apply(SPECIES.length()); 1449 byte[] b = fb.apply(SPECIES.length()); 1450 byte[] r = fr.apply(SPECIES.length()); 1451 1452 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1453 for (int i = 0; i < a.length; i += SPECIES.length()) { 1454 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1455 ByteVector bv = ByteVector.fromArray(SPECIES, b, i); 1456 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i); 1457 } 1458 } 1459 1782 return (byte)(Math.max(a, b)); 1783 } 1784 1785 @Test(dataProvider = "byteBinaryOpProvider") 1786 static void maxByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 1787 byte[] a = fa.apply(SPECIES.length()); 1788 byte[] b = fb.apply(SPECIES.length()); 1789 byte[] r = fr.apply(SPECIES.length()); 1790 1791 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1792 for (int i = 0; i < a.length; i += SPECIES.length()) { 1793 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1794 ByteVector bv = ByteVector.fromArray(SPECIES, b, i); 1795 av.max(bv).intoArray(r, i); 1796 } 1797 } 1798 1799 assertArraysEquals(a, b, r, Byte256VectorTests::max); 1800 } 1801 1802 static byte AND(byte[] a, int idx) { 1803 byte res = -1; 1804 for (int i = idx; i < (idx + SPECIES.length()); i++) { 1805 res &= a[i]; 1806 } 1807 1808 return res; 1809 } 1810 1811 static byte AND(byte[] a) { 1812 byte res = -1; 1813 for (int i = 0; i < a.length; i += SPECIES.length()) { 1814 byte tmp = -1; 1815 for (int j = 0; j < SPECIES.length(); j++) { 1816 tmp &= a[i + j]; 1817 } 1818 res &= tmp; 1819 } 1820 1821 return res; 3226 boolean[] mask = fm.apply(SPECIES.length()); 3227 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3228 3229 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3230 for (int i = 0; i < a.length; i += SPECIES.length()) { 3231 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 3232 ByteVector bv = ByteVector.fromArray(SPECIES, b, i); 3233 ByteVector cv = ByteVector.fromArray(SPECIES, c, i); 3234 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i); 3235 } 3236 } 3237 3238 assertArraysEquals(a, b, c, r, mask, Byte256VectorTests::BITWISE_BLEND); 3239 } 3240 3241 3242 static byte NEG(byte a) { 3243 return (byte)(-((byte)a)); 3244 } 3245 3246 @Test(dataProvider = "byteUnaryOpProvider") 3247 static void NEGByte256VectorTests(IntFunction<byte[]> fa) { 3248 byte[] a = fa.apply(SPECIES.length()); 3249 byte[] r = fr.apply(SPECIES.length()); 3250 3251 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3252 for (int i = 0; i < a.length; i += SPECIES.length()) { 3253 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 3254 av.lanewise(VectorOperators.NEG).intoArray(r, i); 3255 } 3256 } 3257 3258 assertArraysEquals(a, r, Byte256VectorTests::NEG); 3259 } 3260 3261 @Test(dataProvider = "byteUnaryOpMaskProvider") 3262 static void NEGMaskedByte256VectorTests(IntFunction<byte[]> fa, 3263 IntFunction<boolean[]> fm) { 3264 byte[] a = fa.apply(SPECIES.length()); 3265 byte[] r = fr.apply(SPECIES.length()); 3266 boolean[] mask = fm.apply(SPECIES.length()); 3267 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3268 3269 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3270 for (int i = 0; i < a.length; i += SPECIES.length()) { 3271 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 3272 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i); 3273 } 3274 } 3275 3276 assertArraysEquals(a, r, mask, Byte256VectorTests::NEG); 3277 } 3278 3279 static byte ABS(byte a) { 3280 return (byte)(Math.abs((byte)a)); 3320 byte[] a = fa.apply(SPECIES.length()); 3321 byte[] r = fr.apply(SPECIES.length()); 3322 boolean[] mask = fm.apply(SPECIES.length()); 3323 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3324 3325 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3326 for (int i = 0; i < a.length; i += SPECIES.length()) { 3327 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 3328 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i); 3329 } 3330 } 3331 3332 assertArraysEquals(a, r, mask, Byte256VectorTests::ABS); 3333 } 3334 3335 3336 static byte NOT(byte a) { 3337 return (byte)(~((byte)a)); 3338 } 3339 3340 3341 3342 @Test(dataProvider = "byteUnaryOpProvider") 3343 static void NOTByte256VectorTests(IntFunction<byte[]> fa) { 3344 byte[] a = fa.apply(SPECIES.length()); 3345 byte[] r = fr.apply(SPECIES.length()); 3346 3347 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3348 for (int i = 0; i < a.length; i += SPECIES.length()) { 3349 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 3350 av.lanewise(VectorOperators.NOT).intoArray(r, i); 3351 } 3352 } 3353 3354 assertArraysEquals(a, r, Byte256VectorTests::NOT); 3355 } 3356 3357 3358 3359 @Test(dataProvider = "byteUnaryOpMaskProvider") 3360 static void NOTMaskedByte256VectorTests(IntFunction<byte[]> fa, 3361 IntFunction<boolean[]> fm) { 3362 byte[] a = fa.apply(SPECIES.length()); 3363 byte[] r = fr.apply(SPECIES.length()); 3364 boolean[] mask = fm.apply(SPECIES.length()); 3365 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3366 3367 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3368 for (int i = 0; i < a.length; i += SPECIES.length()) { 3369 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 3370 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i); 3371 } 3372 } 3373 3374 assertArraysEquals(a, r, mask, Byte256VectorTests::NOT); | 224 225 interface FBinMaskOp { 226 byte apply(byte a, byte b, boolean m); 227 228 static FBinMaskOp lift(FBinOp f) { 229 return (a, b, m) -> m ? f.apply(a, b) : a; 230 } 231 } 232 233 static void assertArraysEquals(byte[] a, byte[] b, byte[] r, FBinOp f) { 234 int i = 0; 235 try { 236 for (; i < a.length; i++) { 237 Assert.assertEquals(r[i], f.apply(a[i], b[i])); 238 } 239 } catch (AssertionError e) { 240 Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i); 241 } 242 } 243 244 static void assertBroadcastArraysEquals(byte[] a, byte[] b, byte[] r, FBinOp f) { 245 int i = 0; 246 try { 247 for (; i < a.length; i++) { 248 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()])); 249 } 250 } catch (AssertionError e) { 251 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]), 252 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i); 253 } 254 } 255 256 static void assertArraysEquals(byte[] a, byte[] b, byte[] r, boolean[] mask, FBinOp f) { 257 assertArraysEquals(a, b, r, mask, FBinMaskOp.lift(f)); 258 } 259 260 static void assertArraysEquals(byte[] a, byte[] b, byte[] r, boolean[] mask, FBinMaskOp f) { 261 int i = 0; 262 try { 263 for (; i < a.length; i++) { 264 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()])); 265 } 266 } catch (AssertionError err) { 267 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", mask = " + mask[i % SPECIES.length()]); 268 } 269 } 270 271 static void assertBroadcastArraysEquals(byte[] a, byte[] b, byte[] r, boolean[] mask, FBinOp f) { 272 assertBroadcastArraysEquals(a, b, r, mask, FBinMaskOp.lift(f)); 273 } 274 275 static void assertBroadcastArraysEquals(byte[] a, byte[] b, byte[] r, boolean[] mask, FBinMaskOp f) { 276 int i = 0; 277 try { 278 for (; i < a.length; i++) { 279 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()])); 280 } 281 } catch (AssertionError err) { 282 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], 283 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + 284 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " + 285 mask[i % SPECIES.length()]); 286 } 287 } 288 289 static void assertShiftArraysEquals(byte[] a, byte[] b, byte[] r, FBinOp f) { 290 int i = 0; 291 int j = 0; 292 try { 293 for (; j < a.length; j += SPECIES.length()) { 294 for (i = 0; i < SPECIES.length(); i++) { 295 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j])); 296 } 297 } 298 } catch (AssertionError e) { 299 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j); 300 } 301 } 302 303 static void assertShiftArraysEquals(byte[] a, byte[] b, byte[] r, boolean[] mask, FBinOp f) { 304 assertShiftArraysEquals(a, b, r, mask, FBinMaskOp.lift(f)); 305 } 306 307 static void assertShiftArraysEquals(byte[] a, byte[] b, byte[] r, boolean[] mask, FBinMaskOp f) { 308 int i = 0; 1382 static byte OR(byte a, byte b) { 1383 return (byte)(a | b); 1384 } 1385 1386 @Test(dataProvider = "byteBinaryOpProvider") 1387 static void ORByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 1388 byte[] a = fa.apply(SPECIES.length()); 1389 byte[] b = fb.apply(SPECIES.length()); 1390 byte[] r = fr.apply(SPECIES.length()); 1391 1392 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1393 for (int i = 0; i < a.length; i += SPECIES.length()) { 1394 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1395 ByteVector bv = ByteVector.fromArray(SPECIES, b, i); 1396 av.lanewise(VectorOperators.OR, bv).intoArray(r, i); 1397 } 1398 } 1399 1400 assertArraysEquals(a, b, r, Byte256VectorTests::OR); 1401 } 1402 static byte or(byte a, byte b) { 1403 return (byte)(a | b); 1404 } 1405 1406 @Test(dataProvider = "byteBinaryOpProvider") 1407 static void orByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 1408 byte[] a = fa.apply(SPECIES.length()); 1409 byte[] b = fb.apply(SPECIES.length()); 1410 byte[] r = fr.apply(SPECIES.length()); 1411 1412 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1413 for (int i = 0; i < a.length; i += SPECIES.length()) { 1414 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1415 ByteVector bv = ByteVector.fromArray(SPECIES, b, i); 1416 av.or(bv).intoArray(r, i); 1417 } 1418 } 1419 1420 assertArraysEquals(a, b, r, Byte256VectorTests::or); 1421 } 1422 1423 1424 1425 @Test(dataProvider = "byteBinaryOpMaskProvider") 1426 static void ORByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb, 1427 IntFunction<boolean[]> fm) { 1428 byte[] a = fa.apply(SPECIES.length()); 1429 byte[] b = fb.apply(SPECIES.length()); 1430 byte[] r = fr.apply(SPECIES.length()); 1431 boolean[] mask = fm.apply(SPECIES.length()); 1432 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1433 1434 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1435 for (int i = 0; i < a.length; i += SPECIES.length()) { 1436 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1437 ByteVector bv = ByteVector.fromArray(SPECIES, b, i); 1438 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i); 1439 } 1440 } 1441 1470 static void XORByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb, 1471 IntFunction<boolean[]> fm) { 1472 byte[] a = fa.apply(SPECIES.length()); 1473 byte[] b = fb.apply(SPECIES.length()); 1474 byte[] r = fr.apply(SPECIES.length()); 1475 boolean[] mask = fm.apply(SPECIES.length()); 1476 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1477 1478 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1479 for (int i = 0; i < a.length; i += SPECIES.length()) { 1480 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1481 ByteVector bv = ByteVector.fromArray(SPECIES, b, i); 1482 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i); 1483 } 1484 } 1485 1486 assertArraysEquals(a, b, r, mask, Byte256VectorTests::XOR); 1487 } 1488 1489 1490 @Test(dataProvider = "byteBinaryOpProvider") 1491 static void addByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 1492 byte[] a = fa.apply(SPECIES.length()); 1493 byte[] b = fb.apply(SPECIES.length()); 1494 byte[] r = fr.apply(SPECIES.length()); 1495 1496 for (int i = 0; i < a.length; i += SPECIES.length()) { 1497 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1498 av.add(b[i]).intoArray(r, i); 1499 } 1500 1501 assertBroadcastArraysEquals(a, b, r, Byte256VectorTests::add); 1502 } 1503 1504 @Test(dataProvider = "byteBinaryOpMaskProvider") 1505 static void addByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, 1506 IntFunction<boolean[]> fm) { 1507 byte[] a = fa.apply(SPECIES.length()); 1508 byte[] b = fb.apply(SPECIES.length()); 1509 byte[] r = fr.apply(SPECIES.length()); 1510 boolean[] mask = fm.apply(SPECIES.length()); 1511 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1512 1513 for (int i = 0; i < a.length; i += SPECIES.length()) { 1514 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1515 av.add(b[i], vmask).intoArray(r, i); 1516 } 1517 1518 assertBroadcastArraysEquals(a, b, r, mask, Byte256VectorTests::add); 1519 } 1520 1521 @Test(dataProvider = "byteBinaryOpProvider") 1522 static void subByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 1523 byte[] a = fa.apply(SPECIES.length()); 1524 byte[] b = fb.apply(SPECIES.length()); 1525 byte[] r = fr.apply(SPECIES.length()); 1526 1527 for (int i = 0; i < a.length; i += SPECIES.length()) { 1528 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1529 av.sub(b[i]).intoArray(r, i); 1530 } 1531 1532 assertBroadcastArraysEquals(a, b, r, Byte256VectorTests::sub); 1533 } 1534 1535 @Test(dataProvider = "byteBinaryOpMaskProvider") 1536 static void subByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, 1537 IntFunction<boolean[]> fm) { 1538 byte[] a = fa.apply(SPECIES.length()); 1539 byte[] b = fb.apply(SPECIES.length()); 1540 byte[] r = fr.apply(SPECIES.length()); 1541 boolean[] mask = fm.apply(SPECIES.length()); 1542 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1543 1544 for (int i = 0; i < a.length; i += SPECIES.length()) { 1545 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1546 av.sub(b[i], vmask).intoArray(r, i); 1547 } 1548 1549 assertBroadcastArraysEquals(a, b, r, mask, Byte256VectorTests::sub); 1550 } 1551 1552 @Test(dataProvider = "byteBinaryOpProvider") 1553 static void mulByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 1554 byte[] a = fa.apply(SPECIES.length()); 1555 byte[] b = fb.apply(SPECIES.length()); 1556 byte[] r = fr.apply(SPECIES.length()); 1557 1558 for (int i = 0; i < a.length; i += SPECIES.length()) { 1559 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1560 av.mul(b[i]).intoArray(r, i); 1561 } 1562 1563 assertBroadcastArraysEquals(a, b, r, Byte256VectorTests::mul); 1564 } 1565 1566 @Test(dataProvider = "byteBinaryOpMaskProvider") 1567 static void mulByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, 1568 IntFunction<boolean[]> fm) { 1569 byte[] a = fa.apply(SPECIES.length()); 1570 byte[] b = fb.apply(SPECIES.length()); 1571 byte[] r = fr.apply(SPECIES.length()); 1572 boolean[] mask = fm.apply(SPECIES.length()); 1573 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1574 1575 for (int i = 0; i < a.length; i += SPECIES.length()) { 1576 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1577 av.mul(b[i], vmask).intoArray(r, i); 1578 } 1579 1580 assertBroadcastArraysEquals(a, b, r, mask, Byte256VectorTests::mul); 1581 } 1582 1583 1584 1585 1586 @Test(dataProvider = "byteBinaryOpProvider") 1587 static void divByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 1588 byte[] a = fa.apply(SPECIES.length()); 1589 byte[] b = fb.apply(SPECIES.length()); 1590 byte[] r = fr.apply(SPECIES.length()); 1591 1592 replaceZero(b, (byte) 1); 1593 1594 for (int i = 0; i < a.length; i += SPECIES.length()) { 1595 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1596 av.div(b[i]).intoArray(r, i); 1597 } 1598 1599 assertBroadcastArraysEquals(a, b, r, Byte256VectorTests::div); 1600 } 1601 1602 1603 1604 @Test(dataProvider = "byteBinaryOpMaskProvider") 1605 static void divByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, 1606 IntFunction<boolean[]> fm) { 1607 byte[] a = fa.apply(SPECIES.length()); 1608 byte[] b = fb.apply(SPECIES.length()); 1609 byte[] r = fr.apply(SPECIES.length()); 1610 boolean[] mask = fm.apply(SPECIES.length()); 1611 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1612 1613 replaceZero(b, (byte) 1); 1614 1615 for (int i = 0; i < a.length; i += SPECIES.length()) { 1616 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1617 av.div(b[i], vmask).intoArray(r, i); 1618 } 1619 1620 assertBroadcastArraysEquals(a, b, r, mask, Byte256VectorTests::div); 1621 } 1622 1623 1624 1625 @Test(dataProvider = "byteBinaryOpProvider") 1626 static void ORByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 1627 byte[] a = fa.apply(SPECIES.length()); 1628 byte[] b = fb.apply(SPECIES.length()); 1629 byte[] r = fr.apply(SPECIES.length()); 1630 1631 for (int i = 0; i < a.length; i += SPECIES.length()) { 1632 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1633 av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); 1634 } 1635 1636 assertBroadcastArraysEquals(a, b, r, Byte256VectorTests::OR); 1637 } 1638 1639 @Test(dataProvider = "byteBinaryOpProvider") 1640 static void orByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 1641 byte[] a = fa.apply(SPECIES.length()); 1642 byte[] b = fb.apply(SPECIES.length()); 1643 byte[] r = fr.apply(SPECIES.length()); 1644 1645 for (int i = 0; i < a.length; i += SPECIES.length()) { 1646 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1647 av.or(b[i]).intoArray(r, i); 1648 } 1649 1650 assertBroadcastArraysEquals(a, b, r, Byte256VectorTests::or); 1651 } 1652 1653 1654 1655 @Test(dataProvider = "byteBinaryOpMaskProvider") 1656 static void ORByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, 1657 IntFunction<boolean[]> fm) { 1658 byte[] a = fa.apply(SPECIES.length()); 1659 byte[] b = fb.apply(SPECIES.length()); 1660 byte[] r = fr.apply(SPECIES.length()); 1661 boolean[] mask = fm.apply(SPECIES.length()); 1662 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1663 1664 for (int i = 0; i < a.length; i += SPECIES.length()) { 1665 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1666 av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); 1667 } 1668 1669 assertBroadcastArraysEquals(a, b, r, mask, Byte256VectorTests::OR); 1670 } 1671 1672 1673 1674 1675 static byte LSHL(byte a, byte b) { 1676 return (byte)((a << (b & 0x7))); 1677 } 1678 1679 @Test(dataProvider = "byteBinaryOpProvider") 1680 static void LSHLByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 1681 byte[] a = fa.apply(SPECIES.length()); 1682 byte[] b = fb.apply(SPECIES.length()); 1683 byte[] r = fr.apply(SPECIES.length()); 1684 1685 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1686 for (int i = 0; i < a.length; i += SPECIES.length()) { 1687 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 1688 ByteVector bv = ByteVector.fromArray(SPECIES, b, i); 1689 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i); 1690 } 1691 } 1692 2015 return (byte)(Math.max(a, b)); 2016 } 2017 2018 @Test(dataProvider = "byteBinaryOpProvider") 2019 static void maxByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 2020 byte[] a = fa.apply(SPECIES.length()); 2021 byte[] b = fb.apply(SPECIES.length()); 2022 byte[] r = fr.apply(SPECIES.length()); 2023 2024 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2025 for (int i = 0; i < a.length; i += SPECIES.length()) { 2026 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 2027 ByteVector bv = ByteVector.fromArray(SPECIES, b, i); 2028 av.max(bv).intoArray(r, i); 2029 } 2030 } 2031 2032 assertArraysEquals(a, b, r, Byte256VectorTests::max); 2033 } 2034 2035 @Test(dataProvider = "byteBinaryOpProvider") 2036 static void MINByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 2037 byte[] a = fa.apply(SPECIES.length()); 2038 byte[] b = fb.apply(SPECIES.length()); 2039 byte[] r = fr.apply(SPECIES.length()); 2040 2041 for (int i = 0; i < a.length; i += SPECIES.length()) { 2042 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 2043 av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); 2044 } 2045 2046 assertBroadcastArraysEquals(a, b, r, Byte256VectorTests::MIN); 2047 } 2048 2049 @Test(dataProvider = "byteBinaryOpProvider") 2050 static void minByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 2051 byte[] a = fa.apply(SPECIES.length()); 2052 byte[] b = fb.apply(SPECIES.length()); 2053 byte[] r = fr.apply(SPECIES.length()); 2054 2055 for (int i = 0; i < a.length; i += SPECIES.length()) { 2056 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 2057 av.min(b[i]).intoArray(r, i); 2058 } 2059 2060 assertBroadcastArraysEquals(a, b, r, Byte256VectorTests::min); 2061 } 2062 2063 @Test(dataProvider = "byteBinaryOpProvider") 2064 static void MAXByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 2065 byte[] a = fa.apply(SPECIES.length()); 2066 byte[] b = fb.apply(SPECIES.length()); 2067 byte[] r = fr.apply(SPECIES.length()); 2068 2069 for (int i = 0; i < a.length; i += SPECIES.length()) { 2070 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 2071 av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); 2072 } 2073 2074 assertBroadcastArraysEquals(a, b, r, Byte256VectorTests::MAX); 2075 } 2076 2077 @Test(dataProvider = "byteBinaryOpProvider") 2078 static void maxByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) { 2079 byte[] a = fa.apply(SPECIES.length()); 2080 byte[] b = fb.apply(SPECIES.length()); 2081 byte[] r = fr.apply(SPECIES.length()); 2082 2083 for (int i = 0; i < a.length; i += SPECIES.length()) { 2084 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 2085 av.max(b[i]).intoArray(r, i); 2086 } 2087 2088 assertBroadcastArraysEquals(a, b, r, Byte256VectorTests::max); 2089 } 2090 2091 static byte AND(byte[] a, int idx) { 2092 byte res = -1; 2093 for (int i = idx; i < (idx + SPECIES.length()); i++) { 2094 res &= a[i]; 2095 } 2096 2097 return res; 2098 } 2099 2100 static byte AND(byte[] a) { 2101 byte res = -1; 2102 for (int i = 0; i < a.length; i += SPECIES.length()) { 2103 byte tmp = -1; 2104 for (int j = 0; j < SPECIES.length(); j++) { 2105 tmp &= a[i + j]; 2106 } 2107 res &= tmp; 2108 } 2109 2110 return res; 3515 boolean[] mask = fm.apply(SPECIES.length()); 3516 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3517 3518 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3519 for (int i = 0; i < a.length; i += SPECIES.length()) { 3520 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 3521 ByteVector bv = ByteVector.fromArray(SPECIES, b, i); 3522 ByteVector cv = ByteVector.fromArray(SPECIES, c, i); 3523 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i); 3524 } 3525 } 3526 3527 assertArraysEquals(a, b, c, r, mask, Byte256VectorTests::BITWISE_BLEND); 3528 } 3529 3530 3531 static byte NEG(byte a) { 3532 return (byte)(-((byte)a)); 3533 } 3534 3535 static byte neg(byte a) { 3536 return (byte)(-((byte)a)); 3537 } 3538 3539 @Test(dataProvider = "byteUnaryOpProvider") 3540 static void NEGByte256VectorTests(IntFunction<byte[]> fa) { 3541 byte[] a = fa.apply(SPECIES.length()); 3542 byte[] r = fr.apply(SPECIES.length()); 3543 3544 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3545 for (int i = 0; i < a.length; i += SPECIES.length()) { 3546 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 3547 av.lanewise(VectorOperators.NEG).intoArray(r, i); 3548 } 3549 } 3550 3551 assertArraysEquals(a, r, Byte256VectorTests::NEG); 3552 } 3553 3554 @Test(dataProvider = "byteUnaryOpProvider") 3555 static void negByte256VectorTests(IntFunction<byte[]> fa) { 3556 byte[] a = fa.apply(SPECIES.length()); 3557 byte[] r = fr.apply(SPECIES.length()); 3558 3559 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3560 for (int i = 0; i < a.length; i += SPECIES.length()) { 3561 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 3562 av.neg().intoArray(r, i); 3563 } 3564 } 3565 3566 assertArraysEquals(a, r, Byte256VectorTests::neg); 3567 } 3568 3569 @Test(dataProvider = "byteUnaryOpMaskProvider") 3570 static void NEGMaskedByte256VectorTests(IntFunction<byte[]> fa, 3571 IntFunction<boolean[]> fm) { 3572 byte[] a = fa.apply(SPECIES.length()); 3573 byte[] r = fr.apply(SPECIES.length()); 3574 boolean[] mask = fm.apply(SPECIES.length()); 3575 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3576 3577 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3578 for (int i = 0; i < a.length; i += SPECIES.length()) { 3579 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 3580 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i); 3581 } 3582 } 3583 3584 assertArraysEquals(a, r, mask, Byte256VectorTests::NEG); 3585 } 3586 3587 static byte ABS(byte a) { 3588 return (byte)(Math.abs((byte)a)); 3628 byte[] a = fa.apply(SPECIES.length()); 3629 byte[] r = fr.apply(SPECIES.length()); 3630 boolean[] mask = fm.apply(SPECIES.length()); 3631 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3632 3633 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3634 for (int i = 0; i < a.length; i += SPECIES.length()) { 3635 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 3636 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i); 3637 } 3638 } 3639 3640 assertArraysEquals(a, r, mask, Byte256VectorTests::ABS); 3641 } 3642 3643 3644 static byte NOT(byte a) { 3645 return (byte)(~((byte)a)); 3646 } 3647 3648 static byte not(byte a) { 3649 return (byte)(~((byte)a)); 3650 } 3651 3652 3653 3654 @Test(dataProvider = "byteUnaryOpProvider") 3655 static void NOTByte256VectorTests(IntFunction<byte[]> fa) { 3656 byte[] a = fa.apply(SPECIES.length()); 3657 byte[] r = fr.apply(SPECIES.length()); 3658 3659 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3660 for (int i = 0; i < a.length; i += SPECIES.length()) { 3661 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 3662 av.lanewise(VectorOperators.NOT).intoArray(r, i); 3663 } 3664 } 3665 3666 assertArraysEquals(a, r, Byte256VectorTests::NOT); 3667 } 3668 3669 @Test(dataProvider = "byteUnaryOpProvider") 3670 static void notByte256VectorTests(IntFunction<byte[]> fa) { 3671 byte[] a = fa.apply(SPECIES.length()); 3672 byte[] r = fr.apply(SPECIES.length()); 3673 3674 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3675 for (int i = 0; i < a.length; i += SPECIES.length()) { 3676 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 3677 av.not().intoArray(r, i); 3678 } 3679 } 3680 3681 assertArraysEquals(a, r, Byte256VectorTests::not); 3682 } 3683 3684 3685 3686 @Test(dataProvider = "byteUnaryOpMaskProvider") 3687 static void NOTMaskedByte256VectorTests(IntFunction<byte[]> fa, 3688 IntFunction<boolean[]> fm) { 3689 byte[] a = fa.apply(SPECIES.length()); 3690 byte[] r = fr.apply(SPECIES.length()); 3691 boolean[] mask = fm.apply(SPECIES.length()); 3692 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3693 3694 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3695 for (int i = 0; i < a.length; i += SPECIES.length()) { 3696 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 3697 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i); 3698 } 3699 } 3700 3701 assertArraysEquals(a, r, mask, Byte256VectorTests::NOT); |