CoCalc -- TestBooleanVect.java

GitHub Repository: PojavLauncherTeam/mobile
Path: blob/master/test/hotspot/jtreg/compiler/codegen/TestBooleanVect.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
 * @test
26
 * @bug 7119644
27
 * @summary Increase superword's vector size up to 256 bits
28
 *
29
 * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions
30
 *    -XX:-TieredCompilation -XX:-OptimizeFill
31
 *    compiler.codegen.TestBooleanVect
32
 */
33

34
package compiler.codegen;
35

36
public class TestBooleanVect {
37
  private static final int ARRLEN = 997;
38
  private static final int ITERS  = 11000;
39
  private static final int OFFSET = 3;
40
  private static final int SCALE = 2;
41
  private static final int ALIGN_OFF = 8;
42
  private static final int UNALIGN_OFF = 5;
43

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

54
  static int test() {
55
    boolean[] a1 = new boolean[ARRLEN];
56
    boolean[] a2 = new boolean[ARRLEN];
57
    System.out.println("Warmup");
58
    for (int i=0; i<ITERS; i++) {
59
      test_ci(a1);
60
      test_vi(a2, true);
61
      test_cp(a1, a2);
62
      test_2ci(a1, a2);
63
      test_2vi(a1, a2, true, true);
64
      test_ci_neg(a1);
65
      test_vi_neg(a2, true);
66
      test_cp_neg(a1, a2);
67
      test_2ci_neg(a1, a2);
68
      test_2vi_neg(a1, a2, true, true);
69
      test_ci_oppos(a1);
70
      test_vi_oppos(a2, true);
71
      test_cp_oppos(a1, a2);
72
      test_2ci_oppos(a1, a2);
73
      test_2vi_oppos(a1, a2, true, true);
74
      test_ci_off(a1);
75
      test_vi_off(a2, true);
76
      test_cp_off(a1, a2);
77
      test_2ci_off(a1, a2);
78
      test_2vi_off(a1, a2, true, true);
79
      test_ci_inv(a1, OFFSET);
80
      test_vi_inv(a2, true, OFFSET);
81
      test_cp_inv(a1, a2, OFFSET);
82
      test_2ci_inv(a1, a2, OFFSET);
83
      test_2vi_inv(a1, a2, true, true, OFFSET);
84
      test_ci_scl(a1);
85
      test_vi_scl(a2, true);
86
      test_cp_scl(a1, a2);
87
      test_2ci_scl(a1, a2);
88
      test_2vi_scl(a1, a2, true, true);
89
      test_cp_alndst(a1, a2);
90
      test_cp_alnsrc(a1, a2);
91
      test_2ci_aln(a1, a2);
92
      test_2vi_aln(a1, a2, true, true);
93
      test_cp_unalndst(a1, a2);
94
      test_cp_unalnsrc(a1, a2);
95
      test_2ci_unaln(a1, a2);
96
      test_2vi_unaln(a1, a2, true, true);
97
    }
98
    // Initialize
99
    for (int i=0; i<ARRLEN; i++) {
100
      a1[i] = false;
101
      a2[i] = false;
102
    }
103
    // Test and verify results
104
    System.out.println("Verification");
105
    int errn = 0;
106
    {
107
      test_ci(a1);
108
      for (int i=0; i<ARRLEN; i++) {
109
        errn += verify("test_ci: a1", i, a1[i], false);
110
      }
111
      test_vi(a2, true);
112
      for (int i=0; i<ARRLEN; i++) {
113
        errn += verify("test_vi: a2", i, a2[i], true);
114
      }
115
      test_cp(a1, a2);
116
      for (int i=0; i<ARRLEN; i++) {
117
        errn += verify("test_cp: a1", i, a1[i], true);
118
      }
119
      test_2ci(a1, a2);
120
      for (int i=0; i<ARRLEN; i++) {
121
        errn += verify("test_2ci: a1", i, a1[i], false);
122
        errn += verify("test_2ci: a2", i, a2[i], false);
123
      }
124
      test_2vi(a1, a2, true, true);
125
      for (int i=0; i<ARRLEN; i++) {
126
        errn += verify("test_2vi: a1", i, a1[i], true);
127
        errn += verify("test_2vi: a2", i, a2[i], true);
128
      }
129
      // Reset for negative stride
130
      for (int i=0; i<ARRLEN; i++) {
131
        a1[i] = false;
132
        a2[i] = false;
133
      }
134
      test_ci_neg(a1);
135
      for (int i=0; i<ARRLEN; i++) {
136
        errn += verify("test_ci_neg: a1", i, a1[i], false);
137
      }
138
      test_vi_neg(a2, true);
139
      for (int i=0; i<ARRLEN; i++) {
140
        errn += verify("test_vi_neg: a2", i, a2[i], true);
141
      }
142
      test_cp_neg(a1, a2);
143
      for (int i=0; i<ARRLEN; i++) {
144
        errn += verify("test_cp_neg: a1", i, a1[i], true);
145
      }
146
      test_2ci_neg(a1, a2);
147
      for (int i=0; i<ARRLEN; i++) {
148
        errn += verify("test_2ci_neg: a1", i, a1[i], false);
149
        errn += verify("test_2ci_neg: a2", i, a2[i], false);
150
      }
151
      test_2vi_neg(a1, a2, true, true);
152
      for (int i=0; i<ARRLEN; i++) {
153
        errn += verify("test_2vi_neg: a1", i, a1[i], true);
154
        errn += verify("test_2vi_neg: a2", i, a2[i], true);
155
      }
156
      // Reset for opposite stride
157
      for (int i=0; i<ARRLEN; i++) {
158
        a1[i] = false;
159
        a2[i] = false;
160
      }
161
      test_ci_oppos(a1);
162
      for (int i=0; i<ARRLEN; i++) {
163
        errn += verify("test_ci_oppos: a1", i, a1[i], false);
164
      }
165
      test_vi_oppos(a2, true);
166
      for (int i=0; i<ARRLEN; i++) {
167
        errn += verify("test_vi_oppos: a2", i, a2[i], true);
168
      }
169
      test_cp_oppos(a1, a2);
170
      for (int i=0; i<ARRLEN; i++) {
171
        errn += verify("test_cp_oppos: a1", i, a1[i], true);
172
      }
173
      test_2ci_oppos(a1, a2);
174
      for (int i=0; i<ARRLEN; i++) {
175
        errn += verify("test_2ci_oppos: a1", i, a1[i], false);
176
        errn += verify("test_2ci_oppos: a2", i, a2[i], false);
177
      }
178
      test_2vi_oppos(a1, a2, true, true);
179
      for (int i=0; i<ARRLEN; i++) {
180
        errn += verify("test_2vi_oppos: a1", i, a1[i], true);
181
        errn += verify("test_2vi_oppos: a2", i, a2[i], true);
182
      }
183
      // Reset for indexing with offset
184
      for (int i=0; i<ARRLEN; i++) {
185
        a1[i] = false;
186
        a2[i] = false;
187
      }
188
      test_ci_off(a1);
189
      for (int i=OFFSET; i<ARRLEN; i++) {
190
        errn += verify("test_ci_off: a1", i, a1[i], false);
191
      }
192
      test_vi_off(a2, true);
193
      for (int i=OFFSET; i<ARRLEN; i++) {
194
        errn += verify("test_vi_off: a2", i, a2[i], true);
195
      }
196
      test_cp_off(a1, a2);
197
      for (int i=OFFSET; i<ARRLEN; i++) {
198
        errn += verify("test_cp_off: a1", i, a1[i], true);
199
      }
200
      test_2ci_off(a1, a2);
201
      for (int i=OFFSET; i<ARRLEN; i++) {
202
        errn += verify("test_2ci_off: a1", i, a1[i], false);
203
        errn += verify("test_2ci_off: a2", i, a2[i], false);
204
      }
205
      test_2vi_off(a1, a2, true, true);
206
      for (int i=OFFSET; i<ARRLEN; i++) {
207
        errn += verify("test_2vi_off: a1", i, a1[i], true);
208
        errn += verify("test_2vi_off: a2", i, a2[i], true);
209
      }
210
      for (int i=0; i<OFFSET; i++) {
211
        errn += verify("test_2vi_off: a1", i, a1[i], false);
212
        errn += verify("test_2vi_off: a2", i, a2[i], false);
213
      }
214
      // Reset for indexing with invariant offset
215
      for (int i=0; i<ARRLEN; i++) {
216
        a1[i] = false;
217
        a2[i] = false;
218
      }
219
      test_ci_inv(a1, OFFSET);
220
      for (int i=OFFSET; i<ARRLEN; i++) {
221
        errn += verify("test_ci_inv: a1", i, a1[i], false);
222
      }
223
      test_vi_inv(a2, true, OFFSET);
224
      for (int i=OFFSET; i<ARRLEN; i++) {
225
        errn += verify("test_vi_inv: a2", i, a2[i], true);
226
      }
227
      test_cp_inv(a1, a2, OFFSET);
228
      for (int i=OFFSET; i<ARRLEN; i++) {
229
        errn += verify("test_cp_inv: a1", i, a1[i], true);
230
      }
231
      test_2ci_inv(a1, a2, OFFSET);
232
      for (int i=OFFSET; i<ARRLEN; i++) {
233
        errn += verify("test_2ci_inv: a1", i, a1[i], false);
234
        errn += verify("test_2ci_inv: a2", i, a2[i], false);
235
      }
236
      test_2vi_inv(a1, a2, true, true, OFFSET);
237
      for (int i=OFFSET; i<ARRLEN; i++) {
238
        errn += verify("test_2vi_inv: a1", i, a1[i], true);
239
        errn += verify("test_2vi_inv: a2", i, a2[i], true);
240
      }
241
      for (int i=0; i<OFFSET; i++) {
242
        errn += verify("test_2vi_inv: a1", i, a1[i], false);
243
        errn += verify("test_2vi_inv: a2", i, a2[i], false);
244
      }
245
      // Reset for indexing with scale
246
      for (int i=0; i<ARRLEN; i++) {
247
        a1[i] = true;
248
        a2[i] = false;
249
      }
250
      test_ci_scl(a1);
251
      for (int i=0; i<ARRLEN; i++) {
252
        boolean val = (i%SCALE != 0);
253
        errn += verify("test_ci_scl: a1", i, a1[i], val);
254
      }
255
      test_vi_scl(a2, true);
256
      for (int i=0; i<ARRLEN; i++) {
257
        boolean val = (i%SCALE == 0);
258
        errn += verify("test_vi_scl: a2", i, a2[i], val);
259
      }
260
      test_cp_scl(a1, a2);
261
      for (int i=0; i<ARRLEN; i++) {
262
        errn += verify("test_cp_scl: a1", i, a1[i], true);
263
      }
264
      test_2ci_scl(a1, a2);
265
      for (int i=0; i<ARRLEN; i++) {
266
        if (i%SCALE != 0) {
267
          errn += verify("test_2ci_scl: a1", i, a1[i], true);
268
        } else if (i*SCALE < ARRLEN) {
269
          errn += verify("test_2ci_scl: a1", i*SCALE, a1[i*SCALE], false);
270
        }
271
        if (i%SCALE != 0) {
272
          errn += verify("test_2ci_scl: a2", i, a2[i], false);
273
        } else if (i*SCALE < ARRLEN) {
274
          errn += verify("test_2ci_scl: a2", i*SCALE, a2[i*SCALE], false);
275
        }
276
      }
277
      test_2vi_scl(a1, a2, false, true);
278
      for (int i=0; i<ARRLEN; i++) {
279
        if (i%SCALE != 0) {
280
          errn += verify("test_2vi_scl: a1", i, a1[i], true);
281
        } else if (i*SCALE < ARRLEN) {
282
          errn += verify("test_2vi_scl: a1", i*SCALE, a1[i*SCALE], false);
283
        }
284
        if (i%SCALE != 0) {
285
          errn += verify("test_2vi_scl: a2", i, a2[i], false);
286
        } else if (i*SCALE < ARRLEN) {
287
          errn += verify("test_2vi_scl: a2", i*SCALE, a2[i*SCALE], true);
288
        }
289
      }
290
      // Reset for 2 arrays with relative aligned offset
291
      for (int i=0; i<ARRLEN; i++) {
292
        a1[i] = false;
293
        a2[i] = false;
294
      }
295
      test_vi(a2, true);
296
      test_cp_alndst(a1, a2);
297
      for (int i=0; i<ALIGN_OFF; i++) {
298
        errn += verify("test_cp_alndst: a1", i, a1[i], false);
299
      }
300
      for (int i=ALIGN_OFF; i<ARRLEN; i++) {
301
        errn += verify("test_cp_alndst: a1", i, a1[i], true);
302
      }
303
      test_vi(a2, false);
304
      test_cp_alnsrc(a1, a2);
305
      for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
306
        errn += verify("test_cp_alnsrc: a1", i, a1[i], false);
307
      }
308
      for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
309
        errn += verify("test_cp_alnsrc: a1", i, a1[i], true);
310
      }
311
      for (int i=0; i<ARRLEN; i++) {
312
        a1[i] = false;
313
        a2[i] = false;
314
      }
315
      test_2ci_aln(a1, a2);
316
      for (int i=0; i<ALIGN_OFF; i++) {
317
        errn += verify("test_2ci_aln: a1", i, a1[i], false);
318
      }
319
      for (int i=ALIGN_OFF; i<ARRLEN; i++) {
320
        errn += verify("test_2ci_aln: a1", i, a1[i], false);
321
      }
322
      for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
323
        errn += verify("test_2ci_aln: a2", i, a2[i], false);
324
      }
