Mercurial > jdk8-mips64-public > hotspot / file revision
test/compiler/7119644/TestShortLongVect.java@dbb05f6d93c4
test/compiler/7119644/TestShortLongVect.java
Mon, 28 Jul 2014 15:06:38 -0700
- author
- fzhinkin
- date
- Mon, 28 Jul 2014 15:06:38 -0700
- changeset 6997
- dbb05f6d93c4
- parent 0
- f90c822e73f8
- permissions
- -rw-r--r--
8051344: JVM crashed in Compile::start() during method parsing w/ UseRTMDeopt turned on
Summary: call rtm_deopt() only if there were no compilation bailouts before.
Reviewed-by: kvn
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 */
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 TestShortLongVect
31 */
33 public class TestShortLongVect {
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;
41 public static void main(String args[]) {
42 System.out.println("Testing Short + Long 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 }
51 static int test() {
52 short[] a1 = new short[ARRLEN];
53 short[] a2 = new short[ARRLEN];
54 long[] b1 = new long[ARRLEN];
55 long[] b2 = new long[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, (long)103);
60 test_cp(a1, a2, b1, b2);
61 test_ci_neg(a1, b1);
62 test_vi_neg(a1, b1, (short)123, (long)103);
63 test_cp_neg(a1, a2, b1, b2);
64 test_ci_oppos(a1, b1);
65 test_vi_oppos(a1, b1, (short)123, (long)103);
66 test_cp_oppos(a1, a2, b1, b2);
67 test_ci_aln(a1, b1);
68 test_vi_aln(a1, b1, (short)123, (long)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, (long)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], (long)-103);
91 }
92 test_vi(a2, b2, (short)123, (long)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], (long)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], (long)103);
101 }
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], (long)-103);
114 }
115 test_vi_neg(a2, b2, (short)123, (long)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], (long)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], (long)103);
124 }
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], (long)-103);
137 }
138 test_vi_oppos(a2, b2, (short)123, (long)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], (long)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], (long)103);
147 }
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], (long)-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], (long)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], (long)-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], (long)123);
177 }
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], (long)-103);
192 }
193 for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
194 errn += verify("test_ci_aln: b1", i, b1[i], (long)-1);
195 }
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, (long)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], (long)-1);
210 }
211 for (int i=ALIGN_OFF; i<ARRLEN; i++) {
212 errn += verify("test_vi_aln: b1", i, b1[i], (long)103);
213 }
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], (long)-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], (long)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], (long)-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], (long)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], (long)-103);
257 }
258 for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
259 errn += verify("test_ci_unaln: b1", i, b1[i], (long)-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, (long)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], (long)-1);
274 }
275 for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
276 errn += verify("test_vi_unaln: b1", i, b1[i], (long)103);
277 }
279 // Reset for aligned overlap initialization
280 for (int i=0; i<ALIGN_OFF; i++) {
281 a1[i] = (short)i;
282 b1[i] = (long)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], (long)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], (long)-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], (long)v);
307 }
309 // Reset for unaligned overlap initialization
310 for (int i=0; i<UNALIGN_OFF; i++) {
311 a1[i] = (short)i;
312 b1[i] = (long)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], (long)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], (long)-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], (long)v);
337 }
339 }
341 if (errn > 0)
342 return errn;
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, (long)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, (long)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, (long)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, (long)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, (long)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 }
451 static void test_ci(short[] a, long[] 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, long[] b, short c, long 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, long[] c, long[] 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, long[] 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, long[] b, short c, long 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, long[] c, long[] 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, long[] 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, long[] b, short c, long 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, long[] c, long[] 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, long[] 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, long[] b, short c, long 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, long[] c, long[] 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, long[] c, long[] 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, long[] 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, long[] b, short c, long 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, long[] c, long[] 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, long[] c, long[] 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 }
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, long elem, long val) {
565 if (elem != val) {
566 System.err.println(text + "[" + i + "] = " + elem + " != " + val);
567 return 1;
568 }
569 return 0;
570 }
571 }
