TestFloatVect.java revision 11707:ad7af1afda7a 
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
35package compiler.codegen;
36
37public 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}
958