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