CoCalc -- TestIntVect.java

GitHub Repository: PojavLauncherTeam/openjdk-multiarch-jdk8u
Path: blob/aarch64-shenandoah-jdk8u272-b10/hotspot/test/compiler/6340864/TestIntVect.java
³²²⁸⁵ views
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
}
1226

1227
Product

Resources

Company
