Mercurial > hg > truffle

comparison test/compiler/7119644/TestShortDoubleVect.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 TestShortDoubleVect
31 */
32
33 public class TestShortDoubleVect {
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 Short + Double 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 short[] a1 = new short[ARRLEN];
53 short[] a2 = new short[ARRLEN];
54 double[] b1 = new double[ARRLEN];
55 double[] b2 = new double[ARRLEN];
56 System.out.println("Warmup");
57 for (int i=0; i<ITERS; i++) {
58 test_ci(a1, b1);
59 test_vi(a2, b2, (short)123, 103.);
60 test_cp(a1, a2, b1, b2);
61 test_ci_neg(a1, b1);
62 test_vi_neg(a1, b1, (short)123, 103.);
63 test_cp_neg(a1, a2, b1, b2);
64 test_ci_oppos(a1, b1);
65 test_vi_oppos(a1, b1, (short)123, 103.);
66 test_cp_oppos(a1, a2, b1, b2);
67 test_ci_aln(a1, b1);
68 test_vi_aln(a1, b1, (short)123, 103.);
69 test_cp_alndst(a1, a2, b1, b2);
70 test_cp_alnsrc(a1, a2, b1, b2);
71 test_ci_unaln(a1, b1);
72 test_vi_unaln(a1, b1, (short)123, 103.);
73 test_cp_unalndst(a1, a2, b1, b2);
74 test_cp_unalnsrc(a1, a2, b1, b2);
75 }
76 // Initialize
77 for (int i=0; i<ARRLEN; i++) {
78 a1[i] = -1;
79 a2[i] = -1;
80 b1[i] = -1.;
81 b2[i] = -1.;
82 }
83 // Test and verify results
84 System.out.println("Verification");
85 int errn = 0;
86 {
87 test_ci(a1, b1);
88 for (int i=0; i<ARRLEN; i++) {
89 errn += verify("test_ci: a1", i, a1[i], (short)-123);
90 errn += verify("test_ci: b1", i, b1[i], -103.);
91 }
92 test_vi(a2, b2, (short)123, 103.);
93 for (int i=0; i<ARRLEN; i++) {
94 errn += verify("test_vi: a2", i, a2[i], (short)123);
95 errn += verify("test_vi: b2", i, b2[i], 103.);
96 }
97 test_cp(a1, a2, b1, b2);
98 for (int i=0; i<ARRLEN; i++) {
99 errn += verify("test_cp: a1", i, a1[i], (short)123);
100 errn += verify("test_cp: b1", i, b1[i], 103.);
101 }
102
103 // Reset for negative stride
104 for (int i=0; i<ARRLEN; i++) {
105 a1[i] = -1;
106 a2[i] = -1;
107 b1[i] = -1.;
108 b2[i] = -1.;
109 }
110 test_ci_neg(a1, b1);
111 for (int i=0; i<ARRLEN; i++) {
112 errn += verify("test_ci_neg: a1", i, a1[i], (short)-123);
113 errn += verify("test_ci_neg: b1", i, b1[i], -103.);
114 }
115 test_vi_neg(a2, b2, (short)123, 103.);
116 for (int i=0; i<ARRLEN; i++) {
117 errn += verify("test_vi_neg: a2", i, a2[i], (short)123);
118 errn += verify("test_vi_neg: b2", i, b2[i], 103.);
119 }
120 test_cp_neg(a1, a2, b1, b2);
121 for (int i=0; i<ARRLEN; i++) {
122 errn += verify("test_cp_neg: a1", i, a1[i], (short)123);
123 errn += verify("test_cp_neg: b1", i, b1[i], 103.);
124 }
125
126 // Reset for opposite stride
127 for (int i=0; i<ARRLEN; i++) {
128 a1[i] = -1;
129 a2[i] = -1;
130 b1[i] = -1.;
131 b2[i] = -1.;
132 }
133 test_ci_oppos(a1, b1);
134 for (int i=0; i<ARRLEN; i++) {
135 errn += verify("test_ci_oppos: a1", i, a1[i], (short)-123);
136 errn += verify("test_ci_oppos: b1", i, b1[i], -103.);
137 }
138 test_vi_oppos(a2, b2, (short)123, 103.);
139 for (int i=0; i<ARRLEN; i++) {
140 errn += verify("test_vi_oppos: a2", i, a2[i], (short)123);
141 errn += verify("test_vi_oppos: b2", i, b2[i], 103.);
142 }
143 test_cp_oppos(a1, a2, b1, b2);
144 for (int i=0; i<ARRLEN; i++) {
145 errn += verify("test_cp_oppos: a1", i, a1[i], (short)123);
146 errn += verify("test_cp_oppos: b1", i, b1[i], 103.);
147 }
148
149 // Reset for 2 arrays with relative aligned offset
150 for (int i=0; i<ARRLEN; i++) {
151 a1[i] = -1;
152 a2[i] = 123;
153 b1[i] = -1.;
154 b2[i] = 123.;
155 }
156 test_cp_alndst(a1, a2, b1, b2);
157 for (int i=0; i<ALIGN_OFF; i++) {
158 errn += verify("test_cp_alndst: a1", i, a1[i], (short)-1);
159 errn += verify("test_cp_alndst: b1", i, b1[i], -1.);
160 }
161 for (int i=ALIGN_OFF; i<ARRLEN; i++) {
162 errn += verify("test_cp_alndst: a1", i, a1[i], (short)123);
163 errn += verify("test_cp_alndst: b1", i, b1[i], 123.);
164 }
165 for (int i=0; i<ARRLEN; i++) {
166 a2[i] = -123;
167 b2[i] = -123.;
168 }
169 test_cp_alnsrc(a1, a2, b1, b2);
170 for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
171 errn += verify("test_cp_alnsrc: a1", i, a1[i], (short)-123);
172 errn += verify("test_cp_alnsrc: b1", i, b1[i], -123.);
173 }
174 for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
175 errn += verify("test_cp_alnsrc: a1", i, a1[i], (short)123);
176 errn += verify("test_cp_alnsrc: b1", i, b1[i], 123.);
177 }
178
179 for (int i=0; i<ARRLEN; i++) {
180 a1[i] = -1;
181 b1[i] = -1.;
182 }
183 test_ci_aln(a1, b1);
184 for (int i=0; i<ALIGN_OFF; i++) {
185 errn += verify("test_ci_aln: a1", i, a1[i], (short)-1);
186 }
187 for (int i=ALIGN_OFF; i<ARRLEN; i++) {
188 errn += verify("test_ci_aln: a1", i, a1[i], (short)-123);
189 }
190 for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
191 errn += verify("test_ci_aln: b1", i, b1[i], -103.);
192 }
193 for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
194 errn += verify("test_ci_aln: b1", i, b1[i], -1.);
195 }
196
197 for (int i=0; i<ARRLEN; i++) {
198 a1[i] = -1;
199 b1[i] = -1.;
200 }
201 test_vi_aln(a1, b1, (short)123, 103.);
202 for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
203 errn += verify("test_vi_aln: a1", i, a1[i], (short)123);
204 }
205 for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
206 errn += verify("test_vi_aln: a1", i, a1[i], (short)-1);
207 }
208 for (int i=0; i<ALIGN_OFF; i++) {
209 errn += verify("test_vi_aln: b1", i, b1[i], -1.);
210 }
211 for (int i=ALIGN_OFF; i<ARRLEN; i++) {
212 errn += verify("test_vi_aln: b1", i, b1[i], 103.);
213 }
214
215 // Reset for 2 arrays with relative unaligned offset
216 for (int i=0; i<ARRLEN; i++) {
217 a1[i] = -1;
218 a2[i] = 123;
219 b1[i] = -1.;
220 b2[i] = 123.;
221 }
222 test_cp_unalndst(a1, a2, b1, b2);
223 for (int i=0; i<UNALIGN_OFF; i++) {
224 errn += verify("test_cp_unalndst: a1", i, a1[i], (short)-1);
225 errn += verify("test_cp_unalndst: b1", i, b1[i], -1.);
226 }
227 for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
228 errn += verify("test_cp_unalndst: a1", i, a1[i], (short)123);
229 errn += verify("test_cp_unalndst: b1", i, b1[i], 123.);
230 }
231 for (int i=0; i<ARRLEN; i++) {
232 a2[i] = -123;
233 b2[i] = -123.;
234 }
235 test_cp_unalnsrc(a1, a2, b1, b2);
236 for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
237 errn += verify("test_cp_unalnsrc: a1", i, a1[i], (short)-123);
238 errn += verify("test_cp_unalnsrc: b1", i, b1[i], -123.);
239 }
240 for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
241 errn += verify("test_cp_unalnsrc: a1", i, a1[i], (short)123);
242 errn += verify("test_cp_unalnsrc: b1", i, b1[i], 123.);
243 }
244 for (int i=0; i<ARRLEN; i++) {
245 a1[i] = -1;
246 b1[i] = -1;
247 }
248 test_ci_unaln(a1, b1);
249 for (int i=0; i<UNALIGN_OFF; i++) {
250 errn += verify("test_ci_unaln: a1", i, a1[i], (short)-1);
251 }
252 for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
253 errn += verify("test_ci_unaln: a1", i, a1[i], (short)-123);
254 }
255 for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
256 errn += verify("test_ci_unaln: b1", i, b1[i], -103.);
257 }
258 for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
259 errn += verify("test_ci_unaln: b1", i, b1[i], -1.);
260 }
261 for (int i=0; i<ARRLEN; i++) {
262 a1[i] = -1;
263 b1[i] = -1;
264 }
265 test_vi_unaln(a1, b1, (short)123, 103.);
266 for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
267 errn += verify("test_vi_unaln: a1", i, a1[i], (short)123);
268 }
269 for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
270 errn += verify("test_vi_unaln: a1", i, a1[i], (short)-1);
271 }
272 for (int i=0; i<UNALIGN_OFF; i++) {
273 errn += verify("test_vi_unaln: b1", i, b1[i], -1.);
274 }
275 for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
276 errn += verify("test_vi_unaln: b1", i, b1[i], 103.);
277 }
278
279 // Reset for aligned overlap initialization
280 for (int i=0; i<ALIGN_OFF; i++) {
281 a1[i] = (short)i;
282 b1[i] = (double)i;
283 }
284 for (int i=ALIGN_OFF; i<ARRLEN; i++) {
285 a1[i] = -1;
286 b1[i] = -1.;
287 }
288 test_cp_alndst(a1, a1, b1, b1);
289 for (int i=0; i<ARRLEN; i++) {
290 int v = i%ALIGN_OFF;
291 errn += verify("test_cp_alndst_overlap: a1", i, a1[i], (short)v);
292 errn += verify("test_cp_alndst_overlap: b1", i, b1[i], (double)v);
293 }
294 for (int i=0; i<ALIGN_OFF; i++) {
295 a1[i+ALIGN_OFF] = -1;
296 b1[i+ALIGN_OFF] = -1.;
297 }
298 test_cp_alnsrc(a1, a1, b1, b1);
299 for (int i=0; i<ALIGN_OFF; i++) {
300 errn += verify("test_cp_alnsrc_overlap: a1", i, a1[i], (short)-1);
301 errn += verify("test_cp_alnsrc_overlap: b1", i, b1[i], -1.);
302 }
303 for (int i=ALIGN_OFF; i<ARRLEN; i++) {
304 int v = i%ALIGN_OFF;
305 errn += verify("test_cp_alnsrc_overlap: a1", i, a1[i], (short)v);
306 errn += verify("test_cp_alnsrc_overlap: b1", i, b1[i], (double)v);
307 }
308
309 // Reset for unaligned overlap initialization
310 for (int i=0; i<UNALIGN_OFF; i++) {
311 a1[i] = (short)i;
312 b1[i] = (double)i;
313 }
314 for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
315 a1[i] = -1;
316 b1[i] = -1.;
317 }
318 test_cp_unalndst(a1, a1, b1, b1);
319 for (int i=0; i<ARRLEN; i++) {
320 int v = i%UNALIGN_OFF;
321 errn += verify("test_cp_unalndst_overlap: a1", i, a1[i], (short)v);
322 errn += verify("test_cp_unalndst_overlap: b1", i, b1[i], (double)v);
323 }
324 for (int i=0; i<UNALIGN_OFF; i++) {
325 a1[i+UNALIGN_OFF] = -1;
326 b1[i+UNALIGN_OFF] = -1.;
327 }
328 test_cp_unalnsrc(a1, a1, b1, b1);
329 for (int i=0; i<UNALIGN_OFF; i++) {
330 errn += verify("test_cp_unalnsrc_overlap: a1", i, a1[i], (short)-1);
331 errn += verify("test_cp_unalnsrc_overlap: b1", i, b1[i], -1.);
332 }
333 for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
334 int v = i%UNALIGN_OFF;
335 errn += verify("test_cp_unalnsrc_overlap: a1", i, a1[i], (short)v);
336 errn += verify("test_cp_unalnsrc_overlap: b1", i, b1[i], (double)v);
337 }
338
339 }
340
341 if (errn > 0)
342 return errn;
343
344 System.out.println("Time");
345 long start, end;
346 start = System.currentTimeMillis();
347 for (int i=0; i<ITERS; i++) {
348 test_ci(a1, b1);
349 }
350 end = System.currentTimeMillis();
351 System.out.println("test_ci: " + (end - start));
352 start = System.currentTimeMillis();
353 for (int i=0; i<ITERS; i++) {
354 test_vi(a2, b2, (short)123, 103.);
355 }
356 end = System.currentTimeMillis();
357 System.out.println("test_vi: " + (end - start));
358 start = System.currentTimeMillis();
359 for (int i=0; i<ITERS; i++) {
360 test_cp(a1, a2, b1, b2);
361 }
362 end = System.currentTimeMillis();
363 System.out.println("test_cp: " + (end - start));
364 start = System.currentTimeMillis();
365 for (int i=0; i<ITERS; i++) {
366 test_ci_neg(a1, b1);
367 }
368 end = System.currentTimeMillis();
369 System.out.println("test_ci_neg: " + (end - start));
370 start = System.currentTimeMillis();
371 for (int i=0; i<ITERS; i++) {
372 test_vi_neg(a1, b1, (short)123, 103.);
373 }
374 end = System.currentTimeMillis();
375 System.out.println("test_vi_neg: " + (end - start));
376 start = System.currentTimeMillis();
377 for (int i=0; i<ITERS; i++) {
378 test_cp_neg(a1, a2, b1, b2);
379 }
380 end = System.currentTimeMillis();
381 System.out.println("test_cp_neg: " + (end - start));
382 start = System.currentTimeMillis();
383 for (int i=0; i<ITERS; i++) {
384 test_ci_oppos(a1, b1);
385 }
386 end = System.currentTimeMillis();
387 System.out.println("test_ci_oppos: " + (end - start));
388 start = System.currentTimeMillis();
389 for (int i=0; i<ITERS; i++) {
390 test_vi_oppos(a1, b1, (short)123, 103.);
391 }
392 end = System.currentTimeMillis();
393 System.out.println("test_vi_oppos: " + (end - start));
394 start = System.currentTimeMillis();
395 for (int i=0; i<ITERS; i++) {
396 test_cp_oppos(a1, a2, b1, b2);
397 }
398 end = System.currentTimeMillis();
399 System.out.println("test_cp_oppos: " + (end - start));
400 start = System.currentTimeMillis();
401 for (int i=0; i<ITERS; i++) {
402 test_ci_aln(a1, b1);
403 }
404 end = System.currentTimeMillis();
405 System.out.println("test_ci_aln: " + (end - start));
406 start = System.currentTimeMillis();
407 for (int i=0; i<ITERS; i++) {
408 test_vi_aln(a1, b1, (short)123, 103.);
409 }
410 end = System.currentTimeMillis();
411 System.out.println("test_vi_aln: " + (end - start));
412 start = System.currentTimeMillis();
413 for (int i=0; i<ITERS; i++) {
414 test_cp_alndst(a1, a2, b1, b2);
415 }
416 end = System.currentTimeMillis();
417 System.out.println("test_cp_alndst: " + (end - start));
418 start = System.currentTimeMillis();
419 for (int i=0; i<ITERS; i++) {
420 test_cp_alnsrc(a1, a2, b1, b2);
421 }
422 end = System.currentTimeMillis();
423 System.out.println("test_cp_alnsrc: " + (end - start));
424 start = System.currentTimeMillis();
425 for (int i=0; i<ITERS; i++) {
426 test_ci_unaln(a1, b1);
427 }
428 end = System.currentTimeMillis();
429 System.out.println("test_ci_unaln: " + (end - start));
430 start = System.currentTimeMillis();
431 for (int i=0; i<ITERS; i++) {
432 test_vi_unaln(a1, b1, (short)123, 103.);
433 }
434 end = System.currentTimeMillis();
435 System.out.println("test_vi_unaln: " + (end - start));
436 start = System.currentTimeMillis();
437 for (int i=0; i<ITERS; i++) {
438 test_cp_unalndst(a1, a2, b1, b2);
439 }
440 end = System.currentTimeMillis();
441 System.out.println("test_cp_unalndst: " + (end - start));
442 start = System.currentTimeMillis();
443 for (int i=0; i<ITERS; i++) {
444 test_cp_unalnsrc(a1, a2, b1, b2);
445 }
446 end = System.currentTimeMillis();
447 System.out.println("test_cp_unalnsrc: " + (end - start));
448 return errn;
449 }
450
451 static void test_ci(short[] a, double[] b) {
452 for (int i = 0; i < a.length; i+=1) {
453 a[i] = -123;
454 b[i] = -103.;
455 }
456 }
457 static void test_vi(short[] a, double[] b, short c, double d) {
458 for (int i = 0; i < a.length; i+=1) {
459 a[i] = c;
460 b[i] = d;
461 }
462 }
463 static void test_cp(short[] a, short[] b, double[] c, double[] d) {
464 for (int i = 0; i < a.length; i+=1) {
465 a[i] = b[i];
466 c[i] = d[i];
467 }
468 }
469 static void test_ci_neg(short[] a, double[] b) {
470 for (int i = a.length-1; i >= 0; i-=1) {
471 a[i] = -123;
472 b[i] = -103.;
473 }
474 }
475 static void test_vi_neg(short[] a, double[] b, short c, double d) {
476 for (int i = a.length-1; i >= 0; i-=1) {
477 a[i] = c;
478 b[i] = d;
479 }
480 }
481 static void test_cp_neg(short[] a, short[] b, double[] c, double[] d) {
482 for (int i = a.length-1; i >= 0; i-=1) {
483 a[i] = b[i];
484 c[i] = d[i];
485 }
486 }
487 static void test_ci_oppos(short[] a, double[] b) {
488 int limit = a.length-1;
489 for (int i = 0; i < a.length; i+=1) {
490 a[limit-i] = -123;
491 b[i] = -103.;
492 }
493 }
494 static void test_vi_oppos(short[] a, double[] b, short c, double d) {
495 int limit = a.length-1;
496 for (int i = a.length-1; i >= 0; i-=1) {
497 a[i] = c;
498 b[limit-i] = d;
499 }
500 }
501 static void test_cp_oppos(short[] a, short[] b, double[] c, double[] d) {
502 int limit = a.length-1;
503 for (int i = 0; i < a.length; i+=1) {
504 a[i] = b[limit-i];
505 c[limit-i] = d[i];
506 }
507 }
508 static void test_ci_aln(short[] a, double[] b) {
509 for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
510 a[i+ALIGN_OFF] = -123;
511 b[i] = -103.;
512 }
513 }
514 static void test_vi_aln(short[] a, double[] b, short c, double d) {
515 for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
516 a[i] = c;
517 b[i+ALIGN_OFF] = d;
518 }
519 }
520 static void test_cp_alndst(short[] a, short[] b, double[] c, double[] d) {
521 for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
522 a[i+ALIGN_OFF] = b[i];
523 c[i+ALIGN_OFF] = d[i];
524 }
525 }
526 static void test_cp_alnsrc(short[] a, short[] b, double[] c, double[] d) {
527 for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
528 a[i] = b[i+ALIGN_OFF];
529 c[i] = d[i+ALIGN_OFF];
530 }
531 }
532 static void test_ci_unaln(short[] a, double[] b) {
533 for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
534 a[i+UNALIGN_OFF] = -123;
535 b[i] = -103.;
536 }
537 }
538 static void test_vi_unaln(short[] a, double[] b, short c, double d) {
539 for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
540 a[i] = c;
541 b[i+UNALIGN_OFF] = d;
542 }
543 }
544 static void test_cp_unalndst(short[] a, short[] b, double[] c, double[] d) {
545 for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
546 a[i+UNALIGN_OFF] = b[i];
547 c[i+UNALIGN_OFF] = d[i];
548 }
549 }
550 static void test_cp_unalnsrc(short[] a, short[] b, double[] c, double[] d) {
551 for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
552 a[i] = b[i+UNALIGN_OFF];
553 c[i] = d[i+UNALIGN_OFF];
554 }
555 }
556
557 static int verify(String text, int i, short elem, short val) {
558 if (elem != val) {
559 System.err.println(text + "[" + i + "] = " + elem + " != " + val);
560 return 1;
561 }
562 return 0;
563 }
564 static int verify(String text, int i, double elem, double val) {
565 if (elem != val) {
566 System.err.println(text + "[" + i + "] = " + elem + " != " + val);
567 return 1;
568 }
569 return 0;
570 }
571 }