325
      for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
326
        errn += verify("test_2ci_aln: a2", i, a2[i], false);
327
      }
328
      for (int i=0; i<ARRLEN; i++) {
329
        a1[i] = false;
330
        a2[i] = false;
331
      }
332
      test_2vi_aln(a1, a2, true, true);
333
      for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
334
        errn += verify("test_2vi_aln: a1", i, a1[i], true);
335
      }
336
      for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
337
        errn += verify("test_2vi_aln: a1", i, a1[i], false);
338
      }
339
      for (int i=0; i<ALIGN_OFF; i++) {
340
        errn += verify("test_2vi_aln: a2", i, a2[i], false);
341
      }
342
      for (int i=ALIGN_OFF; i<ARRLEN; i++) {
343
        errn += verify("test_2vi_aln: a2", i, a2[i], true);
344
      }
345

346
      // Reset for 2 arrays with relative unaligned offset
347
      for (int i=0; i<ARRLEN; i++) {
348
        a1[i] = false;
349
        a2[i] = false;
350
      }
351
      test_vi(a2, true);
352
      test_cp_unalndst(a1, a2);
353
      for (int i=0; i<UNALIGN_OFF; i++) {
354
        errn += verify("test_cp_unalndst: a1", i, a1[i], false);
355
      }
356
      for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
