Mercurial > hg > truffle

comparison test/compiler/7119644/TestBooleanVect.java @ 6179:8c92982cbbc4

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