CoCalc -- TestShortVect.java

GitHub Repository: PojavLauncherTeam/openjdk-multiarch-jdk8u
Path: blob/aarch64-shenandoah-jdk8u272-b10/hotspot/test/compiler/6340864/TestShortVect.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 TestShortVect
31
 */
32

33
public class TestShortVect {
34
  private static final int ARRLEN = 997;
35
  private static final int ITERS  = 11000;
36
  private static final int ADD_INIT = Short.MAX_VALUE-500;
37
  private static final int BIT_MASK = 0xB731;
38
  private static final int VALUE = 7;
39
  private static final int SHIFT = 16;
40

41
  public static void main(String args[]) {
42
    System.out.println("Testing Short vectors");
43
    int errn = test();
44
    if (errn > 0) {
45
      System.err.println("FAILED: " + errn + " errors");
46
      System.exit(97);
47
    }
48
    System.out.println("PASSED");
49
  }
50

51
  static int test() {
52
    short[] a0 = new short[ARRLEN];
53
    short[] a1 = new short[ARRLEN];
54
    short[] a2 = new short[ARRLEN];
55
    short[] a3 = new short[ARRLEN];
56
    short[] a4 = new short[ARRLEN];
57
     int[] p2 = new  int[ARRLEN/2];
58
    long[] p4 = new long[ARRLEN/4];
59
    // Initialize
60
    int gold_sum = 0;
61
    for (int i=0; i<ARRLEN; i++) {
62
      short val = (short)(ADD_INIT+i);
63
      gold_sum += val;
64
      a1[i] = val;
65
      a2[i] = (short)VALUE;
66
      a3[i] = (short)-VALUE;
67
      a4[i] = (short)BIT_MASK;
68
    }
69
    System.out.println("Warmup");
70
    for (int i=0; i<ITERS; i++) {
71
      test_sum(a1);
72
      test_addc(a0, a1);
73
      test_addv(a0, a1, (short)VALUE);
74
      test_adda(a0, a1, a2);
75
      test_subc(a0, a1);
76
      test_subv(a0, a1, (short)VALUE);
77
      test_suba(a0, a1, a2);
78

79
      test_mulc(a0, a1);
80
      test_mulv(a0, a1, (short)VALUE);
81
      test_mula(a0, a1, a2);
82
      test_divc(a0, a1);
83
      test_divv(a0, a1, (short)VALUE);
84
      test_diva(a0, a1, a2);
85
      test_mulc_n(a0, a1);
86
      test_mulv(a0, a1, (short)-VALUE);
87
      test_mula(a0, a1, a3);
88
      test_divc_n(a0, a1);
89
      test_divv(a0, a1, (short)-VALUE);
90
      test_diva(a0, a1, a3);
91

92
      test_andc(a0, a1);
93
      test_andv(a0, a1, (short)BIT_MASK);
94
      test_anda(a0, a1, a4);
95
      test_orc(a0, a1);
96
      test_orv(a0, a1, (short)BIT_MASK);
97
      test_ora(a0, a1, a4);
98
      test_xorc(a0, a1);
99
      test_xorv(a0, a1, (short)BIT_MASK);
100
      test_xora(a0, a1, a4);
101

102
      test_sllc(a0, a1);
103
      test_sllv(a0, a1, VALUE);
104
      test_srlc(a0, a1);
105
      test_srlv(a0, a1, VALUE);
106
      test_srac(a0, a1);
107
      test_srav(a0, a1, VALUE);
108

109
      test_sllc_n(a0, a1);
110
      test_sllv(a0, a1, -VALUE);
111
      test_srlc_n(a0, a1);
112
      test_srlv(a0, a1, -VALUE);
113
      test_srac_n(a0, a1);
114
      test_srav(a0, a1, -VALUE);
115

116
      test_sllc_o(a0, a1);
117
      test_sllv(a0, a1, SHIFT);
118
      test_srlc_o(a0, a1);
119
      test_srlv(a0, a1, SHIFT);
120
      test_srac_o(a0, a1);
121
      test_srav(a0, a1, SHIFT);
122

123
      test_sllc_on(a0, a1);
124
      test_sllv(a0, a1, -SHIFT);
125
      test_srlc_on(a0, a1);
126
      test_srlv(a0, a1, -SHIFT);
127
      test_srac_on(a0, a1);
128
      test_srav(a0, a1, -SHIFT);
129

130
      test_sllc_add(a0, a1);
131
      test_sllv_add(a0, a1, ADD_INIT);
132
      test_srlc_add(a0, a1);
133
      test_srlv_add(a0, a1, ADD_INIT);
134
      test_srac_add(a0, a1);
135
      test_srav_add(a0, a1, ADD_INIT);
136

137
      test_sllc_and(a0, a1);
138
      test_sllv_and(a0, a1, BIT_MASK);
139
      test_srlc_and(a0, a1);
140
      test_srlv_and(a0, a1, BIT_MASK);
141
      test_srac_and(a0, a1);
142
      test_srav_and(a0, a1, BIT_MASK);
143

144
      test_pack2(p2, a1);
145
      test_unpack2(a0, p2);
146
      test_pack2_swap(p2, a1);
147
      test_unpack2_swap(a0, p2);
148
      test_pack4(p4, a1);
149
      test_unpack4(a0, p4);
150
      test_pack4_swap(p4, a1);
151
      test_unpack4_swap(a0, p4);
152
    }
153
    // Test and verify results
154
    System.out.println("Verification");
155
    int errn = 0;
156
    {
157
      int sum = test_sum(a1);
158
      if (sum != gold_sum) {
159
        System.err.println("test_sum:  " + sum + " != " + gold_sum);
160
        errn++;
161
      }
162

163
      test_addc(a0, a1);
164
      for (int i=0; i<ARRLEN; i++) {
165
        errn += verify("test_addc: ", i, a0[i], (short)((short)(ADD_INIT+i)+VALUE));
166
      }
167
      test_addv(a0, a1, (short)VALUE);
168
      for (int i=0; i<ARRLEN; i++) {
169
        errn += verify("test_addv: ", i, a0[i], (short)((short)(ADD_INIT+i)+VALUE));
170
      }
171
      test_adda(a0, a1, a2);
172
      for (int i=0; i<ARRLEN; i++) {
173
        errn += verify("test_adda: ", i, a0[i], (short)((short)(ADD_INIT+i)+VALUE));
174
      }
175

176
      test_subc(a0, a1);
177
      for (int i=0; i<ARRLEN; i++) {
178
        errn += verify("test_subc: ", i, a0[i], (short)((short)(ADD_INIT+i)-VALUE));
179
      }
180
      test_subv(a0, a1, (short)VALUE);
181
      for (int i=0; i<ARRLEN; i++) {
182
        errn += verify("test_subv: ", i, a0[i], (short)((short)(ADD_INIT+i)-VALUE));
183
      }
184
      test_suba(a0, a1, a2);
185
      for (int i=0; i<ARRLEN; i++) {
186
        errn += verify("test_suba: ", i, a0[i], (short)((short)(ADD_INIT+i)-VALUE));
187
      }
188

189
      test_mulc(a0, a1);
190
      for (int i=0; i<ARRLEN; i++) {
191
        errn += verify("test_mulc: ", i, a0[i], (short)((short)(ADD_INIT+i)*VALUE));
192
      }
193
      test_mulv(a0, a1, (short)VALUE);
194
      for (int i=0; i<ARRLEN; i++) {
195
        errn += verify("test_mulv: ", i, a0[i], (short)((short)(ADD_INIT+i)*VALUE));
196
      }
197
      test_mula(a0, a1, a2);
198
      for (int i=0; i<ARRLEN; i++) {
199
        errn += verify("test_mula: ", i, a0[i], (short)((short)(ADD_INIT+i)*VALUE));
200
      }
201

202
      test_divc(a0, a1);
203
      for (int i=0; i<ARRLEN; i++) {
204
        errn += verify("test_divc: ", i, a0[i], (short)((short)(ADD_INIT+i)/VALUE));
205
      }
206
      test_divv(a0, a1, (short)VALUE);
207
      for (int i=0; i<ARRLEN; i++) {
208
        errn += verify("test_divv: ", i, a0[i], (short)((short)(ADD_INIT+i)/VALUE));
209
      }
210
      test_diva(a0, a1, a2);
211
      for (int i=0; i<ARRLEN; i++) {
212
        errn += verify("test_diva: ", i, a0[i], (short)((short)(ADD_INIT+i)/VALUE));
213
      }
214

215
      test_mulc_n(a0, a1);
216
      for (int i=0; i<ARRLEN; i++) {
217
        errn += verify("test_mulc_n: ", i, a0[i], (short)((short)(ADD_INIT+i)*(-VALUE)));
218
      }
219
      test_mulv(a0, a1, (short)-VALUE);
220
      for (int i=0; i<ARRLEN; i++) {
221
        errn += verify("test_mulv_n: ", i, a0[i], (short)((short)(ADD_INIT+i)*(-VALUE)));
222
      }
223
      test_mula(a0, a1, a3);
224
      for (int i=0; i<ARRLEN; i++) {
225
        errn += verify("test_mula_n: ", i, a0[i], (short)((short)(ADD_INIT+i)*(-VALUE)));
226
      }
227

228
      test_divc_n(a0, a1);
229
      for (int i=0; i<ARRLEN; i++) {
230
        errn += verify("test_divc_n: ", i, a0[i], (short)((short)(ADD_INIT+i)/(-VALUE)));
231
      }
232
      test_divv(a0, a1, (short)-VALUE);
233
      for (int i=0; i<ARRLEN; i++) {
234
        errn += verify("test_divv_n: ", i, a0[i], (short)((short)(ADD_INIT+i)/(-VALUE)));
235
      }
236
      test_diva(a0, a1, a3);
237
      for (int i=0; i<ARRLEN; i++) {
238
        errn += verify("test_diva_n: ", i, a0[i], (short)((short)(ADD_INIT+i)/(-VALUE)));
239
      }
240

241
      test_andc(a0, a1);
242
      for (int i=0; i<ARRLEN; i++) {
243
        errn += verify("test_andc: ", i, a0[i], (short)((short)(ADD_INIT+i)&BIT_MASK));
244
      }
245
      test_andv(a0, a1, (short)BIT_MASK);
246
      for (int i=0; i<ARRLEN; i++) {
247
        errn += verify("test_andv: ", i, a0[i], (short)((short)(ADD_INIT+i)&BIT_MASK));
248
      }
249
      test_anda(a0, a1, a4);
250
      for (int i=0; i<ARRLEN; i++) {
251
        errn += verify("test_anda: ", i, a0[i], (short)((short)(ADD_INIT+i)&BIT_MASK));
252
      }
253

254
      test_orc(a0, a1);
255
      for (int i=0; i<ARRLEN; i++) {
256
        errn += verify("test_orc: ", i, a0[i], (short)((short)(ADD_INIT+i)|BIT_MASK));
257
      }
258
      test_orv(a0, a1, (short)BIT_MASK);
259
      for (int i=0; i<ARRLEN; i++) {
260
        errn += verify("test_orv: ", i, a0[i], (short)((short)(ADD_INIT+i)|BIT_MASK));
261
      }
262
      test_ora(a0, a1, a4);
263
      for (int i=0; i<ARRLEN; i++) {
264
        errn += verify("test_ora: ", i, a0[i], (short)((short)(ADD_INIT+i)|BIT_MASK));
265
      }
266

267
      test_xorc(a0, a1);
268
      for (int i=0; i<ARRLEN; i++) {
269
        errn += verify("test_xorc: ", i, a0[i], (short)((short)(ADD_INIT+i)^BIT_MASK));
270
      }
271
      test_xorv(a0, a1, (short)BIT_MASK);
272
      for (int i=0; i<ARRLEN; i++) {
273
        errn += verify("test_xorv: ", i, a0[i], (short)((short)(ADD_INIT+i)^BIT_MASK));
274
      }
275
      test_xora(a0, a1, a4);
276
      for (int i=0; i<ARRLEN; i++) {
277
        errn += verify("test_xora: ", i, a0[i], (short)((short)(ADD_INIT+i)^BIT_MASK));
278
      }
279

280
      test_sllc(a0, a1);
281
      for (int i=0; i<ARRLEN; i++) {
282
        errn += verify("test_sllc: ", i, a0[i], (short)((short)(ADD_INIT+i)<<VALUE));
283
      }
284
      test_sllv(a0, a1, VALUE);
285
      for (int i=0; i<ARRLEN; i++) {
286
        errn += verify("test_sllv: ", i, a0[i], (short)((short)(ADD_INIT+i)<<VALUE));
287
      }
288

289
      test_srlc(a0, a1);
290
      for (int i=0; i<ARRLEN; i++) {
291
        errn += verify("test_srlc: ", i, a0[i], (short)((short)(ADD_INIT+i)>>>VALUE));
292
      }
293
      test_srlv(a0, a1, VALUE);
294
      for (int i=0; i<ARRLEN; i++) {
295
        errn += verify("test_srlv: ", i, a0[i], (short)((short)(ADD_INIT+i)>>>VALUE));
296
      }
297

298
      test_srac(a0, a1);
299
      for (int i=0; i<ARRLEN; i++) {
300
        errn += verify("test_srac: ", i, a0[i], (short)((short)(ADD_INIT+i)>>VALUE));
301
      }
302
      test_srav(a0, a1, VALUE);
303
      for (int i=0; i<ARRLEN; i++) {
304
        errn += verify("test_srav: ", i, a0[i], (short)((short)(ADD_INIT+i)>>VALUE));
305
      }
306

307
      test_sllc_n(a0, a1);
308
      for (int i=0; i<ARRLEN; i++) {
309
        errn += verify("test_sllc_n: ", i, a0[i], (short)((short)(ADD_INIT+i)<<(-VALUE)));
310
      }
311
      test_sllv(a0, a1, -VALUE);
312
      for (int i=0; i<ARRLEN; i++) {
313
        errn += verify("test_sllv_n: ", i, a0[i], (short)((short)(ADD_INIT+i)<<(-VALUE)));
314
      }
315

316
      test_srlc_n(a0, a1);
317
      for (int i=0; i<ARRLEN; i++) {
318
        errn += verify("test_srlc_n: ", i, a0[i], (short)((short)(ADD_INIT+i)>>>(-VALUE)));
319
      }
320
      test_srlv(a0, a1, -VALUE);
321
      for (int i=0; i<ARRLEN; i++) {
322
        errn += verify("test_srlv_n: ", i, a0[i], (short)((short)(ADD_INIT+i)>>>(-VALUE)));
323
      }
324

325
      test_srac_n(a0, a1);
326
      for (int i=0; i<ARRLEN; i++) {
327
        errn += verify("test_srac_n: ", i, a0[i], (short)((short)(ADD_INIT+i)>>(-VALUE)));
328
      }
329
      test_srav(a0, a1, -VALUE);
330
      for (int i=0; i<ARRLEN; i++) {
331
        errn += verify("test_srav_n: ", i, a0[i], (short)((short)(ADD_INIT+i)>>(-VALUE)));
332
      }
333

334
      test_sllc_o(a0, a1);
335
      for (int i=0; i<ARRLEN; i++) {
336
        errn += verify("test_sllc_o: ", i, a0[i], (short)((short)(ADD_INIT+i)<<SHIFT));
337
      }
338
      test_sllv(a0, a1, SHIFT);
339
      for (int i=0; i<ARRLEN; i++) {
340
        errn += verify("test_sllv_o: ", i, a0[i], (short)((short)(ADD_INIT+i)<<SHIFT));
341
      }
342

343
      test_srlc_o(a0, a1);
344
      for (int i=0; i<ARRLEN; i++) {
345
        errn += verify("test_srlc_o: ", i, a0[i], (short)((short)(ADD_INIT+i)>>>SHIFT));
346
      }
347
      test_srlv(a0, a1, SHIFT);
348
      for (int i=0; i<ARRLEN; i++) {
349
        errn += verify("test_srlv_o: ", i, a0[i], (short)((short)(ADD_INIT+i)>>>SHIFT));
350
      }
351

352
      test_srac_o(a0, a1);
353
      for (int i=0; i<ARRLEN; i++) {
354
        errn += verify("test_srac_o: ", i, a0[i], (short)((short)(ADD_INIT+i)>>SHIFT));
355
      }
356
      test_srav(a0, a1, SHIFT);
357
      for (int i=0; i<ARRLEN; i++) {
358
        errn += verify("test_srav_o: ", i, a0[i], (short)((short)(ADD_INIT+i)>>SHIFT));
359
      }
360

361
      test_sllc_on(a0, a1);
362
      for (int i=0; i<ARRLEN; i++) {
363
        errn += verify("test_sllc_on: ", i, a0[i], (short)((short)(ADD_INIT+i)<<(-SHIFT)));
364
      }
365
      test_sllv(a0, a1, -SHIFT);
366
      for (int i=0; i<ARRLEN; i++) {
367
        errn += verify("test_sllv_on: ", i, a0[i], (short)((short)(ADD_INIT+i)<<(-SHIFT)));
368
      }
369

370
      test_srlc_on(a0, a1);
371
      for (int i=0; i<ARRLEN; i++) {
372
        errn += verify("test_srlc_on: ", i, a0[i], (short)((short)(ADD_INIT+i)>>>(-SHIFT)));
373
      }
374
      test_srlv(a0, a1, -SHIFT);
375
      for (int i=0; i<ARRLEN; i++) {
376
        errn += verify("test_srlv_on: ", i, a0[i], (short)((short)(ADD_INIT+i)>>>(-SHIFT)));
377
      }
378

379
      test_srac_on(a0, a1);
380
      for (int i=0; i<ARRLEN; i++) {
381
        errn += verify("test_srac_on: ", i, a0[i], (short)((short)(ADD_INIT+i)>>(-SHIFT)));
382
      }
383
      test_srav(a0, a1, -SHIFT);
384
      for (int i=0; i<ARRLEN; i++) {
385
        errn += verify("test_srav_on: ", i, a0[i], (short)((short)(ADD_INIT+i)>>(-SHIFT)));
386
      }
387

388
      test_sllc_add(a0, a1);
389
      for (int i=0; i<ARRLEN; i++) {
390
        errn += verify("test_sllc_add: ", i, a0[i], (short)(((short)(ADD_INIT+i) + ADD_INIT)<<VALUE));
391
      }
392
      test_sllv_add(a0, a1, ADD_INIT);
393
      for (int i=0; i<ARRLEN; i++) {
394
        errn += verify("test_sllv_add: ", i, a0[i], (short)(((short)(ADD_INIT+i) + ADD_INIT)<<VALUE));
395
      }
396

397
      test_srlc_add(a0, a1);
398
      for (int i=0; i<ARRLEN; i++) {
399
        errn += verify("test_srlc_add: ", i, a0[i], (short)(((short)(ADD_INIT+i) + ADD_INIT)>>>VALUE));
400
      }
401
      test_srlv_add(a0, a1, ADD_INIT);
402
      for (int i=0; i<ARRLEN; i++) {
403
        errn += verify("test_srlv_add: ", i, a0[i], (short)(((short)(ADD_INIT+i) + ADD_INIT)>>>VALUE));
404
      }
405

406
      test_srac_add(a0, a1);
407
      for (int i=0; i<ARRLEN; i++) {
408
        errn += verify("test_srac_add: ", i, a0[i], (short)(((short)(ADD_INIT+i) + ADD_INIT)>>VALUE));
409
      }
410
      test_srav_add(a0, a1, ADD_INIT);
411
      for (int i=0; i<ARRLEN; i++) {
412
        errn += verify("test_srav_add: ", i, a0[i], (short)(((short)(ADD_INIT+i) + ADD_INIT)>>VALUE));
413
      }
414

415
      test_sllc_and(a0, a1);
416
      for (int i=0; i<ARRLEN; i++) {
417
        errn += verify("test_sllc_and: ", i, a0[i], (short)(((short)(ADD_INIT+i) & BIT_MASK)<<VALUE));
418
      }
419
      test_sllv_and(a0, a1, BIT_MASK);
420
      for (int i=0; i<ARRLEN; i++) {
421
        errn += verify("test_sllv_and: ", i, a0[i], (short)(((short)(ADD_INIT+i) & BIT_MASK)<<VALUE));
422
      }
423

424
      test_srlc_and(a0, a1);
425
      for (int i=0; i<ARRLEN; i++) {
426
        errn += verify("test_srlc_and: ", i, a0[i], (short)(((short)(ADD_INIT+i) & BIT_MASK)>>>VALUE));
427
      }
428
      test_srlv_and(a0, a1, BIT_MASK);
429
      for (int i=0; i<ARRLEN; i++) {
430
        errn += verify("test_srlv_and: ", i, a0[i], (short)(((short)(ADD_INIT+i) & BIT_MASK)>>>VALUE));
431
      }
432

433
      test_srac_and(a0, a1);
434
      for (int i=0; i<ARRLEN; i++) {
435
        errn += verify("test_srac_and: ", i, a0[i], (short)(((short)(ADD_INIT+i) & BIT_MASK)>>VALUE));
436
      }
437
      test_srav_and(a0, a1, BIT_MASK);
438
      for (int i=0; i<ARRLEN; i++) {
439
        errn += verify("test_srav_and: ", i, a0[i], (short)(((short)(ADD_INIT+i) & BIT_MASK)>>VALUE));
440
      }
441

442
      test_pack2(p2, a1);
443
      for (int i=0; i<ARRLEN/2; i++) {
444
        errn += verify("test_pack2: ", i, p2[i], ((int)(ADD_INIT+2*i) & 0xFFFF) | ((int)(ADD_INIT+2*i+1) << 16));
445
      }
446
      for (int i=0; i<ARRLEN; i++) {
447
        a0[i] = -1;
448
      }
449
      test_unpack2(a0, p2);
450
      for (int i=0; i<(ARRLEN&(-2)); i++) {
451
        errn += verify("test_unpack2: ", i, a0[i], (short)(ADD_INIT+i));
452
      }
453

454
      test_pack2_swap(p2, a1);
455
      for (int i=0; i<ARRLEN/2; i++) {
456
        errn += verify("test_pack2_swap: ", i, p2[i], ((int)(ADD_INIT+2*i+1) & 0xFFFF) | ((int)(ADD_INIT+2*i) << 16));
457
      }
458
      for (int i=0; i<ARRLEN; i++) {
459
        a0[i] = -1;
460
      }
461
      test_unpack2_swap(a0, p2);
462
      for (int i=0; i<(ARRLEN&(-2)); i++) {
463
        errn += verify("test_unpack2_swap: ", i, a0[i], (short)(ADD_INIT+i));
464
      }
465

466
      test_pack4(p4, a1);
467
      for (int i=0; i<ARRLEN/4; i++) {
468
        errn += verify("test_pack4: ", i, p4[i],  ((long)(ADD_INIT+4*i+0) & 0xFFFFl) |
469
                                                 (((long)(ADD_INIT+4*i+1) & 0xFFFFl) << 16)  |
470
                                                 (((long)(ADD_INIT+4*i+2) & 0xFFFFl) << 32)  |
471
                                                 (((long)(ADD_INIT+4*i+3) & 0xFFFFl) << 48));
472
      }
473
      for (int i=0; i<ARRLEN; i++) {
474
        a0[i] = -1;
475
      }
476
      test_unpack4(a0, p4);
477
      for (int i=0; i<(ARRLEN&(-4)); i++) {
478
        errn += verify("test_unpack4: ", i, a0[i], (short)(ADD_INIT+i));
479
      }
480

481
      test_pack4_swap(p4, a1);
482
      for (int i=0; i<ARRLEN/4; i++) {
483
        errn += verify("test_pack4_swap: ", i, p4[i],  ((long)(ADD_INIT+4*i+3) & 0xFFFFl) |
484
                                                      (((long)(ADD_INIT+4*i+2) & 0xFFFFl) << 16)  |
485
                                                      (((long)(ADD_INIT+4*i+1) & 0xFFFFl) << 32)  |
486
                                                      (((long)(ADD_INIT+4*i+0) & 0xFFFFl) << 48));
487
      }
488
      for (int i=0; i<ARRLEN; i++) {
489
        a0[i] = -1;
490
      }
491
      test_unpack4_swap(a0, p4);
492
      for (int i=0; i<(ARRLEN&(-4)); i++) {
493
        errn += verify("test_unpack4_swap: ", i, a0[i], (short)(ADD_INIT+i));
494
      }
495

496
    }
497

498
    if (errn > 0)
499
      return errn;
500

501
    System.out.println("Time");
502
    long start, end;
503

504
    start = System.currentTimeMillis();
505
    for (int i=0; i<ITERS; i++) {
506
      test_sum(a1);
507
    }
508
    end = System.currentTimeMillis();
509
    System.out.println("test_sum: " + (end - start));
510

511
    start = System.currentTimeMillis();
512
    for (int i=0; i<ITERS; i++) {
513
      test_addc(a0, a1);
514
    }
515
    end = System.currentTimeMillis();
516
    System.out.println("test_addc: " + (end - start));
517
    start = System.currentTimeMillis();
518
    for (int i=0; i<ITERS; i++) {
519
      test_addv(a0, a1, (short)VALUE);
520
    }
521
    end = System.currentTimeMillis();
522
    System.out.println("test_addv: " + (end - start));
523
    start = System.currentTimeMillis();
524
    for (int i=0; i<ITERS; i++) {
525
      test_adda(a0, a1, a2);
526
    }
527
    end = System.currentTimeMillis();
528
    System.out.println("test_adda: " + (end - start));
529

530
    start = System.currentTimeMillis();
531
    for (int i=0; i<ITERS; i++) {
532
      test_subc(a0, a1);
533
    }
534
    end = System.currentTimeMillis();
535
    System.out.println("test_subc: " + (end - start));
536
    start = System.currentTimeMillis();
537
    for (int i=0; i<ITERS; i++) {
538
      test_subv(a0, a1, (short)VALUE);
539
    }
540
    end = System.currentTimeMillis();
541
    System.out.println("test_subv: " + (end - start));
542
    start = System.currentTimeMillis();
543
    for (int i=0; i<ITERS; i++) {
544
      test_suba(a0, a1, a2);
545
    }
546
    end = System.currentTimeMillis();
547
    System.out.println("test_suba: " + (end - start));
548

549
    start = System.currentTimeMillis();
550
    for (int i=0; i<ITERS; i++) {
551
      test_mulc(a0, a1);
552
    }
553
    end = System.currentTimeMillis();
554
    System.out.println("test_mulc: " + (end - start));
555
    start = System.currentTimeMillis();
556
    for (int i=0; i<ITERS; i++) {
557
      test_mulv(a0, a1, (short)VALUE);
558
    }
559
    end = System.currentTimeMillis();
560
    System.out.println("test_mulv: " + (end - start));
561
    start = System.currentTimeMillis();
562
    for (int i=0; i<ITERS; i++) {
563
      test_mula(a0, a1, a2);
564
    }
565
    end = System.currentTimeMillis();
566
    System.out.println("test_mula: " + (end - start));
567

568
    start = System.currentTimeMillis();
569
    for (int i=0; i<ITERS; i++) {
570
      test_divc(a0, a1);
571
    }
572
    end = System.currentTimeMillis();
573
    System.out.println("test_divc: " + (end - start));
574
    start = System.currentTimeMillis();
575
    for (int i=0; i<ITERS; i++) {
576
      test_divv(a0, a1, (short)VALUE);
577
    }
578
    end = System.currentTimeMillis();
579
    System.out.println("test_divv: " + (end - start));
580
    start = System.currentTimeMillis();
581
    for (int i=0; i<ITERS; i++) {
582
      test_diva(a0, a1, a2);
583
    }
584
    end = System.currentTimeMillis();
585
    System.out.println("test_diva: " + (end - start));
586

587
    start = System.currentTimeMillis();
588
    for (int i=0; i<ITERS; i++) {
589
      test_mulc_n(a0, a1);
590
    }
591
    end = System.currentTimeMillis();
592
    System.out.println("test_mulc_n: " + (end - start));
593
    start = System.currentTimeMillis();
594
    for (int i=0; i<ITERS; i++) {
595
      test_mulv(a0, a1, (short)-VALUE);
596
    }
597
    end = System.currentTimeMillis();
598
    System.out.println("test_mulv_n: " + (end - start));
599
    start = System.currentTimeMillis();
600
    for (int i=0; i<ITERS; i++) {
601
      test_mula(a0, a1, a3);
602
    }
603
    end = System.currentTimeMillis();
604
    System.out.println("test_mula_n: " + (end - start));
605

606
    start = System.currentTimeMillis();
607
    for (int i=0; i<ITERS; i++) {
608
      test_divc_n(a0, a1);
609
    }
610
    end = System.currentTimeMillis();
611
    System.out.println("test_divc_n: " + (end - start));
612
    start = System.currentTimeMillis();
613
    for (int i=0; i<ITERS; i++) {
614
      test_divv(a0, a1, (short)-VALUE);
615
    }
616
    end = System.currentTimeMillis();
617
    System.out.println("test_divv_n: " + (end - start));
618
    start = System.currentTimeMillis();
619
    for (int i=0; i<ITERS; i++) {
620
      test_diva(a0, a1, a3);
621
    }
622
    end = System.currentTimeMillis();
623
    System.out.println("test_diva_n: " + (end - start));
624

625
    start = System.currentTimeMillis();
626
    for (int i=0; i<ITERS; i++) {
627
      test_andc(a0, a1);
628
    }
629
    end = System.currentTimeMillis();
630
    System.out.println("test_andc: " + (end - start));
631
    start = System.currentTimeMillis();
632
    for (int i=0; i<ITERS; i++) {
633
      test_andv(a0, a1, (short)BIT_MASK);
634
    }
635
    end = System.currentTimeMillis();
636
    System.out.println("test_andv: " + (end - start));
637
    start = System.currentTimeMillis();
638
    for (int i=0; i<ITERS; i++) {
639
      test_anda(a0, a1, a4);
640
    }
641
    end = System.currentTimeMillis();
642
    System.out.println("test_anda: " + (end - start));
643

644
    start = System.currentTimeMillis();
645
    for (int i=0; i<ITERS; i++) {
646
      test_orc(a0, a1);
647
    }
648
    end = System.currentTimeMillis();
649
    System.out.println("test_orc: " + (end - start));
650
    start = System.currentTimeMillis();
651
    for (int i=0; i<ITERS; i++) {
652
      test_orv(a0, a1, (short)BIT_MASK);
653
    }
654
    end = System.currentTimeMillis();
655
    System.out.println("test_orv: " + (end - start));
656
    start = System.currentTimeMillis();
657
    for (int i=0; i<ITERS; i++) {
658
      test_ora(a0, a1, a4);
659
    }
660
    end = System.currentTimeMillis();
661
    System.out.println("test_ora: " + (end - start));
662

663
    start = System.currentTimeMillis();
664
    for (int i=0; i<ITERS; i++) {
665
      test_xorc(a0, a1);
666
    }
667
    end = System.currentTimeMillis();
668
    System.out.println("test_xorc: " + (end - start));
669
    start = System.currentTimeMillis();
670
    for (int i=0; i<ITERS; i++) {
671
      test_xorv(a0, a1, (short)BIT_MASK);
672
    }
673
    end = System.currentTimeMillis();
674
    System.out.println("test_xorv: " + (end - start));
675
    start = System.currentTimeMillis();
676
    for (int i=0; i<ITERS; i++) {
677
      test_xora(a0, a1, a4);
678
    }
679
    end = System.currentTimeMillis();
680
    System.out.println("test_xora: " + (end - start));
681

682
    start = System.currentTimeMillis();
683
    for (int i=0; i<ITERS; i++) {
684
      test_sllc(a0, a1);
685
    }
686
    end = System.currentTimeMillis();
687
    System.out.println("test_sllc: " + (end - start));
688
    start = System.currentTimeMillis();
689
    for (int i=0; i<ITERS; i++) {
690
      test_sllv(a0, a1, VALUE);
691
    }
692
    end = System.currentTimeMillis();
693
    System.out.println("test_sllv: " + (end - start));
694

695
    start = System.currentTimeMillis();
696
    for (int i=0; i<ITERS; i++) {
697
      test_srlc(a0, a1);
698
    }
699
    end = System.currentTimeMillis();
700
    System.out.println("test_srlc: " + (end - start));
701
    start = System.currentTimeMillis();
702
    for (int i=0; i<ITERS; i++) {
703
      test_srlv(a0, a1, VALUE);
704
    }
705
    end = System.currentTimeMillis();
706
    System.out.println("test_srlv: " + (end - start));
707

708
    start = System.currentTimeMillis();
709
    for (int i=0; i<ITERS; i++) {
710
      test_srac(a0, a1);
711
    }
712
    end = System.currentTimeMillis();
713
    System.out.println("test_srac: " + (end - start));
714
    start = System.currentTimeMillis();
715
    for (int i=0; i<ITERS; i++) {
716
      test_srav(a0, a1, VALUE);
717
    }
718
    end = System.currentTimeMillis();
719
    System.out.println("test_srav: " + (end - start));
720

721
    start = System.currentTimeMillis();
722
    for (int i=0; i<ITERS; i++) {
723
      test_sllc_n(a0, a1);
724
    }
725
    end = System.currentTimeMillis();
726
    System.out.println("test_sllc_n: " + (end - start));
727
    start = System.currentTimeMillis();
728
    for (int i=0; i<ITERS; i++) {
729
      test_sllv(a0, a1, -VALUE);
730
    }
731
    end = System.currentTimeMillis();
732
    System.out.println("test_sllv_n: " + (end - start));
733

734
    start = System.currentTimeMillis();
735
    for (int i=0; i<ITERS; i++) {
736
      test_srlc_n(a0, a1);
737
    }
738
    end = System.currentTimeMillis();
739
    System.out.println("test_srlc_n: " + (end - start));
740
    start = System.currentTimeMillis();
741
    for (int i=0; i<ITERS; i++) {
742
      test_srlv(a0, a1, -VALUE);
743
    }
744
    end = System.currentTimeMillis();
745
    System.out.println("test_srlv_n: " + (end - start));
746

747
    start = System.currentTimeMillis();
748
    for (int i=0; i<ITERS; i++) {
749
      test_srac_n(a0, a1);
750
    }
751
    end = System.currentTimeMillis();
752
    System.out.println("test_srac_n: " + (end - start));
753
    start = System.currentTimeMillis();
754
    for (int i=0; i<ITERS; i++) {
755
      test_srav(a0, a1, -VALUE);
756
    }
757
    end = System.currentTimeMillis();
758
    System.out.println("test_srav_n: " + (end - start));
759

760
    start = System.currentTimeMillis();
761
    for (int i=0; i<ITERS; i++) {
762
      test_sllc_o(a0, a1);
763
    }
764
    end = System.currentTimeMillis();
765
    System.out.println("test_sllc_o: " + (end - start));
766
    start = System.currentTimeMillis();
767
    for (int i=0; i<ITERS; i++) {
768
      test_sllv(a0, a1, SHIFT);
769
    }
770
    end = System.currentTimeMillis();
771
    System.out.println("test_sllv_o: " + (end - start));
772

773
    start = System.currentTimeMillis();
774
    for (int i=0; i<ITERS; i++) {
775
      test_srlc_o(a0, a1);
776
    }
777
    end = System.currentTimeMillis();
778
    System.out.println("test_srlc_o: " + (end - start));
779
    start = System.currentTimeMillis();
780
    for (int i=0; i<ITERS; i++) {
781
      test_srlv(a0, a1, SHIFT);
782
    }
783
    end = System.currentTimeMillis();
784
    System.out.println("test_srlv_o: " + (end - start));
785

786
    start = System.currentTimeMillis();
787
    for (int i=0; i<ITERS; i++) {
788
      test_srac_o(a0, a1);
789
    }
790
    end = System.currentTimeMillis();
791
    System.out.println("test_srac_o: " + (end - start));
792
    start = System.currentTimeMillis();
793
    for (int i=0; i<ITERS; i++) {
794
      test_srav(a0, a1, SHIFT);
795
    }
796
    end = System.currentTimeMillis();
797
    System.out.println("test_srav_o: " + (end - start));
798

799
    start = System.currentTimeMillis();
800
    for (int i=0; i<ITERS; i++) {
801
      test_sllc_on(a0, a1);
802
    }
803
    end = System.currentTimeMillis();
804
    System.out.println("test_sllc_on: " + (end - start));
805
    start = System.currentTimeMillis();
806
    for (int i=0; i<ITERS; i++) {
807
      test_sllv(a0, a1, -SHIFT);
808
    }
809
    end = System.currentTimeMillis();
810
    System.out.println("test_sllv_on: " + (end - start));
811

812
    start = System.currentTimeMillis();
813
    for (int i=0; i<ITERS; i++) {
814
      test_srlc_on(a0, a1);
815
    }
816
    end = System.currentTimeMillis();
817
    System.out.println("test_srlc_on: " + (end - start));
818
    start = System.currentTimeMillis();
819
    for (int i=0; i<ITERS; i++) {
820
      test_srlv(a0, a1, -SHIFT);
821
    }
822
    end = System.currentTimeMillis();
823
    System.out.println("test_srlv_on: " + (end - start));
824

825
    start = System.currentTimeMillis();
826
    for (int i=0; i<ITERS; i++) {
827
      test_srac_on(a0, a1);
828
    }
829
    end = System.currentTimeMillis();
830
    System.out.println("test_srac_on: " + (end - start));
831
    start = System.currentTimeMillis();
832
    for (int i=0; i<ITERS; i++) {
833
      test_srav(a0, a1, -SHIFT);
834
    }
835
    end = System.currentTimeMillis();
836
    System.out.println("test_srav_on: " + (end - start));
837

838
    start = System.currentTimeMillis();
839
    for (int i=0; i<ITERS; i++) {
840
      test_sllc_add(a0, a1);
841
    }
842
    end = System.currentTimeMillis();
843
    System.out.println("test_sllc_add: " + (end - start));
844
    start = System.currentTimeMillis();
845
    for (int i=0; i<ITERS; i++) {
846
      test_sllv_add(a0, a1, ADD_INIT);
847
    }
848
    end = System.currentTimeMillis();
849
    System.out.println("test_sllv_add: " + (end - start));
850

851
    start = System.currentTimeMillis();
852
    for (int i=0; i<ITERS; i++) {
853
      test_srlc_add(a0, a1);
854
    }
855
    end = System.currentTimeMillis();
856
    System.out.println("test_srlc_add: " + (end - start));
857
    start = System.currentTimeMillis();
858
    for (int i=0; i<ITERS; i++) {
859
      test_srlv_add(a0, a1, ADD_INIT);
860
    }
861
    end = System.currentTimeMillis();
862
    System.out.println("test_srlv_add: " + (end - start));
863

864
    start = System.currentTimeMillis();
865
    for (int i=0; i<ITERS; i++) {
866
      test_srac_add(a0, a1);
867
    }
868
    end = System.currentTimeMillis();
869
    System.out.println("test_srac_add: " + (end - start));
870
    start = System.currentTimeMillis();
871
    for (int i=0; i<ITERS; i++) {
872
      test_srav_add(a0, a1, ADD_INIT);
873
    }
874
    end = System.currentTimeMillis();
875
    System.out.println("test_srav_add: " + (end - start));
876

877
    start = System.currentTimeMillis();
878
    for (int i=0; i<ITERS; i++) {
879
      test_sllc_and(a0, a1);
880
    }
881
    end = System.currentTimeMillis();
882
    System.out.println("test_sllc_and: " + (end - start));
883
    start = System.currentTimeMillis();
884
    for (int i=0; i<ITERS; i++) {
885
      test_sllv_and(a0, a1, BIT_MASK);
886
    }
887
    end = System.currentTimeMillis();
888
    System.out.println("test_sllv_and: " + (end - start));
889

890
    start = System.currentTimeMillis();
891
    for (int i=0; i<ITERS; i++) {
892
      test_srlc_and(a0, a1);
893
    }
894
    end = System.currentTimeMillis();
895
    System.out.println("test_srlc_and: " + (end - start));
896
    start = System.currentTimeMillis();
897
    for (int i=0; i<ITERS; i++) {
898
      test_srlv_and(a0, a1, BIT_MASK);
899
    }
900
    end = System.currentTimeMillis();
901
    System.out.println("test_srlv_and: " + (end - start));
902

903
    start = System.currentTimeMillis();
904
    for (int i=0; i<ITERS; i++) {
905
      test_srac_and(a0, a1);
906
    }
907
    end = System.currentTimeMillis();
908
    System.out.println("test_srac_and: " + (end - start));
909
    start = System.currentTimeMillis();
910
    for (int i=0; i<ITERS; i++) {
911
      test_srav_and(a0, a1, BIT_MASK);
912
    }
913
    end = System.currentTimeMillis();
914
    System.out.println("test_srav_and: " + (end - start));
915

916
    start = System.currentTimeMillis();
917
    for (int i=0; i<ITERS; i++) {
918
      test_pack2(p2, a1);
919
    }
920
    end = System.currentTimeMillis();
921
    System.out.println("test_pack2: " + (end - start));
922
    start = System.currentTimeMillis();
923
    for (int i=0; i<ITERS; i++) {
924
      test_unpack2(a0, p2);
925
    }
926
    end = System.currentTimeMillis();
927
    System.out.println("test_unpack2: " + (end - start));
928
    start = System.currentTimeMillis();
929
    for (int i=0; i<ITERS; i++) {
930
      test_pack2_swap(p2, a1);
931
    }
932
    end = System.currentTimeMillis();
933
    System.out.println("test_pack2_swap: " + (end - start));
934
    start = System.currentTimeMillis();
935
    for (int i=0; i<ITERS; i++) {
936
      test_unpack2_swap(a0, p2);
937
    }
938
    end = System.currentTimeMillis();
939
    System.out.println("test_unpack2_swap: " + (end - start));
940

941
    start = System.currentTimeMillis();
942
    for (int i=0; i<ITERS; i++) {
943
      test_pack4(p4, a1);
944
    }
945
    end = System.currentTimeMillis();
946
    System.out.println("test_pack4: " + (end - start));
947
    start = System.currentTimeMillis();
948
    for (int i=0; i<ITERS; i++) {
949
      test_unpack4(a0, p4);
950
    }
951
    end = System.currentTimeMillis();
952
    System.out.println("test_unpack4: " + (end - start));
953
    start = System.currentTimeMillis();
954
    for (int i=0; i<ITERS; i++) {
955
      test_pack4_swap(p4, a1);
956
    }
957
    end = System.currentTimeMillis();
958
    System.out.println("test_pack4_swap: " + (end - start));
959
    start = System.currentTimeMillis();
960
    for (int i=0; i<ITERS; i++) {
961
      test_unpack4_swap(a0, p4);
962
    }
963
    end = System.currentTimeMillis();
964
    System.out.println("test_unpack4_swap: " + (end - start));
965

966
    return errn;
967
  }
968

969
  static int test_sum(short[] a1) {
970
    int sum = 0;
971
    for (int i = 0; i < a1.length; i+=1) {
972
      sum += a1[i];
973
    }
974
    return sum;
975
  }
976

977
  static void test_addc(short[] a0, short[] a1) {
978
    for (int i = 0; i < a0.length; i+=1) {
979
      a0[i] = (short)(a1[i]+VALUE);
980
    }
981
  }
982
  static void test_addv(short[] a0, short[] a1, short b) {
983
    for (int i = 0; i < a0.length; i+=1) {
984
      a0[i] = (short)(a1[i]+b);
985
    }
986
  }
987
  static void test_adda(short[] a0, short[] a1, short[] a2) {
988
    for (int i = 0; i < a0.length; i+=1) {
989
      a0[i] = (short)(a1[i]+a2[i]);
990
    }
991
  }
992

993
  static void test_subc(short[] a0, short[] a1) {
994
    for (int i = 0; i < a0.length; i+=1) {
995
      a0[i] = (short)(a1[i]-VALUE);
996
    }
997
  }
998
  static void test_subv(short[] a0, short[] a1, short b) {
999
    for (int i = 0; i < a0.length; i+=1) {
1000
      a0[i] = (short)(a1[i]-b);
1001
    }
1002
  }
1003
  static void test_suba(short[] a0, short[] a1, short[] a2) {
1004
    for (int i = 0; i < a0.length; i+=1) {
1005
      a0[i] = (short)(a1[i]-a2[i]);
1006
    }
1007
  }
1008

1009
  static void test_mulc(short[] a0, short[] a1) {
1010
    for (int i = 0; i < a0.length; i+=1) {
1011
      a0[i] = (short)(a1[i]*VALUE);
1012
    }
1013
  }
1014
  static void test_mulc_n(short[] a0, short[] a1) {
1015
    for (int i = 0; i < a0.length; i+=1) {
1016
      a0[i] = (short)(a1[i]*(-VALUE));
1017
    }
1018
  }
1019
  static void test_mulv(short[] a0, short[] a1, short b) {
1020
    for (int i = 0; i < a0.length; i+=1) {
1021
      a0[i] = (short)(a1[i]*b);
1022
    }
1023
  }
1024
  static void test_mula(short[] a0, short[] a1, short[] a2) {
1025
    for (int i = 0; i < a0.length; i+=1) {
1026
      a0[i] = (short)(a1[i]*a2[i]);
1027
    }
1028
  }
1029

1030
  static void test_divc(short[] a0, short[] a1) {
1031
    for (int i = 0; i < a0.length; i+=1) {
1032
      a0[i] = (short)(a1[i]/VALUE);
1033
    }
1034
  }
1035
  static void test_divc_n(short[] a0, short[] a1) {
1036
    for (int i = 0; i < a0.length; i+=1) {
1037
      a0[i] = (short)(a1[i]/(-VALUE));
1038
    }
1039
  }
1040
  static void test_divv(short[] a0, short[] a1, short b) {
1041
    for (int i = 0; i < a0.length; i+=1) {
1042
      a0[i] = (short)(a1[i]/b);
1043
    }
1044
  }
1045
  static void test_diva(short[] a0, short[] a1, short[] a2) {
1046
    for (int i = 0; i < a0.length; i+=1) {
1047
      a0[i] = (short)(a1[i]/a2[i]);
1048
    }
1049
  }
1050

1051
  static void test_andc(short[] a0, short[] a1) {
1052
    for (int i = 0; i < a0.length; i+=1) {
1053
      a0[i] = (short)(a1[i]&BIT_MASK);
1054
    }
1055
  }
1056
  static void test_andv(short[] a0, short[] a1, short b) {
1057
    for (int i = 0; i < a0.length; i+=1) {
1058
      a0[i] = (short)(a1[i]&b);
1059
    }
1060
  }
1061
  static void test_anda(short[] a0, short[] a1, short[] a2) {
1062
    for (int i = 0; i < a0.length; i+=1) {
1063
      a0[i] = (short)(a1[i]&a2[i]);
1064
    }
1065
  }
1066

1067
  static void test_orc(short[] a0, short[] a1) {
1068
    for (int i = 0; i < a0.length; i+=1) {
1069
      a0[i] = (short)(a1[i]|BIT_MASK);
1070
    }
1071
  }
1072
  static void test_orv(short[] a0, short[] a1, short b) {
1073
    for (int i = 0; i < a0.length; i+=1) {
1074
      a0[i] = (short)(a1[i]|b);
1075
    }
1076
  }
1077
  static void test_ora(short[] a0, short[] a1, short[] a2) {
1078
    for (int i = 0; i < a0.length; i+=1) {
1079
      a0[i] = (short)(a1[i]|a2[i]);
1080
    }
1081
  }
1082

1083
  static void test_xorc(short[] a0, short[] a1) {
1084
    for (int i = 0; i < a0.length; i+=1) {
1085
      a0[i] = (short)(a1[i]^BIT_MASK);
1086
    }
1087
  }
1088
  static void test_xorv(short[] a0, short[] a1, short b) {
1089
    for (int i = 0; i < a0.length; i+=1) {
1090
      a0[i] = (short)(a1[i]^b);
1091
    }
1092
  }
1093
  static void test_xora(short[] a0, short[] a1, short[] a2) {
1094
    for (int i = 0; i < a0.length; i+=1) {
1095
      a0[i] = (short)(a1[i]^a2[i]);
1096
    }
1097
  }
1098

1099
  static void test_sllc(short[] a0, short[] a1) {
1100
    for (int i = 0; i < a0.length; i+=1) {
1101
      a0[i] = (short)(a1[i]<<VALUE);
1102
    }
1103
  }
1104
  static void test_sllc_n(short[] a0, short[] a1) {
1105
    for (int i = 0; i < a0.length; i+=1) {
1106
      a0[i] = (short)(a1[i]<<(-VALUE));
1107
    }
1108
  }
1109
  static void test_sllc_o(short[] a0, short[] a1) {
1110
    for (int i = 0; i < a0.length; i+=1) {
1111
      a0[i] = (short)(a1[i]<<SHIFT);
1112
    }
1113
  }
1114
  static void test_sllc_on(short[] a0, short[] a1) {
1115
    for (int i = 0; i < a0.length; i+=1) {
1116
      a0[i] = (short)(a1[i]<<(-SHIFT));
1117
    }
1118
  }
1119
  static void test_sllv(short[] a0, short[] a1, int b) {
1120
    for (int i = 0; i < a0.length; i+=1) {
1121
      a0[i] = (short)(a1[i]<<b);
1122
    }
1123
  }
1124
  static void test_sllc_add(short[] a0, short[] a1) {
1125
    for (int i = 0; i < a0.length; i+=1) {
1126
      a0[i] = (short)((a1[i] + ADD_INIT)<<VALUE);
1127
    }
1128
  }
1129
  static void test_sllv_add(short[] a0, short[] a1, int b) {
1130
    for (int i = 0; i < a0.length; i+=1) {
1131
      a0[i] = (short)((a1[i] + b)<<VALUE);
1132
    }
1133
  }
1134
  static void test_sllc_and(short[] a0, short[] a1) {
1135
    for (int i = 0; i < a0.length; i+=1) {
1136
      a0[i] = (short)((a1[i] & BIT_MASK)<<VALUE);
1137
    }
1138
  }
1139
  static void test_sllv_and(short[] a0, short[] a1, int b) {
1140
    for (int i = 0; i < a0.length; i+=1) {
1141
      a0[i] = (short)((a1[i] & b)<<VALUE);
1142
    }
1143
  }
1144

1145
  static void test_srlc(short[] a0, short[] a1) {
1146
    for (int i = 0; i < a0.length; i+=1) {
1147
      a0[i] = (short)(a1[i]>>>VALUE);
1148
    }
1149
  }
1150
  static void test_srlc_n(short[] a0, short[] a1) {
1151
    for (int i = 0; i < a0.length; i+=1) {
1152
      a0[i] = (short)(a1[i]>>>(-VALUE));
1153
    }
1154
  }
1155
  static void test_srlc_o(short[] a0, short[] a1) {
1156
    for (int i = 0; i < a0.length; i+=1) {
1157
      a0[i] = (short)(a1[i]>>>SHIFT);
1158
    }
1159
  }
1160
  static void test_srlc_on(short[] a0, short[] a1) {
1161
    for (int i = 0; i < a0.length; i+=1) {
1162
      a0[i] = (short)(a1[i]>>>(-SHIFT));
1163
    }
1164
  }
1165
  static void test_srlv(short[] a0, short[] a1, int b) {
1166
    for (int i = 0; i < a0.length; i+=1) {
1167
      a0[i] = (short)(a1[i]>>>b);
1168
    }
1169
  }
1170
  static void test_srlc_add(short[] a0, short[] a1) {
1171
    for (int i = 0; i < a0.length; i+=1) {
1172
      a0[i] = (short)((a1[i] + ADD_INIT)>>>VALUE);
1173
    }
1174
  }
1175
  static void test_srlv_add(short[] a0, short[] a1, int b) {
1176
    for (int i = 0; i < a0.length; i+=1) {
1177
      a0[i] = (short)((a1[i] + b)>>>VALUE);
1178
    }
1179
  }
1180
  static void test_srlc_and(short[] a0, short[] a1) {
1181
    for (int i = 0; i < a0.length; i+=1) {
1182
      a0[i] = (short)((a1[i] & BIT_MASK)>>>VALUE);
1183
    }
1184
  }
1185
  static void test_srlv_and(short[] a0, short[] a1, int b) {
1186
    for (int i = 0; i < a0.length; i+=1) {
1187
      a0[i] = (short)((a1[i] & b)>>>VALUE);
1188
    }
1189
  }
1190

1191
  static void test_srac(short[] a0, short[] a1) {
1192
    for (int i = 0; i < a0.length; i+=1) {
1193
      a0[i] = (short)(a1[i]>>VALUE);
1194
    }
1195
  }
1196
  static void test_srac_n(short[] a0, short[] a1) {
1197
    for (int i = 0; i < a0.length; i+=1) {
1198
      a0[i] = (short)(a1[i]>>(-VALUE));
1199
    }
1200
  }
1201
  static void test_srac_o(short[] a0, short[] a1) {
1202
    for (int i = 0; i < a0.length; i+=1) {
1203
      a0[i] = (short)(a1[i]>>SHIFT);
1204
    }
1205
  }
1206
  static void test_srac_on(short[] a0, short[] a1) {
1207
    for (int i = 0; i < a0.length; i+=1) {
1208
      a0[i] = (short)(a1[i]>>(-SHIFT));
1209
    }
1210
  }
1211
  static void test_srav(short[] a0, short[] a1, int b) {
1212
    for (int i = 0; i < a0.length; i+=1) {
1213
      a0[i] = (short)(a1[i]>>b);
1214
    }
1215
  }
1216
  static void test_srac_add(short[] a0, short[] a1) {
1217
    for (int i = 0; i < a0.length; i+=1) {
1218
      a0[i] = (short)((a1[i] + ADD_INIT)>>VALUE);
1219
    }
1220
  }
1221
  static void test_srav_add(short[] a0, short[] a1, int b) {
1222
    for (int i = 0; i < a0.length; i+=1) {
1223
      a0[i] = (short)((a1[i] + b)>>VALUE);
1224
    }
1225
  }
1226
  static void test_srac_and(short[] a0, short[] a1) {
1227
    for (int i = 0; i < a0.length; i+=1) {
1228
      a0[i] = (short)((a1[i] & BIT_MASK)>>VALUE);
1229
    }
1230
  }
1231
  static void test_srav_and(short[] a0, short[] a1, int b) {
1232
    for (int i = 0; i < a0.length; i+=1) {
1233
      a0[i] = (short)((a1[i] & b)>>VALUE);
1234
    }
1235
  }
1236

1237
  static void test_pack2(int[] p2, short[] a1) {
1238
    if (p2.length*2 > a1.length) return;
1239
    for (int i = 0; i < p2.length; i+=1) {
1240
      int l0 = (int)a1[i*2+0];
1241
      int l1 = (int)a1[i*2+1];
1242
      p2[i] = (l1 << 16) | (l0 & 0xFFFF);
1243
    }
1244
  }
1245
  static void test_unpack2(short[] a0, int[] p2) {
1246
    if (p2.length*2 > a0.length) return;
1247
    for (int i = 0; i < p2.length; i+=1) {
1248
      int l = p2[i];
1249
      a0[i*2+0] = (short)(l & 0xFFFF);
1250
      a0[i*2+1] = (short)(l >> 16);
1251
    }
1252
  }
1253
  static void test_pack2_swap(int[] p2, short[] a1) {
1254
    if (p2.length*2 > a1.length) return;
1255
    for (int i = 0; i < p2.length; i+=1) {
1256
      int l0 = (int)a1[i*2+0];
1257
      int l1 = (int)a1[i*2+1];
1258
      p2[i] = (l0 << 16) | (l1 & 0xFFFF);
1259
    }
1260
  }
1261
  static void test_unpack2_swap(short[] a0, int[] p2) {
1262
    if (p2.length*2 > a0.length) return;
1263
    for (int i = 0; i < p2.length; i+=1) {
1264
      int l = p2[i];
1265
      a0[i*2+0] = (short)(l >> 16);
1266
      a0[i*2+1] = (short)(l & 0xFFFF);
1267
    }
1268
  }
1269

1270
  static void test_pack4(long[] p4, short[] a1) {
1271
    if (p4.length*4 > a1.length) return;
1272
    for (int i = 0; i < p4.length; i+=1) {
1273
      long l0 = (long)a1[i*4+0];
1274
      long l1 = (long)a1[i*4+1];
1275
      long l2 = (long)a1[i*4+2];
1276
      long l3 = (long)a1[i*4+3];
1277
      p4[i] = (l0 & 0xFFFFl) |
1278
             ((l1 & 0xFFFFl) << 16) |
1279
             ((l2 & 0xFFFFl) << 32) |
1280
             ((l3 & 0xFFFFl) << 48);
1281
    }
1282
  }
1283
  static void test_unpack4(short[] a0, long[] p4) {
1284
    if (p4.length*4 > a0.length) return;
1285
    for (int i = 0; i < p4.length; i+=1) {
1286
      long l = p4[i];
1287
      a0[i*4+0] = (short)(l & 0xFFFFl);
1288
      a0[i*4+1] = (short)(l >> 16);
1289
      a0[i*4+2] = (short)(l >> 32);
1290
      a0[i*4+3] = (short)(l >> 48);
1291
    }
1292
  }
1293
  static void test_pack4_swap(long[] p4, short[] a1) {
1294
    if (p4.length*4 > a1.length) return;
1295
    for (int i = 0; i < p4.length; i+=1) {
1296
      long l0 = (long)a1[i*4+0];
1297
      long l1 = (long)a1[i*4+1];
1298
      long l2 = (long)a1[i*4+2];
1299
      long l3 = (long)a1[i*4+3];
1300
      p4[i] = (l3 & 0xFFFFl) |
1301
             ((l2 & 0xFFFFl) << 16) |
1302
             ((l1 & 0xFFFFl) << 32) |
1303
             ((l0 & 0xFFFFl) << 48);
1304
    }
1305
  }
1306
  static void test_unpack4_swap(short[] a0, long[] p4) {
1307
    if (p4.length*4 > a0.length) return;
1308
    for (int i = 0; i < p4.length; i+=1) {
1309
      long l = p4[i];
1310
      a0[i*4+0] = (short)(l >> 48);
1311
      a0[i*4+1] = (short)(l >> 32);
1312
      a0[i*4+2] = (short)(l >> 16);
1313
      a0[i*4+3] = (short)(l & 0xFFFFl);
1314
    }
1315
  }
1316

1317
  static int verify(String text, int i, short elem, short val) {
1318
    if (elem != val) {
1319
      System.err.println(text + "[" + i + "] = " + elem + " != " + val);
1320
      return 1;
1321
    }
1322
    return 0;
1323
  }
1324

1325
  static int verify(String text, int i, int elem, int val) {
1326
    if (elem != val) {
1327
      System.err.println(text + "[" + i + "] = " + Integer.toHexString(elem) + " != " + Integer.toHexString(val));
1328
      return 1;
1329
    }
1330
    return 0;
1331
  }
1332

1333
  static int verify(String text, int i, long elem, long val) {
1334
    if (elem != val) {
1335
      System.err.println(text + "[" + i + "] = " + Long.toHexString(elem) + " != " + Long.toHexString(val));
1336
      return 1;
1337
    }
1338
    return 0;
1339
  }
1340
}
1341

1342
Product

Resources

Company