357
        errn += verify("test_cp_unalndst: a1", i, a1[i], true);
358
      }
359
      test_vi(a2, false);
360
      test_cp_unalnsrc(a1, a2);
361
      for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
362
        errn += verify("test_cp_unalnsrc: a1", i, a1[i], false);
363
      }
364
      for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
365
        errn += verify("test_cp_unalnsrc: a1", i, a1[i], true);
366
      }
367
      for (int i=0; i<ARRLEN; i++) {
368
        a1[i] = false;
369
        a2[i] = false;
370
      }
371
      test_2ci_unaln(a1, a2);
372
      for (int i=0; i<UNALIGN_OFF; i++) {
373
        errn += verify("test_2ci_unaln: a1", i, a1[i], false);
374
      }
375
      for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
376
        errn += verify("test_2ci_unaln: a1", i, a1[i], false);
377
      }
378
      for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
379
        errn += verify("test_2ci_unaln: a2", i, a2[i], false);
380
      }
381
      for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
382
        errn += verify("test_2ci_unaln: a2", i, a2[i], false);
383
      }
384
      for (int i=0; i<ARRLEN; i++) {
385
        a1[i] = false;
386
        a2[i] = false;
387
      }
388
      test_2vi_unaln(a1, a2, true, true);
389
      for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
