CoCalc -- TestLongVect.java

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

33
public class TestLongVect {
34
  private static final int ARRLEN = 997;
35
  private static final int ITERS  = 11000;
36
  private static final long ADD_INIT = Long.MAX_VALUE-500;
37
  private static final long BIT_MASK = 0xEC80F731EC80F731L;
38
  private static final int VALUE = 31;
39
  private static final int SHIFT = 64;
40

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

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

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

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

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

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

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

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

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

135
      test_sllc_and(a0, a1);
136
      test_sllv_and(a0, a1, BIT_MASK);
137
      test_srlc_and(a0, a1);
138
      test_srlv_and(a0, a1, BIT_MASK);
139
      test_srac_and(a0, a1);
140
      test_srav_and(a0, a1, BIT_MASK);
141
    }
142
    // Test and verify results
143
    System.out.println("Verification");
144
    int errn = 0;
145
    {
146
      long sum = test_sum(a1);
147
      if (sum != gold_sum) {
148
        System.err.println("test_sum:  " + sum + " != " + gold_sum);
149
        errn++;
150
      }
151

152
      test_addc(a0, a1);
153
      for (int i=0; i<ARRLEN; i++) {
154
        errn += verify("test_addc: ", i, a0[i], (long)((long)(ADD_INIT+i)+VALUE));
155
      }
156
      test_addv(a0, a1, (long)VALUE);
157
      for (int i=0; i<ARRLEN; i++) {
158
        errn += verify("test_addv: ", i, a0[i], (long)((long)(ADD_INIT+i)+VALUE));
159
      }
160
      test_adda(a0, a1, a2);
161
      for (int i=0; i<ARRLEN; i++) {
162
        errn += verify("test_adda: ", i, a0[i], (long)((long)(ADD_INIT+i)+VALUE));
163
      }
164

165
      test_subc(a0, a1);
166
      for (int i=0; i<ARRLEN; i++) {
167
        errn += verify("test_subc: ", i, a0[i], (long)((long)(ADD_INIT+i)-VALUE));
168
      }
169
      test_subv(a0, a1, (long)VALUE);
170
      for (int i=0; i<ARRLEN; i++) {
171
        errn += verify("test_subv: ", i, a0[i], (long)((long)(ADD_INIT+i)-VALUE));
172
      }
173
      test_suba(a0, a1, a2);
174
      for (int i=0; i<ARRLEN; i++) {
175
        errn += verify("test_suba: ", i, a0[i], (long)((long)(ADD_INIT+i)-VALUE));
176
      }
177

178
      test_mulc(a0, a1);
179
      for (int i=0; i<ARRLEN; i++) {
180
        errn += verify("test_mulc: ", i, a0[i], (long)((long)(ADD_INIT+i)*VALUE));
181
      }
182
      test_mulv(a0, a1, (long)VALUE);
183
      for (int i=0; i<ARRLEN; i++) {
184
        errn += verify("test_mulv: ", i, a0[i], (long)((long)(ADD_INIT+i)*VALUE));
185
      }
186
      test_mula(a0, a1, a2);
187
      for (int i=0; i<ARRLEN; i++) {
188
        errn += verify("test_mula: ", i, a0[i], (long)((long)(ADD_INIT+i)*VALUE));
189
      }
190

191
      test_divc(a0, a1);
192
      for (int i=0; i<ARRLEN; i++) {
193
        errn += verify("test_divc: ", i, a0[i], (long)((long)(ADD_INIT+i)/VALUE));
194
      }
195
      test_divv(a0, a1, (long)VALUE);
196
      for (int i=0; i<ARRLEN; i++) {
197
        errn += verify("test_divv: ", i, a0[i], (long)((long)(ADD_INIT+i)/VALUE));
198
      }
199
      test_diva(a0, a1, a2);
200
      for (int i=0; i<ARRLEN; i++) {
201
        errn += verify("test_diva: ", i, a0[i], (long)((long)(ADD_INIT+i)/VALUE));
202
      }
203

204
      test_mulc_n(a0, a1);
205
      for (int i=0; i<ARRLEN; i++) {
206
        errn += verify("test_mulc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)*(-VALUE)));
207
      }
208
      test_mulv(a0, a1, (long)-VALUE);
209
      for (int i=0; i<ARRLEN; i++) {
210
        errn += verify("test_mulv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)*(-VALUE)));
211
      }
212
      test_mula(a0, a1, a3);
213
      for (int i=0; i<ARRLEN; i++) {
214
        errn += verify("test_mula_n: ", i, a0[i], (long)((long)(ADD_INIT+i)*(-VALUE)));
215
      }
216

217
      test_divc_n(a0, a1);
218
      for (int i=0; i<ARRLEN; i++) {
219
        errn += verify("test_divc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)/(-VALUE)));
220
      }
221
      test_divv(a0, a1, (long)-VALUE);
222
      for (int i=0; i<ARRLEN; i++) {
223
        errn += verify("test_divv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)/(-VALUE)));
224
      }
225
      test_diva(a0, a1, a3);
226
      for (int i=0; i<ARRLEN; i++) {
227
        errn += verify("test_diva_n: ", i, a0[i], (long)((long)(ADD_INIT+i)/(-VALUE)));
228
      }
229

230
      test_andc(a0, a1);
231
      for (int i=0; i<ARRLEN; i++) {
232
        errn += verify("test_andc: ", i, a0[i], (long)((long)(ADD_INIT+i)&BIT_MASK));
233
      }
234
      test_andv(a0, a1, (long)BIT_MASK);
235
      for (int i=0; i<ARRLEN; i++) {
236
        errn += verify("test_andv: ", i, a0[i], (long)((long)(ADD_INIT+i)&BIT_MASK));
237
      }
238
      test_anda(a0, a1, a4);
239
      for (int i=0; i<ARRLEN; i++) {
240
        errn += verify("test_anda: ", i, a0[i], (long)((long)(ADD_INIT+i)&BIT_MASK));
241
      }
242

243
      test_orc(a0, a1);
244
      for (int i=0; i<ARRLEN; i++) {
245
        errn += verify("test_orc: ", i, a0[i], (long)((long)(ADD_INIT+i)|BIT_MASK));
246
      }
247
      test_orv(a0, a1, (long)BIT_MASK);
248
      for (int i=0; i<ARRLEN; i++) {
249
        errn += verify("test_orv: ", i, a0[i], (long)((long)(ADD_INIT+i)|BIT_MASK));
250
      }
251
      test_ora(a0, a1, a4);
252
      for (int i=0; i<ARRLEN; i++) {
253
        errn += verify("test_ora: ", i, a0[i], (long)((long)(ADD_INIT+i)|BIT_MASK));
254
      }
255

256
      test_xorc(a0, a1);
257
      for (int i=0; i<ARRLEN; i++) {
258
        errn += verify("test_xorc: ", i, a0[i], (long)((long)(ADD_INIT+i)^BIT_MASK));
259
      }
260
      test_xorv(a0, a1, (long)BIT_MASK);
261
      for (int i=0; i<ARRLEN; i++) {
262
        errn += verify("test_xorv: ", i, a0[i], (long)((long)(ADD_INIT+i)^BIT_MASK));
263
      }
264
      test_xora(a0, a1, a4);
265
      for (int i=0; i<ARRLEN; i++) {
266
        errn += verify("test_xora: ", i, a0[i], (long)((long)(ADD_INIT+i)^BIT_MASK));
267
      }
268

269
      test_sllc(a0, a1);
270
      for (int i=0; i<ARRLEN; i++) {
271
        errn += verify("test_sllc: ", i, a0[i], (long)((long)(ADD_INIT+i)<<VALUE));
272
      }
273
      test_sllv(a0, a1, VALUE);
274
      for (int i=0; i<ARRLEN; i++) {
275
        errn += verify("test_sllv: ", i, a0[i], (long)((long)(ADD_INIT+i)<<VALUE));
276
      }
277

278
      test_srlc(a0, a1);
279
      for (int i=0; i<ARRLEN; i++) {
280
        errn += verify("test_srlc: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>VALUE));
281
      }
282
      test_srlv(a0, a1, VALUE);
283
      for (int i=0; i<ARRLEN; i++) {
284
        errn += verify("test_srlv: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>VALUE));
285
      }
286

287
      test_srac(a0, a1);
288
      for (int i=0; i<ARRLEN; i++) {
289
        errn += verify("test_srac: ", i, a0[i], (long)((long)(ADD_INIT+i)>>VALUE));
290
      }
291
      test_srav(a0, a1, VALUE);
292
      for (int i=0; i<ARRLEN; i++) {
293
        errn += verify("test_srav: ", i, a0[i], (long)((long)(ADD_INIT+i)>>VALUE));
294
      }
295

296
      test_sllc_n(a0, a1);
297
      for (int i=0; i<ARRLEN; i++) {
298
        errn += verify("test_sllc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-VALUE)));
299
      }
300
      test_sllv(a0, a1, -VALUE);
301
      for (int i=0; i<ARRLEN; i++) {
302
        errn += verify("test_sllv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-VALUE)));
303
      }
304

305
      test_srlc_n(a0, a1);
306
      for (int i=0; i<ARRLEN; i++) {
307
        errn += verify("test_srlc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-VALUE)));
308
      }
309
      test_srlv(a0, a1, -VALUE);
310
      for (int i=0; i<ARRLEN; i++) {
311
        errn += verify("test_srlv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-VALUE)));
312
      }
313

314
      test_srac_n(a0, a1);
315
      for (int i=0; i<ARRLEN; i++) {
316
        errn += verify("test_srac_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-VALUE)));
317
      }
318
      test_srav(a0, a1, -VALUE);
319
      for (int i=0; i<ARRLEN; i++) {
320
        errn += verify("test_srav_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-VALUE)));
321
      }
322

323
      test_sllc_o(a0, a1);
324
      for (int i=0; i<ARRLEN; i++) {
325
        errn += verify("test_sllc_o: ", i, a0[i], (long)((long)(ADD_INIT+i)<<SHIFT));
326
      }
327
      test_sllv(a0, a1, SHIFT);
328
      for (int i=0; i<ARRLEN; i++) {
329
        errn += verify("test_sllv_o: ", i, a0[i], (long)((long)(ADD_INIT+i)<<SHIFT));
330
      }
331

332
      test_srlc_o(a0, a1);
333
      for (int i=0; i<ARRLEN; i++) {
334
        errn += verify("test_srlc_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>SHIFT));
335
      }
336
      test_srlv(a0, a1, SHIFT);
337
      for (int i=0; i<ARRLEN; i++) {
338
        errn += verify("test_srlv_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>SHIFT));
339
      }
340

341
      test_srac_o(a0, a1);
342
      for (int i=0; i<ARRLEN; i++) {
343
        errn += verify("test_srac_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>SHIFT));
344
      }
345
      test_srav(a0, a1, SHIFT);
346
      for (int i=0; i<ARRLEN; i++) {
347
        errn += verify("test_srav_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>SHIFT));
348
      }
349

350
      test_sllc_on(a0, a1);
351
      for (int i=0; i<ARRLEN; i++) {
352
        errn += verify("test_sllc_on: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-SHIFT)));
353
      }
354
      test_sllv(a0, a1, -SHIFT);
355
      for (int i=0; i<ARRLEN; i++) {
356
        errn += verify("test_sllv_on: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-SHIFT)));
357
      }
358

359
      test_srlc_on(a0, a1);
360
      for (int i=0; i<ARRLEN; i++) {
361
        errn += verify("test_srlc_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-SHIFT)));
362
      }
363
      test_srlv(a0, a1, -SHIFT);
364
      for (int i=0; i<ARRLEN; i++) {
365
        errn += verify("test_srlv_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-SHIFT)));
366
      }
367

368
      test_srac_on(a0, a1);
369
      for (int i=0; i<ARRLEN; i++) {
370
        errn += verify("test_srac_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-SHIFT)));
371
      }
372
      test_srav(a0, a1, -SHIFT);
373
      for (int i=0; i<ARRLEN; i++) {
374
        errn += verify("test_srav_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-SHIFT)));
375
      }
376

377
      test_sllc_add(a0, a1);
378
      for (int i=0; i<ARRLEN; i++) {
379
        errn += verify("test_sllc_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)<<VALUE));
380
      }
381
      test_sllv_add(a0, a1, ADD_INIT);
382
      for (int i=0; i<ARRLEN; i++) {
383
        errn += verify("test_sllv_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)<<VALUE));
384
      }
385

386
      test_srlc_add(a0, a1);
387
      for (int i=0; i<ARRLEN; i++) {
388
        errn += verify("test_srlc_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>>VALUE));
389
      }
390
      test_srlv_add(a0, a1, ADD_INIT);
391
      for (int i=0; i<ARRLEN; i++) {
392
        errn += verify("test_srlv_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>>VALUE));
393
      }
394

395
      test_srac_add(a0, a1);
396
      for (int i=0; i<ARRLEN; i++) {
397
        errn += verify("test_srac_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>VALUE));
398
      }
399
      test_srav_add(a0, a1, ADD_INIT);
400
      for (int i=0; i<ARRLEN; i++) {
401
        errn += verify("test_srav_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>VALUE));
402
      }
403

404
      test_sllc_and(a0, a1);
405
      for (int i=0; i<ARRLEN; i++) {
406
        errn += verify("test_sllc_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)<<VALUE));
407
      }
408
      test_sllv_and(a0, a1, BIT_MASK);
409
      for (int i=0; i<ARRLEN; i++) {
410
        errn += verify("test_sllv_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)<<VALUE));
411
      }
412

413
      test_srlc_and(a0, a1);
414
      for (int i=0; i<ARRLEN; i++) {
415
        errn += verify("test_srlc_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>>VALUE));
416
      }
417
      test_srlv_and(a0, a1, BIT_MASK);
418
      for (int i=0; i<ARRLEN; i++) {
419
        errn += verify("test_srlv_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>>VALUE));
420
      }
421

422
      test_srac_and(a0, a1);
423
      for (int i=0; i<ARRLEN; i++) {
424
        errn += verify("test_srac_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>VALUE));
425
      }
426
      test_srav_and(a0, a1, BIT_MASK);
427
      for (int i=0; i<ARRLEN; i++) {
428
        errn += verify("test_srav_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>VALUE));
429
      }
430

431
    }
432

433
    if (errn > 0)
434
      return errn;
435

436
    System.out.println("Time");
437
    long start, end;
438

439
    start = System.currentTimeMillis();
440
    for (int i=0; i<ITERS; i++) {
441
      test_sum(a1);
442
    }
443
    end = System.currentTimeMillis();
444
    System.out.println("test_sum: " + (end - start));
445

446
    start = System.currentTimeMillis();
447
    for (int i=0; i<ITERS; i++) {
448
      test_addc(a0, a1);
449
    }
450
    end = System.currentTimeMillis();
451
    System.out.println("test_addc: " + (end - start));
452
    start = System.currentTimeMillis();
453
    for (int i=0; i<ITERS; i++) {
454
      test_addv(a0, a1, (long)VALUE);
455
    }
456
    end = System.currentTimeMillis();
457
    System.out.println("test_addv: " + (end - start));
458
    start = System.currentTimeMillis();
459
    for (int i=0; i<ITERS; i++) {
460
      test_adda(a0, a1, a2);
461
    }
462
    end = System.currentTimeMillis();
463
    System.out.println("test_adda: " + (end - start));
464

465
    start = System.currentTimeMillis();
466
    for (int i=0; i<ITERS; i++) {
467
      test_subc(a0, a1);
468
    }
469
    end = System.currentTimeMillis();
470
    System.out.println("test_subc: " + (end - start));
471
    start = System.currentTimeMillis();
472
    for (int i=0; i<ITERS; i++) {
473
      test_subv(a0, a1, (long)VALUE);
474
    }
475
    end = System.currentTimeMillis();
476
    System.out.println("test_subv: " + (end - start));
477
    start = System.currentTimeMillis();
478
    for (int i=0; i<ITERS; i++) {
479
      test_suba(a0, a1, a2);
480
    }
481
    end = System.currentTimeMillis();
482
    System.out.println("test_suba: " + (end - start));
483

484
    start = System.currentTimeMillis();
485
    for (int i=0; i<ITERS; i++) {
486
      test_mulc(a0, a1);
487
    }
488
    end = System.currentTimeMillis();
489
    System.out.println("test_mulc: " + (end - start));
490
    start = System.currentTimeMillis();
491
    for (int i=0; i<ITERS; i++) {
492
      test_mulv(a0, a1, (long)VALUE);
493
    }
494
    end = System.currentTimeMillis();
495
    System.out.println("test_mulv: " + (end - start));
496
    start = System.currentTimeMillis();
497
    for (int i=0; i<ITERS; i++) {
498
      test_mula(a0, a1, a2);
499
    }
500
    end = System.currentTimeMillis();
501
    System.out.println("test_mula: " + (end - start));
502

503
    start = System.currentTimeMillis();
504
    for (int i=0; i<ITERS; i++) {
505
      test_divc(a0, a1);
506
    }
507
    end = System.currentTimeMillis();
508
    System.out.println("test_divc: " + (end - start));
509
    start = System.currentTimeMillis();
510
    for (int i=0; i<ITERS; i++) {
511
      test_divv(a0, a1, (long)VALUE);
512
    }
513
    end = System.currentTimeMillis();
514
    System.out.println("test_divv: " + (end - start));
515
    start = System.currentTimeMillis();
516
    for (int i=0; i<ITERS; i++) {
517
      test_diva(a0, a1, a2);
518
    }
519
    end = System.currentTimeMillis();
520
    System.out.println("test_diva: " + (end - start));
521

522
    start = System.currentTimeMillis();
523
    for (int i=0; i<ITERS; i++) {
524
      test_mulc_n(a0, a1);
525
    }
526
    end = System.currentTimeMillis();
527
    System.out.println("test_mulc_n: " + (end - start));
528
    start = System.currentTimeMillis();
529
    for (int i=0; i<ITERS; i++) {
530
      test_mulv(a0, a1, (long)-VALUE);
531
    }
532
    end = System.currentTimeMillis();
533
    System.out.println("test_mulv_n: " + (end - start));
534
    start = System.currentTimeMillis();
535
    for (int i=0; i<ITERS; i++) {
536
      test_mula(a0, a1, a3);
537
    }
538
    end = System.currentTimeMillis();
539
    System.out.println("test_mula_n: " + (end - start));
540

541
    start = System.currentTimeMillis();
542
    for (int i=0; i<ITERS; i++) {
543
      test_divc_n(a0, a1);
544
    }
545
    end = System.currentTimeMillis();
546
    System.out.println("test_divc_n: " + (end - start));
547
    start = System.currentTimeMillis();
548
    for (int i=0; i<ITERS; i++) {
549
      test_divv(a0, a1, (long)-VALUE);
550
    }
551
    end = System.currentTimeMillis();
552
    System.out.println("test_divv_n: " + (end - start));
553
    start = System.currentTimeMillis();
554
    for (int i=0; i<ITERS; i++) {
555
      test_diva(a0, a1, a3);
556
    }
557
    end = System.currentTimeMillis();
558
    System.out.println("test_diva_n: " + (end - start));
559

560
    start = System.currentTimeMillis();
561
    for (int i=0; i<ITERS; i++) {
562
      test_andc(a0, a1);
563
    }
564
    end = System.currentTimeMillis();
565
    System.out.println("test_andc: " + (end - start));
566
    start = System.currentTimeMillis();
567
    for (int i=0; i<ITERS; i++) {
568
      test_andv(a0, a1, (long)BIT_MASK);
569
    }
570
    end = System.currentTimeMillis();
571
    System.out.println("test_andv: " + (end - start));
572
    start = System.currentTimeMillis();
573
    for (int i=0; i<ITERS; i++) {
574
      test_anda(a0, a1, a4);
575
    }
576
    end = System.currentTimeMillis();
577
    System.out.println("test_anda: " + (end - start));
578

579
    start = System.currentTimeMillis();
580
    for (int i=0; i<ITERS; i++) {
581
      test_orc(a0, a1);
582
    }
583
    end = System.currentTimeMillis();
584
    System.out.println("test_orc: " + (end - start));
585
    start = System.currentTimeMillis();
586
    for (int i=0; i<ITERS; i++) {
587
      test_orv(a0, a1, (long)BIT_MASK);
588
    }
589
    end = System.currentTimeMillis();
590
    System.out.println("test_orv: " + (end - start));
591
    start = System.currentTimeMillis();
592
    for (int i=0; i<ITERS; i++) {
593
      test_ora(a0, a1, a4);
594
    }
595
    end = System.currentTimeMillis();
596
    System.out.println("test_ora: " + (end - start));
597

598
    start = System.currentTimeMillis();
599
    for (int i=0; i<ITERS; i++) {
600
      test_xorc(a0, a1);
601
    }
602
    end = System.currentTimeMillis();
603
    System.out.println("test_xorc: " + (end - start));
604
    start = System.currentTimeMillis();
605
    for (int i=0; i<ITERS; i++) {
606
      test_xorv(a0, a1, (long)BIT_MASK);
607
    }
608
    end = System.currentTimeMillis();
609
    System.out.println("test_xorv: " + (end - start));
610
    start = System.currentTimeMillis();
611
    for (int i=0; i<ITERS; i++) {
612
      test_xora(a0, a1, a4);
613
    }
614
    end = System.currentTimeMillis();
615
    System.out.println("test_xora: " + (end - start));
616

617
    start = System.currentTimeMillis();
618
    for (int i=0; i<ITERS; i++) {
619
      test_sllc(a0, a1);
620
    }
621
    end = System.currentTimeMillis();
622
    System.out.println("test_sllc: " + (end - start));
623
    start = System.currentTimeMillis();
624
    for (int i=0; i<ITERS; i++) {
625
      test_sllv(a0, a1, VALUE);
626
    }
627
    end = System.currentTimeMillis();
628
    System.out.println("test_sllv: " + (end - start));
629

630
    start = System.currentTimeMillis();
631
    for (int i=0; i<ITERS; i++) {
632
      test_srlc(a0, a1);
633
    }
634
    end = System.currentTimeMillis();
635
    System.out.println("test_srlc: " + (end - start));
636
    start = System.currentTimeMillis();
637
    for (int i=0; i<ITERS; i++) {
638
      test_srlv(a0, a1, VALUE);
639
    }
640
    end = System.currentTimeMillis();
641
    System.out.println("test_srlv: " + (end - start));
642

643
    start = System.currentTimeMillis();
644
    for (int i=0; i<ITERS; i++) {
645
      test_srac(a0, a1);
646
    }
647
    end = System.currentTimeMillis();
648
    System.out.println("test_srac: " + (end - start));
649
    start = System.currentTimeMillis();
650
    for (int i=0; i<ITERS; i++) {
651
      test_srav(a0, a1, VALUE);
652
    }
653
    end = System.currentTimeMillis();
654
    System.out.println("test_srav: " + (end - start));
655

656
    start = System.currentTimeMillis();
657
    for (int i=0; i<ITERS; i++) {
658
      test_sllc_n(a0, a1);
659
    }
660
    end = System.currentTimeMillis();
661
    System.out.println("test_sllc_n: " + (end - start));
662
    start = System.currentTimeMillis();
663
    for (int i=0; i<ITERS; i++) {
664
      test_sllv(a0, a1, -VALUE);
665
    }
666
    end = System.currentTimeMillis();
667
    System.out.println("test_sllv_n: " + (end - start));
668

669
    start = System.currentTimeMillis();
670
    for (int i=0; i<ITERS; i++) {
671
      test_srlc_n(a0, a1);
672
    }
673
    end = System.currentTimeMillis();
674
    System.out.println("test_srlc_n: " + (end - start));
675
    start = System.currentTimeMillis();
676
    for (int i=0; i<ITERS; i++) {
677
      test_srlv(a0, a1, -VALUE);
678
    }
679
    end = System.currentTimeMillis();
680
    System.out.println("test_srlv_n: " + (end - start));
681

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

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

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

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

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

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

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

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

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

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

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

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

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

851
    return errn;
852
  }
853

854
  static long test_sum(long[] a1) {
855
    long sum = 0;
856
    for (int i = 0; i < a1.length; i+=1) {
857
      sum += a1[i];
858
    }
859
    return sum;
860
  }
861

862
  static void test_addc(long[] a0, long[] a1) {
863
    for (int i = 0; i < a0.length; i+=1) {
864
      a0[i] = (long)(a1[i]+VALUE);
865
    }
866
  }
867
  static void test_addv(long[] a0, long[] a1, long b) {
868
    for (int i = 0; i < a0.length; i+=1) {
869
      a0[i] = (long)(a1[i]+b);
870
    }
871
  }
872
  static void test_adda(long[] a0, long[] a1, long[] a2) {
873
    for (int i = 0; i < a0.length; i+=1) {
874
      a0[i] = (long)(a1[i]+a2[i]);
875
    }
876
  }
877

878
  static void test_subc(long[] a0, long[] a1) {
879
    for (int i = 0; i < a0.length; i+=1) {
880
      a0[i] = (long)(a1[i]-VALUE);
881
    }
882
  }
883
  static void test_subv(long[] a0, long[] a1, long b) {
884
    for (int i = 0; i < a0.length; i+=1) {
885
      a0[i] = (long)(a1[i]-b);
886
    }
887
  }
888
  static void test_suba(long[] a0, long[] a1, long[] a2) {
889
    for (int i = 0; i < a0.length; i+=1) {
890
      a0[i] = (long)(a1[i]-a2[i]);
891
    }
892
  }
893

894
  static void test_mulc(long[] a0, long[] a1) {
895
    for (int i = 0; i < a0.length; i+=1) {
896
      a0[i] = (long)(a1[i]*VALUE);
897
    }
898
  }
899
  static void test_mulc_n(long[] a0, long[] a1) {
900
    for (int i = 0; i < a0.length; i+=1) {
901
      a0[i] = (long)(a1[i]*(-VALUE));
902
    }
903
  }
904
  static void test_mulv(long[] a0, long[] a1, long b) {
905
    for (int i = 0; i < a0.length; i+=1) {
906
      a0[i] = (long)(a1[i]*b);
907
    }
908
  }
909
  static void test_mula(long[] a0, long[] a1, long[] a2) {
910
    for (int i = 0; i < a0.length; i+=1) {
911
      a0[i] = (long)(a1[i]*a2[i]);
912
    }
913
  }
914

915
  static void test_divc(long[] a0, long[] a1) {
916
    for (int i = 0; i < a0.length; i+=1) {
917
      a0[i] = (long)(a1[i]/VALUE);
918
    }
919
  }
920
  static void test_divc_n(long[] a0, long[] a1) {
921
    for (int i = 0; i < a0.length; i+=1) {
922
      a0[i] = (long)(a1[i]/(-VALUE));
923
    }
924
  }
925
  static void test_divv(long[] a0, long[] a1, long b) {
926
    for (int i = 0; i < a0.length; i+=1) {
927
      a0[i] = (long)(a1[i]/b);
928
    }
929
  }
930
  static void test_diva(long[] a0, long[] a1, long[] a2) {
931
    for (int i = 0; i < a0.length; i+=1) {
932
      a0[i] = (long)(a1[i]/a2[i]);
933
    }
934
  }
935

936
  static void test_andc(long[] a0, long[] a1) {
937
    for (int i = 0; i < a0.length; i+=1) {
938
      a0[i] = (long)(a1[i]&BIT_MASK);
939
    }
940
  }
941
  static void test_andv(long[] a0, long[] a1, long b) {
942
    for (int i = 0; i < a0.length; i+=1) {
943
      a0[i] = (long)(a1[i]&b);
944
    }
945
  }
946
  static void test_anda(long[] a0, long[] a1, long[] a2) {
947
    for (int i = 0; i < a0.length; i+=1) {
948
      a0[i] = (long)(a1[i]&a2[i]);
949
    }
950
  }
951

952
  static void test_orc(long[] a0, long[] a1) {
953
    for (int i = 0; i < a0.length; i+=1) {
954
      a0[i] = (long)(a1[i]|BIT_MASK);
955
    }
956
  }
957
  static void test_orv(long[] a0, long[] a1, long b) {
958
    for (int i = 0; i < a0.length; i+=1) {
959
      a0[i] = (long)(a1[i]|b);
960
    }
961
  }
962
  static void test_ora(long[] a0, long[] a1, long[] a2) {
963
    for (int i = 0; i < a0.length; i+=1) {
964
      a0[i] = (long)(a1[i]|a2[i]);
965
    }
966
  }
967

968
  static void test_xorc(long[] a0, long[] a1) {
969
    for (int i = 0; i < a0.length; i+=1) {
970
      a0[i] = (long)(a1[i]^BIT_MASK);
971
    }
972
  }
973
  static void test_xorv(long[] a0, long[] a1, long b) {
974
    for (int i = 0; i < a0.length; i+=1) {
975
      a0[i] = (long)(a1[i]^b);
976
    }
977
  }
978
  static void test_xora(long[] a0, long[] a1, long[] a2) {
979
    for (int i = 0; i < a0.length; i+=1) {
980
      a0[i] = (long)(a1[i]^a2[i]);
981
    }
982
  }
983

984
  static void test_sllc(long[] a0, long[] a1) {
985
    for (int i = 0; i < a0.length; i+=1) {
986
      a0[i] = (long)(a1[i]<<VALUE);
987
    }
988
  }
989
  static void test_sllc_n(long[] a0, long[] a1) {
990
    for (int i = 0; i < a0.length; i+=1) {
991
      a0[i] = (long)(a1[i]<<(-VALUE));
992
    }
993
  }
994
  static void test_sllc_o(long[] a0, long[] a1) {
995
    for (int i = 0; i < a0.length; i+=1) {
996
      a0[i] = (long)(a1[i]<<SHIFT);
997
    }
998
  }
999
  static void test_sllc_on(long[] a0, long[] a1) {
1000
    for (int i = 0; i < a0.length; i+=1) {
1001
      a0[i] = (long)(a1[i]<<(-SHIFT));
1002
    }
1003
  }
1004
  static void test_sllv(long[] a0, long[] a1, int b) {
1005
    for (int i = 0; i < a0.length; i+=1) {
1006
      a0[i] = (long)(a1[i]<<b);
1007
    }
1008
  }
1009
  static void test_sllc_add(long[] a0, long[] a1) {
1010
    for (int i = 0; i < a0.length; i+=1) {
1011
      a0[i] = (long)((a1[i] + ADD_INIT)<<VALUE);
1012
    }
1013
  }
1014
  static void test_sllv_add(long[] a0, long[] a1, long b) {
1015
    for (int i = 0; i < a0.length; i+=1) {
1016
      a0[i] = (long)((a1[i] + b)<<VALUE);
1017
    }
1018
  }
1019
  static void test_sllc_and(long[] a0, long[] a1) {
1020
    for (int i = 0; i < a0.length; i+=1) {
1021
      a0[i] = (long)((a1[i] & BIT_MASK)<<VALUE);
1022
    }
1023
  }
1024
  static void test_sllv_and(long[] a0, long[] a1, long b) {
1025
    for (int i = 0; i < a0.length; i+=1) {
1026
      a0[i] = (long)((a1[i] & b)<<VALUE);
1027
    }
1028
  }
1029

1030
  static void test_srlc(long[] a0, long[] a1) {
1031
    for (int i = 0; i < a0.length; i+=1) {
1032
      a0[i] = (long)(a1[i]>>>VALUE);
1033
    }
1034
  }
1035
  static void test_srlc_n(long[] a0, long[] a1) {
1036
    for (int i = 0; i < a0.length; i+=1) {
1037
      a0[i] = (long)(a1[i]>>>(-VALUE));
1038
    }
1039
  }
1040
  static void test_srlc_o(long[] a0, long[] a1) {
1041
    for (int i = 0; i < a0.length; i+=1) {
1042
      a0[i] = (long)(a1[i]>>>SHIFT);
1043
    }
1044
  }
1045
  static void test_srlc_on(long[] a0, long[] a1) {
1046
    for (int i = 0; i < a0.length; i+=1) {
1047
      a0[i] = (long)(a1[i]>>>(-SHIFT));
1048
    }
1049
  }
1050
  static void test_srlv(long[] a0, long[] a1, int b) {
1051
    for (int i = 0; i < a0.length; i+=1) {
1052
      a0[i] = (long)(a1[i]>>>b);
1053
    }
1054
  }
1055
  static void test_srlc_add(long[] a0, long[] a1) {
1056
    for (int i = 0; i < a0.length; i+=1) {
1057
      a0[i] = (long)((a1[i] + ADD_INIT)>>>VALUE);
1058
    }
1059
  }
1060
  static void test_srlv_add(long[] a0, long[] a1, long b) {
1061
    for (int i = 0; i < a0.length; i+=1) {
1062
      a0[i] = (long)((a1[i] + b)>>>VALUE);
1063
    }
1064
  }
1065
  static void test_srlc_and(long[] a0, long[] a1) {
1066
    for (int i = 0; i < a0.length; i+=1) {
1067
      a0[i] = (long)((a1[i] & BIT_MASK)>>>VALUE);
1068
    }
1069
  }
1070
  static void test_srlv_and(long[] a0, long[] a1, long b) {
1071
    for (int i = 0; i < a0.length; i+=1) {
1072
      a0[i] = (long)((a1[i] & b)>>>VALUE);
1073
    }
1074
  }
1075

1076
  static void test_srac(long[] a0, long[] a1) {
1077
    for (int i = 0; i < a0.length; i+=1) {
1078
      a0[i] = (long)(a1[i]>>VALUE);
1079
    }
1080
  }
1081
  static void test_srac_n(long[] a0, long[] a1) {
1082
    for (int i = 0; i < a0.length; i+=1) {
1083
      a0[i] = (long)(a1[i]>>(-VALUE));
1084
    }
1085
  }
1086
  static void test_srac_o(long[] a0, long[] a1) {
1087
    for (int i = 0; i < a0.length; i+=1) {
1088
      a0[i] = (long)(a1[i]>>SHIFT);
1089
    }
1090
  }
1091
  static void test_srac_on(long[] a0, long[] a1) {
1092
    for (int i = 0; i < a0.length; i+=1) {
1093
      a0[i] = (long)(a1[i]>>(-SHIFT));
1094
    }
1095
  }
1096
  static void test_srav(long[] a0, long[] a1, int b) {
1097
    for (int i = 0; i < a0.length; i+=1) {
1098
      a0[i] = (long)(a1[i]>>b);
1099
    }
1100
  }
1101
  static void test_srac_add(long[] a0, long[] a1) {
1102
    for (int i = 0; i < a0.length; i+=1) {
1103
      a0[i] = (long)((a1[i] + ADD_INIT)>>VALUE);
1104
    }
1105
  }
1106
  static void test_srav_add(long[] a0, long[] a1, long b) {
1107
    for (int i = 0; i < a0.length; i+=1) {
1108
      a0[i] = (long)((a1[i] + b)>>VALUE);
1109
    }
1110
  }
1111
  static void test_srac_and(long[] a0, long[] a1) {
1112
    for (int i = 0; i < a0.length; i+=1) {
1113
      a0[i] = (long)((a1[i] & BIT_MASK)>>VALUE);
1114
    }
1115
  }
1116
  static void test_srav_and(long[] a0, long[] a1, long b) {
1117
    for (int i = 0; i < a0.length; i+=1) {
1118
      a0[i] = (long)((a1[i] & b)>>VALUE);
1119
    }
1120
  }
1121

1122
  static int verify(String text, int i, long elem, long val) {
1123
    if (elem != val) {
1124
      System.err.println(text + "[" + i + "] = " + elem + " != " + val);
1125
      return 1;
1126
    }
1127
    return 0;
1128
  }
1129
}
1130

1131
Product

Resources

Company
