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 6340864
28 * @summary Implement vectorization optimizations in hotspot-server
29 *
30 * @run main/othervm/timeout=400 -Xbatch -Xmx64m TestIntVect
31 */
32
33 public class TestIntVect {
34 private static final int ARRLEN = 997;
35 private static final int ITERS = 11000;
36 private static final int ADD_INIT = Integer.MAX_VALUE-500;
37 private static final int BIT_MASK = 0xEC80F731;
38 private static final int VALUE = 15;
39 private static final int SHIFT = 32;
40
41 public static void main(String args[]) {
42 System.out.println("Testing Integer 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 int[] a0 = new int[ARRLEN];
53 int[] a1 = new int[ARRLEN];
54 int[] a2 = new int[ARRLEN];
55 int[] a3 = new int[ARRLEN];
56 int[] a4 = new int[ARRLEN];
57 long[] p2 = new long[ARRLEN/2];
58 // Initialize
59 int gold_sum = 0;
60 for (int i=0; i<ARRLEN; i++) {
61 int val = (int)(ADD_INIT+i);
62 gold_sum += val;
63 a1[i] = val;
64 a2[i] = (int)VALUE;
65 a3[i] = (int)-VALUE;
66 a4[i] = (int)BIT_MASK;
67 }
68 System.out.println("Warmup");
69 for (int i=0; i<ITERS; i++) {
70 test_sum(a1);
71 test_addc(a0, a1);
72 test_addv(a0, a1, (int)VALUE);
73 test_adda(a0, a1, a2);
74 test_subc(a0, a1);
75 test_subv(a0, a1, (int)VALUE);
76 test_suba(a0, a1, a2);
77
78 test_mulc(a0, a1);
79 test_mulv(a0, a1, (int)VALUE);
80 test_mula(a0, a1, a2);
81 test_divc(a0, a1);
82 test_divv(a0, a1, (int)VALUE);
83 test_diva(a0, a1, a2);
84 test_mulc_n(a0, a1);
85 test_mulv(a0, a1, (int)-VALUE);
86 test_mula(a0, a1, a3);
87 test_divc_n(a0, a1);
88 test_divv(a0, a1, (int)-VALUE);
89 test_diva(a0, a1, a3);
90
91 test_andc(a0, a1);
92 test_andv(a0, a1, (int)BIT_MASK);
93 test_anda(a0, a1, a4);
94 test_orc(a0, a1);
95 test_orv(a0, a1, (int)BIT_MASK);
96 test_ora(a0, a1, a4);
97 test_xorc(a0, a1);
98 test_xorv(a0, a1, (int)BIT_MASK);
99 test_xora(a0, a1, a4);
100
101 test_sllc(a0, a1);
102 test_sllv(a0, a1, VALUE);
103 test_srlc(a0, a1);
104 test_srlv(a0, a1, VALUE);
105 test_srac(a0, a1);
106 test_srav(a0, a1, VALUE);
107
108 test_sllc_n(a0, a1);
109 test_sllv(a0, a1, -VALUE);
110 test_srlc_n(a0, a1);
111 test_srlv(a0, a1, -VALUE);
112 test_srac_n(a0, a1);
113 test_srav(a0, a1, -VALUE);
114
115 test_sllc_o(a0, a1);
116 test_sllv(a0, a1, SHIFT);
117 test_srlc_o(a0, a1);
118 test_srlv(a0, a1, SHIFT);
119 test_srac_o(a0, a1);
120 test_srav(a0, a1, SHIFT);
121
122 test_sllc_on(a0, a1);
123 test_sllv(a0, a1, -SHIFT);
124 test_srlc_on(a0, a1);
125 test_srlv(a0, a1, -SHIFT);
126 test_srac_on(a0, a1);
127 test_srav(a0, a1, -SHIFT);
128
129 test_sllc_add(a0, a1);
130 test_sllv_add(a0, a1, ADD_INIT);
131 test_srlc_add(a0, a1);
132 test_srlv_add(a0, a1, ADD_INIT);
133 test_srac_add(a0, a1);
134 test_srav_add(a0, a1, ADD_INIT);
135
136 test_sllc_and(a0, a1);
137 test_sllv_and(a0, a1, BIT_MASK);
138 test_srlc_and(a0, a1);
139 test_srlv_and(a0, a1, BIT_MASK);
140 test_srac_and(a0, a1);
141 test_srav_and(a0, a1, BIT_MASK);
142
143 test_pack2(p2, a1);
144 test_unpack2(a0, p2);
145 test_pack2_swap(p2, a1);
146 test_unpack2_swap(a0, p2);
147 }
148 // Test and verify results
149 System.out.println("Verification");
150 int errn = 0;
151 {
152 int sum = test_sum(a1);
153 if (sum != gold_sum) {
154 System.err.println("test_sum: " + sum + " != " + gold_sum);
155 errn++;
156 }
157
158 test_addc(a0, a1);
159 for (int i=0; i<ARRLEN; i++) {
160 errn += verify("test_addc: ", i, a0[i], (int)((int)(ADD_INIT+i)+VALUE));
161 }
162 test_addv(a0, a1, (int)VALUE);
163 for (int i=0; i<ARRLEN; i++) {
164 errn += verify("test_addv: ", i, a0[i], (int)((int)(ADD_INIT+i)+VALUE));
165 }
166 test_adda(a0, a1, a2);
167 for (int i=0; i<ARRLEN; i++) {
168 errn += verify("test_adda: ", i, a0[i], (int)((int)(ADD_INIT+i)+VALUE));
169 }
170
171 test_subc(a0, a1);
172 for (int i=0; i<ARRLEN; i++) {
173 errn += verify("test_subc: ", i, a0[i], (int)((int)(ADD_INIT+i)-VALUE));
174 }
175 test_subv(a0, a1, (int)VALUE);
176 for (int i=0; i<ARRLEN; i++) {
177 errn += verify("test_subv: ", i, a0[i], (int)((int)(ADD_INIT+i)-VALUE));
178 }
179 test_suba(a0, a1, a2);
180 for (int i=0; i<ARRLEN; i++) {
181 errn += verify("test_suba: ", i, a0[i], (int)((int)(ADD_INIT+i)-VALUE));
182 }
183
184 test_mulc(a0, a1);
185 for (int i=0; i<ARRLEN; i++) {
186 errn += verify("test_mulc: ", i, a0[i], (int)((int)(ADD_INIT+i)*VALUE));
187 }
188 test_mulv(a0, a1, (int)VALUE);
189 for (int i=0; i<ARRLEN; i++) {
190 errn += verify("test_mulv: ", i, a0[i], (int)((int)(ADD_INIT+i)*VALUE));
191 }
192 test_mula(a0, a1, a2);
193 for (int i=0; i<ARRLEN; i++) {
194 errn += verify("test_mula: ", i, a0[i], (int)((int)(ADD_INIT+i)*VALUE));
195 }
196
197 test_divc(a0, a1);
198 for (int i=0; i<ARRLEN; i++) {
199 errn += verify("test_divc: ", i, a0[i], (int)((int)(ADD_INIT+i)/VALUE));
200 }
201 test_divv(a0, a1, (int)VALUE);
202 for (int i=0; i<ARRLEN; i++) {
203 errn += verify("test_divv: ", i, a0[i], (int)((int)(ADD_INIT+i)/VALUE));
204 }
205 test_diva(a0, a1, a2);
206 for (int i=0; i<ARRLEN; i++) {
207 errn += verify("test_diva: ", i, a0[i], (int)((int)(ADD_INIT+i)/VALUE));
208 }
209
210 test_mulc_n(a0, a1);
211 for (int i=0; i<ARRLEN; i++) {
212 errn += verify("test_mulc_n: ", i, a0[i], (int)((int)(ADD_INIT+i)*(-VALUE)));
213 }
214 test_mulv(a0, a1, (int)-VALUE);
215 for (int i=0; i<ARRLEN; i++) {
216 errn += verify("test_mulv_n: ", i, a0[i], (int)((int)(ADD_INIT+i)*(-VALUE)));
217 }
218 test_mula(a0, a1, a3);
219 for (int i=0; i<ARRLEN; i++) {
220 errn += verify("test_mula_n: ", i, a0[i], (int)((int)(ADD_INIT+i)*(-VALUE)));
221 }
222
223 test_divc_n(a0, a1);
224 for (int i=0; i<ARRLEN; i++) {
225 errn += verify("test_divc_n: ", i, a0[i], (int)((int)(ADD_INIT+i)/(-VALUE)));
226 }
227 test_divv(a0, a1, (int)-VALUE);
228 for (int i=0; i<ARRLEN; i++) {
229 errn += verify("test_divv_n: ", i, a0[i], (int)((int)(ADD_INIT+i)/(-VALUE)));
230 }
231 test_diva(a0, a1, a3);
232 for (int i=0; i<ARRLEN; i++) {
233 errn += verify("test_diva_n: ", i, a0[i], (int)((int)(ADD_INIT+i)/(-VALUE)));
234 }
235
236 test_andc(a0, a1);
237 for (int i=0; i<ARRLEN; i++) {
238 errn += verify("test_andc: ", i, a0[i], (int)((int)(ADD_INIT+i)&BIT_MASK));
239 }
240 test_andv(a0, a1, (int)BIT_MASK);
241 for (int i=0; i<ARRLEN; i++) {
242 errn += verify("test_andv: ", i, a0[i], (int)((int)(ADD_INIT+i)&BIT_MASK));
243 }
244 test_anda(a0, a1, a4);
245 for (int i=0; i<ARRLEN; i++) {
246 errn += verify("test_anda: ", i, a0[i], (int)((int)(ADD_INIT+i)&BIT_MASK));
247 }
248
249 test_orc(a0, a1);
250 for (int i=0; i<ARRLEN; i++) {
251 errn += verify("test_orc: ", i, a0[i], (int)((int)(ADD_INIT+i)|BIT_MASK));
252 }
253 test_orv(a0, a1, (int)BIT_MASK);
254 for (int i=0; i<ARRLEN; i++) {
255 errn += verify("test_orv: ", i, a0[i], (int)((int)(ADD_INIT+i)|BIT_MASK));
256 }
257 test_ora(a0, a1, a4);
258 for (int i=0; i<ARRLEN; i++) {
259 errn += verify("test_ora: ", i, a0[i], (int)((int)(ADD_INIT+i)|BIT_MASK));
260 }
261
262 test_xorc(a0, a1);
263 for (int i=0; i<ARRLEN; i++) {
264 errn += verify("test_xorc: ", i, a0[i], (int)((int)(ADD_INIT+i)^BIT_MASK));
265 }
266 test_xorv(a0, a1, (int)BIT_MASK);
267 for (int i=0; i<ARRLEN; i++) {
268 errn += verify("test_xorv: ", i, a0[i], (int)((int)(ADD_INIT+i)^BIT_MASK));
269 }
270 test_xora(a0, a1, a4);
271 for (int i=0; i<ARRLEN; i++) {
272 errn += verify("test_xora: ", i, a0[i], (int)((int)(ADD_INIT+i)^BIT_MASK));
273 }
274
275 test_sllc(a0, a1);
276 for (int i=0; i<ARRLEN; i++) {
277 errn += verify("test_sllc: ", i, a0[i], (int)((int)(ADD_INIT+i)<<VALUE));
278 }
279 test_sllv(a0, a1, VALUE);
280 for (int i=0; i<ARRLEN; i++) {
281 errn += verify("test_sllv: ", i, a0[i], (int)((int)(ADD_INIT+i)<<VALUE));
282 }
283
284 test_srlc(a0, a1);
285 for (int i=0; i<ARRLEN; i++) {
286 errn += verify("test_srlc: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>VALUE));
287 }
288 test_srlv(a0, a1, VALUE);
289 for (int i=0; i<ARRLEN; i++) {
290 errn += verify("test_srlv: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>VALUE));
291 }
292
293 test_srac(a0, a1);
294 for (int i=0; i<ARRLEN; i++) {
295 errn += verify("test_srac: ", i, a0[i], (int)((int)(ADD_INIT+i)>>VALUE));
296 }
297 test_srav(a0, a1, VALUE);
298 for (int i=0; i<ARRLEN; i++) {
299 errn += verify("test_srav: ", i, a0[i], (int)((int)(ADD_INIT+i)>>VALUE));
300 }
301
302 test_sllc_n(a0, a1);
303 for (int i=0; i<ARRLEN; i++) {
304 errn += verify("test_sllc_n: ", i, a0[i], (int)((int)(ADD_INIT+i)<<(-VALUE)));
305 }
306 test_sllv(a0, a1, -VALUE);
307 for (int i=0; i<ARRLEN; i++) {
308 errn += verify("test_sllv_n: ", i, a0[i], (int)((int)(ADD_INIT+i)<<(-VALUE)));
309 }
310
311 test_srlc_n(a0, a1);
312 for (int i=0; i<ARRLEN; i++) {
313 errn += verify("test_srlc_n: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>(-VALUE)));
314 }
315 test_srlv(a0, a1, -VALUE);
316 for (int i=0; i<ARRLEN; i++) {
317 errn += verify("test_srlv_n: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>(-VALUE)));
318 }
319
320 test_srac_n(a0, a1);
321 for (int i=0; i<ARRLEN; i++) {
322 errn += verify("test_srac_n: ", i, a0[i], (int)((int)(ADD_INIT+i)>>(-VALUE)));
323 }
324 test_srav(a0, a1, -VALUE);
325 for (int i=0; i<ARRLEN; i++) {
326 errn += verify("test_srav_n: ", i, a0[i], (int)((int)(ADD_INIT+i)>>(-VALUE)));
327 }
328
329 test_sllc_o(a0, a1);
330 for (int i=0; i<ARRLEN; i++) {
331 errn += verify("test_sllc_o: ", i, a0[i], (int)((int)(ADD_INIT+i)<<SHIFT));
332 }
333 test_sllv(a0, a1, SHIFT);
334 for (int i=0; i<ARRLEN; i++) {
335 errn += verify("test_sllv_o: ", i, a0[i], (int)((int)(ADD_INIT+i)<<SHIFT));
336 }
337
338 test_srlc_o(a0, a1);
339 for (int i=0; i<ARRLEN; i++) {
340 errn += verify("test_srlc_o: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>SHIFT));
341 }
342 test_srlv(a0, a1, SHIFT);
343 for (int i=0; i<ARRLEN; i++) {
344 errn += verify("test_srlv_o: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>SHIFT));
345 }
346
347 test_srac_o(a0, a1);
348 for (int i=0; i<ARRLEN; i++) {
349 errn += verify("test_srac_o: ", i, a0[i], (int)((int)(ADD_INIT+i)>>SHIFT));
350 }
351 test_srav(a0, a1, SHIFT);
352 for (int i=0; i<ARRLEN; i++) {
353 errn += verify("test_srav_o: ", i, a0[i], (int)((int)(ADD_INIT+i)>>SHIFT));
354 }
355
356 test_sllc_on(a0, a1);
357 for (int i=0; i<ARRLEN; i++) {
358 errn += verify("test_sllc_on: ", i, a0[i], (int)((int)(ADD_INIT+i)<<(-SHIFT)));
359 }
360 test_sllv(a0, a1, -SHIFT);
361 for (int i=0; i<ARRLEN; i++) {
362 errn += verify("test_sllv_on: ", i, a0[i], (int)((int)(ADD_INIT+i)<<(-SHIFT)));
363 }
364
365 test_srlc_on(a0, a1);
366 for (int i=0; i<ARRLEN; i++) {
367 errn += verify("test_srlc_on: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>(-SHIFT)));
368 }
369 test_srlv(a0, a1, -SHIFT);
370 for (int i=0; i<ARRLEN; i++) {
371 errn += verify("test_srlv_on: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>(-SHIFT)));
372 }
373
374 test_srac_on(a0, a1);
375 for (int i=0; i<ARRLEN; i++) {
376 errn += verify("test_srac_on: ", i, a0[i], (int)((int)(ADD_INIT+i)>>(-SHIFT)));
377 }
378 test_srav(a0, a1, -SHIFT);
379 for (int i=0; i<ARRLEN; i++) {
380 errn += verify("test_srav_on: ", i, a0[i], (int)((int)(ADD_INIT+i)>>(-SHIFT)));
381 }
382
383 test_sllc_add(a0, a1);
384 for (int i=0; i<ARRLEN; i++) {
385 errn += verify("test_sllc_add: ", i, a0[i], (int)(((int)(ADD_INIT+i) + ADD_INIT)<<VALUE));
386 }
387 test_sllv_add(a0, a1, ADD_INIT);
388 for (int i=0; i<ARRLEN; i++) {
389 errn += verify("test_sllv_add: ", i, a0[i], (int)(((int)(ADD_INIT+i) + ADD_INIT)<<VALUE));
390 }
391
392 test_srlc_add(a0, a1);
393 for (int i=0; i<ARRLEN; i++) {
394 errn += verify("test_srlc_add: ", i, a0[i], (int)(((int)(ADD_INIT+i) + ADD_INIT)>>>VALUE));
395 }
396 test_srlv_add(a0, a1, ADD_INIT);
397 for (int i=0; i<ARRLEN; i++) {
398 errn += verify("test_srlv_add: ", i, a0[i], (int)(((int)(ADD_INIT+i) + ADD_INIT)>>>VALUE));
399 }
400
401 test_srac_add(a0, a1);
402 for (int i=0; i<ARRLEN; i++) {
403 errn += verify("test_srac_add: ", i, a0[i], (int)(((int)(ADD_INIT+i) + ADD_INIT)>>VALUE));
404 }
405 test_srav_add(a0, a1, ADD_INIT);
406 for (int i=0; i<ARRLEN; i++) {
407 errn += verify("test_srav_add: ", i, a0[i], (int)(((int)(ADD_INIT+i) + ADD_INIT)>>VALUE));
408 }
409
410 test_sllc_and(a0, a1);
411 for (int i=0; i<ARRLEN; i++) {
412 errn += verify("test_sllc_and: ", i, a0[i], (int)(((int)(ADD_INIT+i) & BIT_MASK)<<VALUE));
413 }
414 test_sllv_and(a0, a1, BIT_MASK);
415 for (int i=0; i<ARRLEN; i++) {
416 errn += verify("test_sllv_and: ", i, a0[i], (int)(((int)(ADD_INIT+i) & BIT_MASK)<<VALUE));
417 }
418
419 test_srlc_and(a0, a1);
420 for (int i=0; i<ARRLEN; i++) {
421 errn += verify("test_srlc_and: ", i, a0[i], (int)(((int)(ADD_INIT+i) & BIT_MASK)>>>VALUE));
422 }
423 test_srlv_and(a0, a1, BIT_MASK);
424 for (int i=0; i<ARRLEN; i++) {
425 errn += verify("test_srlv_and: ", i, a0[i], (int)(((int)(ADD_INIT+i) & BIT_MASK)>>>VALUE));
426 }
427
428 test_srac_and(a0, a1);
429 for (int i=0; i<ARRLEN; i++) {
430 errn += verify("test_srac_and: ", i, a0[i], (int)(((int)(ADD_INIT+i) & BIT_MASK)>>VALUE));
431 }
432 test_srav_and(a0, a1, BIT_MASK);
433 for (int i=0; i<ARRLEN; i++) {
434 errn += verify("test_srav_and: ", i, a0[i], (int)(((int)(ADD_INIT+i) & BIT_MASK)>>VALUE));
435 }
436
437 test_pack2(p2, a1);
438 for (int i=0; i<ARRLEN/2; i++) {
439 errn += verify("test_pack2: ", i, p2[i], ((long)(ADD_INIT+2*i) & 0xFFFFFFFFl) | ((long)(ADD_INIT+2*i+1) << 32));
440 }
441 for (int i=0; i<ARRLEN; i++) {
442 a0[i] = -1;
443 }
444 test_unpack2(a0, p2);
445 for (int i=0; i<(ARRLEN&(-2)); i++) {
446 errn += verify("test_unpack2: ", i, a0[i], (ADD_INIT+i));
447 }
448
449 test_pack2_swap(p2, a1);
450 for (int i=0; i<ARRLEN/2; i++) {
451 errn += verify("test_pack2_swap: ", i, p2[i], ((long)(ADD_INIT+2*i+1) & 0xFFFFFFFFl) | ((long)(ADD_INIT+2*i) << 32));
452 }
453 for (int i=0; i<ARRLEN; i++) {
454 a0[i] = -1;
455 }
456 test_unpack2_swap(a0, p2);
457 for (int i=0; i<(ARRLEN&(-2)); i++) {
458 errn += verify("test_unpack2_swap: ", i, a0[i], (ADD_INIT+i));
459 }
460
461 }
462
463 if (errn > 0)
464 return errn;
465
466 System.out.println("Time");
467 long start, end;
468
469 start = System.currentTimeMillis();
470 for (int i=0; i<ITERS; i++) {
471 test_sum(a1);
472 }
473 end = System.currentTimeMillis();
474 System.out.println("test_sum: " + (end - start));
475
476 start = System.currentTimeMillis();
477 for (int i=0; i<ITERS; i++) {
478 test_addc(a0, a1);
479 }
480 end = System.currentTimeMillis();
481 System.out.println("test_addc: " + (end - start));
482 start = System.currentTimeMillis();
483 for (int i=0; i<ITERS; i++) {
484 test_addv(a0, a1, (int)VALUE);
485 }
486 end = System.currentTimeMillis();
487 System.out.println("test_addv: " + (end - start));
488 start = System.currentTimeMillis();
489 for (int i=0; i<ITERS; i++) {
490 test_adda(a0, a1, a2);
491 }
492 end = System.currentTimeMillis();
493 System.out.println("test_adda: " + (end - start));
494
495 start = System.currentTimeMillis();
496 for (int i=0; i<ITERS; i++) {
497 test_subc(a0, a1);
498 }
499 end = System.currentTimeMillis();
500 System.out.println("test_subc: " + (end - start));
501 start = System.currentTimeMillis();
502 for (int i=0; i<ITERS; i++) {
503 test_subv(a0, a1, (int)VALUE);
504 }
505 end = System.currentTimeMillis();
506 System.out.println("test_subv: " + (end - start));
507 start = System.currentTimeMillis();
508 for (int i=0; i<ITERS; i++) {
509 test_suba(a0, a1, a2);
510 }
511 end = System.currentTimeMillis();
512 System.out.println("test_suba: " + (end - start));
513
514 start = System.currentTimeMillis();
515 for (int i=0; i<ITERS; i++) {
516 test_mulc(a0, a1);
517 }
518 end = System.currentTimeMillis();
519 System.out.println("test_mulc: " + (end - start));
520 start = System.currentTimeMillis();
521 for (int i=0; i<ITERS; i++) {
522 test_mulv(a0, a1, (int)VALUE);
523 }
524 end = System.currentTimeMillis();
525 System.out.println("test_mulv: " + (end - start));
526 start = System.currentTimeMillis();
527 for (int i=0; i<ITERS; i++) {
528 test_mula(a0, a1, a2);
529 }
530 end = System.currentTimeMillis();
531 System.out.println("test_mula: " + (end - start));
532
533 start = System.currentTimeMillis();
534 for (int i=0; i<ITERS; i++) {
535 test_divc(a0, a1);
536 }
537 end = System.currentTimeMillis();
538 System.out.println("test_divc: " + (end - start));
539 start = System.currentTimeMillis();
540 for (int i=0; i<ITERS; i++) {
541 test_divv(a0, a1, (int)VALUE);
542 }
543 end = System.currentTimeMillis();
544 System.out.println("test_divv: " + (end - start));
545 start = System.currentTimeMillis();
546 for (int i=0; i<ITERS; i++) {
547 test_diva(a0, a1, a2);
548 }
549 end = System.currentTimeMillis();
550 System.out.println("test_diva: " + (end - start));
551
552 start = System.currentTimeMillis();
553 for (int i=0; i<ITERS; i++) {
554 test_mulc_n(a0, a1);
555 }
556 end = System.currentTimeMillis();
557 System.out.println("test_mulc_n: " + (end - start));
558 start = System.currentTimeMillis();
559 for (int i=0; i<ITERS; i++) {
560 test_mulv(a0, a1, (int)-VALUE);
561 }
562 end = System.currentTimeMillis();
563 System.out.println("test_mulv_n: " + (end - start));
564 start = System.currentTimeMillis();
565 for (int i=0; i<ITERS; i++) {
566 test_mula(a0, a1, a3);
567 }
568 end = System.currentTimeMillis();
569 System.out.println("test_mula_n: " + (end - start));
570
571 start = System.currentTimeMillis();
572 for (int i=0; i<ITERS; i++) {
573 test_divc_n(a0, a1);
574 }
575 end = System.currentTimeMillis();
576 System.out.println("test_divc_n: " + (end - start));
577 start = System.currentTimeMillis();
578 for (int i=0; i<ITERS; i++) {
579 test_divv(a0, a1, (int)-VALUE);
580 }
581 end = System.currentTimeMillis();
582 System.out.println("test_divv_n: " + (end - start));
583 start = System.currentTimeMillis();
584 for (int i=0; i<ITERS; i++) {
585 test_diva(a0, a1, a3);
586 }
587 end = System.currentTimeMillis();
588 System.out.println("test_diva_n: " + (end - start));
589
590 start = System.currentTimeMillis();
591 for (int i=0; i<ITERS; i++) {
592 test_andc(a0, a1);
593 }
594 end = System.currentTimeMillis();
595 System.out.println("test_andc: " + (end - start));
596 start = System.currentTimeMillis();
597 for (int i=0; i<ITERS; i++) {
598 test_andv(a0, a1, (int)BIT_MASK);
599 }
600 end = System.currentTimeMillis();
601 System.out.println("test_andv: " + (end - start));
602 start = System.currentTimeMillis();
603 for (int i=0; i<ITERS; i++) {
604 test_anda(a0, a1, a4);
605 }
606 end = System.currentTimeMillis();
607 System.out.println("test_anda: " + (end - start));
608
609 start = System.currentTimeMillis();
610 for (int i=0; i<ITERS; i++) {
611 test_orc(a0, a1);
612 }
613 end = System.currentTimeMillis();
614 System.out.println("test_orc: " + (end - start));
615 start = System.currentTimeMillis();
616 for (int i=0; i<ITERS; i++) {
617 test_orv(a0, a1, (int)BIT_MASK);
618 }
619 end = System.currentTimeMillis();
620 System.out.println("test_orv: " + (end - start));
621 start = System.currentTimeMillis();
622 for (int i=0; i<ITERS; i++) {
623 test_ora(a0, a1, a4);
624 }
625 end = System.currentTimeMillis();
626 System.out.println("test_ora: " + (end - start));
627
628 start = System.currentTimeMillis();
629 for (int i=0; i<ITERS; i++) {
630 test_xorc(a0, a1);
631 }
632 end = System.currentTimeMillis();
633 System.out.println("test_xorc: " + (end - start));
634 start = System.currentTimeMillis();
635 for (int i=0; i<ITERS; i++) {
636 test_xorv(a0, a1, (int)BIT_MASK);
637 }
638 end = System.currentTimeMillis();
639 System.out.println("test_xorv: " + (end - start));
640 start = System.currentTimeMillis();
641 for (int i=0; i<ITERS; i++) {
642 test_xora(a0, a1, a4);
643 }
644 end = System.currentTimeMillis();
645 System.out.println("test_xora: " + (end - start));
646
647 start = System.currentTimeMillis();
648 for (int i=0; i<ITERS; i++) {
649 test_sllc(a0, a1);
650 }
651 end = System.currentTimeMillis();
652 System.out.println("test_sllc: " + (end - start));
653 start = System.currentTimeMillis();
654 for (int i=0; i<ITERS; i++) {
655 test_sllv(a0, a1, VALUE);
656 }
657 end = System.currentTimeMillis();
658 System.out.println("test_sllv: " + (end - start));
659
660 start = System.currentTimeMillis();
661 for (int i=0; i<ITERS; i++) {
662 test_srlc(a0, a1);
663 }
664 end = System.currentTimeMillis();
665 System.out.println("test_srlc: " + (end - start));
666 start = System.currentTimeMillis();
667 for (int i=0; i<ITERS; i++) {
668 test_srlv(a0, a1, VALUE);
669 }
670 end = System.currentTimeMillis();
671 System.out.println("test_srlv: " + (end - start));
672
673 start = System.currentTimeMillis();
674 for (int i=0; i<ITERS; i++) {
675 test_srac(a0, a1);
676 }
677 end = System.currentTimeMillis();
678 System.out.println("test_srac: " + (end - start));
679 start = System.currentTimeMillis();
680 for (int i=0; i<ITERS; i++) {
681 test_srav(a0, a1, VALUE);
682 }
683 end = System.currentTimeMillis();
684 System.out.println("test_srav: " + (end - start));
685
686 start = System.currentTimeMillis();
687 for (int i=0; i<ITERS; i++) {
688 test_sllc_n(a0, a1);
689 }
690 end = System.currentTimeMillis();
691 System.out.println("test_sllc_n: " + (end - start));
692 start = System.currentTimeMillis();
693 for (int i=0; i<ITERS; i++) {
694 test_sllv(a0, a1, -VALUE);
695 }
696 end = System.currentTimeMillis();
697 System.out.println("test_sllv_n: " + (end - start));
698
699 start = System.currentTimeMillis();
700 for (int i=0; i<ITERS; i++) {
701 test_srlc_n(a0, a1);
702 }
703 end = System.currentTimeMillis();
704 System.out.println("test_srlc_n: " + (end - start));
705 start = System.currentTimeMillis();
706 for (int i=0; i<ITERS; i++) {
707 test_srlv(a0, a1, -VALUE);
708 }
709 end = System.currentTimeMillis();
710 System.out.println("test_srlv_n: " + (end - start));
711
712 start = System.currentTimeMillis();
713 for (int i=0; i<ITERS; i++) {
714 test_srac_n(a0, a1);
715 }
716 end = System.currentTimeMillis();
717 System.out.println("test_srac_n: " + (end - start));
718 start = System.currentTimeMillis();
719 for (int i=0; i<ITERS; i++) {
720 test_srav(a0, a1, -VALUE);
721 }
722 end = System.currentTimeMillis();
723 System.out.println("test_srav_n: " + (end - start));
724
725 start = System.currentTimeMillis();
726 for (int i=0; i<ITERS; i++) {
727 test_sllc_o(a0, a1);
728 }
729 end = System.currentTimeMillis();
730 System.out.println("test_sllc_o: " + (end - start));
731 start = System.currentTimeMillis();
732 for (int i=0; i<ITERS; i++) {
733 test_sllv(a0, a1, SHIFT);
734 }
735 end = System.currentTimeMillis();
736 System.out.println("test_sllv_o: " + (end - start));
737
738 start = System.currentTimeMillis();
739 for (int i=0; i<ITERS; i++) {
740 test_srlc_o(a0, a1);
741 }
742 end = System.currentTimeMillis();
743 System.out.println("test_srlc_o: " + (end - start));
744 start = System.currentTimeMillis();
745 for (int i=0; i<ITERS; i++) {
746 test_srlv(a0, a1, SHIFT);
747 }
748 end = System.currentTimeMillis();
749 System.out.println("test_srlv_o: " + (end - start));
750
751 start = System.currentTimeMillis();
752 for (int i=0; i<ITERS; i++) {
753 test_srac_o(a0, a1);
754 }
755 end = System.currentTimeMillis();
756 System.out.println("test_srac_o: " + (end - start));
757 start = System.currentTimeMillis();
758 for (int i=0; i<ITERS; i++) {
759 test_srav(a0, a1, SHIFT);
760 }
761 end = System.currentTimeMillis();
762 System.out.println("test_srav_o: " + (end - start));
763
764 start = System.currentTimeMillis();
765 for (int i=0; i<ITERS; i++) {
766 test_sllc_on(a0, a1);
767 }
768 end = System.currentTimeMillis();
769 System.out.println("test_sllc_on: " + (end - start));
770 start = System.currentTimeMillis();
771 for (int i=0; i<ITERS; i++) {
772 test_sllv(a0, a1, -SHIFT);
773 }
774 end = System.currentTimeMillis();
775 System.out.println("test_sllv_on: " + (end - start));
776
777 start = System.currentTimeMillis();
778 for (int i=0; i<ITERS; i++) {
779 test_srlc_on(a0, a1);
780 }
781 end = System.currentTimeMillis();
782 System.out.println("test_srlc_on: " + (end - start));
783 start = System.currentTimeMillis();
784 for (int i=0; i<ITERS; i++) {
785 test_srlv(a0, a1, -SHIFT);
786 }
787 end = System.currentTimeMillis();
788 System.out.println("test_srlv_on: " + (end - start));
789
790 start = System.currentTimeMillis();
791 for (int i=0; i<ITERS; i++) {
792 test_srac_on(a0, a1);
793 }
794 end = System.currentTimeMillis();
795 System.out.println("test_srac_on: " + (end - start));
796 start = System.currentTimeMillis();
797 for (int i=0; i<ITERS; i++) {
798 test_srav(a0, a1, -SHIFT);
799 }
800 end = System.currentTimeMillis();
801 System.out.println("test_srav_on: " + (end - start));
802
803 start = System.currentTimeMillis();
804 for (int i=0; i<ITERS; i++) {
805 test_sllc_add(a0, a1);
806 }
807 end = System.currentTimeMillis();
808 System.out.println("test_sllc_add: " + (end - start));
809 start = System.currentTimeMillis();
810 for (int i=0; i<ITERS; i++) {
811 test_sllv_add(a0, a1, ADD_INIT);
812 }
813 end = System.currentTimeMillis();
814 System.out.println("test_sllv_add: " + (end - start));
815
816 start = System.currentTimeMillis();
817 for (int i=0; i<ITERS; i++) {
818 test_srlc_add(a0, a1);
819 }
820 end = System.currentTimeMillis();
821 System.out.println("test_srlc_add: " + (end - start));
822 start = System.currentTimeMillis();
823 for (int i=0; i<ITERS; i++) {
824 test_srlv_add(a0, a1, ADD_INIT);
825 }
826 end = System.currentTimeMillis();
827 System.out.println("test_srlv_add: " + (end - start));
828
829 start = System.currentTimeMillis();
830 for (int i=0; i<ITERS; i++) {
831 test_srac_add(a0, a1);
832 }
833 end = System.currentTimeMillis();
834 System.out.println("test_srac_add: " + (end - start));
835 start = System.currentTimeMillis();
836 for (int i=0; i<ITERS; i++) {
837 test_srav_add(a0, a1, ADD_INIT);
838 }
839 end = System.currentTimeMillis();
840 System.out.println("test_srav_add: " + (end - start));
841
842 start = System.currentTimeMillis();
843 for (int i=0; i<ITERS; i++) {
844 test_sllc_and(a0, a1);
845 }
846 end = System.currentTimeMillis();
847 System.out.println("test_sllc_and: " + (end - start));
848 start = System.currentTimeMillis();
849 for (int i=0; i<ITERS; i++) {
850 test_sllv_and(a0, a1, BIT_MASK);
851 }
852 end = System.currentTimeMillis();
853 System.out.println("test_sllv_and: " + (end - start));
854
855 start = System.currentTimeMillis();
856 for (int i=0; i<ITERS; i++) {
857 test_srlc_and(a0, a1);
858 }
859 end = System.currentTimeMillis();
860 System.out.println("test_srlc_and: " + (end - start));
861 start = System.currentTimeMillis();
862 for (int i=0; i<ITERS; i++) {
863 test_srlv_and(a0, a1, BIT_MASK);
864 }
865 end = System.currentTimeMillis();
866 System.out.println("test_srlv_and: " + (end - start));
867
868 start = System.currentTimeMillis();
869 for (int i=0; i<ITERS; i++) {
870 test_srac_and(a0, a1);
871 }
872 end = System.currentTimeMillis();
873 System.out.println("test_srac_and: " + (end - start));
874 start = System.currentTimeMillis();
875 for (int i=0; i<ITERS; i++) {
876 test_srav_and(a0, a1, BIT_MASK);
877 }
878 end = System.currentTimeMillis();
879 System.out.println("test_srav_and: " + (end - start));
880
881 start = System.currentTimeMillis();
882 for (int i=0; i<ITERS; i++) {
883 test_pack2(p2, a1);
884 }
885 end = System.currentTimeMillis();
886 System.out.println("test_pack2: " + (end - start));
887 start = System.currentTimeMillis();
888 for (int i=0; i<ITERS; i++) {
889 test_unpack2(a0, p2);
890 }
891 end = System.currentTimeMillis();
892 System.out.println("test_unpack2: " + (end - start));
893 start = System.currentTimeMillis();
894 for (int i=0; i<ITERS; i++) {
895 test_pack2_swap(p2, a1);
896 }
897 end = System.currentTimeMillis();
898 System.out.println("test_pack2_swap: " + (end - start));
899 start = System.currentTimeMillis();
900 for (int i=0; i<ITERS; i++) {
901 test_unpack2_swap(a0, p2);
902 }
903 end = System.currentTimeMillis();
904 System.out.println("test_unpack2_swap: " + (end - start));
905
906 return errn;
907 }
908
909 static int test_sum(int[] a1) {
910 int sum = 0;
911 for (int i = 0; i < a1.length; i+=1) {
912 sum += a1[i];
913 }
914 return sum;
915 }
916
917 static void test_addc(int[] a0, int[] a1) {
918 for (int i = 0; i < a0.length; i+=1) {
919 a0[i] = (int)(a1[i]+VALUE);
920 }
921 }
922 static void test_addv(int[] a0, int[] a1, int b) {
923 for (int i = 0; i < a0.length; i+=1) {
924 a0[i] = (int)(a1[i]+b);
925 }
926 }
927 static void test_adda(int[] a0, int[] a1, int[] a2) {
928 for (int i = 0; i < a0.length; i+=1) {
929 a0[i] = (int)(a1[i]+a2[i]);
930 }
931 }
932
933 static void test_subc(int[] a0, int[] a1) {
934 for (int i = 0; i < a0.length; i+=1) {
935 a0[i] = (int)(a1[i]-VALUE);
936 }
937 }
938 static void test_subv(int[] a0, int[] a1, int b) {
939 for (int i = 0; i < a0.length; i+=1) {
940 a0[i] = (int)(a1[i]-b);
941 }
942 }
943 static void test_suba(int[] a0, int[] a1, int[] a2) {
944 for (int i = 0; i < a0.length; i+=1) {
945 a0[i] = (int)(a1[i]-a2[i]);
946 }
947 }
948
949 static void test_mulc(int[] a0, int[] a1) {
950 for (int i = 0; i < a0.length; i+=1) {
951 a0[i] = (int)(a1[i]*VALUE);
952 }
953 }
954 static void test_mulc_n(int[] a0, int[] a1) {
955 for (int i = 0; i < a0.length; i+=1) {
956 a0[i] = (int)(a1[i]*(-VALUE));
957 }
958 }
959 static void test_mulv(int[] a0, int[] a1, int b) {
960 for (int i = 0; i < a0.length; i+=1) {
961 a0[i] = (int)(a1[i]*b);
962 }
963 }
964 static void test_mula(int[] a0, int[] a1, int[] a2) {
965 for (int i = 0; i < a0.length; i+=1) {
966 a0[i] = (int)(a1[i]*a2[i]);
967 }
968 }
969
970 static void test_divc(int[] a0, int[] a1) {
971 for (int i = 0; i < a0.length; i+=1) {
972 a0[i] = (int)(a1[i]/VALUE);
973 }
974 }
975 static void test_divc_n(int[] a0, int[] a1) {
976 for (int i = 0; i < a0.length; i+=1) {
977 a0[i] = (int)(a1[i]/(-VALUE));
978 }
979 }
980 static void test_divv(int[] a0, int[] a1, int b) {
981 for (int i = 0; i < a0.length; i+=1) {
982 a0[i] = (int)(a1[i]/b);
983 }
984 }
985 static void test_diva(int[] a0, int[] a1, int[] a2) {
986 for (int i = 0; i < a0.length; i+=1) {
987 a0[i] = (int)(a1[i]/a2[i]);
988 }
989 }
990
991 static void test_andc(int[] a0, int[] a1) {
992 for (int i = 0; i < a0.length; i+=1) {
993 a0[i] = (int)(a1[i]&BIT_MASK);
994 }
995 }
996 static void test_andv(int[] a0, int[] a1, int b) {
997 for (int i = 0; i < a0.length; i+=1) {
998 a0[i] = (int)(a1[i]&b);
999 }
1000 }
1001 static void test_anda(int[] a0, int[] a1, int[] a2) {
1002 for (int i = 0; i < a0.length; i+=1) {
1003 a0[i] = (int)(a1[i]&a2[i]);
1004 }
1005 }
1006
1007 static void test_orc(int[] a0, int[] a1) {
1008 for (int i = 0; i < a0.length; i+=1) {
1009 a0[i] = (int)(a1[i]|BIT_MASK);
1010 }
1011 }
1012 static void test_orv(int[] a0, int[] a1, int b) {
1013 for (int i = 0; i < a0.length; i+=1) {
1014 a0[i] = (int)(a1[i]|b);
1015 }
1016 }
1017 static void test_ora(int[] a0, int[] a1, int[] a2) {
1018 for (int i = 0; i < a0.length; i+=1) {
1019 a0[i] = (int)(a1[i]|a2[i]);
1020 }
1021 }
1022
1023 static void test_xorc(int[] a0, int[] a1) {
1024 for (int i = 0; i < a0.length; i+=1) {
1025 a0[i] = (int)(a1[i]^BIT_MASK);
1026 }
1027 }
1028 static void test_xorv(int[] a0, int[] a1, int b) {
1029 for (int i = 0; i < a0.length; i+=1) {
1030 a0[i] = (int)(a1[i]^b);
1031 }
1032 }
1033 static void test_xora(int[] a0, int[] a1, int[] a2) {
1034 for (int i = 0; i < a0.length; i+=1) {
1035 a0[i] = (int)(a1[i]^a2[i]);
1036 }
1037 }
1038
1039 static void test_sllc(int[] a0, int[] a1) {
1040 for (int i = 0; i < a0.length; i+=1) {
1041 a0[i] = (int)(a1[i]<<VALUE);
1042 }
1043 }
1044 static void test_sllc_n(int[] a0, int[] a1) {
1045 for (int i = 0; i < a0.length; i+=1) {
1046 a0[i] = (int)(a1[i]<<(-VALUE));
1047 }
1048 }
1049 static void test_sllc_o(int[] a0, int[] a1) {
1050 for (int i = 0; i < a0.length; i+=1) {
1051 a0[i] = (int)(a1[i]<<SHIFT);
1052 }
1053 }
1054 static void test_sllc_on(int[] a0, int[] a1) {
1055 for (int i = 0; i < a0.length; i+=1) {
1056 a0[i] = (int)(a1[i]<<(-SHIFT));
1057 }
1058 }
1059 static void test_sllv(int[] a0, int[] a1, int b) {
1060 for (int i = 0; i < a0.length; i+=1) {
1061 a0[i] = (int)(a1[i]<<b);
1062 }
1063 }
1064 static void test_sllc_add(int[] a0, int[] a1) {
1065 for (int i = 0; i < a0.length; i+=1) {
1066 a0[i] = (int)((a1[i] + ADD_INIT)<<VALUE);
1067 }
1068 }
1069 static void test_sllv_add(int[] a0, int[] a1, int b) {
1070 for (int i = 0; i < a0.length; i+=1) {
1071 a0[i] = (int)((a1[i] + b)<<VALUE);
1072 }
1073 }
1074 static void test_sllc_and(int[] a0, int[] a1) {
1075 for (int i = 0; i < a0.length; i+=1) {
1076 a0[i] = (int)((a1[i] & BIT_MASK)<<VALUE);
1077 }
1078 }
1079 static void test_sllv_and(int[] a0, int[] a1, int b) {
1080 for (int i = 0; i < a0.length; i+=1) {
1081 a0[i] = (int)((a1[i] & b)<<VALUE);
1082 }
1083 }
1084
1085 static void test_srlc(int[] a0, int[] a1) {
1086 for (int i = 0; i < a0.length; i+=1) {
1087 a0[i] = (int)(a1[i]>>>VALUE);
1088 }
1089 }
1090 static void test_srlc_n(int[] a0, int[] a1) {
1091 for (int i = 0; i < a0.length; i+=1) {
1092 a0[i] = (int)(a1[i]>>>(-VALUE));
1093 }
1094 }
1095 static void test_srlc_o(int[] a0, int[] a1) {
1096 for (int i = 0; i < a0.length; i+=1) {
1097 a0[i] = (int)(a1[i]>>>SHIFT);
1098 }
1099 }
1100 static void test_srlc_on(int[] a0, int[] a1) {
1101 for (int i = 0; i < a0.length; i+=1) {
1102 a0[i] = (int)(a1[i]>>>(-SHIFT));
1103 }
1104 }
1105 static void test_srlv(int[] a0, int[] a1, int b) {
1106 for (int i = 0; i < a0.length; i+=1) {
1107 a0[i] = (int)(a1[i]>>>b);
1108 }
1109 }
1110 static void test_srlc_add(int[] a0, int[] a1) {
1111 for (int i = 0; i < a0.length; i+=1) {
1112 a0[i] = (int)((a1[i] + ADD_INIT)>>>VALUE);
1113 }
1114 }
1115 static void test_srlv_add(int[] a0, int[] a1, int b) {
1116 for (int i = 0; i < a0.length; i+=1) {
1117 a0[i] = (int)((a1[i] + b)>>>VALUE);
1118 }
1119 }
1120 static void test_srlc_and(int[] a0, int[] a1) {
1121 for (int i = 0; i < a0.length; i+=1) {
1122 a0[i] = (int)((a1[i] & BIT_MASK)>>>VALUE);
1123 }
1124 }
1125 static void test_srlv_and(int[] a0, int[] a1, int b) {
1126 for (int i = 0; i < a0.length; i+=1) {
1127 a0[i] = (int)((a1[i] & b)>>>VALUE);
1128 }
1129 }
1130
1131 static void test_srac(int[] a0, int[] a1) {
1132 for (int i = 0; i < a0.length; i+=1) {
1133 a0[i] = (int)(a1[i]>>VALUE);
1134 }
1135 }
1136 static void test_srac_n(int[] a0, int[] a1) {
1137 for (int i = 0; i < a0.length; i+=1) {
1138 a0[i] = (int)(a1[i]>>(-VALUE));
1139 }
1140 }
1141 static void test_srac_o(int[] a0, int[] a1) {
1142 for (int i = 0; i < a0.length; i+=1) {
1143 a0[i] = (int)(a1[i]>>SHIFT);
1144 }
1145 }
1146 static void test_srac_on(int[] a0, int[] a1) {
1147 for (int i = 0; i < a0.length; i+=1) {
1148 a0[i] = (int)(a1[i]>>(-SHIFT));
1149 }
1150 }
1151 static void test_srav(int[] a0, int[] a1, int b) {
1152 for (int i = 0; i < a0.length; i+=1) {
1153 a0[i] = (int)(a1[i]>>b);
1154 }
1155 }
1156 static void test_srac_add(int[] a0, int[] a1) {
1157 for (int i = 0; i < a0.length; i+=1) {
1158 a0[i] = (int)((a1[i] + ADD_INIT)>>VALUE);
1159 }
1160 }
1161 static void test_srav_add(int[] a0, int[] a1, int b) {
1162 for (int i = 0; i < a0.length; i+=1) {
1163 a0[i] = (int)((a1[i] + b)>>VALUE);
1164 }
1165 }
1166 static void test_srac_and(int[] a0, int[] a1) {
1167 for (int i = 0; i < a0.length; i+=1) {
1168 a0[i] = (int)((a1[i] & BIT_MASK)>>VALUE);
1169 }
1170 }
1171 static void test_srav_and(int[] a0, int[] a1, int b) {
1172 for (int i = 0; i < a0.length; i+=1) {
1173 a0[i] = (int)((a1[i] & b)>>VALUE);
1174 }
1175 }
1176
1177 static void test_pack2(long[] p2, int[] a1) {
1178 if (p2.length*2 > a1.length) return;
1179 for (int i = 0; i < p2.length; i+=1) {
1180 long l0 = (long)a1[i*2+0];
1181 long l1 = (long)a1[i*2+1];
1182 p2[i] = (l1 << 32) | (l0 & 0xFFFFFFFFl);
1183 }
1184 }
1185 static void test_unpack2(int[] a0, long[] p2) {
1186 if (p2.length*2 > a0.length) return;
1187 for (int i = 0; i < p2.length; i+=1) {
1188 long l = p2[i];
1189 a0[i*2+0] = (int)(l & 0xFFFFFFFFl);
1190 a0[i*2+1] = (int)(l >> 32);
1191 }
1192 }
1193 static void test_pack2_swap(long[] p2, int[] a1) {
1194 if (p2.length*2 > a1.length) return;
1195 for (int i = 0; i < p2.length; i+=1) {
1196 long l0 = (long)a1[i*2+0];
1197 long l1 = (long)a1[i*2+1];
1198 p2[i] = (l0 << 32) | (l1 & 0xFFFFFFFFl);
1199 }
1200 }
1201 static void test_unpack2_swap(int[] a0, long[] p2) {
1202 if (p2.length*2 > a0.length) return;
1203 for (int i = 0; i < p2.length; i+=1) {
1204 long l = p2[i];
1205 a0[i*2+0] = (int)(l >> 32);
1206 a0[i*2+1] = (int)(l & 0xFFFFFFFFl);
1207 }
1208 }
1209
1210 static int verify(String text, int i, int elem, int val) {
1211 if (elem != val) {
1212 System.err.println(text + "[" + i + "] = " + elem + " != " + val);
1213 return 1;
1214 }
1215 return 0;
1216 }
1217
1218 static int verify(String text, int i, long elem, long val) {
1219 if (elem != val) {
1220 System.err.println(text + "[" + i + "] = " + Long.toHexString(elem) + " != " + Long.toHexString(val));
1221 return 1;
1222 }
1223 return 0;
1224 }
1225 }