390
        errn += verify("test_2vi_unaln: a1", i, a1[i], true);
391
      }
392
      for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
393
        errn += verify("test_2vi_unaln: a1", i, a1[i], false);
394
      }
395
      for (int i=0; i<UNALIGN_OFF; i++) {
396
        errn += verify("test_2vi_unaln: a2", i, a2[i], false);
397
      }
398
      for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
399
        errn += verify("test_2vi_unaln: a2", i, a2[i], true);
400
      }
401

402
      // Reset for aligned overlap initialization
403
      for (int i=0; i<ALIGN_OFF; i++) {
404
        a1[i] = (i > 0);
405
      }
406
      for (int i=ALIGN_OFF; i<ARRLEN; i++) {
407
        a1[i] = false;
408
      }
409
      test_cp_alndst(a1, a1);
410
      for (int i=0; i<ARRLEN; i++) {
411
        boolean v = (i%ALIGN_OFF > 0);
412
        errn += verify("test_cp_alndst_overlap: a1", i, a1[i], v);
413
      }
414
      for (int i=0; i<ALIGN_OFF; i++) {
415
        a1[i+ALIGN_OFF] = false;
416
      }
417
      test_cp_alnsrc(a1, a1);
418
      for (int i=0; i<ALIGN_OFF; i++) {
419
        errn += verify("test_cp_alnsrc_overlap: a1", i, a1[i], false);
420
      }
421
      for (int i=ALIGN_OFF; i<ARRLEN; i++) {
422
        boolean v = (i%ALIGN_OFF > 0);
423
        errn += verify("test_cp_alnsrc_overlap: a1", i, a1[i], v);
424
      }
425
      for (int i=0; i<ARRLEN; i++) {
426
        a1[i] = false;
427
      }
428
      test_2ci_aln(a1, a1);
429
      for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
430
        errn += verify("test_2ci_aln_overlap: a1", i, a1[i], false);
431
      }
432
      for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
433
        errn += verify("test_2ci_aln_overlap: a1", i, a1[i], false);
434
      }
435
      for (int i=0; i<ARRLEN; i++) {
436
        a1[i] = false;
437
      }
438
      test_2vi_aln(a1, a1, true, true);
439
      for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
440
        errn += verify("test_2vi_aln_overlap: a1", i, a1[i], true);
441
      }
442
      for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
443
        errn += verify("test_2vi_aln_overlap: a1", i, a1[i], true);
444
      }
445

446
      // Reset for unaligned overlap initialization
447
      for (int i=0; i<UNALIGN_OFF; i++) {
448
        a1[i] = (i > 0);
449
      }
450
      for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
451
        a1[i] = false;
452
      }
453
      test_cp_unalndst(a1, a1);
454
      for (int i=0; i<ARRLEN; i++) {
455
        boolean v = (i%UNALIGN_OFF > 0);
456
        errn += verify("test_cp_unalndst_overlap: a1", i, a1[i], v);
457
      }
458
      for (int i=0; i<UNALIGN_OFF; i++) {
459
        a1[i+UNALIGN_OFF] = false;
460
      }
461
      test_cp_unalnsrc(a1, a1);
462
      for (int i=0; i<UNALIGN_OFF; i++) {
463
        errn += verify("test_cp_unalnsrc_overlap: a1", i, a1[i], false);
464
      }
