1 /*
2 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 /**
26 * @test
27 * @bug 7119644
28 * @summary Increase superword's vector size up to 256 bits
29 *
30 * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions
31 * -XX:-TieredCompilation -XX:-OptimizeFill
32 * compiler.codegen.TestBooleanVect
33 */
34
35 package compiler.codegen;
36
37 public class TestBooleanVect {
38 private static final int ARRLEN = 997;
39 private static final int ITERS = 11000;
40 private static final int OFFSET = 3;
41 private static final int SCALE = 2;
42 private static final int ALIGN_OFF = 8;
43 private static final int UNALIGN_OFF = 5;
44
45 public static void main(String args[]) {
46 System.out.println("Testing Boolean vectors");
47 int errn = test();
48 if (errn > 0) {
49 System.err.println("FAILED: " + errn + " errors");
50 System.exit(97);
51 }
52 System.out.println("PASSED");
53 }
54
55 static int test() {
56 boolean[] a1 = new boolean[ARRLEN];
57 boolean[] a2 = new boolean[ARRLEN];
58 System.out.println("Warmup");
59 for (int i=0; i<ITERS; i++) {
60 test_ci(a1);
61 test_vi(a2, true);
62 test_cp(a1, a2);
63 test_2ci(a1, a2);
64 test_2vi(a1, a2, true, true);
65 test_ci_neg(a1);
66 test_vi_neg(a2, true);
67 test_cp_neg(a1, a2);
68 test_2ci_neg(a1, a2);
69 test_2vi_neg(a1, a2, true, true);
70 test_ci_oppos(a1);
71 test_vi_oppos(a2, true);
72 test_cp_oppos(a1, a2);
73 test_2ci_oppos(a1, a2);
74 test_2vi_oppos(a1, a2, true, true);
75 test_ci_off(a1);
76 test_vi_off(a2, true);
77 test_cp_off(a1, a2);
78 test_2ci_off(a1, a2);
79 test_2vi_off(a1, a2, true, true);
80 test_ci_inv(a1, OFFSET);
81 test_vi_inv(a2, true, OFFSET);
82 test_cp_inv(a1, a2, OFFSET);
83 test_2ci_inv(a1, a2, OFFSET);
84 test_2vi_inv(a1, a2, true, true, OFFSET);
85 test_ci_scl(a1);
86 test_vi_scl(a2, true);
87 test_cp_scl(a1, a2);
88 test_2ci_scl(a1, a2);
89 test_2vi_scl(a1, a2, true, true);
90 test_cp_alndst(a1, a2);
91 test_cp_alnsrc(a1, a2);
92 test_2ci_aln(a1, a2);
93 test_2vi_aln(a1, a2, true, true);
94 test_cp_unalndst(a1, a2);
95 test_cp_unalnsrc(a1, a2);
96 test_2ci_unaln(a1, a2);
97 test_2vi_unaln(a1, a2, true, true);
98 }
99 // Initialize
100 for (int i=0; i<ARRLEN; i++) {
101 a1[i] = false;
102 a2[i] = false;
103 }
104 // Test and verify results
105 System.out.println("Verification");
106 int errn = 0;
107 {
108 test_ci(a1);
109 for (int i=0; i<ARRLEN; i++) {
110 errn += verify("test_ci: a1", i, a1[i], false);
111 }
112 test_vi(a2, true);
113 for (int i=0; i<ARRLEN; i++) {
114 errn += verify("test_vi: a2", i, a2[i], true);
115 }
116 test_cp(a1, a2);
117 for (int i=0; i<ARRLEN; i++) {
118 errn += verify("test_cp: a1", i, a1[i], true);
119 }
120 test_2ci(a1, a2);
121 for (int i=0; i<ARRLEN; i++) {
122 errn += verify("test_2ci: a1", i, a1[i], false);
123 errn += verify("test_2ci: a2", i, a2[i], false);
124 }
125 test_2vi(a1, a2, true, true);
126 for (int i=0; i<ARRLEN; i++) {
127 errn += verify("test_2vi: a1", i, a1[i], true);
128 errn += verify("test_2vi: a2", i, a2[i], true);
129 }
130 // Reset for negative stride
131 for (int i=0; i<ARRLEN; i++) {
132 a1[i] = false;
133 a2[i] = false;
134 }
135 test_ci_neg(a1);
136 for (int i=0; i<ARRLEN; i++) {
137 errn += verify("test_ci_neg: a1", i, a1[i], false);
138 }
139 test_vi_neg(a2, true);
140 for (int i=0; i<ARRLEN; i++) {
141 errn += verify("test_vi_neg: a2", i, a2[i], true);
142 }
143 test_cp_neg(a1, a2);
144 for (int i=0; i<ARRLEN; i++) {
145 errn += verify("test_cp_neg: a1", i, a1[i], true);
146 }
147 test_2ci_neg(a1, a2);
148 for (int i=0; i<ARRLEN; i++) {
149 errn += verify("test_2ci_neg: a1", i, a1[i], false);
150 errn += verify("test_2ci_neg: a2", i, a2[i], false);
151 }
152 test_2vi_neg(a1, a2, true, true);
153 for (int i=0; i<ARRLEN; i++) {
154 errn += verify("test_2vi_neg: a1", i, a1[i], true);
155 errn += verify("test_2vi_neg: a2", i, a2[i], true);
156 }
157 // Reset for opposite stride
158 for (int i=0; i<ARRLEN; i++) {
159 a1[i] = false;
160 a2[i] = false;
161 }
162 test_ci_oppos(a1);
163 for (int i=0; i<ARRLEN; i++) {
164 errn += verify("test_ci_oppos: a1", i, a1[i], false);
165 }
166 test_vi_oppos(a2, true);
167 for (int i=0; i<ARRLEN; i++) {
168 errn += verify("test_vi_oppos: a2", i, a2[i], true);
169 }
170 test_cp_oppos(a1, a2);
171 for (int i=0; i<ARRLEN; i++) {
172 errn += verify("test_cp_oppos: a1", i, a1[i], true);
173 }
174 test_2ci_oppos(a1, a2);
175 for (int i=0; i<ARRLEN; i++) {
176 errn += verify("test_2ci_oppos: a1", i, a1[i], false);
177 errn += verify("test_2ci_oppos: a2", i, a2[i], false);
178 }
179 test_2vi_oppos(a1, a2, true, true);
180 for (int i=0; i<ARRLEN; i++) {
181 errn += verify("test_2vi_oppos: a1", i, a1[i], true);
182 errn += verify("test_2vi_oppos: a2", i, a2[i], true);
183 }
184 // Reset for indexing with offset
185 for (int i=0; i<ARRLEN; i++) {
186 a1[i] = false;
187 a2[i] = false;
188 }
189 test_ci_off(a1);
190 for (int i=OFFSET; i<ARRLEN; i++) {
191 errn += verify("test_ci_off: a1", i, a1[i], false);
192 }
193 test_vi_off(a2, true);
194 for (int i=OFFSET; i<ARRLEN; i++) {
195 errn += verify("test_vi_off: a2", i, a2[i], true);
196 }
197 test_cp_off(a1, a2);
198 for (int i=OFFSET; i<ARRLEN; i++) {
199 errn += verify("test_cp_off: a1", i, a1[i], true);
200 }
201 test_2ci_off(a1, a2);
202 for (int i=OFFSET; i<ARRLEN; i++) {
203 errn += verify("test_2ci_off: a1", i, a1[i], false);
204 errn += verify("test_2ci_off: a2", i, a2[i], false);
205 }
206 test_2vi_off(a1, a2, true, true);
207 for (int i=OFFSET; i<ARRLEN; i++) {
208 errn += verify("test_2vi_off: a1", i, a1[i], true);
209 errn += verify("test_2vi_off: a2", i, a2[i], true);
210 }
211 for (int i=0; i<OFFSET; i++) {
212 errn += verify("test_2vi_off: a1", i, a1[i], false);
213 errn += verify("test_2vi_off: a2", i, a2[i], false);
214 }
215 // Reset for indexing with invariant offset
216 for (int i=0; i<ARRLEN; i++) {
217 a1[i] = false;
218 a2[i] = false;
219 }
220 test_ci_inv(a1, OFFSET);
221 for (int i=OFFSET; i<ARRLEN; i++) {
222 errn += verify("test_ci_inv: a1", i, a1[i], false);
223 }
224 test_vi_inv(a2, true, OFFSET);
225 for (int i=OFFSET; i<ARRLEN; i++) {
226 errn += verify("test_vi_inv: a2", i, a2[i], true);
227 }
228 test_cp_inv(a1, a2, OFFSET);
229 for (int i=OFFSET; i<ARRLEN; i++) {
230 errn += verify("test_cp_inv: a1", i, a1[i], true);
231 }
232 test_2ci_inv(a1, a2, OFFSET);
233 for (int i=OFFSET; i<ARRLEN; i++) {
234 errn += verify("test_2ci_inv: a1", i, a1[i], false);
235 errn += verify("test_2ci_inv: a2", i, a2[i], false);
236 }
237 test_2vi_inv(a1, a2, true, true, OFFSET);
238 for (int i=OFFSET; i<ARRLEN; i++) {
239 errn += verify("test_2vi_inv: a1", i, a1[i], true);
240 errn += verify("test_2vi_inv: a2", i, a2[i], true);
241 }
242 for (int i=0; i<OFFSET; i++) {
243 errn += verify("test_2vi_inv: a1", i, a1[i], false);
244 errn += verify("test_2vi_inv: a2", i, a2[i], false);
245 }
246 // Reset for indexing with scale
247 for (int i=0; i<ARRLEN; i++) {
248 a1[i] = true;
249 a2[i] = false;
250 }
251 test_ci_scl(a1);
252 for (int i=0; i<ARRLEN; i++) {
253 boolean val = (i%SCALE != 0);
254 errn += verify("test_ci_scl: a1", i, a1[i], val);
255 }
256 test_vi_scl(a2, true);
257 for (int i=0; i<ARRLEN; i++) {
258 boolean val = (i%SCALE == 0);
259 errn += verify("test_vi_scl: a2", i, a2[i], val);
260 }
261 test_cp_scl(a1, a2);
262 for (int i=0; i<ARRLEN; i++) {
263 errn += verify("test_cp_scl: a1", i, a1[i], true);
264 }
265 test_2ci_scl(a1, a2);
266 for (int i=0; i<ARRLEN; i++) {
267 if (i%SCALE != 0) {
268 errn += verify("test_2ci_scl: a1", i, a1[i], true);
269 } else if (i*SCALE < ARRLEN) {
270 errn += verify("test_2ci_scl: a1", i*SCALE, a1[i*SCALE], false);
271 }
272 if (i%SCALE != 0) {
273 errn += verify("test_2ci_scl: a2", i, a2[i], false);
274 } else if (i*SCALE < ARRLEN) {
275 errn += verify("test_2ci_scl: a2", i*SCALE, a2[i*SCALE], false);
276 }
277 }
278 test_2vi_scl(a1, a2, false, true);
279 for (int i=0; i<ARRLEN; i++) {
280 if (i%SCALE != 0) {
281 errn += verify("test_2vi_scl: a1", i, a1[i], true);
282 } else if (i*SCALE < ARRLEN) {
283 errn += verify("test_2vi_scl: a1", i*SCALE, a1[i*SCALE], false);
284 }
285 if (i%SCALE != 0) {
286 errn += verify("test_2vi_scl: a2", i, a2[i], false);
287 } else if (i*SCALE < ARRLEN) {
288 errn += verify("test_2vi_scl: a2", i*SCALE, a2[i*SCALE], true);
289 }
290 }
291 // Reset for 2 arrays with relative aligned offset
292 for (int i=0; i<ARRLEN; i++) {
293 a1[i] = false;
294 a2[i] = false;
295 }
296 test_vi(a2, true);
297 test_cp_alndst(a1, a2);
298 for (int i=0; i<ALIGN_OFF; i++) {
299 errn += verify("test_cp_alndst: a1", i, a1[i], false);
300 }
301 for (int i=ALIGN_OFF; i<ARRLEN; i++) {
302 errn += verify("test_cp_alndst: a1", i, a1[i], true);
303 }
304 test_vi(a2, false);
305 test_cp_alnsrc(a1, a2);
306 for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
307 errn += verify("test_cp_alnsrc: a1", i, a1[i], false);
308 }
309 for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
310 errn += verify("test_cp_alnsrc: a1", i, a1[i], true);
311 }
312 for (int i=0; i<ARRLEN; i++) {
313 a1[i] = false;
314 a2[i] = false;
315 }
316 test_2ci_aln(a1, a2);
317 for (int i=0; i<ALIGN_OFF; i++) {
318 errn += verify("test_2ci_aln: a1", i, a1[i], false);
319 }
320 for (int i=ALIGN_OFF; i<ARRLEN; i++) {
321 errn += verify("test_2ci_aln: a1", i, a1[i], false);
322 }
323 for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
324 errn += verify("test_2ci_aln: a2", i, a2[i], false);
325 }
326 for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
327 errn += verify("test_2ci_aln: a2", i, a2[i], false);
328 }
329 for (int i=0; i<ARRLEN; i++) {
330 a1[i] = false;
331 a2[i] = false;
332 }
333 test_2vi_aln(a1, a2, true, true);
334 for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
335 errn += verify("test_2vi_aln: a1", i, a1[i], true);
336 }
337 for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
338 errn += verify("test_2vi_aln: a1", i, a1[i], false);
339 }
340 for (int i=0; i<ALIGN_OFF; i++) {
341 errn += verify("test_2vi_aln: a2", i, a2[i], false);
342 }
343 for (int i=ALIGN_OFF; i<ARRLEN; i++) {
344 errn += verify("test_2vi_aln: a2", i, a2[i], true);
345 }
346
347 // Reset for 2 arrays with relative unaligned offset
348 for (int i=0; i<ARRLEN; i++) {
349 a1[i] = false;
350 a2[i] = false;
351 }
352 test_vi(a2, true);
353 test_cp_unalndst(a1, a2);
354 for (int i=0; i<UNALIGN_OFF; i++) {
355 errn += verify("test_cp_unalndst: a1", i, a1[i], false);
356 }
357 for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
358 errn += verify("test_cp_unalndst: a1", i, a1[i], true);
359 }
360 test_vi(a2, false);
361 test_cp_unalnsrc(a1, a2);
362 for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
363 errn += verify("test_cp_unalnsrc: a1", i, a1[i], false);
364 }
365 for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
366 errn += verify("test_cp_unalnsrc: a1", i, a1[i], true);
367 }
368 for (int i=0; i<ARRLEN; i++) {
369 a1[i] = false;
370 a2[i] = false;
371 }
372 test_2ci_unaln(a1, a2);
373 for (int i=0; i<UNALIGN_OFF; i++) {
374 errn += verify("test_2ci_unaln: a1", i, a1[i], false);
375 }
376 for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
377 errn += verify("test_2ci_unaln: a1", i, a1[i], false);
378 }
379 for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
380 errn += verify("test_2ci_unaln: a2", i, a2[i], false);
381 }
382 for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
383 errn += verify("test_2ci_unaln: a2", i, a2[i], false);
384 }
385 for (int i=0; i<ARRLEN; i++) {
386 a1[i] = false;
387 a2[i] = false;
388 }
389 test_2vi_unaln(a1, a2, true, true);
390 for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
391 errn += verify("test_2vi_unaln: a1", i, a1[i], true);
392 }
393 for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
394 errn += verify("test_2vi_unaln: a1", i, a1[i], false);
395 }
396 for (int i=0; i<UNALIGN_OFF; i++) {
397 errn += verify("test_2vi_unaln: a2", i, a2[i], false);
398 }
399 for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
400 errn += verify("test_2vi_unaln: a2", i, a2[i], true);
401 }
402
403 // Reset for aligned overlap initialization
404 for (int i=0; i<ALIGN_OFF; i++) {
405 a1[i] = (i > 0);
406 }
407 for (int i=ALIGN_OFF; i<ARRLEN; i++) {
408 a1[i] = false;
409 }
410 test_cp_alndst(a1, a1);
411 for (int i=0; i<ARRLEN; i++) {
412 boolean v = (i%ALIGN_OFF > 0);
413 errn += verify("test_cp_alndst_overlap: a1", i, a1[i], v);
414 }
415 for (int i=0; i<ALIGN_OFF; i++) {
416 a1[i+ALIGN_OFF] = false;
417 }
418 test_cp_alnsrc(a1, a1);
419 for (int i=0; i<ALIGN_OFF; i++) {
420 errn += verify("test_cp_alnsrc_overlap: a1", i, a1[i], false);
421 }
422 for (int i=ALIGN_OFF; i<ARRLEN; i++) {
423 boolean v = (i%ALIGN_OFF > 0);
424 errn += verify("test_cp_alnsrc_overlap: a1", i, a1[i], v);
425 }
426 for (int i=0; i<ARRLEN; i++) {
427 a1[i] = false;
428 }
429 test_2ci_aln(a1, a1);
430 for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
431 errn += verify("test_2ci_aln_overlap: a1", i, a1[i], false);
432 }
433 for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
434 errn += verify("test_2ci_aln_overlap: a1", i, a1[i], false);
435 }
436 for (int i=0; i<ARRLEN; i++) {
437 a1[i] = false;
438 }
439 test_2vi_aln(a1, a1, true, true);
440 for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
441 errn += verify("test_2vi_aln_overlap: a1", i, a1[i], true);
442 }
443 for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
444 errn += verify("test_2vi_aln_overlap: a1", i, a1[i], true);
445 }
446
447 // Reset for unaligned overlap initialization
448 for (int i=0; i<UNALIGN_OFF; i++) {
449 a1[i] = (i > 0);
450 }
451 for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
452 a1[i] = false;
453 }
454 test_cp_unalndst(a1, a1);
455 for (int i=0; i<ARRLEN; i++) {
456 boolean v = (i%UNALIGN_OFF > 0);
457 errn += verify("test_cp_unalndst_overlap: a1", i, a1[i], v);
458 }
459 for (int i=0; i<UNALIGN_OFF; i++) {
460 a1[i+UNALIGN_OFF] = false;
461 }
462 test_cp_unalnsrc(a1, a1);
463 for (int i=0; i<UNALIGN_OFF; i++) {
464 errn += verify("test_cp_unalnsrc_overlap: a1", i, a1[i], false);
465 }
466 for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
467 boolean v = (i%UNALIGN_OFF > 0);
468 errn += verify("test_cp_unalnsrc_overlap: a1", i, a1[i], v);
469 }
470 for (int i=0; i<ARRLEN; i++) {
471 a1[i] = false;
472 }
473 test_2ci_unaln(a1, a1);
474 for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
475 errn += verify("test_2ci_unaln_overlap: a1", i, a1[i], false);
476 }
477 for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
478 errn += verify("test_2ci_unaln_overlap: a1", i, a1[i], false);
479 }
480 for (int i=0; i<ARRLEN; i++) {
481 a1[i] = false;
482 }
483 test_2vi_unaln(a1, a1, true, true);
484 for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
485 errn += verify("test_2vi_unaln_overlap: a1", i, a1[i], true);
486 }
487 for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
488 errn += verify("test_2vi_unaln_overlap: a1", i, a1[i], true);
489 }
490
491 }
492
493 if (errn > 0)
494 return errn;
495
496 System.out.println("Time");
497 long start, end;
498 start = System.currentTimeMillis();
499 for (int i=0; i<ITERS; i++) {
500 test_ci(a1);
501 }
502 end = System.currentTimeMillis();
503 System.out.println("test_ci: " + (end - start));
504 start = System.currentTimeMillis();
505 for (int i=0; i<ITERS; i++) {
506 test_vi(a2, true);
507 }
508 end = System.currentTimeMillis();
509 System.out.println("test_vi: " + (end - start));
510 start = System.currentTimeMillis();
511 for (int i=0; i<ITERS; i++) {
512 test_cp(a1, a2);
513 }
514 end = System.currentTimeMillis();
515 System.out.println("test_cp: " + (end - start));
516 start = System.currentTimeMillis();
517 for (int i=0; i<ITERS; i++) {
518 test_2ci(a1, a2);
519 }
520 end = System.currentTimeMillis();
521 System.out.println("test_2ci: " + (end - start));
522 start = System.currentTimeMillis();
523 for (int i=0; i<ITERS; i++) {
524 test_2vi(a1, a2, true, true);
525 }
526 end = System.currentTimeMillis();
527 System.out.println("test_2vi: " + (end - start));
528
529 start = System.currentTimeMillis();
530 for (int i=0; i<ITERS; i++) {
531 test_ci_neg(a1);
532 }
533 end = System.currentTimeMillis();
534 System.out.println("test_ci_neg: " + (end - start));
535 start = System.currentTimeMillis();
536 for (int i=0; i<ITERS; i++) {
537 test_vi_neg(a2, true);
538 }
539 end = System.currentTimeMillis();
540 System.out.println("test_vi_neg: " + (end - start));
541 start = System.currentTimeMillis();
542 for (int i=0; i<ITERS; i++) {
543 test_cp_neg(a1, a2);
544 }
545 end = System.currentTimeMillis();
546 System.out.println("test_cp_neg: " + (end - start));
547 start = System.currentTimeMillis();
548 for (int i=0; i<ITERS; i++) {
549 test_2ci_neg(a1, a2);
550 }
551 end = System.currentTimeMillis();
552 System.out.println("test_2ci_neg: " + (end - start));
553 start = System.currentTimeMillis();
554 for (int i=0; i<ITERS; i++) {
555 test_2vi_neg(a1, a2, true, true);
556 }
557 end = System.currentTimeMillis();
558 System.out.println("test_2vi_neg: " + (end - start));
559
560 start = System.currentTimeMillis();
561 for (int i=0; i<ITERS; i++) {
562 test_ci_oppos(a1);
563 }
564 end = System.currentTimeMillis();
565 System.out.println("test_ci_oppos: " + (end - start));
566 start = System.currentTimeMillis();
567 for (int i=0; i<ITERS; i++) {
568 test_vi_oppos(a2, true);
569 }
570 end = System.currentTimeMillis();
571 System.out.println("test_vi_oppos: " + (end - start));
572 start = System.currentTimeMillis();
573 for (int i=0; i<ITERS; i++) {
574 test_cp_oppos(a1, a2);
575 }
576 end = System.currentTimeMillis();
577 System.out.println("test_cp_oppos: " + (end - start));
578 start = System.currentTimeMillis();
579 for (int i=0; i<ITERS; i++) {
580 test_2ci_oppos(a1, a2);
581 }
582 end = System.currentTimeMillis();
583 System.out.println("test_2ci_oppos: " + (end - start));
584 start = System.currentTimeMillis();
585 for (int i=0; i<ITERS; i++) {
586 test_2vi_oppos(a1, a2, true, true);
587 }
588 end = System.currentTimeMillis();
589 System.out.println("test_2vi_oppos: " + (end - start));
590
591 start = System.currentTimeMillis();
592 for (int i=0; i<ITERS; i++) {
593 test_ci_off(a1);
594 }
595 end = System.currentTimeMillis();
596 System.out.println("test_ci_off: " + (end - start));
597 start = System.currentTimeMillis();
598 for (int i=0; i<ITERS; i++) {
599 test_vi_off(a2, true);
600 }
601 end = System.currentTimeMillis();
602 System.out.println("test_vi_off: " + (end - start));
603 start = System.currentTimeMillis();
604 for (int i=0; i<ITERS; i++) {
605 test_cp_off(a1, a2);
606 }
607 end = System.currentTimeMillis();
608 System.out.println("test_cp_off: " + (end - start));
609 start = System.currentTimeMillis();
610 for (int i=0; i<ITERS; i++) {
611 test_2ci_off(a1, a2);
612 }
613 end = System.currentTimeMillis();
614 System.out.println("test_2ci_off: " + (end - start));
615 start = System.currentTimeMillis();
616 for (int i=0; i<ITERS; i++) {
617 test_2vi_off(a1, a2, true, true);
618 }
619 end = System.currentTimeMillis();
620 System.out.println("test_2vi_off: " + (end - start));
621
622 start = System.currentTimeMillis();
623 for (int i=0; i<ITERS; i++) {
624 test_ci_inv(a1, OFFSET);
625 }
626 end = System.currentTimeMillis();
627 System.out.println("test_ci_inv: " + (end - start));
628 start = System.currentTimeMillis();
629 for (int i=0; i<ITERS; i++) {
630 test_vi_inv(a2, true, OFFSET);
631 }
632 end = System.currentTimeMillis();
633 System.out.println("test_vi_inv: " + (end - start));
634 start = System.currentTimeMillis();
635 for (int i=0; i<ITERS; i++) {
636 test_cp_inv(a1, a2, OFFSET);
637 }
638 end = System.currentTimeMillis();
639 System.out.println("test_cp_inv: " + (end - start));
640 start = System.currentTimeMillis();
641 for (int i=0; i<ITERS; i++) {
642 test_2ci_inv(a1, a2, OFFSET);
643 }
644 end = System.currentTimeMillis();
645 System.out.println("test_2ci_inv: " + (end - start));
646 start = System.currentTimeMillis();
647 for (int i=0; i<ITERS; i++) {
648 test_2vi_inv(a1, a2, true, true, OFFSET);
649 }
650 end = System.currentTimeMillis();
651 System.out.println("test_2vi_inv: " + (end - start));
652
653 start = System.currentTimeMillis();
654 for (int i=0; i<ITERS; i++) {
655 test_ci_scl(a1);
656 }
657 end = System.currentTimeMillis();
658 System.out.println("test_ci_scl: " + (end - start));
659 start = System.currentTimeMillis();
660 for (int i=0; i<ITERS; i++) {
661 test_vi_scl(a2, true);
662 }
663 end = System.currentTimeMillis();
664 System.out.println("test_vi_scl: " + (end - start));
665 start = System.currentTimeMillis();
666 for (int i=0; i<ITERS; i++) {
667 test_cp_scl(a1, a2);
668 }
669 end = System.currentTimeMillis();
670 System.out.println("test_cp_scl: " + (end - start));
671 start = System.currentTimeMillis();
672 for (int i=0; i<ITERS; i++) {
673 test_2ci_scl(a1, a2);
674 }
675 end = System.currentTimeMillis();
676 System.out.println("test_2ci_scl: " + (end - start));
677 start = System.currentTimeMillis();
678 for (int i=0; i<ITERS; i++) {
679 test_2vi_scl(a1, a2, true, true);
680 }
681 end = System.currentTimeMillis();
682 System.out.println("test_2vi_scl: " + (end - start));
683
684 start = System.currentTimeMillis();
685 for (int i=0; i<ITERS; i++) {
686 test_cp_alndst(a1, a2);
687 }
688 end = System.currentTimeMillis();
689 System.out.println("test_cp_alndst: " + (end - start));
690 start = System.currentTimeMillis();
691 for (int i=0; i<ITERS; i++) {
692 test_cp_alnsrc(a1, a2);
693 }
694 end = System.currentTimeMillis();
695 System.out.println("test_cp_alnsrc: " + (end - start));
696 start = System.currentTimeMillis();
697 for (int i=0; i<ITERS; i++) {
698 test_2ci_aln(a1, a2);
699 }
700 end = System.currentTimeMillis();
701 System.out.println("test_2ci_aln: " + (end - start));
702 start = System.currentTimeMillis();
703 for (int i=0; i<ITERS; i++) {
704 test_2vi_aln(a1, a2, true, true);
705 }
706 end = System.currentTimeMillis();
707 System.out.println("test_2vi_aln: " + (end - start));
708
709 start = System.currentTimeMillis();
710 for (int i=0; i<ITERS; i++) {
711 test_cp_unalndst(a1, a2);
712 }
713 end = System.currentTimeMillis();
714 System.out.println("test_cp_unalndst: " + (end - start));
715 start = System.currentTimeMillis();
716 for (int i=0; i<ITERS; i++) {
717 test_cp_unalnsrc(a1, a2);
718 }
719 end = System.currentTimeMillis();
720 System.out.println("test_cp_unalnsrc: " + (end - start));
721 start = System.currentTimeMillis();
722 for (int i=0; i<ITERS; i++) {
723 test_2ci_unaln(a1, a2);
724 }
725 end = System.currentTimeMillis();
726 System.out.println("test_2ci_unaln: " + (end - start));
727 start = System.currentTimeMillis();
728 for (int i=0; i<ITERS; i++) {
729 test_2vi_unaln(a1, a2, true, true);
730 }
731 end = System.currentTimeMillis();
732 System.out.println("test_2vi_unaln: " + (end - start));
733
734 return errn;
735 }
736
737 static void test_ci(boolean[] a) {
738 for (int i = 0; i < a.length; i+=1) {
739 a[i] = false;
740 }
741 }
742 static void test_vi(boolean[] a, boolean b) {
743 for (int i = 0; i < a.length; i+=1) {
744 a[i] = b;
745 }
746 }
747 static void test_cp(boolean[] a, boolean[] b) {
748 for (int i = 0; i < a.length; i+=1) {
749 a[i] = b[i];
750 }
751 }
752 static void test_2ci(boolean[] a, boolean[] b) {
753 for (int i = 0; i < a.length; i+=1) {
754 a[i] = false;
755 b[i] = false;
756 }
757 }
758 static void test_2vi(boolean[] a, boolean[] b, boolean c, boolean d) {
759 for (int i = 0; i < a.length; i+=1) {
760 a[i] = c;
761 b[i] = d;
762 }
763 }
764 static void test_ci_neg(boolean[] a) {
765 for (int i = a.length-1; i >= 0; i-=1) {
766 a[i] = false;
767 }
768 }
769 static void test_vi_neg(boolean[] a, boolean b) {
770 for (int i = a.length-1; i >= 0; i-=1) {
771 a[i] = b;
772 }
773 }
774 static void test_cp_neg(boolean[] a, boolean[] b) {
775 for (int i = a.length-1; i >= 0; i-=1) {
776 a[i] = b[i];
777 }
778 }
779 static void test_2ci_neg(boolean[] a, boolean[] b) {
780 for (int i = a.length-1; i >= 0; i-=1) {
781 a[i] = false;
782 b[i] = false;
783 }
784 }
785 static void test_2vi_neg(boolean[] a, boolean[] b, boolean c, boolean d) {
786 for (int i = a.length-1; i >= 0; i-=1) {
787 a[i] = c;
788 b[i] = d;
789 }
790 }
791 static void test_ci_oppos(boolean[] a) {
792 int limit = a.length-1;
793 for (int i = 0; i < a.length; i+=1) {
794 a[limit-i] = false;
795 }
796 }
797 static void test_vi_oppos(boolean[] a, boolean b) {
798 int limit = a.length-1;
799 for (int i = limit; i >= 0; i-=1) {
800 a[limit-i] = b;
801 }
802 }
803 static void test_cp_oppos(boolean[] a, boolean[] b) {
804 int limit = a.length-1;
805 for (int i = 0; i < a.length; i+=1) {
806 a[i] = b[limit-i];
807 }
808 }
809 static void test_2ci_oppos(boolean[] a, boolean[] b) {
810 int limit = a.length-1;
811 for (int i = 0; i < a.length; i+=1) {
812 a[limit-i] = false;
813 b[i] = false;
814 }
815 }
816 static void test_2vi_oppos(boolean[] a, boolean[] b, boolean c, boolean d) {
817 int limit = a.length-1;
818 for (int i = limit; i >= 0; i-=1) {
819 a[i] = c;
820 b[limit-i] = d;
821 }
822 }
823 static void test_ci_off(boolean[] a) {
824 for (int i = 0; i < a.length-OFFSET; i+=1) {
825 a[i+OFFSET] = false;
826 }
827 }
828 static void test_vi_off(boolean[] a, boolean b) {
829 for (int i = 0; i < a.length-OFFSET; i+=1) {
830 a[i+OFFSET] = b;
831 }
832 }
833 static void test_cp_off(boolean[] a, boolean[] b) {
834 for (int i = 0; i < a.length-OFFSET; i+=1) {
835 a[i+OFFSET] = b[i+OFFSET];
836 }
837 }
838 static void test_2ci_off(boolean[] a, boolean[] b) {
839 for (int i = 0; i < a.length-OFFSET; i+=1) {
840 a[i+OFFSET] = false;
841 b[i+OFFSET] = false;
842 }
843 }
844 static void test_2vi_off(boolean[] a, boolean[] b, boolean c, boolean d) {
845 for (int i = 0; i < a.length-OFFSET; i+=1) {
846 a[i+OFFSET] = c;
847 b[i+OFFSET] = d;
848 }
849 }
850 static void test_ci_inv(boolean[] a, int k) {
851 for (int i = 0; i < a.length-k; i+=1) {
852 a[i+k] = false;
853 }
854 }
855 static void test_vi_inv(boolean[] a, boolean b, int k) {
856 for (int i = 0; i < a.length-k; i+=1) {
857 a[i+k] = b;
858 }
859 }
860 static void test_cp_inv(boolean[] a, boolean[] b, int k) {
861 for (int i = 0; i < a.length-k; i+=1) {
862 a[i+k] = b[i+k];
863 }
864 }
865 static void test_2ci_inv(boolean[] a, boolean[] b, int k) {
866 for (int i = 0; i < a.length-k; i+=1) {
867 a[i+k] = false;
868 b[i+k] = false;
869 }
870 }
871 static void test_2vi_inv(boolean[] a, boolean[] b, boolean c, boolean d, int k) {
872 for (int i = 0; i < a.length-k; i+=1) {
873 a[i+k] = c;
874 b[i+k] = d;
875 }
876 }
877 static void test_ci_scl(boolean[] a) {
878 for (int i = 0; i*SCALE < a.length; i+=1) {
879 a[i*SCALE] = false;
880 }
881 }
882 static void test_vi_scl(boolean[] a, boolean b) {
883 for (int i = 0; i*SCALE < a.length; i+=1) {
884 a[i*SCALE] = b;
885 }
886 }
887 static void test_cp_scl(boolean[] a, boolean[] b) {
888 for (int i = 0; i*SCALE < a.length; i+=1) {
889 a[i*SCALE] = b[i*SCALE];
890 }
891 }
892 static void test_2ci_scl(boolean[] a, boolean[] b) {
893 for (int i = 0; i*SCALE < a.length; i+=1) {
894 a[i*SCALE] = false;
895 b[i*SCALE] = false;
896 }
897 }
898 static void test_2vi_scl(boolean[] a, boolean[] b, boolean c, boolean d) {
899 for (int i = 0; i*SCALE < a.length; i+=1) {
900 a[i*SCALE] = c;
901 b[i*SCALE] = d;
902 }
903 }
904 static void test_cp_alndst(boolean[] a, boolean[] b) {
905 for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
906 a[i+ALIGN_OFF] = b[i];
907 }
908 }
909 static void test_cp_alnsrc(boolean[] a, boolean[] b) {
910 for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
911 a[i] = b[i+ALIGN_OFF];
912 }
913 }
914 static void test_2ci_aln(boolean[] a, boolean[] b) {
915 for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
916 a[i+ALIGN_OFF] = false;
917 b[i] = false;
918 }
919 }
920 static void test_2vi_aln(boolean[] a, boolean[] b, boolean c, boolean d) {
921 for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
922 a[i] = c;
923 b[i+ALIGN_OFF] = d;
924 }
925 }
926 static void test_cp_unalndst(boolean[] a, boolean[] b) {
927 for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
928 a[i+UNALIGN_OFF] = b[i];
929 }
930 }
931 static void test_cp_unalnsrc(boolean[] a, boolean[] b) {
932 for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
933 a[i] = b[i+UNALIGN_OFF];
934 }
935 }
936 static void test_2ci_unaln(boolean[] a, boolean[] b) {
937 for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
938 a[i+UNALIGN_OFF] = false;
939 b[i] = false;
940 }
941 }
942 static void test_2vi_unaln(boolean[] a, boolean[] b, boolean c, boolean d) {
943 for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
944 a[i] = c;
945 b[i+UNALIGN_OFF] = d;
946 }
947 }
948
949 static int verify(String text, int i, boolean elem, boolean val) {
950 if (elem != val) {
951 System.err.println(text + "[" + i + "] = " + elem + " != " + val);
952 return 1;
953 }
954 return 0;
955 }
956 }