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
21 * questions.
22 */
23
24 package benchmark.jdk.incubator.vector;
25
26 import jdk.incubator.vector.Vector;
27 import jdk.incubator.vector.Vector.Shape;
28 import jdk.incubator.vector.Vector.Species;
29 import jdk.incubator.vector.IntVector;
30
31 import java.util.concurrent.TimeUnit;
32 import java.util.function.BiFunction;
33 import java.util.function.IntFunction;
34
35 import org.openjdk.jmh.annotations.*;
36 import org.openjdk.jmh.infra.Blackhole;
37
38 @BenchmarkMode(Mode.Throughput)
39 @OutputTimeUnit(TimeUnit.MILLISECONDS)
40 @State(Scope.Benchmark)
41 @Warmup(iterations = 3, time = 1)
42 @Measurement(iterations = 5, time = 1)
43 @Fork(value = 1, jvmArgsPrepend = {"--add-modules=jdk.incubator.vector"})
44 public class IntMaxVector extends AbstractVectorBenchmark {
45 static final Species<Integer> SPECIES = IntVector.SPECIES_MAX;
46
47 static final int INVOC_COUNT = 1; // get rid of outer loop
48
49 @Param("1024")
50 int size;
51
52 int[] fill(IntFunction<Integer> f) {
53 int[] array = new int[size];
54 for (int i = 0; i < array.length; i++) {
55 array[i] = f.apply(i);
56 }
57 return array;
58 }
59
60 int[] a, b, c, r;
61 boolean[] m, rm;
62 int[] s;
63
64 @Setup
65 public void init() {
91 int[] b = fb.apply(SPECIES.length());
92 int[] r = fr.apply(SPECIES.length());
93
94 for (int ic = 0; ic < INVOC_COUNT; ic++) {
95 for (int i = 0; i < a.length; i += SPECIES.length()) {
96 IntVector av = IntVector.fromArray(SPECIES, a, i);
97 IntVector bv = IntVector.fromArray(SPECIES, b, i);
98 av.add(bv).intoArray(r, i);
99 }
100 }
101
102 bh.consume(r);
103 }
104
105 @Benchmark
106 public void addMasked(Blackhole bh) {
107 int[] a = fa.apply(SPECIES.length());
108 int[] b = fb.apply(SPECIES.length());
109 int[] r = fr.apply(SPECIES.length());
110 boolean[] mask = fm.apply(SPECIES.length());
111 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
112
113 for (int ic = 0; ic < INVOC_COUNT; ic++) {
114 for (int i = 0; i < a.length; i += SPECIES.length()) {
115 IntVector av = IntVector.fromArray(SPECIES, a, i);
116 IntVector bv = IntVector.fromArray(SPECIES, b, i);
117 av.add(bv, vmask).intoArray(r, i);
118 }
119 }
120
121 bh.consume(r);
122 }
123
124 @Benchmark
125 public void sub(Blackhole bh) {
126 int[] a = fa.apply(SPECIES.length());
127 int[] b = fb.apply(SPECIES.length());
128 int[] r = fr.apply(SPECIES.length());
129
130 for (int ic = 0; ic < INVOC_COUNT; ic++) {
131 for (int i = 0; i < a.length; i += SPECIES.length()) {
132 IntVector av = IntVector.fromArray(SPECIES, a, i);
133 IntVector bv = IntVector.fromArray(SPECIES, b, i);
134 av.sub(bv).intoArray(r, i);
135 }
136 }
137
138 bh.consume(r);
139 }
140
141 @Benchmark
142 public void subMasked(Blackhole bh) {
143 int[] a = fa.apply(SPECIES.length());
144 int[] b = fb.apply(SPECIES.length());
145 int[] r = fr.apply(SPECIES.length());
146 boolean[] mask = fm.apply(SPECIES.length());
147 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
148
149 for (int ic = 0; ic < INVOC_COUNT; ic++) {
150 for (int i = 0; i < a.length; i += SPECIES.length()) {
151 IntVector av = IntVector.fromArray(SPECIES, a, i);
152 IntVector bv = IntVector.fromArray(SPECIES, b, i);
153 av.sub(bv, vmask).intoArray(r, i);
154 }
155 }
156
157 bh.consume(r);
158 }
159
160
161
162 @Benchmark
163 public void mul(Blackhole bh) {
164 int[] a = fa.apply(SPECIES.length());
165 int[] b = fb.apply(SPECIES.length());
166 int[] r = fr.apply(SPECIES.length());
167
168 for (int ic = 0; ic < INVOC_COUNT; ic++) {
169 for (int i = 0; i < a.length; i += SPECIES.length()) {
170 IntVector av = IntVector.fromArray(SPECIES, a, i);
171 IntVector bv = IntVector.fromArray(SPECIES, b, i);
172 av.mul(bv).intoArray(r, i);
173 }
174 }
175
176 bh.consume(r);
177 }
178
179 @Benchmark
180 public void mulMasked(Blackhole bh) {
181 int[] a = fa.apply(SPECIES.length());
182 int[] b = fb.apply(SPECIES.length());
183 int[] r = fr.apply(SPECIES.length());
184 boolean[] mask = fm.apply(SPECIES.length());
185 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
186
187 for (int ic = 0; ic < INVOC_COUNT; ic++) {
188 for (int i = 0; i < a.length; i += SPECIES.length()) {
189 IntVector av = IntVector.fromArray(SPECIES, a, i);
190 IntVector bv = IntVector.fromArray(SPECIES, b, i);
191 av.mul(bv, vmask).intoArray(r, i);
192 }
193 }
194
195 bh.consume(r);
196 }
197
198
199 @Benchmark
200 public void and(Blackhole bh) {
201 int[] a = fa.apply(SPECIES.length());
202 int[] b = fb.apply(SPECIES.length());
203 int[] r = fr.apply(SPECIES.length());
204
205 for (int ic = 0; ic < INVOC_COUNT; ic++) {
206 for (int i = 0; i < a.length; i += SPECIES.length()) {
207 IntVector av = IntVector.fromArray(SPECIES, a, i);
208 IntVector bv = IntVector.fromArray(SPECIES, b, i);
209 av.and(bv).intoArray(r, i);
210 }
211 }
212
213 bh.consume(r);
214 }
215
216
217
218 @Benchmark
219 public void andMasked(Blackhole bh) {
220 int[] a = fa.apply(SPECIES.length());
221 int[] b = fb.apply(SPECIES.length());
222 int[] r = fr.apply(SPECIES.length());
223 boolean[] mask = fm.apply(SPECIES.length());
224 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
225
226 for (int ic = 0; ic < INVOC_COUNT; ic++) {
227 for (int i = 0; i < a.length; i += SPECIES.length()) {
228 IntVector av = IntVector.fromArray(SPECIES, a, i);
229 IntVector bv = IntVector.fromArray(SPECIES, b, i);
230 av.and(bv, vmask).intoArray(r, i);
231 }
232 }
233
234 bh.consume(r);
235 }
236
237
238
239 @Benchmark
240 public void or(Blackhole bh) {
241 int[] a = fa.apply(SPECIES.length());
242 int[] b = fb.apply(SPECIES.length());
243 int[] r = fr.apply(SPECIES.length());
244
245 for (int ic = 0; ic < INVOC_COUNT; ic++) {
246 for (int i = 0; i < a.length; i += SPECIES.length()) {
247 IntVector av = IntVector.fromArray(SPECIES, a, i);
248 IntVector bv = IntVector.fromArray(SPECIES, b, i);
249 av.or(bv).intoArray(r, i);
250 }
251 }
252
253 bh.consume(r);
254 }
255
256
257
258 @Benchmark
259 public void orMasked(Blackhole bh) {
260 int[] a = fa.apply(SPECIES.length());
261 int[] b = fb.apply(SPECIES.length());
262 int[] r = fr.apply(SPECIES.length());
263 boolean[] mask = fm.apply(SPECIES.length());
264 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
265
266 for (int ic = 0; ic < INVOC_COUNT; ic++) {
267 for (int i = 0; i < a.length; i += SPECIES.length()) {
268 IntVector av = IntVector.fromArray(SPECIES, a, i);
269 IntVector bv = IntVector.fromArray(SPECIES, b, i);
270 av.or(bv, vmask).intoArray(r, i);
271 }
272 }
273
274 bh.consume(r);
275 }
276
277
278
279 @Benchmark
280 public void xor(Blackhole bh) {
281 int[] a = fa.apply(SPECIES.length());
282 int[] b = fb.apply(SPECIES.length());
283 int[] r = fr.apply(SPECIES.length());
284
285 for (int ic = 0; ic < INVOC_COUNT; ic++) {
286 for (int i = 0; i < a.length; i += SPECIES.length()) {
287 IntVector av = IntVector.fromArray(SPECIES, a, i);
288 IntVector bv = IntVector.fromArray(SPECIES, b, i);
289 av.xor(bv).intoArray(r, i);
290 }
291 }
292
293 bh.consume(r);
294 }
295
296
297
298 @Benchmark
299 public void xorMasked(Blackhole bh) {
300 int[] a = fa.apply(SPECIES.length());
301 int[] b = fb.apply(SPECIES.length());
302 int[] r = fr.apply(SPECIES.length());
303 boolean[] mask = fm.apply(SPECIES.length());
304 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
305
306 for (int ic = 0; ic < INVOC_COUNT; ic++) {
307 for (int i = 0; i < a.length; i += SPECIES.length()) {
308 IntVector av = IntVector.fromArray(SPECIES, a, i);
309 IntVector bv = IntVector.fromArray(SPECIES, b, i);
310 av.xor(bv, vmask).intoArray(r, i);
311 }
312 }
313
314 bh.consume(r);
315 }
316
317
318
319 @Benchmark
320 public void shiftR(Blackhole bh) {
321 int[] a = fa.apply(SPECIES.length());
322 int[] b = fb.apply(SPECIES.length());
323 int[] r = fr.apply(SPECIES.length());
324
325 for (int ic = 0; ic < INVOC_COUNT; ic++) {
326 for (int i = 0; i < a.length; i += SPECIES.length()) {
327 IntVector av = IntVector.fromArray(SPECIES, a, i);
328 IntVector bv = IntVector.fromArray(SPECIES, b, i);
329 av.shiftR(bv).intoArray(r, i);
330 }
331 }
332
333 bh.consume(r);
334 }
335
336
337
338 @Benchmark
339 public void shiftRMasked(Blackhole bh) {
340 int[] a = fa.apply(SPECIES.length());
341 int[] b = fb.apply(SPECIES.length());
342 int[] r = fr.apply(SPECIES.length());
343 boolean[] mask = fm.apply(SPECIES.length());
344 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
345
346 for (int ic = 0; ic < INVOC_COUNT; ic++) {
347 for (int i = 0; i < a.length; i += SPECIES.length()) {
348 IntVector av = IntVector.fromArray(SPECIES, a, i);
349 IntVector bv = IntVector.fromArray(SPECIES, b, i);
350 av.shiftR(bv, vmask).intoArray(r, i);
351 }
352 }
353
354 bh.consume(r);
355 }
356
357
358
359 @Benchmark
360 public void shiftL(Blackhole bh) {
361 int[] a = fa.apply(SPECIES.length());
362 int[] b = fb.apply(SPECIES.length());
363 int[] r = fr.apply(SPECIES.length());
364
365 for (int ic = 0; ic < INVOC_COUNT; ic++) {
366 for (int i = 0; i < a.length; i += SPECIES.length()) {
367 IntVector av = IntVector.fromArray(SPECIES, a, i);
368 IntVector bv = IntVector.fromArray(SPECIES, b, i);
369 av.shiftL(bv).intoArray(r, i);
370 }
371 }
372
373 bh.consume(r);
374 }
375
376
377
378 @Benchmark
379 public void shiftLMasked(Blackhole bh) {
380 int[] a = fa.apply(SPECIES.length());
381 int[] b = fb.apply(SPECIES.length());
382 int[] r = fr.apply(SPECIES.length());
383 boolean[] mask = fm.apply(SPECIES.length());
384 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
385
386 for (int ic = 0; ic < INVOC_COUNT; ic++) {
387 for (int i = 0; i < a.length; i += SPECIES.length()) {
388 IntVector av = IntVector.fromArray(SPECIES, a, i);
389 IntVector bv = IntVector.fromArray(SPECIES, b, i);
390 av.shiftL(bv, vmask).intoArray(r, i);
391 }
392 }
393
394 bh.consume(r);
395 }
396
397
398
399 @Benchmark
400 public void aShiftR(Blackhole bh) {
401 int[] a = fa.apply(SPECIES.length());
402 int[] b = fb.apply(SPECIES.length());
403 int[] r = fr.apply(SPECIES.length());
404
405 for (int ic = 0; ic < INVOC_COUNT; ic++) {
406 for (int i = 0; i < a.length; i += SPECIES.length()) {
407 IntVector av = IntVector.fromArray(SPECIES, a, i);
408 IntVector bv = IntVector.fromArray(SPECIES, b, i);
409 av.aShiftR(bv).intoArray(r, i);
410 }
411 }
412
413 bh.consume(r);
414 }
415
416
417
418 @Benchmark
419 public void aShiftRMasked(Blackhole bh) {
420 int[] a = fa.apply(SPECIES.length());
421 int[] b = fb.apply(SPECIES.length());
422 int[] r = fr.apply(SPECIES.length());
423 boolean[] mask = fm.apply(SPECIES.length());
424 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
425
426 for (int ic = 0; ic < INVOC_COUNT; ic++) {
427 for (int i = 0; i < a.length; i += SPECIES.length()) {
428 IntVector av = IntVector.fromArray(SPECIES, a, i);
429 IntVector bv = IntVector.fromArray(SPECIES, b, i);
430 av.aShiftR(bv, vmask).intoArray(r, i);
431 }
432 }
433
434 bh.consume(r);
435 }
436
437
438
439 @Benchmark
440 public void aShiftRShift(Blackhole bh) {
441 int[] a = fa.apply(SPECIES.length());
442 int[] b = fb.apply(SPECIES.length());
443 int[] r = fr.apply(SPECIES.length());
444
445 for (int ic = 0; ic < INVOC_COUNT; ic++) {
446 for (int i = 0; i < a.length; i += SPECIES.length()) {
447 IntVector av = IntVector.fromArray(SPECIES, a, i);
448 av.aShiftR((int)b[i]).intoArray(r, i);
449 }
450 }
451
452 bh.consume(r);
453 }
454
455
456
457 @Benchmark
458 public void aShiftRMaskedShift(Blackhole bh) {
459 int[] a = fa.apply(SPECIES.length());
460 int[] b = fb.apply(SPECIES.length());
461 int[] r = fr.apply(SPECIES.length());
462 boolean[] mask = fm.apply(SPECIES.length());
463 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
464
465 for (int ic = 0; ic < INVOC_COUNT; ic++) {
466 for (int i = 0; i < a.length; i += SPECIES.length()) {
467 IntVector av = IntVector.fromArray(SPECIES, a, i);
468 av.aShiftR((int)b[i], vmask).intoArray(r, i);
469 }
470 }
471
472 bh.consume(r);
473 }
474
475
476
477 @Benchmark
478 public void shiftRShift(Blackhole bh) {
479 int[] a = fa.apply(SPECIES.length());
480 int[] b = fb.apply(SPECIES.length());
481 int[] r = fr.apply(SPECIES.length());
482
483 for (int ic = 0; ic < INVOC_COUNT; ic++) {
484 for (int i = 0; i < a.length; i += SPECIES.length()) {
485 IntVector av = IntVector.fromArray(SPECIES, a, i);
486 av.shiftR((int)b[i]).intoArray(r, i);
487 }
488 }
489
490 bh.consume(r);
491 }
492
493
494
495 @Benchmark
496 public void shiftRMaskedShift(Blackhole bh) {
497 int[] a = fa.apply(SPECIES.length());
498 int[] b = fb.apply(SPECIES.length());
499 int[] r = fr.apply(SPECIES.length());
500 boolean[] mask = fm.apply(SPECIES.length());
501 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
502
503 for (int ic = 0; ic < INVOC_COUNT; ic++) {
504 for (int i = 0; i < a.length; i += SPECIES.length()) {
505 IntVector av = IntVector.fromArray(SPECIES, a, i);
506 av.shiftR((int)b[i], vmask).intoArray(r, i);
507 }
508 }
509
510 bh.consume(r);
511 }
512
513
514
515 @Benchmark
516 public void shiftLShift(Blackhole bh) {
517 int[] a = fa.apply(SPECIES.length());
518 int[] b = fb.apply(SPECIES.length());
519 int[] r = fr.apply(SPECIES.length());
520
521 for (int ic = 0; ic < INVOC_COUNT; ic++) {
522 for (int i = 0; i < a.length; i += SPECIES.length()) {
523 IntVector av = IntVector.fromArray(SPECIES, a, i);
524 av.shiftL((int)b[i]).intoArray(r, i);
525 }
526 }
527
528 bh.consume(r);
529 }
530
531
532
533 @Benchmark
534 public void shiftLMaskedShift(Blackhole bh) {
535 int[] a = fa.apply(SPECIES.length());
536 int[] b = fb.apply(SPECIES.length());
537 int[] r = fr.apply(SPECIES.length());
538 boolean[] mask = fm.apply(SPECIES.length());
539 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
540
541 for (int ic = 0; ic < INVOC_COUNT; ic++) {
542 for (int i = 0; i < a.length; i += SPECIES.length()) {
543 IntVector av = IntVector.fromArray(SPECIES, a, i);
544 av.shiftL((int)b[i], vmask).intoArray(r, i);
545 }
546 }
547
548 bh.consume(r);
549 }
550
551
552
553
554
555
556
557
558
559
697 int ra = Integer.MIN_VALUE;
698
699 for (int ic = 0; ic < INVOC_COUNT; ic++) {
700 ra = Integer.MIN_VALUE;
701 for (int i = 0; i < a.length; i += SPECIES.length()) {
702 IntVector av = IntVector.fromArray(SPECIES, a, i);
703 ra = (int)Math.max(ra, av.maxAll());
704 }
705 }
706 bh.consume(ra);
707 }
708
709
710 @Benchmark
711 public void anyTrue(Blackhole bh) {
712 boolean[] mask = fm.apply(SPECIES.length());
713 boolean[] r = fmr.apply(SPECIES.length());
714
715 for (int ic = 0; ic < INVOC_COUNT; ic++) {
716 for (int i = 0; i < mask.length; i += SPECIES.length()) {
717 Vector.Mask<Integer> vmask = IntVector.maskFromArray(SPECIES, mask, i);
718 r[i] = vmask.anyTrue();
719 }
720 }
721
722 bh.consume(r);
723 }
724
725
726
727 @Benchmark
728 public void allTrue(Blackhole bh) {
729 boolean[] mask = fm.apply(SPECIES.length());
730 boolean[] r = fmr.apply(SPECIES.length());
731
732 for (int ic = 0; ic < INVOC_COUNT; ic++) {
733 for (int i = 0; i < mask.length; i += SPECIES.length()) {
734 Vector.Mask<Integer> vmask = IntVector.maskFromArray(SPECIES, mask, i);
735 r[i] = vmask.allTrue();
736 }
737 }
738
739 bh.consume(r);
740 }
741
742
743 @Benchmark
744 public void with(Blackhole bh) {
745 int[] a = fa.apply(SPECIES.length());
746 int[] r = fr.apply(SPECIES.length());
747
748 for (int ic = 0; ic < INVOC_COUNT; ic++) {
749 for (int i = 0; i < a.length; i += SPECIES.length()) {
750 IntVector av = IntVector.fromArray(SPECIES, a, i);
751 av.with(0, (int)4).intoArray(r, i);
752 }
753 }
754
755 bh.consume(r);
756 }
757
758 @Benchmark
759 public Object lessThan() {
760 int[] a = fa.apply(size);
761 int[] b = fb.apply(size);
762 boolean[] ms = fm.apply(size);
763 Vector.Mask<Integer> m = IntVector.maskFromArray(SPECIES, ms, 0);
764
765 for (int ic = 0; ic < INVOC_COUNT; ic++) {
766 for (int i = 0; i < a.length; i += SPECIES.length()) {
767 IntVector av = IntVector.fromArray(SPECIES, a, i);
768 IntVector bv = IntVector.fromArray(SPECIES, b, i);
769 Vector.Mask<Integer> mv = av.lessThan(bv);
770
771 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
772 }
773 }
774 return m;
775 }
776
777
778 @Benchmark
779 public Object greaterThan() {
780 int[] a = fa.apply(size);
781 int[] b = fb.apply(size);
782 boolean[] ms = fm.apply(size);
783 Vector.Mask<Integer> m = IntVector.maskFromArray(SPECIES, ms, 0);
784
785 for (int ic = 0; ic < INVOC_COUNT; ic++) {
786 for (int i = 0; i < a.length; i += SPECIES.length()) {
787 IntVector av = IntVector.fromArray(SPECIES, a, i);
788 IntVector bv = IntVector.fromArray(SPECIES, b, i);
789 Vector.Mask<Integer> mv = av.greaterThan(bv);
790
791 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
792 }
793 }
794 return m;
795 }
796
797
798 @Benchmark
799 public Object equal() {
800 int[] a = fa.apply(size);
801 int[] b = fb.apply(size);
802 boolean[] ms = fm.apply(size);
803 Vector.Mask<Integer> m = IntVector.maskFromArray(SPECIES, ms, 0);
804
805 for (int ic = 0; ic < INVOC_COUNT; ic++) {
806 for (int i = 0; i < a.length; i += SPECIES.length()) {
807 IntVector av = IntVector.fromArray(SPECIES, a, i);
808 IntVector bv = IntVector.fromArray(SPECIES, b, i);
809 Vector.Mask<Integer> mv = av.equal(bv);
810
811 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
812 }
813 }
814 return m;
815 }
816
817
818 @Benchmark
819 public Object notEqual() {
820 int[] a = fa.apply(size);
821 int[] b = fb.apply(size);
822 boolean[] ms = fm.apply(size);
823 Vector.Mask<Integer> m = IntVector.maskFromArray(SPECIES, ms, 0);
824
825 for (int ic = 0; ic < INVOC_COUNT; ic++) {
826 for (int i = 0; i < a.length; i += SPECIES.length()) {
827 IntVector av = IntVector.fromArray(SPECIES, a, i);
828 IntVector bv = IntVector.fromArray(SPECIES, b, i);
829 Vector.Mask<Integer> mv = av.notEqual(bv);
830
831 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
832 }
833 }
834 return m;
835 }
836
837
838 @Benchmark
839 public Object lessThanEq() {
840 int[] a = fa.apply(size);
841 int[] b = fb.apply(size);
842 boolean[] ms = fm.apply(size);
843 Vector.Mask<Integer> m = IntVector.maskFromArray(SPECIES, ms, 0);
844
845 for (int ic = 0; ic < INVOC_COUNT; ic++) {
846 for (int i = 0; i < a.length; i += SPECIES.length()) {
847 IntVector av = IntVector.fromArray(SPECIES, a, i);
848 IntVector bv = IntVector.fromArray(SPECIES, b, i);
849 Vector.Mask<Integer> mv = av.lessThanEq(bv);
850
851 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
852 }
853 }
854 return m;
855 }
856
857
858 @Benchmark
859 public Object greaterThanEq() {
860 int[] a = fa.apply(size);
861 int[] b = fb.apply(size);
862 boolean[] ms = fm.apply(size);
863 Vector.Mask<Integer> m = IntVector.maskFromArray(SPECIES, ms, 0);
864
865 for (int ic = 0; ic < INVOC_COUNT; ic++) {
866 for (int i = 0; i < a.length; i += SPECIES.length()) {
867 IntVector av = IntVector.fromArray(SPECIES, a, i);
868 IntVector bv = IntVector.fromArray(SPECIES, b, i);
869 Vector.Mask<Integer> mv = av.greaterThanEq(bv);
870
871 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
872 }
873 }
874 return m;
875 }
876
877
878 @Benchmark
879 public void blend(Blackhole bh) {
880 int[] a = fa.apply(SPECIES.length());
881 int[] b = fb.apply(SPECIES.length());
882 int[] r = fr.apply(SPECIES.length());
883 boolean[] mask = fm.apply(SPECIES.length());
884 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
885
886 for (int ic = 0; ic < INVOC_COUNT; ic++) {
887 for (int i = 0; i < a.length; i += SPECIES.length()) {
888 IntVector av = IntVector.fromArray(SPECIES, a, i);
889 IntVector bv = IntVector.fromArray(SPECIES, b, i);
890 av.blend(bv, vmask).intoArray(r, i);
891 }
892 }
893
894 bh.consume(r);
895 }
896
897 @Benchmark
898 public void rearrange(Blackhole bh) {
899 int[] a = fa.apply(SPECIES.length());
900 int[] order = fs.apply(a.length, SPECIES.length());
901 int[] r = fr.apply(SPECIES.length());
902
903 for (int ic = 0; ic < INVOC_COUNT; ic++) {
904 for (int i = 0; i < a.length; i += SPECIES.length()) {
905 IntVector av = IntVector.fromArray(SPECIES, a, i);
906 av.rearrange(IntVector.shuffleFromArray(SPECIES, order, i)).intoArray(r, i);
907 }
908 }
909
910 bh.consume(r);
911 }
912
913 @Benchmark
914 public void extract(Blackhole bh) {
915 int[] a = fa.apply(SPECIES.length());
916 int[] r = fr.apply(SPECIES.length());
917
918 for (int ic = 0; ic < INVOC_COUNT; ic++) {
919 for (int i = 0; i < a.length; i += SPECIES.length()) {
920 IntVector av = IntVector.fromArray(SPECIES, a, i);
921 int num_lanes = SPECIES.length();
922 // Manually unroll because full unroll happens after intrinsification.
923 // Unroll is needed because get intrinsic requires for index to be a known constant.
924 if (num_lanes == 1) {
925 r[i]=av.get(0);
926 } else if (num_lanes == 2) {
1089 @Benchmark
1090 public void neg(Blackhole bh) {
1091 int[] a = fa.apply(SPECIES.length());
1092 int[] r = fr.apply(SPECIES.length());
1093
1094 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1095 for (int i = 0; i < a.length; i += SPECIES.length()) {
1096 IntVector av = IntVector.fromArray(SPECIES, a, i);
1097 av.neg().intoArray(r, i);
1098 }
1099 }
1100
1101 bh.consume(r);
1102 }
1103
1104 @Benchmark
1105 public void negMasked(Blackhole bh) {
1106 int[] a = fa.apply(SPECIES.length());
1107 int[] r = fr.apply(SPECIES.length());
1108 boolean[] mask = fm.apply(SPECIES.length());
1109 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
1110
1111 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1112 for (int i = 0; i < a.length; i += SPECIES.length()) {
1113 IntVector av = IntVector.fromArray(SPECIES, a, i);
1114 av.neg(vmask).intoArray(r, i);
1115 }
1116 }
1117
1118 bh.consume(r);
1119 }
1120
1121 @Benchmark
1122 public void abs(Blackhole bh) {
1123 int[] a = fa.apply(SPECIES.length());
1124 int[] r = fr.apply(SPECIES.length());
1125
1126 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1127 for (int i = 0; i < a.length; i += SPECIES.length()) {
1128 IntVector av = IntVector.fromArray(SPECIES, a, i);
1129 av.abs().intoArray(r, i);
1130 }
1131 }
1132
1133 bh.consume(r);
1134 }
1135
1136 @Benchmark
1137 public void absMasked(Blackhole bh) {
1138 int[] a = fa.apply(SPECIES.length());
1139 int[] r = fr.apply(SPECIES.length());
1140 boolean[] mask = fm.apply(SPECIES.length());
1141 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
1142
1143 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1144 for (int i = 0; i < a.length; i += SPECIES.length()) {
1145 IntVector av = IntVector.fromArray(SPECIES, a, i);
1146 av.abs(vmask).intoArray(r, i);
1147 }
1148 }
1149
1150 bh.consume(r);
1151 }
1152
1153
1154 @Benchmark
1155 public void not(Blackhole bh) {
1156 int[] a = fa.apply(SPECIES.length());
1157 int[] r = fr.apply(SPECIES.length());
1158
1159 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1160 for (int i = 0; i < a.length; i += SPECIES.length()) {
1161 IntVector av = IntVector.fromArray(SPECIES, a, i);
1162 av.not().intoArray(r, i);
1163 }
1164 }
1165
1166 bh.consume(r);
1167 }
1168
1169
1170
1171 @Benchmark
1172 public void notMasked(Blackhole bh) {
1173 int[] a = fa.apply(SPECIES.length());
1174 int[] r = fr.apply(SPECIES.length());
1175 boolean[] mask = fm.apply(SPECIES.length());
1176 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
1177
1178 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1179 for (int i = 0; i < a.length; i += SPECIES.length()) {
1180 IntVector av = IntVector.fromArray(SPECIES, a, i);
1181 av.not(vmask).intoArray(r, i);
1182 }
1183 }
1184
1185 bh.consume(r);
1186 }
1187
1188
1189
1190
1191
1192 @Benchmark
1193 public void gather(Blackhole bh) {
1194 int[] a = fa.apply(SPECIES.length());
1195 int[] b = fs.apply(a.length, SPECIES.length());
1196 int[] r = new int[a.length];
|
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
21 * questions.
22 */
23
24 package benchmark.jdk.incubator.vector;
25
26 import jdk.incubator.vector.Vector;
27 import jdk.incubator.vector.VectorShape;
28 import jdk.incubator.vector.VectorSpecies;
29 import jdk.incubator.vector.VectorShuffle;
30 import jdk.incubator.vector.IntVector;
31
32 import java.util.concurrent.TimeUnit;
33 import java.util.function.BiFunction;
34 import java.util.function.IntFunction;
35
36 import org.openjdk.jmh.annotations.*;
37 import org.openjdk.jmh.infra.Blackhole;
38
39 @BenchmarkMode(Mode.Throughput)
40 @OutputTimeUnit(TimeUnit.MILLISECONDS)
41 @State(Scope.Benchmark)
42 @Warmup(iterations = 3, time = 1)
43 @Measurement(iterations = 5, time = 1)
44 @Fork(value = 1, jvmArgsPrepend = {"--add-modules=jdk.incubator.vector"})
45 public class IntMaxVector extends AbstractVectorBenchmark {
46 static final VectorSpecies<Integer> SPECIES = IntVector.SPECIES_MAX;
47
48 static final int INVOC_COUNT = 1; // get rid of outer loop
49
50 @Param("1024")
51 int size;
52
53 int[] fill(IntFunction<Integer> f) {
54 int[] array = new int[size];
55 for (int i = 0; i < array.length; i++) {
56 array[i] = f.apply(i);
57 }
58 return array;
59 }
60
61 int[] a, b, c, r;
62 boolean[] m, rm;
63 int[] s;
64
65 @Setup
66 public void init() {
92 int[] b = fb.apply(SPECIES.length());
93 int[] r = fr.apply(SPECIES.length());
94
95 for (int ic = 0; ic < INVOC_COUNT; ic++) {
96 for (int i = 0; i < a.length; i += SPECIES.length()) {
97 IntVector av = IntVector.fromArray(SPECIES, a, i);
98 IntVector bv = IntVector.fromArray(SPECIES, b, i);
99 av.add(bv).intoArray(r, i);
100 }
101 }
102
103 bh.consume(r);
104 }
105
106 @Benchmark
107 public void addMasked(Blackhole bh) {
108 int[] a = fa.apply(SPECIES.length());
109 int[] b = fb.apply(SPECIES.length());
110 int[] r = fr.apply(SPECIES.length());
111 boolean[] mask = fm.apply(SPECIES.length());
112 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
113
114 for (int ic = 0; ic < INVOC_COUNT; ic++) {
115 for (int i = 0; i < a.length; i += SPECIES.length()) {
116 IntVector av = IntVector.fromArray(SPECIES, a, i);
117 IntVector bv = IntVector.fromArray(SPECIES, b, i);
118 av.add(bv, vmask).intoArray(r, i);
119 }
120 }
121
122 bh.consume(r);
123 }
124
125 @Benchmark
126 public void sub(Blackhole bh) {
127 int[] a = fa.apply(SPECIES.length());
128 int[] b = fb.apply(SPECIES.length());
129 int[] r = fr.apply(SPECIES.length());
130
131 for (int ic = 0; ic < INVOC_COUNT; ic++) {
132 for (int i = 0; i < a.length; i += SPECIES.length()) {
133 IntVector av = IntVector.fromArray(SPECIES, a, i);
134 IntVector bv = IntVector.fromArray(SPECIES, b, i);
135 av.sub(bv).intoArray(r, i);
136 }
137 }
138
139 bh.consume(r);
140 }
141
142 @Benchmark
143 public void subMasked(Blackhole bh) {
144 int[] a = fa.apply(SPECIES.length());
145 int[] b = fb.apply(SPECIES.length());
146 int[] r = fr.apply(SPECIES.length());
147 boolean[] mask = fm.apply(SPECIES.length());
148 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
149
150 for (int ic = 0; ic < INVOC_COUNT; ic++) {
151 for (int i = 0; i < a.length; i += SPECIES.length()) {
152 IntVector av = IntVector.fromArray(SPECIES, a, i);
153 IntVector bv = IntVector.fromArray(SPECIES, b, i);
154 av.sub(bv, vmask).intoArray(r, i);
155 }
156 }
157
158 bh.consume(r);
159 }
160
161
162
163 @Benchmark
164 public void mul(Blackhole bh) {
165 int[] a = fa.apply(SPECIES.length());
166 int[] b = fb.apply(SPECIES.length());
167 int[] r = fr.apply(SPECIES.length());
168
169 for (int ic = 0; ic < INVOC_COUNT; ic++) {
170 for (int i = 0; i < a.length; i += SPECIES.length()) {
171 IntVector av = IntVector.fromArray(SPECIES, a, i);
172 IntVector bv = IntVector.fromArray(SPECIES, b, i);
173 av.mul(bv).intoArray(r, i);
174 }
175 }
176
177 bh.consume(r);
178 }
179
180 @Benchmark
181 public void mulMasked(Blackhole bh) {
182 int[] a = fa.apply(SPECIES.length());
183 int[] b = fb.apply(SPECIES.length());
184 int[] r = fr.apply(SPECIES.length());
185 boolean[] mask = fm.apply(SPECIES.length());
186 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
187
188 for (int ic = 0; ic < INVOC_COUNT; ic++) {
189 for (int i = 0; i < a.length; i += SPECIES.length()) {
190 IntVector av = IntVector.fromArray(SPECIES, a, i);
191 IntVector bv = IntVector.fromArray(SPECIES, b, i);
192 av.mul(bv, vmask).intoArray(r, i);
193 }
194 }
195
196 bh.consume(r);
197 }
198
199
200 @Benchmark
201 public void and(Blackhole bh) {
202 int[] a = fa.apply(SPECIES.length());
203 int[] b = fb.apply(SPECIES.length());
204 int[] r = fr.apply(SPECIES.length());
205
206 for (int ic = 0; ic < INVOC_COUNT; ic++) {
207 for (int i = 0; i < a.length; i += SPECIES.length()) {
208 IntVector av = IntVector.fromArray(SPECIES, a, i);
209 IntVector bv = IntVector.fromArray(SPECIES, b, i);
210 av.and(bv).intoArray(r, i);
211 }
212 }
213
214 bh.consume(r);
215 }
216
217
218
219 @Benchmark
220 public void andMasked(Blackhole bh) {
221 int[] a = fa.apply(SPECIES.length());
222 int[] b = fb.apply(SPECIES.length());
223 int[] r = fr.apply(SPECIES.length());
224 boolean[] mask = fm.apply(SPECIES.length());
225 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
226
227 for (int ic = 0; ic < INVOC_COUNT; ic++) {
228 for (int i = 0; i < a.length; i += SPECIES.length()) {
229 IntVector av = IntVector.fromArray(SPECIES, a, i);
230 IntVector bv = IntVector.fromArray(SPECIES, b, i);
231 av.and(bv, vmask).intoArray(r, i);
232 }
233 }
234
235 bh.consume(r);
236 }
237
238
239
240 @Benchmark
241 public void or(Blackhole bh) {
242 int[] a = fa.apply(SPECIES.length());
243 int[] b = fb.apply(SPECIES.length());
244 int[] r = fr.apply(SPECIES.length());
245
246 for (int ic = 0; ic < INVOC_COUNT; ic++) {
247 for (int i = 0; i < a.length; i += SPECIES.length()) {
248 IntVector av = IntVector.fromArray(SPECIES, a, i);
249 IntVector bv = IntVector.fromArray(SPECIES, b, i);
250 av.or(bv).intoArray(r, i);
251 }
252 }
253
254 bh.consume(r);
255 }
256
257
258
259 @Benchmark
260 public void orMasked(Blackhole bh) {
261 int[] a = fa.apply(SPECIES.length());
262 int[] b = fb.apply(SPECIES.length());
263 int[] r = fr.apply(SPECIES.length());
264 boolean[] mask = fm.apply(SPECIES.length());
265 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
266
267 for (int ic = 0; ic < INVOC_COUNT; ic++) {
268 for (int i = 0; i < a.length; i += SPECIES.length()) {
269 IntVector av = IntVector.fromArray(SPECIES, a, i);
270 IntVector bv = IntVector.fromArray(SPECIES, b, i);
271 av.or(bv, vmask).intoArray(r, i);
272 }
273 }
274
275 bh.consume(r);
276 }
277
278
279
280 @Benchmark
281 public void xor(Blackhole bh) {
282 int[] a = fa.apply(SPECIES.length());
283 int[] b = fb.apply(SPECIES.length());
284 int[] r = fr.apply(SPECIES.length());
285
286 for (int ic = 0; ic < INVOC_COUNT; ic++) {
287 for (int i = 0; i < a.length; i += SPECIES.length()) {
288 IntVector av = IntVector.fromArray(SPECIES, a, i);
289 IntVector bv = IntVector.fromArray(SPECIES, b, i);
290 av.xor(bv).intoArray(r, i);
291 }
292 }
293
294 bh.consume(r);
295 }
296
297
298
299 @Benchmark
300 public void xorMasked(Blackhole bh) {
301 int[] a = fa.apply(SPECIES.length());
302 int[] b = fb.apply(SPECIES.length());
303 int[] r = fr.apply(SPECIES.length());
304 boolean[] mask = fm.apply(SPECIES.length());
305 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
306
307 for (int ic = 0; ic < INVOC_COUNT; ic++) {
308 for (int i = 0; i < a.length; i += SPECIES.length()) {
309 IntVector av = IntVector.fromArray(SPECIES, a, i);
310 IntVector bv = IntVector.fromArray(SPECIES, b, i);
311 av.xor(bv, vmask).intoArray(r, i);
312 }
313 }
314
315 bh.consume(r);
316 }
317
318
319
320 @Benchmark
321 public void shiftR(Blackhole bh) {
322 int[] a = fa.apply(SPECIES.length());
323 int[] b = fb.apply(SPECIES.length());
324 int[] r = fr.apply(SPECIES.length());
325
326 for (int ic = 0; ic < INVOC_COUNT; ic++) {
327 for (int i = 0; i < a.length; i += SPECIES.length()) {
328 IntVector av = IntVector.fromArray(SPECIES, a, i);
329 IntVector bv = IntVector.fromArray(SPECIES, b, i);
330 av.shiftR(bv).intoArray(r, i);
331 }
332 }
333
334 bh.consume(r);
335 }
336
337
338
339 @Benchmark
340 public void shiftRMasked(Blackhole bh) {
341 int[] a = fa.apply(SPECIES.length());
342 int[] b = fb.apply(SPECIES.length());
343 int[] r = fr.apply(SPECIES.length());
344 boolean[] mask = fm.apply(SPECIES.length());
345 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
346
347 for (int ic = 0; ic < INVOC_COUNT; ic++) {
348 for (int i = 0; i < a.length; i += SPECIES.length()) {
349 IntVector av = IntVector.fromArray(SPECIES, a, i);
350 IntVector bv = IntVector.fromArray(SPECIES, b, i);
351 av.shiftR(bv, vmask).intoArray(r, i);
352 }
353 }
354
355 bh.consume(r);
356 }
357
358
359
360 @Benchmark
361 public void shiftL(Blackhole bh) {
362 int[] a = fa.apply(SPECIES.length());
363 int[] b = fb.apply(SPECIES.length());
364 int[] r = fr.apply(SPECIES.length());
365
366 for (int ic = 0; ic < INVOC_COUNT; ic++) {
367 for (int i = 0; i < a.length; i += SPECIES.length()) {
368 IntVector av = IntVector.fromArray(SPECIES, a, i);
369 IntVector bv = IntVector.fromArray(SPECIES, b, i);
370 av.shiftL(bv).intoArray(r, i);
371 }
372 }
373
374 bh.consume(r);
375 }
376
377
378
379 @Benchmark
380 public void shiftLMasked(Blackhole bh) {
381 int[] a = fa.apply(SPECIES.length());
382 int[] b = fb.apply(SPECIES.length());
383 int[] r = fr.apply(SPECIES.length());
384 boolean[] mask = fm.apply(SPECIES.length());
385 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
386
387 for (int ic = 0; ic < INVOC_COUNT; ic++) {
388 for (int i = 0; i < a.length; i += SPECIES.length()) {
389 IntVector av = IntVector.fromArray(SPECIES, a, i);
390 IntVector bv = IntVector.fromArray(SPECIES, b, i);
391 av.shiftL(bv, vmask).intoArray(r, i);
392 }
393 }
394
395 bh.consume(r);
396 }
397
398
399
400 @Benchmark
401 public void aShiftR(Blackhole bh) {
402 int[] a = fa.apply(SPECIES.length());
403 int[] b = fb.apply(SPECIES.length());
404 int[] r = fr.apply(SPECIES.length());
405
406 for (int ic = 0; ic < INVOC_COUNT; ic++) {
407 for (int i = 0; i < a.length; i += SPECIES.length()) {
408 IntVector av = IntVector.fromArray(SPECIES, a, i);
409 IntVector bv = IntVector.fromArray(SPECIES, b, i);
410 av.aShiftR(bv).intoArray(r, i);
411 }
412 }
413
414 bh.consume(r);
415 }
416
417
418
419 @Benchmark
420 public void aShiftRMasked(Blackhole bh) {
421 int[] a = fa.apply(SPECIES.length());
422 int[] b = fb.apply(SPECIES.length());
423 int[] r = fr.apply(SPECIES.length());
424 boolean[] mask = fm.apply(SPECIES.length());
425 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
426
427 for (int ic = 0; ic < INVOC_COUNT; ic++) {
428 for (int i = 0; i < a.length; i += SPECIES.length()) {
429 IntVector av = IntVector.fromArray(SPECIES, a, i);
430 IntVector bv = IntVector.fromArray(SPECIES, b, i);
431 av.aShiftR(bv, vmask).intoArray(r, i);
432 }
433 }
434
435 bh.consume(r);
436 }
437
438
439
440 @Benchmark
441 public void aShiftRShift(Blackhole bh) {
442 int[] a = fa.apply(SPECIES.length());
443 int[] b = fb.apply(SPECIES.length());
444 int[] r = fr.apply(SPECIES.length());
445
446 for (int ic = 0; ic < INVOC_COUNT; ic++) {
447 for (int i = 0; i < a.length; i += SPECIES.length()) {
448 IntVector av = IntVector.fromArray(SPECIES, a, i);
449 av.aShiftR((int)b[i]).intoArray(r, i);
450 }
451 }
452
453 bh.consume(r);
454 }
455
456
457
458 @Benchmark
459 public void aShiftRMaskedShift(Blackhole bh) {
460 int[] a = fa.apply(SPECIES.length());
461 int[] b = fb.apply(SPECIES.length());
462 int[] r = fr.apply(SPECIES.length());
463 boolean[] mask = fm.apply(SPECIES.length());
464 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
465
466 for (int ic = 0; ic < INVOC_COUNT; ic++) {
467 for (int i = 0; i < a.length; i += SPECIES.length()) {
468 IntVector av = IntVector.fromArray(SPECIES, a, i);
469 av.aShiftR((int)b[i], vmask).intoArray(r, i);
470 }
471 }
472
473 bh.consume(r);
474 }
475
476
477
478 @Benchmark
479 public void shiftRShift(Blackhole bh) {
480 int[] a = fa.apply(SPECIES.length());
481 int[] b = fb.apply(SPECIES.length());
482 int[] r = fr.apply(SPECIES.length());
483
484 for (int ic = 0; ic < INVOC_COUNT; ic++) {
485 for (int i = 0; i < a.length; i += SPECIES.length()) {
486 IntVector av = IntVector.fromArray(SPECIES, a, i);
487 av.shiftR((int)b[i]).intoArray(r, i);
488 }
489 }
490
491 bh.consume(r);
492 }
493
494
495
496 @Benchmark
497 public void shiftRMaskedShift(Blackhole bh) {
498 int[] a = fa.apply(SPECIES.length());
499 int[] b = fb.apply(SPECIES.length());
500 int[] r = fr.apply(SPECIES.length());
501 boolean[] mask = fm.apply(SPECIES.length());
502 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
503
504 for (int ic = 0; ic < INVOC_COUNT; ic++) {
505 for (int i = 0; i < a.length; i += SPECIES.length()) {
506 IntVector av = IntVector.fromArray(SPECIES, a, i);
507 av.shiftR((int)b[i], vmask).intoArray(r, i);
508 }
509 }
510
511 bh.consume(r);
512 }
513
514
515
516 @Benchmark
517 public void shiftLShift(Blackhole bh) {
518 int[] a = fa.apply(SPECIES.length());
519 int[] b = fb.apply(SPECIES.length());
520 int[] r = fr.apply(SPECIES.length());
521
522 for (int ic = 0; ic < INVOC_COUNT; ic++) {
523 for (int i = 0; i < a.length; i += SPECIES.length()) {
524 IntVector av = IntVector.fromArray(SPECIES, a, i);
525 av.shiftL((int)b[i]).intoArray(r, i);
526 }
527 }
528
529 bh.consume(r);
530 }
531
532
533
534 @Benchmark
535 public void shiftLMaskedShift(Blackhole bh) {
536 int[] a = fa.apply(SPECIES.length());
537 int[] b = fb.apply(SPECIES.length());
538 int[] r = fr.apply(SPECIES.length());
539 boolean[] mask = fm.apply(SPECIES.length());
540 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
541
542 for (int ic = 0; ic < INVOC_COUNT; ic++) {
543 for (int i = 0; i < a.length; i += SPECIES.length()) {
544 IntVector av = IntVector.fromArray(SPECIES, a, i);
545 av.shiftL((int)b[i], vmask).intoArray(r, i);
546 }
547 }
548
549 bh.consume(r);
550 }
551
552
553
554
555
556
557
558
559
560
698 int ra = Integer.MIN_VALUE;
699
700 for (int ic = 0; ic < INVOC_COUNT; ic++) {
701 ra = Integer.MIN_VALUE;
702 for (int i = 0; i < a.length; i += SPECIES.length()) {
703 IntVector av = IntVector.fromArray(SPECIES, a, i);
704 ra = (int)Math.max(ra, av.maxAll());
705 }
706 }
707 bh.consume(ra);
708 }
709
710
711 @Benchmark
712 public void anyTrue(Blackhole bh) {
713 boolean[] mask = fm.apply(SPECIES.length());
714 boolean[] r = fmr.apply(SPECIES.length());
715
716 for (int ic = 0; ic < INVOC_COUNT; ic++) {
717 for (int i = 0; i < mask.length; i += SPECIES.length()) {
718 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
719 r[i] = vmask.anyTrue();
720 }
721 }
722
723 bh.consume(r);
724 }
725
726
727
728 @Benchmark
729 public void allTrue(Blackhole bh) {
730 boolean[] mask = fm.apply(SPECIES.length());
731 boolean[] r = fmr.apply(SPECIES.length());
732
733 for (int ic = 0; ic < INVOC_COUNT; ic++) {
734 for (int i = 0; i < mask.length; i += SPECIES.length()) {
735 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
736 r[i] = vmask.allTrue();
737 }
738 }
739
740 bh.consume(r);
741 }
742
743
744 @Benchmark
745 public void with(Blackhole bh) {
746 int[] a = fa.apply(SPECIES.length());
747 int[] r = fr.apply(SPECIES.length());
748
749 for (int ic = 0; ic < INVOC_COUNT; ic++) {
750 for (int i = 0; i < a.length; i += SPECIES.length()) {
751 IntVector av = IntVector.fromArray(SPECIES, a, i);
752 av.with(0, (int)4).intoArray(r, i);
753 }
754 }
755
756 bh.consume(r);
757 }
758
759 @Benchmark
760 public Object lessThan() {
761 int[] a = fa.apply(size);
762 int[] b = fb.apply(size);
763 boolean[] ms = fm.apply(size);
764 VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
765
766 for (int ic = 0; ic < INVOC_COUNT; ic++) {
767 for (int i = 0; i < a.length; i += SPECIES.length()) {
768 IntVector av = IntVector.fromArray(SPECIES, a, i);
769 IntVector bv = IntVector.fromArray(SPECIES, b, i);
770 VectorMask<Integer> mv = av.lessThan(bv);
771
772 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
773 }
774 }
775 return m;
776 }
777
778
779 @Benchmark
780 public Object greaterThan() {
781 int[] a = fa.apply(size);
782 int[] b = fb.apply(size);
783 boolean[] ms = fm.apply(size);
784 VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
785
786 for (int ic = 0; ic < INVOC_COUNT; ic++) {
787 for (int i = 0; i < a.length; i += SPECIES.length()) {
788 IntVector av = IntVector.fromArray(SPECIES, a, i);
789 IntVector bv = IntVector.fromArray(SPECIES, b, i);
790 VectorMask<Integer> mv = av.greaterThan(bv);
791
792 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
793 }
794 }
795 return m;
796 }
797
798
799 @Benchmark
800 public Object equal() {
801 int[] a = fa.apply(size);
802 int[] b = fb.apply(size);
803 boolean[] ms = fm.apply(size);
804 VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
805
806 for (int ic = 0; ic < INVOC_COUNT; ic++) {
807 for (int i = 0; i < a.length; i += SPECIES.length()) {
808 IntVector av = IntVector.fromArray(SPECIES, a, i);
809 IntVector bv = IntVector.fromArray(SPECIES, b, i);
810 VectorMask<Integer> mv = av.equal(bv);
811
812 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
813 }
814 }
815 return m;
816 }
817
818
819 @Benchmark
820 public Object notEqual() {
821 int[] a = fa.apply(size);
822 int[] b = fb.apply(size);
823 boolean[] ms = fm.apply(size);
824 VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
825
826 for (int ic = 0; ic < INVOC_COUNT; ic++) {
827 for (int i = 0; i < a.length; i += SPECIES.length()) {
828 IntVector av = IntVector.fromArray(SPECIES, a, i);
829 IntVector bv = IntVector.fromArray(SPECIES, b, i);
830 VectorMask<Integer> mv = av.notEqual(bv);
831
832 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
833 }
834 }
835 return m;
836 }
837
838
839 @Benchmark
840 public Object lessThanEq() {
841 int[] a = fa.apply(size);
842 int[] b = fb.apply(size);
843 boolean[] ms = fm.apply(size);
844 VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
845
846 for (int ic = 0; ic < INVOC_COUNT; ic++) {
847 for (int i = 0; i < a.length; i += SPECIES.length()) {
848 IntVector av = IntVector.fromArray(SPECIES, a, i);
849 IntVector bv = IntVector.fromArray(SPECIES, b, i);
850 VectorMask<Integer> mv = av.lessThanEq(bv);
851
852 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
853 }
854 }
855 return m;
856 }
857
858
859 @Benchmark
860 public Object greaterThanEq() {
861 int[] a = fa.apply(size);
862 int[] b = fb.apply(size);
863 boolean[] ms = fm.apply(size);
864 VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
865
866 for (int ic = 0; ic < INVOC_COUNT; ic++) {
867 for (int i = 0; i < a.length; i += SPECIES.length()) {
868 IntVector av = IntVector.fromArray(SPECIES, a, i);
869 IntVector bv = IntVector.fromArray(SPECIES, b, i);
870 VectorMask<Integer> mv = av.greaterThanEq(bv);
871
872 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
873 }
874 }
875 return m;
876 }
877
878
879 @Benchmark
880 public void blend(Blackhole bh) {
881 int[] a = fa.apply(SPECIES.length());
882 int[] b = fb.apply(SPECIES.length());
883 int[] r = fr.apply(SPECIES.length());
884 boolean[] mask = fm.apply(SPECIES.length());
885 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
886
887 for (int ic = 0; ic < INVOC_COUNT; ic++) {
888 for (int i = 0; i < a.length; i += SPECIES.length()) {
889 IntVector av = IntVector.fromArray(SPECIES, a, i);
890 IntVector bv = IntVector.fromArray(SPECIES, b, i);
891 av.blend(bv, vmask).intoArray(r, i);
892 }
893 }
894
895 bh.consume(r);
896 }
897
898 @Benchmark
899 public void rearrange(Blackhole bh) {
900 int[] a = fa.apply(SPECIES.length());
901 int[] order = fs.apply(a.length, SPECIES.length());
902 int[] r = fr.apply(SPECIES.length());
903
904 for (int ic = 0; ic < INVOC_COUNT; ic++) {
905 for (int i = 0; i < a.length; i += SPECIES.length()) {
906 IntVector av = IntVector.fromArray(SPECIES, a, i);
907 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
908 }
909 }
910
911 bh.consume(r);
912 }
913
914 @Benchmark
915 public void extract(Blackhole bh) {
916 int[] a = fa.apply(SPECIES.length());
917 int[] r = fr.apply(SPECIES.length());
918
919 for (int ic = 0; ic < INVOC_COUNT; ic++) {
920 for (int i = 0; i < a.length; i += SPECIES.length()) {
921 IntVector av = IntVector.fromArray(SPECIES, a, i);
922 int num_lanes = SPECIES.length();
923 // Manually unroll because full unroll happens after intrinsification.
924 // Unroll is needed because get intrinsic requires for index to be a known constant.
925 if (num_lanes == 1) {
926 r[i]=av.get(0);
927 } else if (num_lanes == 2) {
1090 @Benchmark
1091 public void neg(Blackhole bh) {
1092 int[] a = fa.apply(SPECIES.length());
1093 int[] r = fr.apply(SPECIES.length());
1094
1095 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1096 for (int i = 0; i < a.length; i += SPECIES.length()) {
1097 IntVector av = IntVector.fromArray(SPECIES, a, i);
1098 av.neg().intoArray(r, i);
1099 }
1100 }
1101
1102 bh.consume(r);
1103 }
1104
1105 @Benchmark
1106 public void negMasked(Blackhole bh) {
1107 int[] a = fa.apply(SPECIES.length());
1108 int[] r = fr.apply(SPECIES.length());
1109 boolean[] mask = fm.apply(SPECIES.length());
1110 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
1111
1112 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1113 for (int i = 0; i < a.length; i += SPECIES.length()) {
1114 IntVector av = IntVector.fromArray(SPECIES, a, i);
1115 av.neg(vmask).intoArray(r, i);
1116 }
1117 }
1118
1119 bh.consume(r);
1120 }
1121
1122 @Benchmark
1123 public void abs(Blackhole bh) {
1124 int[] a = fa.apply(SPECIES.length());
1125 int[] r = fr.apply(SPECIES.length());
1126
1127 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1128 for (int i = 0; i < a.length; i += SPECIES.length()) {
1129 IntVector av = IntVector.fromArray(SPECIES, a, i);
1130 av.abs().intoArray(r, i);
1131 }
1132 }
1133
1134 bh.consume(r);
1135 }
1136
1137 @Benchmark
1138 public void absMasked(Blackhole bh) {
1139 int[] a = fa.apply(SPECIES.length());
1140 int[] r = fr.apply(SPECIES.length());
1141 boolean[] mask = fm.apply(SPECIES.length());
1142 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
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 av.abs(vmask).intoArray(r, i);
1148 }
1149 }
1150
1151 bh.consume(r);
1152 }
1153
1154
1155 @Benchmark
1156 public void not(Blackhole bh) {
1157 int[] a = fa.apply(SPECIES.length());
1158 int[] r = fr.apply(SPECIES.length());
1159
1160 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1161 for (int i = 0; i < a.length; i += SPECIES.length()) {
1162 IntVector av = IntVector.fromArray(SPECIES, a, i);
1163 av.not().intoArray(r, i);
1164 }
1165 }
1166
1167 bh.consume(r);
1168 }
1169
1170
1171
1172 @Benchmark
1173 public void notMasked(Blackhole bh) {
1174 int[] a = fa.apply(SPECIES.length());
1175 int[] r = fr.apply(SPECIES.length());
1176 boolean[] mask = fm.apply(SPECIES.length());
1177 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
1178
1179 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1180 for (int i = 0; i < a.length; i += SPECIES.length()) {
1181 IntVector av = IntVector.fromArray(SPECIES, a, i);
1182 av.not(vmask).intoArray(r, i);
1183 }
1184 }
1185
1186 bh.consume(r);
1187 }
1188
1189
1190
1191
1192
1193 @Benchmark
1194 public void gather(Blackhole bh) {
1195 int[] a = fa.apply(SPECIES.length());
1196 int[] b = fs.apply(a.length, SPECIES.length());
1197 int[] r = new int[a.length];
|