465
      for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
466
        boolean v = (i%UNALIGN_OFF > 0);
467
        errn += verify("test_cp_unalnsrc_overlap: a1", i, a1[i], v);
468
      }
469
      for (int i=0; i<ARRLEN; i++) {
470
        a1[i] = false;
471
      }
472
      test_2ci_unaln(a1, a1);
473
      for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
474
        errn += verify("test_2ci_unaln_overlap: a1", i, a1[i], false);
475
      }
476
      for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
477
        errn += verify("test_2ci_unaln_overlap: a1", i, a1[i], false);
478
      }
479
      for (int i=0; i<ARRLEN; i++) {
480
        a1[i] = false;
481
      }
482
      test_2vi_unaln(a1, a1, true, true);
483
      for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
484
        errn += verify("test_2vi_unaln_overlap: a1", i, a1[i], true);
485
      }
486
      for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
487
        errn += verify("test_2vi_unaln_overlap: a1", i, a1[i], true);
488
      }
489

490
    }
491

492
    if (errn > 0)
493
      return errn;
494

495
    System.out.println("Time");
496
    long start, end;
497
    start = System.currentTimeMillis();
498
    for (int i=0; i<ITERS; i++) {
499
      test_ci(a1);
500
    }
501
    end = System.currentTimeMillis();
502
    System.out.println("test_ci: " + (end - start));
503
    start = System.currentTimeMillis();
504
    for (int i=0; i<ITERS; i++) {
505
      test_vi(a2, true);
506
    }
507
    end = System.currentTimeMillis();
508
    System.out.println("test_vi: " + (end - start));
509
    start = System.currentTimeMillis();
510
    for (int i=0; i<ITERS; i++) {
511
      test_cp(a1, a2);
512
    }
513
    end = System.currentTimeMillis();
514
    System.out.println("test_cp: " + (end - start));
515
    start = System.currentTimeMillis();
516
    for (int i=0; i<ITERS; i++) {
517
      test_2ci(a1, a2);
518
    }
519
    end = System.currentTimeMillis();
520
    System.out.println("test_2ci: " + (end - start));
521
    start = System.currentTimeMillis();
522
    for (int i=0; i<ITERS; i++) {
523
      test_2vi(a1, a2, true, true);
524
    }
525
    end = System.currentTimeMillis();
526
    System.out.println("test_2vi: " + (end - start));
527

528
    start = System.currentTimeMillis();
529
    for (int i=0; i<ITERS; i++) {
530
      test_ci_neg(a1);
531
    }
532
    end = System.currentTimeMillis();
533
    System.out.println("test_ci_neg: " + (end - start));
534
    start = System.currentTimeMillis();
535
    for (int i=0; i<ITERS; i++) {
536
      test_vi_neg(a2, true);
537
    }
538
    end = System.currentTimeMillis();
539
    System.out.println("test_vi_neg: " + (end - start));
540
    start = System.currentTimeMillis();
541
    for (int i=0; i<ITERS; i++) {
542
      test_cp_neg(a1, a2);
543
    }
544
    end = System.currentTimeMillis();
545
    System.out.println("test_cp_neg: " + (end - start));
546
    start = System.currentTimeMillis();
547
    for (int i=0; i<ITERS; i++) {
548
      test_2ci_neg(a1, a2);
549
    }
550
    end = System.currentTimeMillis();
551
    System.out.println("test_2ci_neg: " + (end - start));
552
    start = System.currentTimeMillis();
553
    for (int i=0; i<ITERS; i++) {
554
      test_2vi_neg(a1, a2, true, true);
555
    }
556
    end = System.currentTimeMillis();
557
    System.out.println("test_2vi_neg: " + (end - start));
558

559
    start = System.currentTimeMillis();
560
    for (int i=0; i<ITERS; i++) {
561
      test_ci_oppos(a1);
562
    }
563
    end = System.currentTimeMillis();
564
    System.out.println("test_ci_oppos: " + (end - start));
565
    start = System.currentTimeMillis();
566
    for (int i=0; i<ITERS; i++) {
567
      test_vi_oppos(a2, true);
568
    }
569
    end = System.currentTimeMillis();
570
    System.out.println("test_vi_oppos: " + (end - start));
571
    start = System.currentTimeMillis();
572
    for (int i=0; i<ITERS; i++) {
573
      test_cp_oppos(a1, a2);
574
    }
575
    end = System.currentTimeMillis();
576
    System.out.println("test_cp_oppos: " + (end - start));
577
    start = System.currentTimeMillis();
578
    for (int i=0; i<ITERS; i++) {
579
      test_2ci_oppos(a1, a2);
580
    }
581
    end = System.currentTimeMillis();
582
    System.out.println("test_2ci_oppos: " + (end - start));
583
    start = System.currentTimeMillis();
584
    for (int i=0; i<ITERS; i++) {
585
      test_2vi_oppos(a1, a2, true, true);
586
    }
587
    end = System.currentTimeMillis();
588
    System.out.println("test_2vi_oppos: " + (end - start));
589

590
    start = System.currentTimeMillis();
591
    for (int i=0; i<ITERS; i++) {
592
      test_ci_off(a1);
593
    }
594
    end = System.currentTimeMillis();
595
    System.out.println("test_ci_off: " + (end - start));
596
    start = System.currentTimeMillis();
597
    for (int i=0; i<ITERS; i++) {
598
      test_vi_off(a2, true);
599
    }
600
    end = System.currentTimeMillis();
601
    System.out.println("test_vi_off: " + (end - start));
602
    start = System.currentTimeMillis();
603
    for (int i=0; i<ITERS; i++) {
604
      test_cp_off(a1, a2);
605
    }
606
    end = System.currentTimeMillis();
607
    System.out.println("test_cp_off: " + (end - start));
608
    start = System.currentTimeMillis();
609
    for (int i=0; i<ITERS; i++) {
610
      test_2ci_off(a1, a2);
611
    }
612
    end = System.currentTimeMillis();
613
    System.out.println("test_2ci_off: " + (end - start));
614
    start = System.currentTimeMillis();
615
    for (int i=0; i<ITERS; i++) {
616
      test_2vi_off(a1, a2, true, true);
617
    }
618
    end = System.currentTimeMillis();
619
    System.out.println("test_2vi_off: " + (end - start));
620

621
    start = System.currentTimeMillis();
622
    for (int i=0; i<ITERS; i++) {
623
      test_ci_inv(a1, OFFSET);
624
    }
625
    end = System.currentTimeMillis();
626
    System.out.println("test_ci_inv: " + (end - start));
627
    start = System.currentTimeMillis();
628
    for (int i=0; i<ITERS; i++) {
629
      test_vi_inv(a2, true, OFFSET);
630
    }
631
    end = System.currentTimeMillis();
632
    System.out.println("test_vi_inv: " + (end - start));
633
    start = System.currentTimeMillis();
634
    for (int i=0; i<ITERS; i++) {
635
      test_cp_inv(a1, a2, OFFSET);
636
    }
637
    end = System.currentTimeMillis();
638
    System.out.println("test_cp_inv: " + (end - start));
639
    start = System.currentTimeMillis();
640
    for (int i=0; i<ITERS; i++) {
641
      test_2ci_inv(a1, a2, OFFSET);
642
    }
643
    end = System.currentTimeMillis();
644
    System.out.println("test_2ci_inv: " + (end - start));
645
    start = System.currentTimeMillis();
646
    for (int i=0; i<ITERS; i++) {
647
      test_2vi_inv(a1, a2, true, true, OFFSET);
648
    }
649
    end = System.currentTimeMillis();
650
    System.out.println("test_2vi_inv: " + (end - start));
651

652
    start = System.currentTimeMillis();
653
    for (int i=0; i<ITERS; i++) {
654
      test_ci_scl(a1);
655
    }
656
    end = System.currentTimeMillis();
657
    System.out.println("test_ci_scl: " + (end - start));
658
    start = System.currentTimeMillis();
659
    for (int i=0; i<ITERS; i++) {
660
      test_vi_scl(a2, true);
661
    }
662
    end = System.currentTimeMillis();
663
    System.out.println("test_vi_scl: " + (end - start));
664
    start = System.currentTimeMillis();
665
    for (int i=0; i<ITERS; i++) {
666
      test_cp_scl(a1, a2);
667
    }
668
    end = System.currentTimeMillis();
669
    System.out.println("test_cp_scl: " + (end - start));
670
    start = System.currentTimeMillis();
671
    for (int i=0; i<ITERS; i++) {
672
      test_2ci_scl(a1, a2);
673
    }
674
    end = System.currentTimeMillis();
675
    System.out.println("test_2ci_scl: " + (end - start));
676
    start = System.currentTimeMillis();
677
    for (int i=0; i<ITERS; i++) {
678
      test_2vi_scl(a1, a2, true, true);
679
    }
680
    end = System.currentTimeMillis();
681
    System.out.println("test_2vi_scl: " + (end - start));
682

683
    start = System.currentTimeMillis();
684
    for (int i=0; i<ITERS; i++) {
685
      test_cp_alndst(a1, a2);
686
    }
687
    end = System.currentTimeMillis();
688
    System.out.println("test_cp_alndst: " + (end - start));
689
    start = System.currentTimeMillis();
690
    for (int i=0; i<ITERS; i++) {
691
      test_cp_alnsrc(a1, a2);
692
    }
693
    end = System.currentTimeMillis();
694
    System.out.println("test_cp_alnsrc: " + (end - start));
695
    start = System.currentTimeMillis();
696
    for (int i=0; i<ITERS; i++) {
697
      test_2ci_aln(a1, a2);
698
    }
699
    end = System.currentTimeMillis();
700
    System.out.println("test_2ci_aln: " + (end - start));
701
    start = System.currentTimeMillis();
702
    for (int i=0; i<ITERS; i++) {
703
      test_2vi_aln(a1, a2, true, true);
704
    }
705
    end = System.currentTimeMillis();
706
    System.out.println("test_2vi_aln: " + (end - start));
707

708
    start = System.currentTimeMillis();
709
    for (int i=0; i<ITERS; i++) {
710
      test_cp_unalndst(a1, a2);
711
    }
712
    end = System.currentTimeMillis();
713
    System.out.println("test_cp_unalndst: " + (end - start));
714
    start = System.currentTimeMillis();
715
    for (int i=0; i<ITERS; i++) {
716
      test_cp_unalnsrc(a1, a2);
717
    }
718
    end = System.currentTimeMillis();
719
    System.out.println("test_cp_unalnsrc: " + (end - start));
720
    start = System.currentTimeMillis();
721
    for (int i=0; i<ITERS; i++) {
722
      test_2ci_unaln(a1, a2);
723
    }
724
    end = System.currentTimeMillis();
725
    System.out.println("test_2ci_unaln: " + (end - start));
726
    start = System.currentTimeMillis();
727
    for (int i=0; i<ITERS; i++) {
728
      test_2vi_unaln(a1, a2, true, true);
729
    }
730
    end = System.currentTimeMillis();
731
    System.out.println("test_2vi_unaln: " + (end - start));
732

733
    return errn;
734
  }
735

736
  static void test_ci(boolean[] a) {
737
    for (int i = 0; i < a.length; i+=1) {
738
      a[i] = false;
739
    }
740
  }
741
  static void test_vi(boolean[] a, boolean b) {
742
    for (int i = 0; i < a.length; i+=1) {
743
      a[i] = b;
744
    }
745
  }
746
  static void test_cp(boolean[] a, boolean[] b) {
747
    for (int i = 0; i < a.length; i+=1) {
748
      a[i] = b[i];
749
    }
750
  }
751
  static void test_2ci(boolean[] a, boolean[] b) {
752
    for (int i = 0; i < a.length; i+=1) {
753
      a[i] = false;
754
      b[i] = false;
755
    }
756
  }
757
  static void test_2vi(boolean[] a, boolean[] b, boolean c, boolean d) {
758
    for (int i = 0; i < a.length; i+=1) {
759
      a[i] = c;
760
      b[i] = d;
761
    }
762
  }
763
  static void test_ci_neg(boolean[] a) {
764
    for (int i = a.length-1; i >= 0; i-=1) {
765
      a[i] = false;
766
    }
767
  }
768
  static void test_vi_neg(boolean[] a, boolean b) {
769
    for (int i = a.length-1; i >= 0; i-=1) {
770
      a[i] = b;
771
    }
772
  }
773
  static void test_cp_neg(boolean[] a, boolean[] b) {
774
    for (int i = a.length-1; i >= 0; i-=1) {
775
      a[i] = b[i];
776
    }
777
  }
778
  static void test_2ci_neg(boolean[] a, boolean[] b) {
779
    for (int i = a.length-1; i >= 0; i-=1) {
780
      a[i] = false;
781
      b[i] = false;
782
    }
783
  }
784
  static void test_2vi_neg(boolean[] a, boolean[] b, boolean c, boolean d) {
785
    for (int i = a.length-1; i >= 0; i-=1) {
786
      a[i] = c;
787
      b[i] = d;
788
    }
789
  }
790
  static void test_ci_oppos(boolean[] a) {
791
    int limit = a.length-1;
792
    for (int i = 0; i < a.length; i+=1) {
793
      a[limit-i] = false;
794
    }
795
  }
796
  static void test_vi_oppos(boolean[] a, boolean b) {
797
    int limit = a.length-1;
798
    for (int i = limit; i >= 0; i-=1) {
799
      a[limit-i] = b;
800
    }
801
  }
802
  static void test_cp_oppos(boolean[] a, boolean[] b) {
803
    int limit = a.length-1;
804
    for (int i = 0; i < a.length; i+=1) {
805
      a[i] = b[limit-i];
806
    }
807
  }
808
  static void test_2ci_oppos(boolean[] a, boolean[] b) {
809
    int limit = a.length-1;
810
    for (int i = 0; i < a.length; i+=1) {
811
      a[limit-i] = false;
812
      b[i] = false;
813
    }
814
  }
815
  static void test_2vi_oppos(boolean[] a, boolean[] b, boolean c, boolean d) {
816
    int limit = a.length-1;
817
    for (int i = limit; i >= 0; i-=1) {
818
      a[i] = c;
819
      b[limit-i] = d;
820
    }
821
  }
822
  static void test_ci_off(boolean[] a) {
823
    for (int i = 0; i < a.length-OFFSET; i+=1) {
824
      a[i+OFFSET] = false;
825
    }
826
  }
827
  static void test_vi_off(boolean[] a, boolean b) {
828
    for (int i = 0; i < a.length-OFFSET; i+=1) {
829
      a[i+OFFSET] = b;
830
    }
831
  }
832
  static void test_cp_off(boolean[] a, boolean[] b) {
833
    for (int i = 0; i < a.length-OFFSET; i+=1) {
834
      a[i+OFFSET] = b[i+OFFSET];
835
    }
836
  }
837
  static void test_2ci_off(boolean[] a, boolean[] b) {
838
    for (int i = 0; i < a.length-OFFSET; i+=1) {
839
      a[i+OFFSET] = false;
840
      b[i+OFFSET] = false;
841
    }
842
  }
843
  static void test_2vi_off(boolean[] a, boolean[] b, boolean c, boolean d) {
844
    for (int i = 0; i < a.length-OFFSET; i+=1) {
845
      a[i+OFFSET] = c;
846
      b[i+OFFSET] = d;
847
    }
848
  }
849
  static void test_ci_inv(boolean[] a, int k) {
850
    for (int i = 0; i < a.length-k; i+=1) {
851
      a[i+k] = false;
852
    }
853
  }
854
  static void test_vi_inv(boolean[] a, boolean b, int k) {
855
    for (int i = 0; i < a.length-k; i+=1) {
856
      a[i+k] = b;
857
    }
858
  }
859
  static void test_cp_inv(boolean[] a, boolean[] b, int k) {
860
    for (int i = 0; i < a.length-k; i+=1) {
861
      a[i+k] = b[i+k];
862
    }
863
  }
864
  static void test_2ci_inv(boolean[] a, boolean[] b, int k) {
865
    for (int i = 0; i < a.length-k; i+=1) {
866
      a[i+k] = false;
867
      b[i+k] = false;
868
    }
869
  }
870
  static void test_2vi_inv(boolean[] a, boolean[] b, boolean c, boolean d, int k) {
871
    for (int i = 0; i < a.length-k; i+=1) {
872
      a[i+k] = c;
873
      b[i+k] = d;
874
    }
875
  }
876
  static void test_ci_scl(boolean[] a) {
877
    for (int i = 0; i*SCALE < a.length; i+=1) {
878
      a[i*SCALE] = false;
879
    }
880
  }
881
  static void test_vi_scl(boolean[] a, boolean b) {
882
    for (int i = 0; i*SCALE < a.length; i+=1) {
883
      a[i*SCALE] = b;
884
    }
885
  }
886
  static void test_cp_scl(boolean[] a, boolean[] b) {
887
    for (int i = 0; i*SCALE < a.length; i+=1) {
888
      a[i*SCALE] = b[i*SCALE];
889
    }
890
  }
891
  static void test_2ci_scl(boolean[] a, boolean[] b) {
892
    for (int i = 0; i*SCALE < a.length; i+=1) {
893
      a[i*SCALE] = false;
894
      b[i*SCALE] = false;
895
    }
896
  }
897
  static void test_2vi_scl(boolean[] a, boolean[] b, boolean c, boolean d) {
898
    for (int i = 0; i*SCALE < a.length; i+=1) {
899
      a[i*SCALE] = c;
900
      b[i*SCALE] = d;
901
    }
902
  }
903
  static void test_cp_alndst(boolean[] a, boolean[] b) {
904
    for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
905
      a[i+ALIGN_OFF] = b[i];
906
    }
907
  }
908
  static void test_cp_alnsrc(boolean[] a, boolean[] b) {
909
    for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
910
      a[i] = b[i+ALIGN_OFF];
911
    }
912
  }
913
  static void test_2ci_aln(boolean[] a, boolean[] b) {
914
    for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
915
      a[i+ALIGN_OFF] = false;
916
      b[i] = false;
917
    }
918
  }
919
  static void test_2vi_aln(boolean[] a, boolean[] b, boolean c, boolean d) {
920
    for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
921
      a[i] = c;
922
      b[i+ALIGN_OFF] = d;
923
    }
924
  }
925
  static void test_cp_unalndst(boolean[] a, boolean[] b) {
926
    for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
927
      a[i+UNALIGN_OFF] = b[i];
928
    }
929
  }
930
  static void test_cp_unalnsrc(boolean[] a, boolean[] b) {
931
    for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
932
      a[i] = b[i+UNALIGN_OFF];
933
    }
934
  }
935
  static void test_2ci_unaln(boolean[] a, boolean[] b) {
936
    for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
937
      a[i+UNALIGN_OFF] = false;
938
      b[i] = false;
939
    }
940
  }
941
  static void test_2vi_unaln(boolean[] a, boolean[] b, boolean c, boolean d) {
942
    for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
943
      a[i] = c;
944
      b[i+UNALIGN_OFF] = d;
945
    }
946
  }
947

948
  static int verify(String text, int i, boolean elem, boolean val) {
949
    if (elem != val) {
950
      System.err.println(text + "[" + i + "] = " + elem + " != " + val);
951
      return 1;
952
    }
953
    return 0;
954
  }
955
}
956

957
Product

Resources

Company
